Bugfix: catch LookupErrors instead of IndexError in ContainerSubHandler.

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

diff --git a/pymin/services/util.py b/pymin/services/util.py
index 8d3775ecaa61a2f0e1f12fcd1ff718035b72c424..9c96fcab36d6b56f645ccd6ffe5d565f1f72c67e 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.
 


@@ -623,14 +649,16 @@ class ContainerSubHandler(SubHandler):
         if cls is not None:
             self._cont_subhandler_class = cls
 
         if cls is not None:
             self._cont_subhandler_class = cls
 

-    def _cont(self):
-        return getattr(self.parent, self._cont_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 _vcont(self):
-        if isinstance(self._cont(), dict):
-            return dict([(k, i) for (k, i) in self._cont().items()
+    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])
                     if not hasattr(i, '_delete') or not i._delete])

-        return [i for i in self._cont()
+        return [i for i in self._attr()

                 if not hasattr(i, '_delete') or not i._delete]
 
     @handler(u'Add a new item')
                 if not hasattr(i, '_delete') or not i._delete]
 
     @handler(u'Add a new item')


@@ -640,25 +668,25 @@ class ContainerSubHandler(SubHandler):
         if hasattr(item, '_add'):
             item._add = True
         key = item
         if hasattr(item, '_add'):
             item._add = True
         key = item

-        if isinstance(self._cont(), dict):
+        if isinstance(self._attr(), dict):

             key = item.as_tuple()[0]
         # do we have the same item? then raise an error
             key = item.as_tuple()[0]
         # do we have the same item? then raise an error

-        if key in self._vcont():
+        if key in self._vattr():

             raise ItemAlreadyExistsError(item)
         # do we have the same item, but logically deleted? then update flags
             raise ItemAlreadyExistsError(item)
         # do we have the same item, but logically deleted? then update flags

-        if key in self._cont():
+        if key in self._attr():

             index = key
             index = key

-            if not isinstance(self._cont(), dict):
-                index = self._cont().index(item)
+            if not isinstance(self._attr(), dict):
+                index = self._attr().index(item)

             if hasattr(item, '_add'):
             if hasattr(item, '_add'):

-                self._cont()[index]._add = False
+                self._attr()[index]._add = False

             if hasattr(item, '_delete'):
             if hasattr(item, '_delete'):

-                self._cont()[index]._delete = False
+                self._attr()[index]._delete = False

         else: # it's *really* new
         else: # it's *really* new

-            if isinstance(self._cont(), dict):
-                self._cont()[key] = item
+            if isinstance(self._attr(), dict):
+                self._attr()[key] = item

             else:
             else:

-                self._cont().append(item)
+                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):


@@ -666,49 +694,57 @@ class ContainerSubHandler(SubHandler):
         # 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

-        if not isinstance(self._cont(), dict):
+        if not isinstance(self._attr(), dict):

             index = int(index) # TODO validation
         if not hasattr(self._cont_subhandler_class, 'update'):
             raise CommandNotFoundError(('update',))
         try:
             index = int(index) # TODO validation
         if not hasattr(self._cont_subhandler_class, 'update'):
             raise CommandNotFoundError(('update',))
         try:

-            item = self._vcont()[index]
+            item = self._vattr()[index]

             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')
     def delete(self, index):
         r"delete(index) -> None :: Delete an item of the container."
             raise ItemNotFoundError(index)
 
     @handler(u'Delete an item')
     def delete(self, index):
         r"delete(index) -> None :: Delete an item of the container."

-        if not isinstance(self._cont(), dict):
+        if not isinstance(self._attr(), dict):

             index = int(index) # TODO validation
         try:
             index = int(index) # TODO validation
         try:

-            item = self._vcont()[index]
+            item = self._vattr()[index]

             if hasattr(item, '_delete'):
                 item._delete = True
             else:
             if hasattr(item, '_delete'):
                 item._delete = True
             else:

-                del self._cont()[index]
+                del self._attr()[index]

             return item
             return item

-        except IndexError:
+        except LookupError:

             raise ItemNotFoundError(index)
 
             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:
+            self._attr(list())
+

     @handler(u'Get information about an item')
     def get(self, index):
         r"get(index) -> item :: List all the information of an item."
     @handler(u'Get information about an item')
     def get(self, index):
         r"get(index) -> item :: List all the information of an item."

-        if not isinstance(self._cont(), dict):
+        if not isinstance(self._attr(), dict):

             index = int(index) # TODO validation
         try:
             index = int(index) # TODO validation
         try:

-            return self._vcont()[index]
-        except IndexError:
+            return self._vattr()[index]
+        except LookupError:

             raise ItemNotFoundError(index)
 
     @handler(u'Get information about all items')
     def show(self):
         r"show() -> list of items :: List all the complete items information."
             raise ItemNotFoundError(index)
 
     @handler(u'Get information about all items')
     def show(self):
         r"show() -> list of items :: List all the complete items information."

-        if isinstance(self._cont(), dict):
-            return self._cont().values()
-        return self._vcont()
+        if isinstance(self._attr(), dict):
+            return self._attr().values()
+        return self._vattr()

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


@@ -737,7 +773,7 @@ class ListSubHandler(ContainerSubHandler):
     @handler(u'Get how many items are in the list')
     def len(self):
         r"len() -> int :: Get how many items are in the list."
     @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._vcont())
+        return len(self._vattr())

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


@@ -767,7 +803,7 @@ class DictSubHandler(ContainerSubHandler):
     @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._cont().keys()
+        return self._attr().keys()

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