Bugfix: _persistent_attrs should be a sequence.

[software/pymin.git] / pymin / services / util.py

diff --git a/pymin/services/util.py b/pymin/services/util.py
index 2fe7f9b6d45e3d9dcabdeb8f09c0670c5a92392a..418616b7a99361df587f6ba3a52f8595bad7e864 100644 (file)
--- a/pymin/services/util.py
+++ b/pymin/services/util.py
@@ -15,10 +15,13 @@ from pymin.dispatcher import Handler, handler, HandlerError, \
 #DEBUG = False
 DEBUG = True
 
 #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"""
 
 class Error(HandlerError):
     r"""


@@ -126,6 +129,44 @@ class ItemNotFoundError(ItemError):
         r"Initialize the object. See class documentation for more info."
         self.message = u'Item not found: "%s"' % key
 
         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,
 
 def call(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
             stderr=subprocess.PIPE, close_fds=True, universal_newlines=True,


@@ -703,7 +744,7 @@ class ContainerSubHandler(SubHandler):
             item.update(*args, **kwargs)
             if hasattr(item, '_update'):
                 item._update = True
             item.update(*args, **kwargs)
             if hasattr(item, '_update'):
                 item._update = True

-        except IndexError:
+        except LookupError:

             raise ItemNotFoundError(index)
 
     @handler(u'Delete an item')
             raise ItemNotFoundError(index)
 
     @handler(u'Delete an item')


@@ -718,11 +759,12 @@ class ContainerSubHandler(SubHandler):
             else:
                 del self._attr()[index]
             return 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):
             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:
         if isinstance(self._attr(), dict):
             self._attr.clear()
         else:


@@ -735,7 +777,7 @@ class ContainerSubHandler(SubHandler):
             index = int(index) # TODO validation
         try:
             return self._vattr()[index]
             index = int(index) # TODO validation
         try:
             return self._vattr()[index]

-        except IndexError:
+        except LookupError:

             raise ItemNotFoundError(index)
 
     @handler(u'Get information about all items')
             raise ItemNotFoundError(index)
 
     @handler(u'Get information about all items')


@@ -748,25 +790,8 @@ class ContainerSubHandler(SubHandler):
 class ListSubHandler(ContainerSubHandler):
     r"""ListSubHandler(parent) -> ListSubHandler instance.
 
 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')
     """
 
     @handler(u'Get how many items are in the list')


@@ -777,32 +802,209 @@ class ListSubHandler(ContainerSubHandler):
 class DictSubHandler(ContainerSubHandler):
     r"""DictSubHandler(parent) -> DictSubHandler instance.
 
 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
     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')
     """
 
     @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__':
 
 
 if __name__ == '__main__':