pymin/services/util.py

   1 # vim: set encoding=utf-8 et sw=4 sts=4 :
   2
   3 import subprocess
   4 from mako.template import Template
   5 from mako.runtime import Context
   6 from os import path
   7 try:
   8     import cPickle as pickle
   9 except ImportError:
  10     import pickle
  11
  12 from pymin.dispatcher import Handler, handler, HandlerError, \
  13                                 CommandNotFoundError
  14
  15 #DEBUG = False
  16 DEBUG = True
  17
  18 __ALL__ = ('ServiceHandler', 'InitdHandler', 'SubHandler', 'DictSubHandler',
  19             'ListSubHandler', 'Persistent', 'ConfigWriter', 'Error',
  20             'ReturnNot0Error', 'ExecutionError', 'ItemError',
  21             'ItemAlreadyExistsError', 'ItemNotFoundError', 'call')
  22
  23 class Error(HandlerError):
  24     r"""
  25     Error(message) -> Error instance :: Base ServiceHandler exception class.
  26
  27     All exceptions raised by the ServiceHandler inherits from this one, so
  28     you can easily catch any ServiceHandler exception.
  29
  30     message - A descriptive error message.
  31     """
  32     pass
  33
  34 class ReturnNot0Error(Error):
  35     r"""
  36     ReturnNot0Error(return_value) -> ReturnNot0Error instance.
  37
  38     A command didn't returned the expected 0 return value.
  39
  40     return_value - Return value returned by the command.
  41     """
  42
  43     def __init__(self, return_value):
  44         r"Initialize the object. See class documentation for more info."
  45         self.return_value = return_value
  46
  47     def __unicode__(self):
  48         return 'The command returned %d' % self.return_value
  49
  50 class ExecutionError(Error):
  51     r"""
  52     ExecutionError(command, error) -> ExecutionError instance.
  53
  54     Error executing a command.
  55
  56     command - Command that was tried to execute.
  57
  58     error - Error received when trying to execute the command.
  59     """
  60
  61     def __init__(self, command, error):
  62         r"Initialize the object. See class documentation for more info."
  63         self.command = command
  64         self.error = error
  65
  66     def __unicode__(self):
  67         command = self.command
  68         if not isinstance(self.command, basestring):
  69             command = ' '.join(command)
  70         return "Can't execute command %s: %s" % (command, self.error)
  71
  72 class ParameterError(Error, KeyError):
  73     r"""
  74     ParameterError(paramname) -> ParameterError instance
  75
  76     This is the base exception for all DhcpHandler parameters related errors.
  77     """
  78
  79     def __init__(self, paramname):
  80         r"Initialize the object. See class documentation for more info."
  81         self.message = 'Parameter error: "%s"' % paramname
  82
  83 class ParameterNotFoundError(ParameterError):
  84     r"""
  85     ParameterNotFoundError(paramname) -> ParameterNotFoundError instance
  86
  87     This exception is raised when trying to operate on a parameter that doesn't
  88     exists.
  89     """
  90
  91     def __init__(self, paramname):
  92         r"Initialize the object. See class documentation for more info."
  93         self.message = 'Parameter not found: "%s"' % paramname
  94
  95 class ItemError(Error, KeyError):
  96     r"""
  97     ItemError(key) -> ItemError instance.
  98
  99     This is the base exception for all item related errors.
 100     """
 101
 102     def __init__(self, key):
 103         r"Initialize the object. See class documentation for more info."
 104         self.message = u'Item error: "%s"' % key
 105
 106 class ItemAlreadyExistsError(ItemError):
 107     r"""
 108     ItemAlreadyExistsError(key) -> ItemAlreadyExistsError instance.
 109
 110     This exception is raised when trying to add an item that already exists.
 111     """
 112
 113     def __init__(self, key):
 114         r"Initialize the object. See class documentation for more info."
 115         self.message = u'Item already exists: "%s"' % key
 116
 117 class ItemNotFoundError(ItemError):
 118     r"""
 119     ItemNotFoundError(key) -> ItemNotFoundError instance
 120
 121     This exception is raised when trying to operate on an item that doesn't
 122     exists.
 123     """
 124
 125     def __init__(self, key):
 126         r"Initialize the object. See class documentation for more info."
 127         self.message = u'Item not found: "%s"' % key
 128
 129
 130 def call(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
 131             stderr=subprocess.PIPE, close_fds=True, universal_newlines=True,
 132             **kw):
 133     if DEBUG:
 134         if not isinstance(command, basestring):
 135             command = ' '.join(command)
 136         print 'Executing command:', command
 137         return
 138     try:
 139         r = subprocess.call(command, stdin=stdin, stdout=stdout, stderr=stderr,
 140                                 universal_newlines=universal_newlines,
 141                                 close_fds=close_fds, **kw)
 142     except Exception, e:
 143         raise ExecutionError(command, e)
 144     if r is not 0:
 145         raise ExecutionError(command, ReturnNot0Error(r))
 146
 147 class Persistent:
 148     r"""Persistent([attrs[, dir[, ext]]]) -> Persistent.
 149
 150     This is a helper class to inherit from to automatically handle data
 151     persistence using pickle.
 152
 153     The variables attributes to persist (attrs), and the pickle directory (dir)
 154     and file extension (ext) can be defined by calling the constructor or in a
 155     more declarative way as class attributes, like:
 156
 157     class TestHandler(Persistent):
 158         _persistent_attrs = ('some_attr', 'other_attr')
 159         _persistent_dir = 'persistent-data'
 160         _persistent_ext = '.pickle'
 161
 162     The default dir is '.' and the default extension is '.pkl'. There are no
 163     default variables, and they should be specified as string if a single
 164     attribute should be persistent or as a tuple of strings if they are more.
 165     The strings should be the attribute names to be persisted. For each
 166     attribute a separated pickle file is generated in the pickle directory.
 167
 168     You can call _dump() and _load() to write and read the data respectively.
 169     """
 170     # TODO implement it using metaclasses to add the handlers method by demand
 171     # (only for specifieds commands).
 172
 173     _persistent_attrs = ()
 174     _persistent_dir = '.'
 175     _persistent_ext = '.pkl'
 176
 177     def __init__(self, attrs=None, dir=None, ext=None):
 178         r"Initialize the object, see the class documentation for details."
 179         if attrs is not None:
 180             self._persistent_attrs = attrs
 181         if dir is not None:
 182             self._persistent_dir = dir
 183         if ext is not None:
 184             self._persistent_ext = ext
 185
 186     def _dump(self):
 187         r"_dump() -> None :: Dump all persistent data to pickle files."
 188         if isinstance(self._persistent_attrs, basestring):
 189             self._persistent_attrs = (self._persistent_attrs,)
 190         for attrname in self._persistent_attrs:
 191             self._dump_attr(attrname)
 192
 193     def _load(self):
 194         r"_load() -> None :: Load all persistent data from pickle files."
 195         if isinstance(self._persistent_attrs, basestring):
 196             self._persistent_attrs = (self._persistent_attrs,)
 197         for attrname in self._persistent_attrs:
 198             self._load_attr(attrname)
 199
 200     def _dump_attr(self, attrname):
 201         r"_dump_attr() -> None :: Dump a specific variable to a pickle file."
 202         f = file(self._pickle_filename(attrname), 'wb')
 203         pickle.dump(getattr(self, attrname), f, 2)
 204         f.close()
 205
 206     def _load_attr(self, attrname):
 207         r"_load_attr() -> object :: Load a specific pickle file."
 208         f = file(self._pickle_filename(attrname))
 209         setattr(self, attrname, pickle.load(f))
 210         f.close()
 211
 212     def _pickle_filename(self, name):
 213         r"_pickle_filename() -> string :: Construct a pickle filename."
 214         return path.join(self._persistent_dir, name) + self._persistent_ext
 215
 216 class Restorable(Persistent):
 217     r"""Restorable([defaults]) -> Restorable.
 218
 219     This is a helper class to inherit from that provides a nice _restore()
 220     method to restore the persistent data if any, or load some nice defaults
 221     if not.
 222
 223     The defaults can be defined by calling the constructor or in a more
 224     declarative way as class attributes, like:
 225
 226     class TestHandler(Restorable):
 227         _persistent_attrs = ('some_attr', 'other_attr')
 228         _restorable_defaults = dict(
 229                 some_attr = 'some_default',
 230                 other_attr = 'other_default')
 231
 232     The defaults is a dictionary, very coupled with the _persistent_attrs
 233     attribute inherited from Persistent. The defaults keys should be the
 234     values from _persistent_attrs, and the values the default values.
 235
 236     The _restore() method returns True if the data was restored successfully
 237     or False if the defaults were loaded (in case you want to take further
 238     actions). If a _write_config method if found, it's executed when a restore
 239     fails too.
 240     """
 241     # TODO implement it using metaclasses to add the handlers method by demand
 242     # (only for specifieds commands).
 243
 244     _restorable_defaults = dict()
 245
 246     def __init__(self, defaults=None):
 247         r"Initialize the object, see the class documentation for details."
 248         if defaults is not None:
 249             self._restorable_defaults = defaults
 250
 251     def _restore(self):
 252         r"_restore() -> bool :: Restore persistent data or create a default."
 253         try:
 254             self._load()
 255             # TODO tener en cuenta servicios que hay que levantar y los que no
 256             if hasattr(self, 'commit'): # TODO deberia ser reload y/o algo para comandos
 257                 self.commit()
 258             return True
 259         except IOError:
 260             for (k, v) in self._restorable_defaults.items():
 261                 setattr(self, k, v)
 262             # TODO tener en cuenta servicios que hay que levantar y los que no
 263             if hasattr(self, 'commit'):
 264                 self.commit()
 265                 return False
 266             self._dump()
 267             if hasattr(self, '_write_config'):
 268                 self._write_config()
 269             if hasattr(self, 'reload'):
 270                 self.reload()
 271             return False
 272
 273 class ConfigWriter:
 274     r"""ConfigWriter([initd_name[, initd_dir]]) -> ConfigWriter.
 275
 276     This is a helper class to inherit from to automatically handle
 277     configuration generation. Mako template system is used for configuration
 278     files generation.
 279
 280     The configuration filenames, the generated configuration files directory
 281     and the templates directory can be defined by calling the constructor or
 282     in a more declarative way as class attributes, like:
 283
 284     class TestHandler(ConfigWriter):
 285         _config_writer_files = ('base.conf', 'custom.conf')
 286         _config_writer_cfg_dir = {
 287                                     'base.conf': '/etc/service',
 288                                     'custom.conf': '/etc/service/conf.d',
 289                                  }
 290         _config_writer_tpl_dir = 'templates'
 291
 292     The generated configuration files directory defaults to '.' and the
 293     templates directory to 'templates'. _config_writer_files has no default and
 294     must be specified in either way. It can be string or a tuple if more than
 295     one configuration file must be generated. _config_writer_cfg_dir could be a
 296     dict mapping which file should be stored in which directory, or a single
 297     string if all the config files should go to the same directory.
 298
 299     The template filename and the generated configuration filename are both the
 300     same (so if you want to generate some /etc/config, you should have some
 301     templates/config template). That's why _config_writer_cfg_dir and
 302     _config_writer_tpl_dir can't be the same. This is not true for very
 303     specific cases where _write_single_config() is used.
 304
 305     When you write your Handler, you should call _config_build_templates() in
 306     you Handler constructor to build the templates.
 307
 308     To write the configuration files, you must use the _write_config() method.
 309     To know what variables to replace in the template, you have to provide a
 310     method called _get_config_vars(tamplate_name), which should return a
 311     dictionary of variables to pass to the template system to be replaced in
 312     the template for the configuration file 'config_file'.
 313     """
 314     # TODO implement it using metaclasses to add the handlers method by demand
 315     # (only for specifieds commands).
 316
 317     _config_writer_files = ()
 318     _config_writer_cfg_dir = '.'
 319     _config_writer_tpl_dir = 'templates'
 320
 321     def __init__(self, files=None, cfg_dir=None, tpl_dir=None):
 322         r"Initialize the object, see the class documentation for details."
 323         if files is not None:
 324             self._config_writer_files = files
 325         if cfg_dir is not None:
 326             self._config_writer_cfg_dir = cfg_dir
 327         if tpl_dir is not None:
 328             self._config_writer_tpl_dir = tpl_dir
 329         self._config_build_templates()
 330
 331     def _config_build_templates(self):
 332         r"_config_writer_templates() -> None :: Build the template objects."
 333         if isinstance(self._config_writer_files, basestring):
 334             self._config_writer_files = (self._config_writer_files,)
 335         if not hasattr(self, '_config_writer_templates') \
 336                                         or not self._config_writer_templates:
 337             self._config_writer_templates = dict()
 338             for t in self._config_writer_files:
 339                 f = path.join(self._config_writer_tpl_dir, t)
 340                 self._config_writer_templates[t] = Template(filename=f)
 341
 342     def _render_config(self, template_name, vars=None):
 343         r"""_render_config(template_name[, config_filename[, vars]]).
 344
 345         Render a single config file using the template 'template_name'. If
 346         vars is specified, it's used as the dictionary with the variables
 347         to replace in the templates, if not, it looks for a
 348         _get_config_vars() method to get it.
 349         """
 350         if vars is None:
 351             if hasattr(self, '_get_config_vars'):
 352                 vars = self._get_config_vars(template_name)
 353             else:
 354                 vars = dict()
 355         elif callable(vars):
 356             vars = vars(template_name)
 357         return self._config_writer_templates[template_name].render(**vars)
 358
 359     def _get_config_path(self, template_name, config_filename=None):
 360         r"Get a complete configuration path."
 361         if not config_filename:
 362             config_filename = template_name
 363         if isinstance(self._config_writer_cfg_dir, basestring):
 364             return path.join(self._config_writer_cfg_dir, config_filename)
 365         return path.join(self._config_writer_cfg_dir[template_name],
 366                             config_filename)
 367
 368     def _write_single_config(self, template_name, config_filename=None, vars=None):
 369         r"""_write_single_config(template_name[, config_filename[, vars]]).
 370
 371         Write a single config file using the template 'template_name'. If no
 372         config_filename is specified, the config filename will be the same as
 373         the 'template_name' (but stored in the generated config files
 374         directory). If it's specified, the generated config file is stored in
 375         the file called 'config_filename' (also in the generated files
 376         directory). If vars is specified, it's used as the dictionary with the
 377         variables to replace in the templates, if not, it looks for a
 378         _get_config_vars() method to get it.
 379         """
 380         if vars is None:
 381             if hasattr(self, '_get_config_vars'):
 382                 vars = self._get_config_vars(template_name)
 383             else:
 384                 vars = dict()
 385         elif callable(vars):
 386             vars = vars(template_name)
 387         f = file(self._get_config_path(template_name, config_filename), 'w')
 388         ctx = Context(f, **vars)
 389         self._config_writer_templates[template_name].render_context(ctx)
 390         f.close()
 391
 392     def _write_config(self):
 393         r"_write_config() -> None :: Generate all the configuration files."
 394         for t in self._config_writer_files:
 395             self._write_single_config(t)
 396
 397
 398 class ServiceHandler(Handler):
 399     r"""ServiceHandler([start[, stop[, restart[, reload]]]]) -> ServiceHandler.
 400
 401     This is a helper class to inherit from to automatically handle services
 402     with start, stop, restart, reload actions.
 403
 404     The actions can be defined by calling the constructor with all the
 405     parameters or in a more declarative way as class attributes, like:
 406
 407     class TestHandler(ServiceHandler):
 408         _service_start = ('command', 'start')
 409         _service_stop = ('command', 'stop')
 410         _service_restart = ('command', 'restart')
 411         _service_reload = 'reload-command'
 412
 413     Commands are executed without using the shell, that's why they are specified
 414     as tuples (where the first element is the command and the others are the
 415     command arguments). If only a command is needed (without arguments) a single
 416     string can be specified.
 417
 418     All commands must be specified.
 419     """
 420     # TODO implement it using metaclasses to add the handlers method by demand
 421     # (only for specifieds commands).
 422
 423     def __init__(self, start=None, stop=None, restart=None, reload=None):
 424         r"Initialize the object, see the class documentation for details."
 425         for (name, action) in dict(start=start, stop=stop, restart=restart,
 426                                                     reload=reload).items():
 427             if action is not None:
 428                 setattr(self, '_service_%s' % name, action)
 429
 430     @handler(u'Start the service.')
 431     def start(self):
 432         r"start() -> None :: Start the service."
 433         call(self._service_start)
 434
 435     @handler(u'Stop the service.')
 436     def stop(self):
 437         r"stop() -> None :: Stop the service."
 438         call(self._service_stop)
 439
 440     @handler(u'Restart the service.')
 441     def restart(self):
 442         r"restart() -> None :: Restart the service."
 443         call(self._service_restart)
 444
 445     @handler(u'Reload the service config (without restarting, if possible).')
 446     def reload(self):
 447         r"reload() -> None :: Reload the configuration of the service."
 448         call(self._service_reload)
 449
 450 class InitdHandler(Handler):
 451     r"""InitdHandler([initd_name[, initd_dir]]) -> InitdHandler.
 452
 453     This is a helper class to inherit from to automatically handle services
 454     with start, stop, restart, reload actions using a /etc/init.d like script.
 455
 456     The name and directory of the script can be defined by calling the
 457     constructor or in a more declarative way as class attributes, like:
 458
 459     class TestHandler(ServiceHandler):
 460         _initd_name = 'some-service'
 461         _initd_dir = '/usr/local/etc/init.d'
 462
 463     The default _initd_dir is '/etc/init.d', _initd_name has no default and
 464     must be specified in either way.
 465
 466     Commands are executed without using the shell.
 467     """
 468     # TODO implement it using metaclasses to add the handlers method by demand
 469     # (only for specifieds commands).
 470
 471     _initd_dir = '/etc/init.d'
 472
 473     def __init__(self, initd_name=None, initd_dir=None):
 474         r"Initialize the object, see the class documentation for details."
 475         if initd_name is not None:
 476             self._initd_name = initd_name
 477         if initd_dir is not None:
 478             self._initd_dir = initd_dir
 479
 480     @handler(u'Start the service.')
 481     def start(self):
 482         r"start() -> None :: Start the service."
 483         call((path.join(self._initd_dir, self._initd_name), 'start'))
 484
 485     @handler(u'Stop the service.')
 486     def stop(self):
 487         r"stop() -> None :: Stop the service."
 488         call((path.join(self._initd_dir, self._initd_name), 'stop'))
 489
 490     @handler(u'Restart the service.')
 491     def restart(self):
 492         r"restart() -> None :: Restart the service."
 493         call((path.join(self._initd_dir, self._initd_name), 'restart'))
 494
 495     @handler(u'Reload the service config (without restarting, if possible).')
 496     def reload(self):
 497         r"reload() -> None :: Reload the configuration of the service."
 498         call((path.join(self._initd_dir, self._initd_name), 'reload'))
 499
 500 class TransactionalHandler(Handler):
 501     r"""Handle command transactions providing a commit and rollback commands.
 502
 503     This is a helper class to inherit from to automatically handle
 504     transactional handlers, which have commit and rollback commands.
 505
 506     The handler should provide a reload() method (see ServiceHandler and
 507     InitdHandler for helper classes to provide this) which will be called
 508     when a commit command is issued (if a reload() command is present).
 509     The persistent data will be written too (if a _dump() method is provided,
 510     see Persistent and Restorable for that), and the configuration files
 511     will be generated (if a _write_config method is present, see ConfigWriter).
 512     """
 513     # TODO implement it using metaclasses to add the handlers method by demand
 514     # (only for specifieds commands).
 515
 516     @handler(u'Commit the changes (reloading the service, if necessary).')
 517     def commit(self):
 518         r"commit() -> None :: Commit the changes and reload the service."
 519         if hasattr(self, '_dump'):
 520             self._dump()
 521         if hasattr(self, '_write_config'):
 522             self._write_config()
 523         if hasattr(self, 'reload'):
 524             self.reload()
 525
 526     @handler(u'Discard all the uncommited changes.')
 527     def rollback(self):
 528         r"rollback() -> None :: Discard the changes not yet commited."
 529         if hasattr(self, '_load'):
 530             self._load()
 531
 532 class ParametersHandler(Handler):
 533     r"""ParametersHandler([attr]) -> ParametersHandler.
 534
 535     This is a helper class to inherit from to automatically handle
 536     service parameters, providing set, get, list and show commands.
 537
 538     The attribute that holds the parameters can be defined by calling the
 539     constructor or in a more declarative way as class attributes, like:
 540
 541     class TestHandler(ServiceHandler):
 542         _parameters_attr = 'some_attr'
 543
 544     The default is 'params' and it should be a dictionary.
 545     """
 546     # TODO implement it using metaclasses to add the handlers method by demand
 547     # (only for specifieds commands).
 548
 549     _parameters_attr = 'params'
 550
 551     def __init__(self, attr=None):
 552         r"Initialize the object, see the class documentation for details."
 553         if attr is not None:
 554             self._parameters_attr = attr
 555
 556     @handler(u'Set a service parameter.')
 557     def set(self, param, value):
 558         r"set(param, value) -> None :: Set a service parameter."
 559         if not param in self.params:
 560             raise ParameterNotFoundError(param)
 561         self.params[param] = value
 562
 563     @handler(u'Get a service parameter.')
 564     def get(self, param):
 565         r"get(param) -> None :: Get a service parameter."
 566         if not param in self.params:
 567             raise ParameterNotFoundError(param)
 568         return self.params[param]
 569
 570     @handler(u'List all available service parameters.')
 571     def list(self):
 572         r"list() -> tuple :: List all the parameter names."
 573         return self.params.keys()
 574
 575     @handler(u'Get all service parameters, with their values.')
 576     def show(self):
 577         r"show() -> (key, value) tuples :: List all the parameters."
 578         return self.params.items()
 579
 580 class SubHandler(Handler):
 581     r"""SubHandler(parent) -> SubHandler instance :: Handles subcommands.
 582
 583     This is a helper class to build sub handlers that needs to reference the
 584     parent handler.
 585
 586     parent - Parent Handler object.
 587     """
 588
 589     def __init__(self, parent):
 590         r"Initialize the object, see the class documentation for details."
 591         self.parent = parent
 592
 593 class ContainerSubHandler(SubHandler):
 594     r"""ContainerSubHandler(parent) -> ContainerSubHandler instance.
 595
 596     This is a helper class to implement ListSubHandler and DictSubHandler. You
 597     should not use it directly.
 598
 599     The container attribute to handle and the class of objects that it
 600     contains can be defined by calling the constructor or in a more declarative
 601     way as class attributes, like:
 602
 603     class TestHandler(ContainerSubHandler):
 604         _cont_subhandler_attr = 'some_cont'
 605         _cont_subhandler_class = SomeClass
 606
 607     This way, the parent's some_cont attribute (self.parent.some_cont)
 608     will be managed automatically, providing the commands: add, update,
 609     delete, get and show. New items will be instances of SomeClass,
 610     which should provide a cmp operator to see if the item is on the
 611     container and an update() method, if it should be possible to modify
 612     it. If SomeClass has an _add, _update or _delete attribute, it set
 613     them to true when the item is added, updated or deleted respectively
 614     (in case that it's deleted, it's not removed from the container,
 615     but it's not listed either).
 616     """
 617
 618     def __init__(self, parent, attr=None, cls=None):
 619         r"Initialize the object, see the class documentation for details."
 620         self.parent = parent
 621         if attr is not None:
 622             self._cont_subhandler_attr = attr
 623         if cls is not None:
 624             self._cont_subhandler_class = cls
 625
 626     def _cont(self):
 627         return getattr(self.parent, self._cont_subhandler_attr)
 628
 629     def _vcont(self):
 630         if isinstance(self._cont(), dict):
 631             return dict([(k, i) for (k, i) in self._cont().items()
 632                     if not hasattr(i, '_delete') or not i._delete])
 633         return [i for i in self._cont()
 634                 if not hasattr(i, '_delete') or not i._delete]
 635
 636     @handler(u'Add a new item')
 637     def add(self, *args, **kwargs):
 638         r"add(...) -> None :: Add an item to the list."
 639         item = self._cont_subhandler_class(*args, **kwargs)
 640         if hasattr(item, '_add'):
 641             item._add = True
 642         key = item
 643         if isinstance(self._cont(), dict):
 644             key = item.as_tuple()[0]
 645         # do we have the same item? then raise an error
 646         if key in self._vcont():
 647             raise ItemAlreadyExistsError(item)
 648         # do we have the same item, but logically deleted? then update flags
 649         if key in self._cont():
 650             index = key
 651             if not isinstance(self._cont(), dict):
 652                 index = self._cont().index(item)
 653             if hasattr(item, '_add'):
 654                 self._cont()[index]._add = False
 655             if hasattr(item, '_delete'):
 656                 self._cont()[index]._delete = False
 657         else: # it's *really* new
 658             if isinstance(self._cont(), dict):
 659                 self._cont()[key] = item
 660             else:
 661                 self._cont().append(item)
 662
 663     @handler(u'Update an item')
 664     def update(self, index, *args, **kwargs):
 665         r"update(index, ...) -> None :: Update an item of the container."
 666         # TODO make it right with metaclasses, so the method is not created
 667         # unless the update() method really exists.
 668         # TODO check if the modified item is the same of an existing one
 669         if not isinstance(self._cont(), dict):
 670             index = int(index) # TODO validation
 671         if not hasattr(self._cont_subhandler_class, 'update'):
 672             raise CommandNotFoundError(('update',))
 673         try:
 674             item = self._vcont()[index]
 675             item.update(*args, **kwargs)
 676             if hasattr(item, '_update'):
 677                 item._update = True
 678         except IndexError:
 679             raise ItemNotFoundError(index)
 680
 681     @handler(u'Delete an item')
 682     def delete(self, index):
 683         r"delete(index) -> None :: Delete an item of the container."
 684         if not isinstance(self._cont(), dict):
 685             index = int(index) # TODO validation
 686         try:
 687             item = self._vcont()[index]
 688             if hasattr(item, '_delete'):
 689                 item._delete = True
 690             else:
 691                 del self._cont()[index]
 692             return item
 693         except IndexError:
 694             raise ItemNotFoundError(index)
 695
 696     @handler(u'Get information about an item')
 697     def get(self, index):
 698         r"get(index) -> item :: List all the information of an item."
 699         if not isinstance(self._cont(), dict):
 700             index = int(index) # TODO validation
 701         try:
 702             return self._vcont()[index]
 703         except IndexError:
 704             raise ItemNotFoundError(index)
 705
 706     @handler(u'Get information about all items')
 707     def show(self):
 708         r"show() -> list of items :: List all the complete items information."
 709         if isinstance(self._cont(), dict):
 710             return self._cont().values()
 711         return self._vcont()
 712
 713 class ListSubHandler(ContainerSubHandler):
 714     r"""ListSubHandler(parent) -> ListSubHandler instance.
 715
 716     This is a helper class to inherit from to automatically handle subcommands
 717     that operates over a list parent attribute.
 718
 719     The list attribute to handle and the class of objects that it contains can
 720     be defined by calling the constructor or in a more declarative way as
 721     class attributes, like:
 722
 723     class TestHandler(ListSubHandler):
 724         _cont_subhandler_attr = 'some_list'
 725         _cont_subhandler_class = SomeClass
 726
 727     This way, the parent's some_list attribute (self.parent.some_list) will be
 728     managed automatically, providing the commands: add, update, delete, get,
 729     list and show. New items will be instances of SomeClass, which should
 730     provide a cmp operator to see if the item is on the list and an update()
 731     method, if it should be possible to modify it. If SomeClass has an _add,
 732     _update or _delete attribute, it set them to true when the item is added,
 733     updated or deleted respectively (in case that it's deleted, it's not
 734     removed from the list, but it's not listed either).
 735     """
 736
 737     @handler(u'Get how many items are in the list')
 738     def len(self):
 739         r"len() -> int :: Get how many items are in the list."
 740         return len(self._vcont())
 741
 742 class DictSubHandler(ContainerSubHandler):
 743     r"""DictSubHandler(parent) -> DictSubHandler instance.
 744
 745     This is a helper class to inherit from to automatically handle subcommands
 746     that operates over a dict parent attribute.
 747
 748     The dict attribute to handle and the class of objects that it contains can
 749     be defined by calling the constructor or in a more declarative way as
 750     class attributes, like:
 751
 752     class TestHandler(DictSubHandler):
 753         _cont_subhandler_attr = 'some_dict'
 754         _cont_subhandler_class = SomeClass
 755
 756     This way, the parent's some_dict attribute (self.parent.some_dict) will be
 757     managed automatically, providing the commands: add, update, delete, get,
 758     list and show. New items will be instances of SomeClass, which should
 759     provide a constructor with at least the key value, an as_tuple() method
 760     and an update() method,     if it should be possible to modify
 761     it. If SomeClass has an _add, _update or _delete attribute, it set
 762     them to true when the item is added, updated or deleted respectively
 763     (in case that it's deleted, it's not removed from the dict, but it's
 764     not listed either).
 765     """
 766
 767     @handler(u'List all the items by key')
 768     def list(self):
 769         r"list() -> tuple :: List all the item keys."
 770         return self._cont().keys()
 771
 772
 773 if __name__ == '__main__':
 774
 775     # Execution tests
 776     class STestHandler1(ServiceHandler):
 777         _service_start = ('service', 'start')
 778         _service_stop = ('service', 'stop')
 779         _service_restart = ('ls', '/')
 780         _service_reload = ('cp', '/la')
 781     class STestHandler2(ServiceHandler):
 782         def __init__(self):
 783             ServiceHandler.__init__(self, 'cmd-start', 'cmd-stop',
 784                                         'cmd-restart', 'cmd-reload')
 785     class ITestHandler1(InitdHandler):
 786         _initd_name = 'test1'
 787     class ITestHandler2(InitdHandler):
 788         def __init__(self):
 789             InitdHandler.__init__(self, 'test2', '/usr/local/etc/init.d')
 790     handlers = [
 791         STestHandler1(),
 792         STestHandler2(),
 793         ITestHandler1(),
 794         ITestHandler2(),
 795     ]
 796     for h in handlers:
 797         print h.__class__.__name__
 798         try:
 799             h.start()
 800         except ExecutionError, e:
 801             print e
 802         try:
 803             h.stop()
 804         except ExecutionError, e:
 805             print e
 806         try:
 807             h.restart()
 808         except ExecutionError, e:
 809             print e
 810         try:
 811             h.reload()
 812         except ExecutionError, e:
 813             print e
 814         print
 815
 816     # Persistent test
 817     print 'PTestHandler'
 818     class PTestHandler(Persistent):
 819         _persistent_attrs = 'vars'
 820         def __init__(self):
 821             self.vars = dict(a=1, b=2)
 822     h = PTestHandler()
 823     print h.vars
 824     h._dump()
 825     h.vars['x'] = 100
 826     print h.vars
 827     h._load()
 828     print h.vars
 829     h.vars['x'] = 100
 830     h._dump()
 831     print h.vars
 832     del h.vars['x']
 833     print h.vars
 834     h._load()
 835     print h.vars
 836     print
 837
 838     # Restorable test
 839     print 'RTestHandler'
 840     class RTestHandler(Restorable):
 841         _persistent_attrs = 'vars'
 842         _restorable_defaults = dict(vars=dict(a=1, b=2))
 843         def __init__(self):
 844             self._restore()
 845     h = RTestHandler()
 846     print h.vars
 847     h.vars['x'] = 100
 848     h._dump()
 849     h = RTestHandler()
 850     print h.vars
 851     print
 852
 853     # ConfigWriter test
 854     print 'CTestHandler'
 855     import os
 856     os.mkdir('templates')
 857     f = file('templates/config', 'w')
 858     f.write('Hello, ${name}! You are ${what}.')
 859     f.close()
 860     print 'template:'
 861     print file('templates/config').read()
 862     class CTestHandler(ConfigWriter):
 863         _config_writer_files = 'config'
 864         def __init__(self):
 865             self._config_build_templates()
 866         def _get_config_vars(self, config_file):
 867             return dict(name='you', what='a parrot')
 868     h = CTestHandler()
 869     h._write_config()
 870     print 'config:'
 871     print file('config').read()
 872     os.unlink('config')
 873     os.unlink('templates/config')
 874     os.rmdir('templates')
 875     print
 876