tiramisu/option.py

   1 # -*- coding: utf-8 -*-
   2 "option types and option description for the configuration management"
   3 # Copyright (C) 2012 Team tiramisu (see AUTHORS for all contributors)
   4 #
   5 # This program is free software; you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation; either version 2 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program; if not, write to the Free Software
  17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 #
  19 # The original `Config` design model is unproudly borrowed from
  20 # the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
  21 # the whole pypy projet is under MIT licence
  22 # ____________________________________________________________
  23 from tiramisu.autolib import special_owners
  24 from tiramisu.basetype import HiddenBaseType, DisabledBaseType, ModeBaseType, modes
  25 from tiramisu.error import (ConfigError, ConflictConfigError, NotFoundError,
  26                    SpecialOwnersError, RequiresError)
  27 available_actions = ['hide', 'show', 'enable', 'disable']
  28 reverse_actions = {'hide': 'show', 'show': 'hide',
  29                    'disable':'enable', 'enable': 'disable'}
  30 # ____________________________________________________________
  31 # OptionDescription authorized group_type values
  32 group_types = ['default', 'family', 'group', 'master']
  33 # multi types
  34
  35 class Multi(list):
  36     "container that support items for the values of list (multi) options"
  37     def __init__(self, lst, config, child):
  38         self.config = config
  39         self.child = child
  40         super(Multi, self).__init__(lst)
  41
  42     def __setitem__(self, key, value):
  43         return self.setoption(value, key)
  44
  45     def append(self, value):
  46         self.setoption(value)
  47
  48     def setoption(self, value, key=None):
  49         owners = self.child.getowner(self.config)
  50         # None is replaced by default_multi
  51         if value == None:
  52             defval = self.child.getdefault()
  53             if key is not None and len(defval) > key:
  54                 value = defval[key]
  55             else:
  56                 value = self.child.default_multi
  57             who = 'default'
  58         else:
  59             who = self.config._cfgimpl_owner
  60             if not self.child._validate(value):
  61                 raise ConfigError("invalid value {0} "
  62                     "for option {1}".format(str(value), self.child._name))
  63         oldvalue = list(self)
  64         oldowner = self.child.getowner(self.config)
  65         if key is None:
  66             ret = super(Multi, self).append(value)
  67             oldvalue.append(None)
  68             oldowner.append(who)
  69         else:
  70             ret = super(Multi, self).__setitem__(key, value)
  71             oldowner[key] = who
  72         self.config._cfgimpl_previous_values[self.child._name] = oldvalue
  73         self.child.setowner(self.config, oldowner)
  74         return ret
  75
  76     def pop(self, key):
  77         oldowner = self.child.getowner(self.config)
  78         oldowner.pop(key)
  79         self.child.setowner(self.config, oldowner)
  80         super(Multi, self).pop(key)
  81 # ____________________________________________________________
  82 #
  83 class Option(HiddenBaseType, DisabledBaseType, ModeBaseType):
  84     #reminder: an Option object is **not** a container for the value
  85     _frozen = False
  86     def __init__(self, name, doc, default=None, default_multi=None,
  87                  requires=None, mandatory=False, multi=False, callback=None,
  88                  callback_params=None, mode='normal'):
  89         self._name = name
  90         self.doc = doc
  91         self._requires = requires
  92         self._mandatory = mandatory
  93         self.multi = multi
  94         if not self.multi and default_multi is not None:
  95             raise ConfigError("a default_multi is set whereas multi is False"
  96                   " in option: {0}".format(name))
  97         if default_multi is not None and not self._validate(default_multi):
  98             raise ConfigError("invalid default_multi value {0} "
  99                 "for option {1}".format(str(default_multi), name))
 100         self.default_multi = default_multi
 101         #if self.multi and default_multi is None:
 102             # _cfgimpl_warnings[name] = DefaultMultiWarning
 103         if callback is not None and (default is not None or default_multi is not None):
 104             raise ConfigError("defaut values not allowed if option: {0}"
 105                 "is calculated".format(name))
 106         self.callback = callback
 107         if self.callback is None and callback_params is not None:
 108             raise ConfigError("params defined for a callback function but"
 109             " no callback defined yet for option {0}".format(name))
 110         self.callback_params = callback_params
 111         if mode not in modes:
 112             raise ConfigError("mode {0} not available".format(mode))
 113         self.mode = mode
 114         if self.multi == True:
 115             if default == None:
 116                 default = []
 117             if not isinstance(default, list) or not self.validate(default):
 118                 raise ConfigError("invalid default value {0} "
 119                 "for option {1} : not list type".format(str(default), name))
 120         else:
 121             if default != None and not self.validate(default):
 122                 raise ConfigError("invalid default value {0} "
 123                                          "for option {1}".format(str(default), name))
 124         self.default = default
 125
 126     def validate(self, value):
 127         if self.multi == False:
 128             # None allows the reset of the value
 129             if value != None:
 130                 return self._validate(value)
 131         else:
 132             if not isinstance(value, list):
 133                 raise ConfigError("invalid value {0} "
 134                         "for option {1} which must be a list".format(value,
 135                         self._name))
 136             for val in value:
 137                 if val != None:
 138                     # None allows the reset of the value
 139                     if not self._validate(val):
 140                         return False
 141         return True
 142
 143     def getdefault(self):
 144         return self.default
 145
 146     def getdoc(self):
 147         return self.doc
 148
 149     def getcallback(self):
 150         return self.callback
 151
 152     def getcallback_params(self):
 153         return self.callback_params
 154
 155     def setowner(self, config, owner):
 156         # config *must* be only the **parent** config (not the toplevel config)
 157         # owner is a **real* owner, a list is actually allowable here
 158         name = self._name
 159         if self._frozen:
 160             raise TypeError("trying to change a frozen option's owner: %s" % name)
 161         if owner in special_owners:
 162             if self.callback == None:
 163                 raise SpecialOwnersError("no callback specified for"
 164                                                       "option {0}".format(name))
 165         if self.is_multi():
 166             if not type(owner) == list:
 167                 raise ConfigError("invalid owner for multi "
 168                     "option: {0}".format(self._name))
 169         config._cfgimpl_value_owners[name] = owner
 170
 171     def getowner(self, config):
 172         # config *must* be only the **parent** config (not the toplevel config)
 173         return config._cfgimpl_value_owners[self._name]
 174
 175     def setoption(self, config, value, who):
 176         "who is **not necessarily** a owner because it cannot be a list"
 177         name = self._name
 178         if self._frozen:
 179             raise TypeError('trying to change a frozen option object: %s' % name)
 180         # we want the possibility to reset everything
 181         if who == "default" and value is None:
 182             self.default = None
 183             return
 184         if not self.validate(value):
 185             raise ConfigError('invalid value %s for option %s' % (value, name))
 186         if who == "default":
 187             # changes the default value (and therefore resets the previous value)
 188             if self._validate(value):
 189                 self.default = value
 190             else:
 191                 raise ConfigError("invalid value %s for option %s" % (value, name))
 192         apply_requires(self, config)
 193         # FIXME put the validation for the multi somewhere else
 194 #            # it is a multi **and** it has requires
 195 #            if self.multi == True:
 196 #                if type(value) != list:
 197 #                    raise TypeError("value {0} must be a list".format(value))
 198 #                if self._requires is not None:
 199 #                    for reqname in self._requires:
 200 #                        # FIXME : verify that the slaves are all multi
 201 #                        #option = getattr(config._cfgimpl_descr, reqname)
 202 #    #                    if not option.multi == True:
 203 #    #                        raise ConflictConfigError("an option with requires "
 204 #    #                         "has to be a list type : {0}".format(name))
 205 #                        if len(config._cfgimpl_values[reqname]) != len(value):
 206 #                            raise ConflictConfigError("an option with requires "
 207 #                             "has not the same length of the others "
 208 #                             "in the group : {0}".format(reqname))
 209         if type(config._cfgimpl_values[name]) == Multi:
 210             config._cfgimpl_previous_values[name] = list(config._cfgimpl_values[name])
 211         else:
 212             config._cfgimpl_previous_values[name] = config._cfgimpl_values[name]
 213         config._cfgimpl_values[name] = value
 214
 215     def getkey(self, value):
 216         return value
 217
 218     def freeze(self):
 219         self._frozen = True
 220         return True
 221
 222     def unfreeze(self):
 223         self._frozen = False
 224     # ____________________________________________________________
 225     def is_multi(self):
 226         return self.multi
 227
 228     def is_mandatory(self):
 229         return self._mandatory
 230
 231 class ChoiceOption(Option):
 232     opt_type = 'string'
 233
 234     def __init__(self, name, doc, values, default=None,
 235                  requires=None, callback=None, callback_params=None,
 236                  multi=False, mandatory=False, open_values=False):
 237         self.values = values
 238         if open_values not in [True, False]:
 239             raise ConfigError('Open_values must be a boolean for '
 240                               '{0}'.format(name))
 241         self.open_values = open_values
 242         super(ChoiceOption, self).__init__(name, doc, default=default,
 243                            callback=callback, callback_params=callback_params,
 244                            requires=requires, multi=multi, mandatory=mandatory)
 245
 246     def setoption(self, config, value, who):
 247         name = self._name
 248         super(ChoiceOption, self).setoption(config, value, who)
 249
 250     def _validate(self, value):
 251         if not self.open_values:
 252             return value is None or value in self.values
 253         else:
 254             return True
 255
 256 class BoolOption(Option):
 257     opt_type = 'bool'
 258
 259 #    def __init__(self, name, doc, default=None, requires=None,
 260 #                                  validator=None, multi=False, mandatory=False):
 261 #        super(BoolOption, self).__init__(name, doc, default=default,
 262 #                            requires=requires, multi=multi, mandatory=mandatory)
 263         #self._validator = validator
 264
 265     def _validate(self, value):
 266         return isinstance(value, bool)
 267
 268 # FIXME config level validator
 269 #    def setoption(self, config, value, who):
 270 #        name = self._name
 271 #        if value and self._validator is not None:
 272 #            toplevel = config._cfgimpl_get_toplevel()
 273 #            self._validator(toplevel)
 274 #        super(BoolOption, self).setoption(config, value, who)
 275
 276 class IntOption(Option):
 277     opt_type = 'int'
 278
 279     def _validate(self, value):
 280         try:
 281             int(value)
 282         except TypeError:
 283             return False
 284         return True
 285
 286     def setoption(self, config, value, who):
 287         try:
 288             super(IntOption, self).setoption(config, value, who)
 289         except TypeError, e:
 290             raise ConfigError(*e.args)
 291
 292 class FloatOption(Option):
 293     opt_type = 'float'
 294
 295     def _validate(self, value):
 296         try:
 297             float(value)
 298         except TypeError:
 299             return False
 300         return True
 301
 302     def setoption(self, config, value, who):
 303         try:
 304             super(FloatOption, self).setoption(config, float(value), who)
 305         except TypeError, e:
 306             raise ConfigError(*e.args)
 307
 308 class StrOption(Option):
 309     opt_type = 'string'
 310
 311     def _validate(self, value):
 312         return isinstance(value, str)
 313
 314     def setoption(self, config, value, who):
 315         try:
 316             super(StrOption, self).setoption(config, value, who)
 317         except TypeError, e:
 318             raise ConfigError(*e.args)
 319
 320 class SymLinkOption(object): #(HiddenBaseType, DisabledBaseType):
 321     opt_type = 'symlink'
 322
 323     def __init__(self, name, path):
 324         self._name = name
 325         self.path = path
 326
 327     def setoption(self, config, value, who):
 328         try:
 329             setattr(config, self.path, value) # .setoption(self.path, value, who)
 330         except TypeError, e:
 331             raise ConfigError(*e.args)
 332
 333 class IPOption(Option):
 334     opt_type = 'ip'
 335
 336     def _validate(self, value):
 337         # by now the validation is nothing but a string, use IPy instead
 338         return isinstance(value, str)
 339
 340     def setoption(self, config, value, who):
 341         try:
 342             super(IPOption, self).setoption(config, value, who)
 343         except TypeError, e:
 344             raise ConfigError(*e.args)
 345
 346 class NetmaskOption(Option):
 347     opt_type = 'netmask'
 348
 349     def _validate(self, value):
 350         # by now the validation is nothing but a string, use IPy instead
 351         return isinstance(value, str)
 352
 353     def setoption(self, config, value, who):
 354         try:
 355             super(NetmaskOption, self).setoption(config, value, who)
 356         except TypeError, e:
 357             raise ConfigError(*e.args)
 358
 359 class ArbitraryOption(Option):
 360     def __init__(self, name, doc, default=None, defaultfactory=None,
 361                                    requires=None, multi=False, mandatory=False):
 362         super(ArbitraryOption, self).__init__(name, doc, requires=requires,
 363                                                multi=multi, mandatory=mandatory)
 364         self.defaultfactory = defaultfactory
 365         if defaultfactory is not None:
 366             assert default is None
 367
 368     def _validate(self, value):
 369         return True
 370
 371     def getdefault(self):
 372         if self.defaultfactory is not None:
 373             return self.defaultfactory()
 374         return self.default
 375
 376 class OptionDescription(HiddenBaseType, DisabledBaseType, ModeBaseType):
 377     group_type = 'default'
 378
 379     def __init__(self, name, doc, children, requires=None):
 380         self._name = name
 381         self.doc = doc
 382         self._children = children
 383         self._requires = requires
 384         self._build()
 385
 386     def getdoc(self):
 387         return self.doc
 388
 389     def _build(self):
 390         for child in self._children:
 391             setattr(self, child._name, child)
 392
 393     def add_child(self, child):
 394         "dynamically adds a configuration option"
 395         #Nothing is static. Even the Mona Lisa is falling apart.
 396         for ch in self._children:
 397             if isinstance(ch, Option):
 398                 if child._name == ch._name:
 399                     raise ConflictConfigError("existing option : {0}".format(
 400                                                                    child._name))
 401         self._children.append(child)
 402         setattr(self, child._name, child)
 403
 404     def update_child(self, child):
 405         "modification of an existing option"
 406         # XXX : corresponds to the `redefine`, is it usefull
 407         pass
 408
 409     def getkey(self, config):
 410         return tuple([child.getkey(getattr(config, child._name))
 411                       for child in self._children])
 412
 413     def getpaths(self, include_groups=False, currpath=None):
 414         """returns a list of all paths in self, recursively
 415            currpath should not be provided (helps with recursion)
 416         """
 417         if currpath is None:
 418             currpath = []
 419         paths = []
 420         for option in self._children:
 421             attr = option._name
 422             if attr.startswith('_cfgimpl'):
 423                 continue
 424             value = getattr(self, attr)
 425             if isinstance(value, OptionDescription):
 426                 if include_groups:
 427                     paths.append('.'.join(currpath + [attr]))
 428                 currpath.append(attr)
 429                 paths += value.getpaths(include_groups=include_groups,
 430                                         currpath=currpath)
 431                 currpath.pop()
 432             else:
 433                 paths.append('.'.join(currpath + [attr]))
 434         return paths
 435     # ____________________________________________________________
 436
 437     def set_group_type(self, group_type):
 438         if group_type in group_types:
 439             self.group_type = group_type
 440         else:
 441             raise ConfigError('not allowed value for group_type : {0}'.format(
 442                               group_type))
 443
 444     def get_group_type(self):
 445         return self.group_type
 446     # ____________________________________________________________
 447     def hide(self):
 448         super(OptionDescription, self).hide()
 449         # FIXME : AND THE SUBCHILDREN ?
 450         for child in self._children:
 451             if isinstance(child, OptionDescription):
 452                 child.hide()
 453
 454     def show(self):
 455         # FIXME : AND THE SUBCHILDREN ??
 456         super(OptionDescription, self).show()
 457         for child in self._children:
 458             if isinstance(child, OptionDescription):
 459                 child.show()
 460     # ____________________________________________________________
 461     def disable(self):
 462         super(OptionDescription, self).disable()
 463         # FIXME : AND THE SUBCHILDREN ?
 464         for child in self._children:
 465             if isinstance(child, OptionDescription):
 466                 child.disable()
 467
 468     def enable(self):
 469         # FIXME : AND THE SUBCHILDREN ?
 470         super(OptionDescription, self).enable()
 471         for child in self._children:
 472             if isinstance(child, OptionDescription):
 473                 child.enable()
 474 # ____________________________________________________________
 475 def apply_requires(opt, config):
 476     if hasattr(opt, '_requires'):
 477         if opt._requires is not None:
 478             # malformed requirements
 479             rootconfig = config._cfgimpl_get_toplevel()
 480             for req in opt._requires:
 481                 if not type(req) == tuple and len(req) in (3, 4):
 482                     raise RequiresError("malformed requirements for option:"
 483                                                    " {0}".format(opt._name))
 484             # all actions **must** be identical
 485             actions = [req[2] for req in opt._requires]
 486             action = actions[0]
 487             for act in actions:
 488                 if act != action:
 489                     raise RequiresError("malformed requirements for option:"
 490                                                    " {0}".format(opt._name))
 491             # filters the callbacks
 492             matches = False
 493             for req in opt._requires:
 494                 if len(req) == 3:
 495                     name, expected, action = req
 496                     inverted = False
 497                 if len(req) == 4:
 498                     name, expected, action, inverted = req
 499                     if inverted == 'inverted':
 500                         inverted = True
 501                 homeconfig, shortname = \
 502                                       rootconfig._cfgimpl_get_home_by_path(name)
 503                 # FIXME: doesn't work with 'auto' or 'fill' yet
 504                 # (copy the code from the __getattr__
 505                 if shortname in homeconfig._cfgimpl_values:
 506                     value = homeconfig._cfgimpl_values[shortname]
 507                     if (not inverted and value == expected) or \
 508                             (inverted and value != expected):
 509                         if action not in available_actions:
 510                             raise RequiresError("malformed requirements"
 511                                            " for option: {0}".format(opt._name))
 512                         getattr(opt, action)() #.hide() or show() or...
 513                         matches = True
 514                 else: # option doesn't exist ! should not happen...
 515                     raise NotFoundError("required option not found: "
 516                                                              "{0}".format(name))
 517             # no callback has been triggered, then just reverse the action
 518             if not matches:
 519                 getattr(opt, reverse_actions[action])()
 520