Add a default __cmp__() implementation to pymin.seqtool.Sequence.

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

diff --git a/pymin/services/util.py b/pymin/services/util.py
index 95a07e9992d8b0f9b92df39e7a1c41e2cd34f6aa..2fe7f9b6d45e3d9dcabdeb8f09c0670c5a92392a 100644 (file)
--- a/pymin/services/util.py
+++ b/pymin/services/util.py
@@ -15,10 +15,10 @@ from pymin.dispatcher import Handler, handler, HandlerError, \
 #DEBUG = False
 DEBUG = True
 
 #DEBUG = False
 DEBUG = True
 

-__ALL__ = ('ServiceHandler', 'InitdHandler', 'SubHandler', 'DictSubHandler',
-            'ListSubHandler', 'Persistent', 'ConfigWriter', 'Error',
-            'ReturnNot0Error', 'ExecutionError', 'ItemError',
-            'ItemAlreadyExistsError', 'ItemNotFoundError', 'call')
+__ALL__ = ('ServiceHandler', 'RestartHandler', 'ReloadHandler', 'InitdHandler',
+            'SubHandler', 'DictSubHandler', 'ListSubHandler', 'Persistent',
+            'ConfigWriter', 'Error', 'ReturnNot0Error', 'ExecutionError',
+            'ItemError', 'ItemAlreadyExistsError', 'ItemNotFoundError', 'call')

 
 class Error(HandlerError):
     r"""
 
 class Error(HandlerError):
     r"""


@@ -116,7 +116,7 @@ class ItemAlreadyExistsError(ItemError):
 
 class ItemNotFoundError(ItemError):
     r"""
 
 class ItemNotFoundError(ItemError):
     r"""

-    ItemNotFoundError(key) -> ItemNotFoundError instance
+    ItemNotFoundError(key) -> ItemNotFoundError instance.

 
     This exception is raised when trying to operate on an item that doesn't
     exists.
 
     This exception is raised when trying to operate on an item that doesn't
     exists.


@@ -447,6 +447,32 @@ class ServiceHandler(Handler):
         r"reload() -> None :: Reload the configuration of the service."
         call(self._service_reload)
 
         r"reload() -> None :: Reload the configuration of the service."
         call(self._service_reload)
 

+class RestartHandler(Handler):
+    r"""RestartHandler() -> RestartHandler :: Provides generic restart command.
+
+    This is a helper class to inherit from to automatically add a restart
+    command that first stop the service and then starts it again (using start
+    and stop commands respectively).
+    """
+
+    @handler(u'Restart the service (alias to stop + start).')
+    def restart(self):
+        r"restart() -> None :: Restart the service calling stop() and start()."
+        self.stop()
+        self.start()
+
+class ReloadHandler(Handler):
+    r"""ReloadHandler() -> ReloadHandler :: Provides generic reload command.
+
+    This is a helper class to inherit from to automatically add a reload
+    command that calls restart.
+    """
+
+    @handler(u'Reload the service config (alias to restart).')
+    def reload(self):
+        r"reload() -> None :: Reload the configuration of the service."
+        self.restart()
+

 class InitdHandler(Handler):
     r"""InitdHandler([initd_name[, initd_dir]]) -> InitdHandler.
 
 class InitdHandler(Handler):
     r"""InitdHandler([initd_name[, initd_dir]]) -> InitdHandler.
 


@@ -590,162 +616,193 @@ class SubHandler(Handler):
         r"Initialize the object, see the class documentation for details."
         self.parent = parent
 
         r"Initialize the object, see the class documentation for details."
         self.parent = parent
 

-class ListSubHandler(SubHandler):
-    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):
-        _list_subhandler_attr = 'some_list'
-        _list_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.
+class ContainerSubHandler(SubHandler):
+    r"""ContainerSubHandler(parent) -> ContainerSubHandler instance.
+
+    This is a helper class to implement ListSubHandler and DictSubHandler. You
+    should not use it directly.
+
+    The container 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(ContainerSubHandler):
+        _cont_subhandler_attr = 'some_cont'
+        _cont_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. New items will be instances of SomeClass,
+    which 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 container,
+    but it's not listed either).

     """
 
     def __init__(self, parent, attr=None, cls=None):
         r"Initialize the object, see the class documentation for details."
         self.parent = parent
         if attr is not None:
     """
 
     def __init__(self, parent, attr=None, cls=None):
         r"Initialize the object, see the class documentation for details."
         self.parent = parent
         if attr is not None:

-            self._list_subhandler_attr = attr
+            self._cont_subhandler_attr = attr

         if cls is not None:
         if cls is not None:

-            self._list_subhandler_class = cls
+            self._cont_subhandler_class = cls

 
 

-    def _list(self):
-        return getattr(self.parent, self._list_subhandler_attr)
+    def _attr(self, attr=None):
+        if attr is None:
+            return getattr(self.parent, self._cont_subhandler_attr)
+        setattr(self.parent, self._cont_subhandler_attr, attr)
+
+    def _vattr(self):
+        if isinstance(self._attr(), dict):
+            return dict([(k, i) for (k, i) in self._attr().items()
+                    if not hasattr(i, '_delete') or not i._delete])
+        return [i for i in self._attr()
+                if not hasattr(i, '_delete') or not i._delete]

 
     @handler(u'Add a new item')
     def add(self, *args, **kwargs):
         r"add(...) -> None :: Add an item to the list."
 
     @handler(u'Add a new item')
     def add(self, *args, **kwargs):
         r"add(...) -> None :: Add an item to the list."

-        item = self._list_subhandler_class(*args, **kwargs)
-        if item in self._list():
+        item = self._cont_subhandler_class(*args, **kwargs)
+        if hasattr(item, '_add'):
+            item._add = True
+        key = item
+        if isinstance(self._attr(), dict):
+            key = item.as_tuple()[0]
+        # do we have the same item? then raise an error
+        if key in self._vattr():

             raise ItemAlreadyExistsError(item)
             raise ItemAlreadyExistsError(item)

-        self._list().append(item)
+        # do we have the same item, but logically deleted? then update flags
+        if key in self._attr():
+            index = key
+            if not isinstance(self._attr(), dict):
+                index = self._attr().index(item)
+            if hasattr(item, '_add'):
+                self._attr()[index]._add = False
+            if hasattr(item, '_delete'):
+                self._attr()[index]._delete = False
+        else: # it's *really* new
+            if isinstance(self._attr(), dict):
+                self._attr()[key] = item
+            else:
+                self._attr().append(item)

 
     @handler(u'Update an item')
     def update(self, index, *args, **kwargs):
 
     @handler(u'Update an item')
     def update(self, index, *args, **kwargs):

-        r"update(index, ...) -> None :: Update an item of the list."
+        r"update(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
         # 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

-        index = int(index) # TODO validation
-        if not hasattr(self._list_subhandler_class, 'update'):
+        if not isinstance(self._attr(), dict):
+            index = int(index) # TODO validation
+        if not hasattr(self._cont_subhandler_class, 'update'):

             raise CommandNotFoundError(('update',))
         try:
             raise CommandNotFoundError(('update',))
         try:

-            self._list()[index].update(*args, **kwargs)
+            item = self._vattr()[index]
+            item.update(*args, **kwargs)
+            if hasattr(item, '_update'):
+                item._update = True

         except IndexError:
             raise ItemNotFoundError(index)
 
     @handler(u'Delete an item')
     def delete(self, index):
         except IndexError:
             raise ItemNotFoundError(index)
 
     @handler(u'Delete an item')
     def delete(self, index):

-        r"delete(index) -> None :: Delete an item of the list."
-        index = int(index) # TODO validation
+        r"delete(index) -> None :: Delete an item of the container."
+        if not isinstance(self._attr(), dict):
+            index = int(index) # TODO validation

         try:
         try:

-            return self._list().pop(index)
+            item = self._vattr()[index]
+            if hasattr(item, '_delete'):
+                item._delete = True
+            else:
+                del self._attr()[index]
+            return item

         except IndexError:
             raise ItemNotFoundError(index)
 
         except IndexError:
             raise ItemNotFoundError(index)
 

+    @handler(u'Remove all items (use with care).')
+    def clear(self):
+        if isinstance(self._attr(), dict):
+            self._attr.clear()
+        else:
+            self._attr(list())
+

     @handler(u'Get information about an item')
     def get(self, index):
     @handler(u'Get information about an item')
     def get(self, index):

-        r"get(index) -> Host :: List all the information of an item."
-        index = int(index) # TODO validation
+        r"get(index) -> item :: List all the information of an item."
+        if not isinstance(self._attr(), dict):
+            index = int(index) # TODO validation

         try:
         try:

-            return self._list()[index]
+            return self._vattr()[index]

         except IndexError:
             raise ItemNotFoundError(index)
 
         except IndexError:
             raise ItemNotFoundError(index)
 

-    @handler(u'Get how many items are in the list')
-    def len(self):
-        r"len() -> int :: Get how many items are in the list."
-        return len(self._list())
-

     @handler(u'Get information about all items')
     def show(self):
     @handler(u'Get information about all items')
     def show(self):

-        r"show() -> list of Hosts :: List all the complete items information."
-        return self._list()
+        r"show() -> list of items :: List all the complete items information."
+        if isinstance(self._attr(), dict):
+            return self._attr().values()
+        return self._vattr()

 
 

-class DictSubHandler(SubHandler):
-    r"""DictSubHandler(parent) -> DictSubHandler instance.
+class ListSubHandler(ContainerSubHandler):
+    r"""ListSubHandler(parent) -> ListSubHandler instance.

 
     This is a helper class to inherit from to automatically handle subcommands
 
     This is a helper class to inherit from to automatically handle subcommands

-    that operates over a dict parent attribute.
+    that operates over a list parent attribute.

 
 

-    The dict attribute to handle and the class of objects that it contains can
+    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:
 
     be defined by calling the constructor or in a more declarative way as
     class attributes, like:
 

-    class TestHandler(DictSubHandler):
-        _dict_subhandler_attr = 'some_dict'
-        _dict_subhandler_class = SomeClass
+    class TestHandler(ListSubHandler):
+        _cont_subhandler_attr = 'some_list'
+        _cont_subhandler_class = SomeClass

 
 

-    This way, the parent's some_dict attribute (self.parent.some_dict) will be
+    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
     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 and an update() method,
-    if it should be possible to modify it.
+    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).

     """
 
     """
 

-    def __init__(self, parent, attr=None, cls=None):
-        r"Initialize the object, see the class documentation for details."
-        self.parent = parent
-        if attr is not None:
-            self._dict_subhandler_attr = attr
-        if cls is not None:
-            self._dict_subhandler_class = cls
+    @handler(u'Get how many items are in the list')
+    def len(self):
+        r"len() -> int :: Get how many items are in the list."
+        return len(self._vattr())

 
 

-    def _dict(self):
-        return getattr(self.parent, self._dict_subhandler_attr)
+class DictSubHandler(ContainerSubHandler):
+    r"""DictSubHandler(parent) -> DictSubHandler instance.

 
 

-    @handler(u'Add a new item')
-    def add(self, key, *args, **kwargs):
-        r"add(key, ...) -> None :: Add an item to the dict."
-        item = self._dict_subhandler_class(key, *args, **kwargs)
-        if key in self._dict():
-            raise ItemAlreadyExistsError(key)
-        self._dict()[key] = item
+    This is a helper class to inherit from to automatically handle subcommands
+    that operates over a dict parent attribute.

 
 

-    @handler(u'Update an item')
-    def update(self, key, *args, **kwargs):
-        r"update(key, ...) -> None :: Update an item of the dict."
-        # TODO make it right with metaclasses, so the method is not created
-        # unless the update() method really exists.
-        if not hasattr(self._dict_subhandler_class, 'update'):
-            raise CommandNotFoundError(('update',))
-        if not key in self._dict():
-            raise ItemNotFoundError(key)
-        self._dict()[key].update(*args, **kwargs)
+    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:

 
 

-    @handler(u'Delete an item')
-    def delete(self, key):
-        r"delete(key) -> None :: Delete an item of the dict."
-        if not key in self._dict():
-            raise ItemNotFoundError(key)
-        del self._dict()[key]
+    class TestHandler(DictSubHandler):
+        _cont_subhandler_attr = 'some_dict'
+        _cont_subhandler_class = SomeClass

 
 

-    @handler(u'Get information about an item')
-    def get(self, key):
-        r"get(key) -> Host :: List all the information of an item."
-        if not key in self._dict():
-            raise ItemNotFoundError(key)
-        return self._dict()[key]
+    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
+    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).
+    """

 
     @handler(u'List all the items by key')
     def list(self):
         r"list() -> tuple :: List all the item keys."
 
     @handler(u'List all the items by key')
     def list(self):
         r"list() -> tuple :: List all the item keys."

-        return self._dict().keys()
-
-    @handler(u'Get information about all items')
-    def show(self):
-        r"show() -> list of Hosts :: List all the complete items information."
-        return self._dict().values()
+        return self._attr().keys()

 
 
 if __name__ == '__main__':
 
 
 if __name__ == '__main__':