import cPickle as pickle
except ImportError:
import pickle
+import logging ; log = logging.getLogger('pymin.services.util')
from pymin.dispatcher import Handler, handler, HandlerError, \
CommandNotFoundError
+from pymin.seqtools import Sequence
#DEBUG = False
DEBUG = True
-__ALL__ = ('ServiceHandler', 'InitdHandler', 'SubHandler', 'DictSubHandler',
- 'ListSubHandler', 'Persistent', 'ConfigWriter', 'Error',
- 'ReturnNot0Error', 'ExecutionError', 'ItemError',
- 'ItemAlreadyExistsError', 'ItemNotFoundError', 'call')
+__all__ = ('Error', 'ExecutionError', 'ItemError', 'ItemAlreadyExistsError',
+ 'ItemNotFoundError', 'ContainerError', 'ContainerNotFoundError',
+ 'call', 'get_network_devices', 'Persistent', 'Restorable',
+ 'ConfigWriter', 'ServiceHandler', 'RestartHandler',
+ 'ReloadHandler', 'InitdHandler', 'SubHandler', 'DictSubHandler',
+ 'ListSubHandler', 'ComposedSubHandler', 'ListComposedSubHandler',
+ 'DictComposedSubHandler', 'Device','Address')
class Error(HandlerError):
r"""
"""
pass
-class ReturnNot0Error(Error):
- r"""
- ReturnNot0Error(return_value) -> ReturnNot0Error instance.
-
- A command didn't returned the expected 0 return value.
-
- return_value - Return value returned by the command.
- """
-
- def __init__(self, return_value):
- r"Initialize the object. See class documentation for more info."
- self.return_value = return_value
-
- def __unicode__(self):
- return 'The command returned %d' % self.return_value
-
class ExecutionError(Error):
r"""
ExecutionError(command, error) -> ExecutionError instance.
def __init__(self, key):
r"Initialize the object. See class documentation for more info."
- self.message = u'Item already exists: "%s"' % key
+ self.message = u'Item already exists: %s' % key
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"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
+
+class Address(Sequence):
+ def __init__(self, ip, netmask, broadcast=None, peer=None):
+ self.ip = ip
+ self.netmask = netmask
+ self.broadcast = broadcast
+ self.peer = peer
+ def update(self, netmask=None, broadcast=None):
+ if netmask is not None: self.netmask = netmask
+ if broadcast is not None: self.broadcast = broadcast
+ def as_tuple(self):
+ return (self.ip, self.netmask, self.broadcast, self.peer)
+
+
+class Device(Sequence):
+ def __init__(self, name, mac, ppp):
+ self.name = name
+ self.mac = mac
+ self.ppp = ppp
+ self.active = True
+ self.addrs = dict()
+ self.routes = list()
+ def as_tuple(self):
+ return (self.name, self.mac, self.active, self.addrs)
+
+
+
+def get_network_devices():
+ p = subprocess.Popen(('ip', '-o', 'link'), stdout=subprocess.PIPE,
+ close_fds=True)
+ string = p.stdout.read()
+ p.wait()
+ d = dict()
+ devices = string.splitlines()
+ for dev in devices:
+ mac = ''
+ if dev.find('link/ether') != -1:
+ i = dev.find('link/ether')
+ mac = dev[i+11 : i+11+17]
+ i = dev.find(':')
+ j = dev.find(':', i+1)
+ name = dev[i+2: j]
+ d[name] = Device(name,mac,False)
+ elif dev.find('link/ppp') != -1:
+ i = dev.find('link/ppp')
+ mac = '00:00:00:00:00:00'
+ i = dev.find(':')
+ j = dev.find(':', i+1)
+ name = dev[i+2 : j]
+ d[name] = Device(name,mac,True)
+ #since the device is ppp, get the address and peer
+ try:
+ p = subprocess.Popen(('ip', '-o', 'addr', 'show', name), stdout=subprocess.PIPE,
+ close_fds=True, stderr=subprocess.PIPE)
+ string = p.stdout.read()
+ p.wait()
+ addrs = string.splitlines()
+ inet = addrs[1].find('inet')
+ peer = addrs[1].find('peer')
+ bar = addrs[1].find('/')
+ from_addr = addrs[1][inet+5 : peer-1]
+ to_addr = addrs[1][peer+5 : bar]
+ d[name].addrs[from_addr] = Address(from_addr,24, peer=to_addr)
+ except IndexError:
+ pass
+ return d
+
+def get_peers():
+ p = subprocess.Popen(('ip', '-o', 'addr'), stdout=subprocess.PIPE,
+ close_fds=True)
def call(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, close_fds=True, universal_newlines=True,
**kw):
+ log.debug(u'call(%r)', command)
if DEBUG:
- if not isinstance(command, basestring):
- command = ' '.join(command)
- print 'Executing command:', command
+ log.debug(u'call: not really executing, DEBUG mode')
return
try:
- r = subprocess.call(command, stdin=stdin, stdout=stdout, stderr=stderr,
- universal_newlines=universal_newlines,
- close_fds=close_fds, **kw)
+ subprocess.check_call(command, stdin=stdin, stdout=stdout,
+ stderr=stderr, close_fds=close_fds,
+ universal_newlines=universal_newlines, **kw)
except Exception, e:
+ log.debug(u'call: Execution error %r', e)
raise ExecutionError(command, e)
- if r is not 0:
- raise ExecutionError(command, ReturnNot0Error(r))
class Persistent:
r"""Persistent([attrs[, dir[, ext]]]) -> Persistent.
def _dump_attr(self, attrname):
r"_dump_attr() -> None :: Dump a specific variable to a pickle file."
+ fname = self._pickle_filename(attrname)
+ attr = getattr(self, attrname)
+ log.debug(u'Persistent._dump_attr(%r) -> file=%r, value=%r',
+ attrname, fname, attr)
f = file(self._pickle_filename(attrname), 'wb')
- pickle.dump(getattr(self, attrname), f, 2)
+ pickle.dump(attr, f, 2)
f.close()
def _load_attr(self, attrname):
r"_load_attr() -> object :: Load a specific pickle file."
- f = file(self._pickle_filename(attrname))
- setattr(self, attrname, pickle.load(f))
+ fname = self._pickle_filename(attrname)
+ f = file(fname)
+ attr = pickle.load(f)
+ log.debug(u'Persistent._load_attr(%r) -> file=%r, value=%r',
+ attrname, fname, attr)
+ setattr(self, attrname, attr)
f.close()
def _pickle_filename(self, name):
def _restore(self):
r"_restore() -> bool :: Restore persistent data or create a default."
+ log.debug(u'Restorable._restore()')
try:
+ log.debug(u'Restorable._restore: trying to load...')
self._load()
- # TODO tener en cuenta servicios que hay que levantar y los que no
- if hasattr(self, 'commit'): # TODO deberia ser reload y/o algo para comandos
- self.commit()
+ log.debug(u'Restorable._restore: load OK')
return True
except IOError:
+ log.debug(u'Restorable._restore: load FAILED, making defaults: %r',
+ self._restorable_defaults)
for (k, v) in self._restorable_defaults.items():
setattr(self, k, v)
# TODO tener en cuenta servicios que hay que levantar y los que no
if hasattr(self, 'commit'):
+ log.debug(u'Restorable._restore: commit() found, commiting...')
self.commit()
return False
+ log.debug(u'Restorable._restore: dumping new defaults...')
self._dump()
if hasattr(self, '_write_config'):
+ log.debug(u'Restorable._restore: _write_config() found, '
+ u'writing new config...')
self._write_config()
- if hasattr(self, 'reload'):
- self.reload()
return False
class ConfigWriter:
def _config_build_templates(self):
r"_config_writer_templates() -> None :: Build the template objects."
+ log.debug(u'ConfigWriter.build_templates()')
if isinstance(self._config_writer_files, basestring):
self._config_writer_files = (self._config_writer_files,)
if not hasattr(self, '_config_writer_templates') \
vars = dict()
elif callable(vars):
vars = vars(template_name)
+ log.debug(u'ConfigWriter._render_config: rendering template %r with '
+ u'vars=%r', template_name, vars)
return self._config_writer_templates[template_name].render(**vars)
def _get_config_path(self, template_name, config_filename=None):
vars = dict()
elif callable(vars):
vars = vars(template_name)
- f = file(self._get_config_path(template_name, config_filename), 'w')
+ fname = self._get_config_path(template_name, config_filename)
+ f = file(fname, 'w')
ctx = Context(f, **vars)
+ log.debug(u'ConfigWriter._write_single_config: rendering template '
+ u'%r with vars=%r to file %r', template_name, vars, fname)
self._config_writer_templates[template_name].render_context(ctx)
f.close()
self._write_single_config(t)
-class ServiceHandler(Handler):
+class ServiceHandler(Handler, Restorable):
r"""ServiceHandler([start[, stop[, restart[, reload]]]]) -> ServiceHandler.
This is a helper class to inherit from to automatically handle services
def __init__(self, start=None, stop=None, restart=None, reload=None):
r"Initialize the object, see the class documentation for details."
+ log.debug(u'ServiceHandler(%r, %r, %r, %r)', start, stop, restart,
+ reload)
for (name, action) in dict(start=start, stop=stop, restart=restart,
reload=reload).items():
if action is not None:
- setattr(self, '_service_%s' % name, action)
+ attr_name = '_service_%s' % name
+ log.debug(u'ServiceHandler: using %r as %s', attr_name, action)
+ setattr(self, attr_name, action)
+ self._persistent_attrs = list(self._persistent_attrs)
+ self._persistent_attrs.append('_service_running')
+ if '_service_running' not in self._restorable_defaults:
+ self._restorable_defaults['_service_running'] = False
+ log.debug(u'ServiceHandler: restoring service configuration...')
+ self._restore()
+ if self._service_running:
+ log.debug(u'ServiceHandler: service was running, starting it...')
+ self._service_running = False
+ self.start()
@handler(u'Start the service.')
def start(self):
r"start() -> None :: Start the service."
- call(self._service_start)
+ log.debug(u'ServiceHandler.start()')
+ if not self._service_running:
+ log.debug(u'ServiceHandler.start: not running, starting it...')
+ if callable(self._service_start):
+ self._service_start()
+ else:
+ call(self._service_start)
+ self._service_running = True
+ self._dump_attr('_service_running')
@handler(u'Stop the service.')
def stop(self):
+ log.debug(u'ServiceHandler.stop()')
r"stop() -> None :: Stop the service."
- call(self._service_stop)
+ if self._service_running:
+ log.debug(u'ServiceHandler.stop: running, stoping it...')
+ if callable(self._service_stop):
+ self._service_stop()
+ else:
+ call(self._service_stop)
+ self._service_running = False
+ self._dump_attr('_service_running')
@handler(u'Restart the service.')
def restart(self):
r"restart() -> None :: Restart the service."
- call(self._service_restart)
+ log.debug(u'ServiceHandler.restart()')
+ if callable(self._service_restart):
+ self._service_restart()
+ else:
+ call(self._service_restart)
+ self._service_running = True
+ self._dump_attr('_service_running')
@handler(u'Reload the service config (without restarting, if possible).')
def reload(self):
r"reload() -> None :: Reload the configuration of the service."
- call(self._service_reload)
+ log.debug(u'ServiceHandler.reload()')
+ if self._service_running:
+ log.debug(u'ServiceHandler.reload: running, reloading...')
+ if callable(self._service_reload):
+ self._service_reload()
+ else:
+ call(self._service_reload)
+
+ @handler(u'Tell if the service is running.')
+ def running(self):
+ r"reload() -> None :: Reload the configuration of the service."
+ log.debug(u'ServiceHandler.running() -> %r', self._service_running)
+ if self._service_running:
+ return 1
+ else:
+ return 0
+
+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()."
+ log.debug(u'RestartHandler.restart()')
+ self.stop()
+ self.start()
+
+class ReloadHandler(Handler):
+ r"""ReloadHandler() -> ReloadHandler :: Provides generic reload command.
-class InitdHandler(Handler):
+ 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."
+ log.debug(u'ReloadHandler.reload()')
+ if hasattr(self, '_service_running') and self._service_running:
+ log.debug(u'ReloadHandler.reload: running, reloading...')
+ self.restart()
+
+class InitdHandler(ServiceHandler):
+ # TODO update docs, declarative style is depracated
r"""InitdHandler([initd_name[, initd_dir]]) -> InitdHandler.
This is a helper class to inherit from to automatically handle services
def __init__(self, initd_name=None, initd_dir=None):
r"Initialize the object, see the class documentation for details."
+ log.debug(u'InitdHandler(%r, %r)', initd_name, initd_dir)
if initd_name is not None:
self._initd_name = initd_name
if initd_dir is not None:
self._initd_dir = initd_dir
-
- @handler(u'Start the service.')
- def start(self):
- r"start() -> None :: Start the service."
- call((path.join(self._initd_dir, self._initd_name), 'start'))
-
- @handler(u'Stop the service.')
- def stop(self):
- r"stop() -> None :: Stop the service."
- call((path.join(self._initd_dir, self._initd_name), 'stop'))
-
- @handler(u'Restart the service.')
- def restart(self):
- r"restart() -> None :: Restart the service."
- call((path.join(self._initd_dir, self._initd_name), 'restart'))
-
- @handler(u'Reload the service config (without restarting, if possible).')
- def reload(self):
- r"reload() -> None :: Reload the configuration of the service."
- call((path.join(self._initd_dir, self._initd_name), 'reload'))
+ actions = dict()
+ for action in ('start', 'stop', 'restart', 'reload'):
+ actions[action] = (path.join(self._initd_dir, self._initd_name),
+ action)
+ ServiceHandler.__init__(self, **actions)
+
+ def handle_timer(self):
+ # TODO documentation
+ log.debug(u'InitdHandler.handle_timer(): self=%r', self)
+ p = subprocess.Popen(('pgrep', '-f', self._initd_name),
+ stdout=subprocess.PIPE)
+ pid = p.communicate()[0]
+ if p.returncode == 0 and len(pid) > 0:
+ log.debug(u'InitdHandler.handle_timer: pid present, running')
+ self._service_running = True
+ else:
+ log.debug(u'InitdHandler.handle_timer: pid absent, NOT running')
+ self._service_running = False
class TransactionalHandler(Handler):
r"""Handle command transactions providing a commit and rollback commands.
@handler(u'Commit the changes (reloading the service, if necessary).')
def commit(self):
r"commit() -> None :: Commit the changes and reload the service."
+ log.debug(u'TransactionalHandler.commit()')
if hasattr(self, '_dump'):
+ log.debug(u'TransactionalHandler.commit: _dump() present, '
+ u'dumping...')
self._dump()
+ unchanged = False
if hasattr(self, '_write_config'):
- self._write_config()
- if hasattr(self, 'reload'):
+ log.debug(u'TransactionalHandler.commit: _write_config() present, '
+ u'writing config...')
+ unchanged = self._write_config()
+ if not unchanged and hasattr(self, 'reload'):
+ log.debug(u'TransactionalHandler.commit: reload() present, and'
+ u'configuration changed, reloading...')
self.reload()
@handler(u'Discard all the uncommited changes.')
def rollback(self):
r"rollback() -> None :: Discard the changes not yet commited."
+ log.debug(u'TransactionalHandler.reload()')
if hasattr(self, '_load'):
+ log.debug(u'TransactionalHandler.reload: _load() present, loading'
+ u'pickled values...')
self._load()
class ParametersHandler(Handler):
def __init__(self, attr=None):
r"Initialize the object, see the class documentation for details."
+ log.debug(u'ParametersHandler(%r)', attr)
if attr is not None:
self._parameters_attr = attr
@handler(u'Set a service parameter.')
def set(self, param, value):
r"set(param, value) -> None :: Set a service parameter."
+ log.debug(u'ParametersHandler.set(%r, %r)', param, value)
if not param in self.params:
+ log.debug(u'ParametersHandler.set: parameter not found')
raise ParameterNotFoundError(param)
self.params[param] = value
+ if hasattr(self, '_update'):
+ log.debug(u'ParametersHandler.set: _update found, setting to True')
+ self._update = True
@handler(u'Get a service parameter.')
def get(self, param):
r"get(param) -> None :: Get a service parameter."
+ log.debug(u'ParametersHandler.get(%r)', param)
if not param in self.params:
+ log.debug(u'ParametersHandler.get: parameter not found')
raise ParameterNotFoundError(param)
return self.params[param]
@handler(u'List all available service parameters.')
def list(self):
r"list() -> tuple :: List all the parameter names."
+ log.debug(u'ParametersHandler.list()')
return self.params.keys()
@handler(u'Get all service parameters, with their values.')
def show(self):
r"show() -> (key, value) tuples :: List all the parameters."
+ log.debug(u'ParametersHandler.show()')
return self.params.items()
class SubHandler(Handler):
def __init__(self, parent):
r"Initialize the object, see the class documentation for details."
+ log.debug(u'SubHandler(%r)', parent)
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."
+ log.debug(u'ContainerSubHandler(%r, %r, %r)', parent, attr, cls)
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 _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 _list(self):
- return getattr(self.parent, self._list_subhandler_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():
- raise ItemAlreadyExistsError(item)
- self._list().append(item)
+ log.debug(u'ContainerSubHandler.add(%r, %r)', args, kwargs)
+ item = self._cont_subhandler_class(*args, **kwargs)
+ if hasattr(item, '_add'):
+ log.debug(u'ContainerSubHandler.add: _add found, setting to True')
+ 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():
+ log.debug(u'ContainerSubHandler.add: allready exists')
+ if not isinstance(self._attr(), dict):
+ key = self._attr().index(item)
+ raise ItemAlreadyExistsError(key)
+ # do we have the same item, but logically deleted? then update flags
+ if key in self._attr():
+ log.debug(u'ContainerSubHandler.add: was deleted, undeleting it')
+ 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."
+ log.debug(u'ContainerSubHandler.update(%r, %r, %r)',
+ index, args, kwargs)
# 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'):
+ log.debug(u'ContainerSubHandler.update: update() not found, '
+ u"can't really update, raising command not found")
raise CommandNotFoundError(('update',))
try:
- self._list()[index].update(*args, **kwargs)
- except IndexError:
+ item = self._vattr()[index]
+ item.update(*args, **kwargs)
+ if hasattr(item, '_update'):
+ log.debug(u'ContainerSubHandler.update: _update found, '
+ u'setting to True')
+ item._update = True
+ except LookupError:
+ log.debug(u'ContainerSubHandler.update: item not found')
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."
+ log.debug(u'ContainerSubHandler.delete(%r)', index)
+ 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'):
+ log.debug(u'ContainerSubHandler.delete: _delete found, '
+ u'setting to True')
+ item._delete = True
+ else:
+ del self._attr()[index]
+ return item
+ except LookupError:
+ log.debug(u'ContainerSubHandler.delete: item not found')
raise ItemNotFoundError(index)
+ @handler(u'Remove all items (use with care).')
+ def clear(self):
+ r"clear() -> None :: Delete all items of the container."
+ log.debug(u'ContainerSubHandler.clear()')
+ # FIXME broken really, no _delete attribute is setted :S
+ 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."
+ log.debug(u'ContainerSubHandler.get(%r)', index)
+ if not isinstance(self._attr(), dict):
+ index = int(index) # TODO validation
try:
- return self._list()[index]
- except IndexError:
+ return self._vattr()[index]
+ except LookupError:
+ log.debug(u'ContainerSubHandler.get: item not found')
raise ItemNotFoundError(index)
+ @handler(u'Get information about all items')
+ def show(self):
+ r"show() -> list of items :: List all the complete items information."
+ log.debug(u'ContainerSubHandler.show()')
+ if isinstance(self._attr(), dict):
+ return self._attr().values()
+ return self._vattr()
+
+class ListSubHandler(ContainerSubHandler):
+ r"""ListSubHandler(parent) -> ListSubHandler instance.
+
+ ContainerSubHandler holding lists. See ComposedSubHandler documentation
+ for details.
+ """
+
@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()
+ log.debug(u'ListContainerSubHandler.len()')
+ return len(self._vattr())
-class DictSubHandler(SubHandler):
+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.
-
- 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:
+ ContainerSubHandler holding dicts. See ComposedSubHandler documentation
+ for details.
+ """
- class TestHandler(DictSubHandler):
- _dict_subhandler_attr = 'some_dict'
- _dict_subhandler_class = SomeClass
+ @handler(u'List all the items by key')
+ def list(self):
+ r"list() -> tuple :: List all the item keys."
+ log.debug(u'DictContainerSubHandler.list()')
+ return self._attr().keys()
+
+class ComposedSubHandler(SubHandler):
+ r"""ComposedSubHandler(parent) -> ComposedSubHandler instance.
+
+ 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).
+
+ 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:
- 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 and an update() method,
- if it should be possible to modify it.
+ 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 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, attr=None, cls=None):
+ def __init__(self, parent, cont=None, attr=None, cls=None):
r"Initialize the object, see the class documentation for details."
+ log.debug(u'ComposedSubHandler(%r, %r, %r, %r)',
+ parent, cont, attr, cls)
self.parent = parent
+ if cont is not None:
+ self._comp_subhandler_cont = cont
if attr is not None:
- self._dict_subhandler_attr = attr
+ self._comp_subhandler_attr = attr
if cls is not None:
- self._dict_subhandler_class = cls
+ self._comp_subhandler_class = cls
+
+ def _cont(self):
+ return getattr(self.parent, self._comp_subhandler_cont)
- def _dict(self):
- return getattr(self.parent, self._dict_subhandler_attr)
+ 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, 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():
+ def add(self, cont, *args, **kwargs):
+ r"add(cont, ...) -> None :: Add an item to the list."
+ log.debug(u'ComposedSubHandler.add(%r, %r, %r)', cont, args, kwargs)
+ if not cont in self._cont():
+ log.debug(u'ComposedSubHandler.add: container not found')
+ raise ContainerNotFoundError(cont)
+ item = self._comp_subhandler_class(*args, **kwargs)
+ if hasattr(item, '_add'):
+ log.debug(u'ComposedSubHandler.add: _add found, setting to True')
+ 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):
+ log.debug(u'ComposedSubHandler.add: allready exists')
+ if not isinstance(self._attr(), dict):
+ key = self._attr().index(item)
raise ItemAlreadyExistsError(key)
- self._dict()[key] = item
+ # do we have the same item, but logically deleted? then update flags
+ if key in self._attr(cont):
+ log.debug(u'ComposedSubHandler.add: was deleted, undeleting it')
+ 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'):
+ log.debug(u"ComposedSubHandler.add: container's _update found, "
+ u'setting to True')
+ self._cont()[cont]._update = True
@handler(u'Update an item')
- def update(self, key, *args, **kwargs):
- r"update(key, ...) -> None :: Update an item of the dict."
+ 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.
- if not hasattr(self._dict_subhandler_class, 'update'):
+ log.debug(u'ComposedSubHandler.update(%r, %r, %r, %r)',
+ cont, index, args, kwargs)
+ if not cont in self._cont():
+ log.debug(u'ComposedSubHandler.add: container not found')
+ raise ContainerNotFoundError(cont)
+ if not isinstance(self._attr(cont), dict):
+ index = int(index) # TODO validation
+ if not hasattr(self._comp_subhandler_class, 'update'):
+ log.debug(u'ComposedSubHandler.update: update() not found, '
+ u"can't really update, raising command not found")
raise CommandNotFoundError(('update',))
- if not key in self._dict():
- raise ItemNotFoundError(key)
- self._dict()[key].update(*args, **kwargs)
+ try:
+ item = self._vattr(cont)[index]
+ item.update(*args, **kwargs)
+ if hasattr(item, '_update'):
+ log.debug(u'ComposedSubHandler.update: _update found, '
+ u'setting to True')
+ item._update = True
+ if hasattr(self._cont()[cont], '_update'):
+ log.debug(u"ComposedSubHandler.add: container's _update found, "
+ u'setting to True')
+ self._cont()[cont]._update = True
+ except LookupError:
+ log.debug(u'ComposedSubHandler.update: item not found')
+ raise ItemNotFoundError(index)
@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]
+ def delete(self, cont, index):
+ r"delete(cont, index) -> None :: Delete an item of the container."
+ log.debug(u'ComposedSubHandler.delete(%r, %r)', cont, index)
+ if not cont in self._cont():
+ log.debug(u'ComposedSubHandler.add: container not found')
+ 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'):
+ log.debug(u'ComposedSubHandler.delete: _delete found, '
+ u'setting to True')
+ item._delete = True
+ else:
+ del self._attr(cont)[index]
+ if hasattr(self._cont()[cont], '_update'):
+ log.debug(u"ComposedSubHandler.add: container's _update found, "
+ u'setting to True')
+ self._cont()[cont]._update = True
+ return item
+ except LookupError:
+ log.debug(u'ComposedSubHandler.delete: item not found')
+ raise ItemNotFoundError(index)
- @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]
+ @handler(u'Remove all items (use with care).')
+ def clear(self, cont):
+ r"clear(cont) -> None :: Delete all items of the container."
+ # FIXME broken really, no item or container _delete attribute is
+ # setted :S
+ log.debug(u'ComposedSubHandler.clear(%r)', cont)
+ if not cont in self._cont():
+ log.debug(u'ComposedSubHandler.add: container not found')
+ raise ContainerNotFoundError(cont)
+ if isinstance(self._attr(cont), dict):
+ self._attr(cont).clear()
+ else:
+ self._attr(cont, list())
- @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 an item')
+ def get(self, cont, index):
+ r"get(cont, index) -> item :: List all the information of an item."
+ log.debug(u'ComposedSubHandler.get(%r, %r)', cont, index)
+ if not cont in self._cont():
+ log.debug(u'ComposedSubHandler.add: container not found')
+ raise ContainerNotFoundError(cont)
+ if not isinstance(self._attr(cont), dict):
+ index = int(index) # TODO validation
+ try:
+ return self._vattr(cont)[index]
+ except LookupError:
+ log.debug(u'ComposedSubHandler.get: item not found')
+ raise ItemNotFoundError(index)
@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()
+ def show(self, cont):
+ r"show(cont) -> list of items :: List all the complete items information."
+ log.debug(u'ComposedSubHandler.show(%r)', cont)
+ if not cont in self._cont():
+ log.debug(u'ComposedSubHandler.add: container not found')
+ 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."
+ log.debug(u'ListComposedSubHandler.len(%r)', cont)
+ 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, cont):
+ r"list(cont) -> tuple :: List all the item keys."
+ log.debug(u'DictComposedSubHandler.list(%r)', cont)
+ if not cont in self._cont():
+ raise ContainerNotFoundError(cont)
+ return self._attr(cont).keys()
if __name__ == '__main__':
+ logging.basicConfig(
+ level = logging.DEBUG,
+ format = '%(asctime)s %(levelname)-8s %(message)s',
+ datefmt = '%H:%M:%S',
+ )
+
+ import sys
+
# Execution tests
class STestHandler1(ServiceHandler):
_service_start = ('service', 'start')
os.rmdir('templates')
print
+ print get_network_devices()
+
projects / software / pymin.git / blobdiff