recursive requirements are detected now
[tiramisu.git] / 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, RequirementRecursionError)
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                 path = config._cfgimpl_get_path() + '.' + opt._name
502                 if name.startswith(path):
503                     raise RequirementRecursionError("malformed requirements imbrication "
504                           "detected for option: '{0}' with requirement on: '{1}'".format(path, name))
505                 homeconfig, shortname = \
506                                       rootconfig._cfgimpl_get_home_by_path(name)
507                 # FIXME: doesn't work with 'auto' or 'fill' yet 
508                 # (copy the code from the __getattr__
509                 if shortname in homeconfig._cfgimpl_values:
510                     value = homeconfig._cfgimpl_values[shortname]
511                     if (not inverted and value == expected) or \
512                             (inverted and value != expected):
513                         if action not in available_actions:
514                             raise RequiresError("malformed requirements"
515                                            " for option: {0}".format(opt._name))
516                         getattr(opt, action)() #.hide() or show() or...
517                         matches = True
518                 else: # option doesn't exist ! should not happen...
519                     raise NotFoundError("required option not found: "
520                                                              "{0}".format(name))
521             # no callback has been triggered, then just reverse the action
522             if not matches:
523                 getattr(opt, reverse_actions[action])()
524