#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 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.
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.
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:
- self._list_subhandler_attr = attr
+ self._cont_subhandler_attr = attr
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."
- 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)
- 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):
- 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
- 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:
- self._list()[index].update(*args, **kwargs)
- except IndexError:
+ item = self._vattr()[index]
+ item.update(*args, **kwargs)
+ if hasattr(item, '_update'):
+ item._update = True
+ except LookupError:
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:
- return self._list().pop(index)
- except IndexError:
+ item = self._vattr()[index]
+ if hasattr(item, '_delete'):
+ item._delete = True
+ else:
+ del self._attr()[index]
+ return item
+ 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:
+ self._attr(list())
+
@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:
- return self._list()[index]
- except IndexError:
+ return self._vattr()[index]
+ except LookupError:
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):
- 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
- 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:
- 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
- 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."
- 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__':
projects / software / pymin.git / blobdiff