#DEBUG = False
DEBUG = True
-__ALL__ = ('ServiceHandler', 'RestartHandler', 'ReloadHandler', 'InitdHandler',
- 'SubHandler', 'DictSubHandler', 'ListSubHandler', 'Persistent',
- 'ConfigWriter', 'Error', 'ReturnNot0Error', 'ExecutionError',
- 'ItemError', 'ItemAlreadyExistsError', 'ItemNotFoundError', 'call')
+__ALL__ = ('Error', 'ReturnNot0Error', 'ExecutionError', 'ItemError',
+ 'ItemAlreadyExistsError', 'ItemNotFoundError', 'ContainerError',
+ 'ContainerNotFoundError', 'call', 'get_network_devices',
+ 'Persistent', 'Restorable', 'ConfigWriter', 'ServiceHandler',
+ 'RestartHandler', 'ReloadHandler', 'InitdHandler', 'SubHandler',
+ 'DictSubHandler', 'ListSubHandler', 'ComposedSubHandler',
+ 'ListComposedSubHandler', 'DictComposedSubHandler')
class Error(HandlerError):
r"""
r"Initialize the object. See class documentation for more info."
self.message = u'Item not found: "%s"' % key
+class ContainerError(Error, KeyError):
+ r"""
+ ContainerError(key) -> ContainerError instance.
+
+ This is the base exception for all container related errors.
+ """
+
+ def __init__(self, key):
+ r"Initialize the object. See class documentation for more info."
+ self.message = u'Container error: "%s"' % key
+
+class ContainerNotFoundError(ContainerError):
+ r"""
+ ContainerNotFoundError(key) -> ContainerNotFoundError instance.
+
+ This exception is raised when trying to operate on an container that
+ doesn't exists.
+ """
+
+ def __init__(self, key):
+ r"Initialize the object. See class documentation for more info."
+ self.message = u'Container not found: "%s"' % key
+
+
+def get_network_devices():
+ p = subprocess.Popen(('ip', 'link', 'list'), stdout=subprocess.PIPE,
+ close_fds=True)
+ string = p.stdout.read()
+ p.wait()
+ d = dict()
+ i = string.find('eth')
+ while i != -1:
+ eth = string[i:i+4]
+ m = string.find('link/ether', i+4)
+ mac = string[ m+11 : m+11+17]
+ d[eth] = mac
+ i = string.find('eth', m+11+17)
+ return d
def call(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, close_fds=True, universal_newlines=True,
item.update(*args, **kwargs)
if hasattr(item, '_update'):
item._update = True
- except IndexError:
+ except LookupError:
raise ItemNotFoundError(index)
@handler(u'Delete an item')
else:
del self._attr()[index]
return item
- except IndexError:
+ except LookupError:
raise ItemNotFoundError(index)
@handler(u'Remove all items (use with care).')
def clear(self):
+ r"clear() -> None :: Delete all items of the container."
if isinstance(self._attr(), dict):
self._attr.clear()
else:
index = int(index) # TODO validation
try:
return self._vattr()[index]
- except IndexError:
+ except LookupError:
raise ItemNotFoundError(index)
@handler(u'Get information about all items')
class ListSubHandler(ContainerSubHandler):
r"""ListSubHandler(parent) -> ListSubHandler instance.
- This is a helper class to inherit from to automatically handle subcommands
- that operates over a list parent attribute.
-
- The list attribute to handle and the class of objects that it contains can
- be defined by calling the constructor or in a more declarative way as
- class attributes, like:
-
- class TestHandler(ListSubHandler):
- _cont_subhandler_attr = 'some_list'
- _cont_subhandler_class = SomeClass
-
- This way, the parent's some_list attribute (self.parent.some_list) will be
- managed automatically, providing the commands: add, update, delete, get,
- list and show. New items will be instances of SomeClass, which should
- provide a cmp operator to see if the item is on the list and an update()
- method, if it should be possible to modify it. If SomeClass has an _add,
- _update or _delete attribute, it set them to true when the item is added,
- updated or deleted respectively (in case that it's deleted, it's not
- removed from the list, but it's not listed either).
+ ContainerSubHandler holding lists. See ComposedSubHandler documentation
+ for details.
"""
@handler(u'Get how many items are in the list')
class DictSubHandler(ContainerSubHandler):
r"""DictSubHandler(parent) -> DictSubHandler instance.
- This is a helper class to inherit from to automatically handle subcommands
- that operates over a dict parent attribute.
+ ContainerSubHandler holding dicts. See ComposedSubHandler documentation
+ for details.
+ """
+
+ @handler(u'List all the items by key')
+ def list(self):
+ r"list() -> tuple :: List all the item keys."
+ return self._attr().keys()
- The dict attribute to handle and the class of objects that it contains can
- be defined by calling the constructor or in a more declarative way as
- class attributes, like:
+class ComposedSubHandler(SubHandler):
+ r"""ComposedSubHandler(parent) -> ComposedSubHandler instance.
- class TestHandler(DictSubHandler):
- _cont_subhandler_attr = 'some_dict'
- _cont_subhandler_class = SomeClass
+ This is a helper class to implement ListComposedSubHandler and
+ DictComposedSubHandler. You should not use it directly.
+
+ This class is usefull when you have a parent that has a dict (cont)
+ that stores some object that has an attribute (attr) with a list or
+ a dict of objects of some class. In that case, this class provides
+ automated commands to add, update, delete, get and show that objects.
+ This commands takes the cont (key of the dict for the object holding
+ the attr), and an index for access the object itself (in the attr
+ list/dict).
- This way, the parent's some_dict attribute (self.parent.some_dict) will be
- managed automatically, providing the commands: add, update, delete, get,
- list and show. New items will be instances of SomeClass, which should
- provide a constructor with at least the key value, an as_tuple() method
- and an update() method, if it should be possible to modify
+ The container object (cont) that holds a containers, the attribute of
+ that object that is the container itself, and the class of the objects
+ that it contains can be defined by calling the constructor or in a
+ more declarative way as class attributes, like:
+
+ class TestHandler(ComposedSubHandler):
+ _comp_subhandler_cont = 'some_cont'
+ _comp_subhandler_attr = 'some_attr'
+ _comp_subhandler_class = SomeClass
+
+ This way, the parent's some_cont attribute (self.parent.some_cont)
+ will be managed automatically, providing the commands: add, update,
+ delete, get and show for manipulating a particular instance that holds
+ of SomeClass. For example, updating an item at the index 5 is the same
+ (simplified) as doing parent.some_cont[cont][5].update().
+ SomeClass should provide a cmp operator to see if the item is on the
+ container and an update() method, if it should be possible to modify
it. If SomeClass has an _add, _update or _delete attribute, it set
them to true when the item is added, updated or deleted respectively
- (in case that it's deleted, it's not removed from the dict, but it's
- not listed either).
+ (in case that it's deleted, it's not removed from the container,
+ but it's not listed either). If the container objects
+ (parent.some_cont[cont]) has an _update attribute, it's set to True
+ when any add, update or delete command is executed.
+ """
+
+ def __init__(self, parent, cont=None, attr=None, cls=None):
+ r"Initialize the object, see the class documentation for details."
+ self.parent = parent
+ if cont is not None:
+ self._comp_subhandler_cont = cont
+ if attr is not None:
+ self._comp_subhandler_attr = attr
+ if cls is not None:
+ self._comp_subhandler_class = cls
+
+ def _cont(self):
+ return getattr(self.parent, self._comp_subhandler_cont)
+
+ def _attr(self, cont, attr=None):
+ if attr is None:
+ return getattr(self._cont()[cont], self._comp_subhandler_attr)
+ setattr(self._cont()[cont], self._comp_subhandler_attr, attr)
+
+ def _vattr(self, cont):
+ if isinstance(self._attr(cont), dict):
+ return dict([(k, i) for (k, i) in self._attr(cont).items()
+ if not hasattr(i, '_delete') or not i._delete])
+ return [i for i in self._attr(cont)
+ if not hasattr(i, '_delete') or not i._delete]
+
+ @handler(u'Add a new item')
+ def add(self, cont, *args, **kwargs):
+ r"add(cont, ...) -> None :: Add an item to the list."
+ if not cont in self._cont():
+ raise ContainerNotFoundError(cont)
+ item = self._comp_subhandler_class(*args, **kwargs)
+ if hasattr(item, '_add'):
+ item._add = True
+ key = item
+ if isinstance(self._attr(cont), dict):
+ key = item.as_tuple()[0]
+ # do we have the same item? then raise an error
+ if key in self._vattr(cont):
+ raise ItemAlreadyExistsError(item)
+ # do we have the same item, but logically deleted? then update flags
+ if key in self._attr(cont):
+ index = key
+ if not isinstance(self._attr(cont), dict):
+ index = self._attr(cont).index(item)
+ if hasattr(item, '_add'):
+ self._attr(cont)[index]._add = False
+ if hasattr(item, '_delete'):
+ self._attr(cont)[index]._delete = False
+ else: # it's *really* new
+ if isinstance(self._attr(cont), dict):
+ self._attr(cont)[key] = item
+ else:
+ self._attr(cont).append(item)
+ if hasattr(self._cont()[cont], '_update'):
+ self._cont()[cont]._update = True
+
+ @handler(u'Update an item')
+ def update(self, cont, index, *args, **kwargs):
+ r"update(cont, index, ...) -> None :: Update an item of the container."
+ # TODO make it right with metaclasses, so the method is not created
+ # unless the update() method really exists.
+ # TODO check if the modified item is the same of an existing one
+ if not cont in self._cont():
+ raise ContainerNotFoundError(cont)
+ if not isinstance(self._attr(cont), dict):
+ index = int(index) # TODO validation
+ if not hasattr(self._comp_subhandler_class, 'update'):
+ raise CommandNotFoundError(('update',))
+ try:
+ item = self._vattr(cont)[index]
+ item.update(*args, **kwargs)
+ if hasattr(item, '_update'):
+ item._update = True
+ if hasattr(self._cont()[cont], '_update'):
+ self._cont()[cont]._update = True
+ except LookupError:
+ raise ItemNotFoundError(index)
+
+ @handler(u'Delete an item')
+ def delete(self, cont, index):
+ r"delete(cont, index) -> None :: Delete an item of the container."
+ if not cont in self._cont():
+ raise ContainerNotFoundError(cont)
+ if not isinstance(self._attr(cont), dict):
+ index = int(index) # TODO validation
+ try:
+ item = self._vattr(cont)[index]
+ if hasattr(item, '_delete'):
+ item._delete = True
+ else:
+ del self._attr(cont)[index]
+ if hasattr(self._cont()[cont], '_update'):
+ self._cont()[cont]._update = True
+ return item
+ except LookupError:
+ raise ItemNotFoundError(index)
+
+ @handler(u'Remove all items (use with care).')
+ def clear(self, cont):
+ r"clear(cont) -> None :: Delete all items of the container."
+ if not cont in self._cont():
+ raise ContainerNotFoundError(cont)
+ if isinstance(self._attr(cont), dict):
+ self._attr(cont).clear()
+ else:
+ self._attr(cont, list())
+
+ @handler(u'Get information about an item')
+ def get(self, cont, index):
+ r"get(cont, index) -> item :: List all the information of an item."
+ if not cont in self._cont():
+ raise ContainerNotFoundError(cont)
+ if not isinstance(self._attr(cont), dict):
+ index = int(index) # TODO validation
+ try:
+ return self._vattr(cont)[index]
+ except LookupError:
+ raise ItemNotFoundError(index)
+
+ @handler(u'Get information about all items')
+ def show(self, cont):
+ r"show(cont) -> list of items :: List all the complete items information."
+ if not cont in self._cont():
+ raise ContainerNotFoundError(cont)
+ if isinstance(self._attr(cont), dict):
+ return self._attr(cont).values()
+ return self._vattr(cont)
+
+class ListComposedSubHandler(ComposedSubHandler):
+ r"""ListComposedSubHandler(parent) -> ListComposedSubHandler instance.
+
+ ComposedSubHandler holding lists. See ComposedSubHandler documentation
+ for details.
+ """
+
+ @handler(u'Get how many items are in the list')
+ def len(self, cont):
+ r"len(cont) -> int :: Get how many items are in the list."
+ if not cont in self._cont():
+ raise ContainerNotFoundError(cont)
+ return len(self._vattr(cont))
+
+class DictComposedSubHandler(ComposedSubHandler):
+ r"""DictComposedSubHandler(parent) -> DictComposedSubHandler instance.
+
+ ComposedSubHandler holding dicts. See ComposedSubHandler documentation
+ for details.
"""
@handler(u'List all the items by key')
- def list(self):
- r"list() -> tuple :: List all the item keys."
- return self._attr().keys()
+ def list(self, cont):
+ r"list(cont) -> tuple :: List all the item keys."
+ if not cont in self._cont():
+ raise ContainerNotFoundError(cont)
+ return self._attr(cont).keys()
if __name__ == '__main__':
projects / software / pymin.git / blobdiff