874 lines
38 KiB
Python
874 lines
38 KiB
Python
"""creole loader
|
|
flattened XML specific
|
|
"""
|
|
from os.path import join, isfile, isdir
|
|
from os import listdir
|
|
#from ast import literal_eval
|
|
from lxml.etree import parse, DTD
|
|
|
|
from tiramisu.option import (UnicodeOption, OptionDescription, PortOption,
|
|
IntOption, ChoiceOption, BoolOption, SymLinkOption, IPOption,
|
|
NetworkOption, NetmaskOption, DomainnameOption, BroadcastOption,
|
|
URLOption, EmailOption, FilenameOption, UsernameOption, DateOption,
|
|
PasswordOption, BoolOption, Leadership)
|
|
from tiramisu import Config, MetaConfig, MixConfig
|
|
from tiramisu.setting import groups
|
|
from tiramisu.error import ConfigError
|
|
from tiramisu.setting import owners
|
|
from tiramisu import Params, ParamOption, ParamValue, ParamContext
|
|
|
|
from .config import (FLATTENED_CREOLE_DIR, dtdfilename, eoledirs, eoleextradico, forbiddenextra,
|
|
configeol, eoleextraconfig)
|
|
from .i18n import _
|
|
from .var_loader import convert_tiramisu_value, modes_level, MACOption # FIXME YO
|
|
from .loader1 import load_config_eol, load_extras, _list_extras
|
|
#For compatibility
|
|
from .loader1 import config_save_values, config_load_store, config_get_values, add_eol_version
|
|
from .loader1 import load_store, load_config_store, load_values
|
|
from .xmlreflector import HIGH_COMPATIBILITY
|
|
#from . import eosfunc
|
|
from .objspace import CreoleObjSpace
|
|
import imp
|
|
|
|
|
|
class CreoleLoaderError(Exception):
|
|
pass
|
|
|
|
CONVERT_OPTION = {'number': dict(opttype=IntOption),
|
|
'choice': dict(opttype=ChoiceOption),
|
|
'string': dict(opttype=UnicodeOption),
|
|
'password': dict(opttype=PasswordOption),
|
|
'mail': dict(opttype=EmailOption),
|
|
'boolean': dict(opttype=BoolOption),
|
|
'symlink': dict(opttype=SymLinkOption),
|
|
'filename': dict(opttype=FilenameOption),
|
|
'date': dict(opttype=DateOption),
|
|
'unix_user': dict(opttype=UsernameOption),
|
|
'ip': dict(opttype=IPOption, initkwargs={'allow_reserved': True}),
|
|
'local_ip': dict(opttype=IPOption, initkwargs={'private_only': True, 'warnings_only': True}),
|
|
'netmask': dict(opttype=NetmaskOption),
|
|
'network': dict(opttype=NetworkOption),
|
|
'broadcast': dict(opttype=BroadcastOption),
|
|
'netbios': dict(opttype=DomainnameOption, initkwargs={'type_': 'netbios', 'warnings_only': True}),
|
|
'domain': dict(opttype=DomainnameOption, initkwargs={'type_': 'domainname', 'allow_ip': True, 'allow_without_dot': True}),
|
|
'domain_strict': dict(opttype=DomainnameOption, initkwargs={'type_': 'domainname', 'allow_ip': False}),
|
|
'hostname': dict(opttype=DomainnameOption, initkwargs={'type_': 'hostname', 'allow_ip': True}),
|
|
'hostname_strict': dict(opttype=DomainnameOption, initkwargs={'type_': 'hostname', 'allow_ip': False}),
|
|
'web_address': dict(opttype=URLOption, initkwargs={'allow_ip': True, 'allow_without_dot': True}),
|
|
'port': dict(opttype=PortOption, initkwargs={'allow_private': True}),
|
|
'mac': dict(opttype=MACOption) # FIXME YO
|
|
}
|
|
|
|
|
|
REMOVED_ATTRIB = ['path', 'type']
|
|
|
|
|
|
class Elt(object):
|
|
def __init__(self, attrib):
|
|
self.attrib = attrib
|
|
|
|
|
|
class PopulateTiramisuObjects(object):
|
|
def __init__(self):
|
|
self.storage = ElementStorage()
|
|
self.booleans = []
|
|
self.force_store_values = set()
|
|
self.separators = {}
|
|
self.groups = {}
|
|
|
|
def parse_dtd(self, dtdfilename):
|
|
"""Loads the Creole DTD
|
|
|
|
:raises IOError: if the DTD is not found
|
|
|
|
:param dtdfilename: the full filename of the Creole DTD
|
|
"""
|
|
if not isfile(dtdfilename):
|
|
raise IOError(_("no such DTD file: {}").format(dtdfilename))
|
|
with open(dtdfilename, 'r') as dtdfd:
|
|
dtd = DTD(dtdfd)
|
|
for elt in dtd.iterelements():
|
|
if elt.name == 'variable':
|
|
for attr in elt.iterattributes():
|
|
if set(attr.itervalues()) == set(['True', 'False']):
|
|
self.booleans.append(attr.name)
|
|
|
|
def make_tiramisu_objects(self, xmlroot, creolefunc_file, load_extra=True):
|
|
elt = Elt({'name': 'baseoption'})
|
|
family = Family(elt, self.booleans)
|
|
self.storage.add('.', family)
|
|
self.eosfunc = imp.load_source('eosfunc', creolefunc_file)
|
|
|
|
elts = {}
|
|
for elt in xmlroot:
|
|
elts.setdefault(elt.tag, []).append(elt)
|
|
list_elts = list(elts.keys())
|
|
if 'family' in list_elts:
|
|
list_elts.remove('family')
|
|
list_elts.insert(0, 'family')
|
|
for elt in list_elts:
|
|
xmlelts_ = elts[elt]
|
|
if elt == 'family':
|
|
xmlelts = []
|
|
actions = None
|
|
# `creole` family has to be loaded before any other family
|
|
# because `extra` family could use `creole` variables.
|
|
# `actions` family has to be loaded at the very end
|
|
# because it may use `creole` or `extra` variables
|
|
for xml in xmlelts_:
|
|
if not load_extra and xml.attrib['name'] not in ['creole', 'containers']:
|
|
continue
|
|
if xml.attrib['name'] == 'creole':
|
|
xmlelts.insert(0, xml)
|
|
elif xml.attrib['name'] == 'actions':
|
|
actions = xml
|
|
else:
|
|
xmlelts.append(xml)
|
|
if actions is not None:
|
|
xmlelts.append(actions)
|
|
else:
|
|
xmlelts = xmlelts_
|
|
for xmlelt in xmlelts:
|
|
if xmlelt.tag == 'family':
|
|
self._iter_family(xmlelt, family=family)
|
|
elif xmlelt.tag == 'help':
|
|
self._iter_help(xmlelt)
|
|
elif xmlelt.tag == 'constraints':
|
|
self._iter_constraints(xmlelt, load_extra)
|
|
else:
|
|
raise CreoleLoaderError(_('unknown tag {}').format(xmlelt.tag))
|
|
|
|
def _populate_variable(self, elt, subpath, is_slave, is_master):
|
|
variable = Variable(elt, self.booleans, self.storage, is_slave, is_master, self.eosfunc)
|
|
path = self._build_path(subpath, elt)
|
|
properties = variable.attrib.get('properties', [])
|
|
if 'force_store_value' in properties or "auto_freeze" in properties:
|
|
self.force_store_values.add(path)
|
|
self.storage.add(path, variable)
|
|
return variable
|
|
|
|
def _populate_family(self, elt, subpath):
|
|
if subpath is None:
|
|
force_icon = False
|
|
else:
|
|
force_icon = not subpath.startswith('containers') and not subpath.startswith('actions')
|
|
family = Family(elt, self.booleans, force_icon)
|
|
path = self._build_path(subpath, elt)
|
|
self.storage.add(path, family)
|
|
return family
|
|
|
|
def _build_path(self, subpath, elt):
|
|
if subpath is None:
|
|
subpath = elt.attrib['name']
|
|
else:
|
|
subpath += '.' + elt.attrib['name']
|
|
return subpath
|
|
|
|
def _iter_constraints(self, xmlelt, load_extra):
|
|
for elt in xmlelt:
|
|
if elt.tag == 'fill':
|
|
self._parse_fill(elt, load_extra)
|
|
elif elt.tag == 'condition':
|
|
self._parse_condition(elt, load_extra)
|
|
elif elt.tag == 'check':
|
|
self._parse_check(elt, load_extra)
|
|
else:
|
|
raise CreoleLoaderError(_('unknown constraint {}').format(elt.tag))
|
|
|
|
def _check_extra(self, variable, load_extra):
|
|
if load_extra:
|
|
return True
|
|
return variable.startswith('creole.') or variable.startswith('containers.')
|
|
|
|
|
|
def _parse_fill(self, elt, load_extra):
|
|
if not self._check_extra(elt.attrib['target'], load_extra):
|
|
return
|
|
callback = getattr(self.eosfunc, elt.attrib['name'])
|
|
callback_params = {}
|
|
for param in elt:
|
|
name = param.attrib.get('name', '')
|
|
if param.attrib['type'] == 'string':
|
|
value = str(param.text)
|
|
elif param.attrib['type'] == 'eole':
|
|
hidden = param.attrib['hidden']
|
|
if hidden == 'True':
|
|
hidden = False
|
|
elif hidden == 'False':
|
|
hidden = True
|
|
else:
|
|
raise CreoleLoaderError(_('unknown hidden boolean {}').format(hidden))
|
|
if not self._check_extra(param.text, load_extra):
|
|
return
|
|
value = [self.storage.get(param.text), hidden]
|
|
elif param.attrib['type'] == 'number':
|
|
value = int(param.text)
|
|
elif param.attrib['type'] == 'context':
|
|
value = (None,)
|
|
else:
|
|
raise CreoleLoaderError(_('unknown param type {} in fill to {}').format(param.attrib['type'], elt.attrib['target']))
|
|
callback_params.setdefault(name, []).append(value)
|
|
if callback_params == {}:
|
|
callback_params = None
|
|
self.storage.add_callback(elt.attrib['target'], callback, callback_params)
|
|
|
|
def _parse_check(self, elt, load_extra):
|
|
if not self._check_extra(elt.attrib['target'], load_extra):
|
|
return
|
|
all_param_eole = True
|
|
for param in elt:
|
|
if param.attrib.get('type') != 'eole':
|
|
all_param_eole = False
|
|
break
|
|
if elt.attrib['name'] == 'valid_enum':
|
|
# only for valid_enum with checkval to True
|
|
if len(elt) != 1:
|
|
raise CreoleLoaderError(_('valid_enum cannot have more than one param for {}').format(elt.attrib['target']))
|
|
if elt.attrib['probe'] == 'True':
|
|
proposed = elt[0].text
|
|
type_ = 'string'
|
|
elif elt[0].attrib['type'] == 'eole':
|
|
proposed = elt[0].text
|
|
type_ = 'eole'
|
|
else:
|
|
#proposed_value = literal_eval(elt[0].text)
|
|
proposed_value = eval(elt[0].text)
|
|
proposed = tuple(proposed_value)
|
|
type_ = 'string'
|
|
self.storage.add_information(elt.attrib['target'], 'proposed_value', {'value': proposed, 'type': type_})
|
|
|
|
validator = getattr(self.eosfunc, elt.attrib['name'])
|
|
elif elt.attrib['name'] == 'valid_differ' and all_param_eole:
|
|
if (HIGH_COMPATIBILITY and len(elt) not in [0, 1]) or (not HIGH_COMPATIBILITY and len(elt) != 1):
|
|
raise CreoleLoaderError(_('valid_differ length should be 1'))
|
|
if HIGH_COMPATIBILITY and len(elt) == 1:
|
|
if not self._check_extra(elt[0].text, load_extra):
|
|
return
|
|
variables = [self.storage.get(elt[0].text)]
|
|
else:
|
|
variables = []
|
|
self.storage.add_consistency(elt.attrib['target'],
|
|
'not_equal',
|
|
variables,
|
|
elt.attrib['warnings_only'],
|
|
elt.attrib['transitive'])
|
|
elif elt.attrib['name'] == 'valid_networknetmask':
|
|
if len(elt) != 1:
|
|
raise CreoleLoaderError(_('valid_networknetmask length should be 1'))
|
|
if not all_param_eole:
|
|
raise CreoleLoaderError(_('valid_networknetmask must have only eole variable'))
|
|
variables = [self.storage.get(elt[0].text)]
|
|
self.storage.add_consistency(elt.attrib['target'],
|
|
'network_netmask',
|
|
variables,
|
|
elt.attrib['warnings_only'],
|
|
elt.attrib['transitive'])
|
|
elif elt.attrib['name'] == 'valid_ipnetmask':
|
|
if len(elt) != 1:
|
|
raise CreoleLoaderError(_('valid_ipnetmask length should be 1'))
|
|
if not all_param_eole:
|
|
raise CreoleLoaderError(_('valid_ipnetmask must have only eole variable'))
|
|
if not self._check_extra(elt[0].text, load_extra):
|
|
return
|
|
variables = [self.storage.get(elt[0].text)]
|
|
self.storage.add_consistency(elt.attrib['target'],
|
|
'ip_netmask',
|
|
variables,
|
|
elt.attrib['warnings_only'],
|
|
elt.attrib['transitive'])
|
|
elif elt.attrib['name'] == 'valid_broadcast':
|
|
if len(elt) != 2:
|
|
raise CreoleLoaderError(_('valid_broadcast length should be 2'))
|
|
if not all_param_eole:
|
|
raise CreoleLoaderError(_('valid_broadcast must have only eole variable'))
|
|
if not self._check_extra(elt[0].text, load_extra):
|
|
return
|
|
variables = [self.storage.get(elt[0].text)]
|
|
if not self._check_extra(elt[1].text, load_extra):
|
|
return
|
|
variables.append(self.storage.get(elt[1].text))
|
|
self.storage.add_consistency(elt.attrib['target'],
|
|
'broadcast',
|
|
variables,
|
|
elt.attrib['warnings_only'],
|
|
elt.attrib['transitive'])
|
|
elif elt.attrib['name'] == 'valid_in_network':
|
|
if len(elt) != 2:
|
|
raise CreoleLoaderError(_('valid_in_network length should be 2'))
|
|
if not all_param_eole:
|
|
raise CreoleLoaderError(_('valid_in_network must have only eole variable'))
|
|
if not self._check_extra(elt[0].text, load_extra):
|
|
return
|
|
variables = [self.storage.get(elt[0].text)]
|
|
if not self._check_extra(elt[1].text, load_extra):
|
|
return
|
|
variables.append(self.storage.get(elt[1].text))
|
|
self.storage.add_consistency(elt.attrib['target'],
|
|
'in_network',
|
|
variables,
|
|
elt.attrib['warnings_only'],
|
|
elt.attrib['transitive'])
|
|
else:
|
|
validator = getattr(self.eosfunc, elt.attrib['name'])
|
|
validator_params = {}
|
|
for param in elt:
|
|
text = param.text
|
|
if param.attrib['type'] == 'eole':
|
|
hidden = param.attrib.get('hidden', 'True')
|
|
if hidden == 'True':
|
|
hidden = False
|
|
elif hidden == 'False':
|
|
hidden = True
|
|
else:
|
|
raise CreoleLoaderError(_('unknown hidden boolean {}').format(hidden))
|
|
if not self._check_extra(text, load_extra):
|
|
return
|
|
text = [self.storage.get(text), hidden]
|
|
validator_params.setdefault(param.attrib.get('name', ''), []).append(text)
|
|
self.storage.add_validator(elt.attrib['target'], validator, validator_params)
|
|
|
|
def _parse_condition(self, elt, load_extra):
|
|
if not self._check_extra(elt.attrib['source'], load_extra):
|
|
return
|
|
if elt.attrib['name'] == 'disabled_if_in':
|
|
actions = ['disabled']
|
|
inverse = False
|
|
elif elt.attrib['name'] == 'disabled_if_not_in':
|
|
actions = ['disabled']
|
|
inverse = True
|
|
elif elt.attrib['name'] == 'auto_frozen_if_in':
|
|
actions = ['frozen']
|
|
inverse = False
|
|
elif elt.attrib['name'] == 'frozen_if_in':
|
|
actions = ['frozen', 'hidden', 'force_default_on_freeze']
|
|
inverse = False
|
|
elif elt.attrib['name'] == 'frozen_if_not_in':
|
|
actions = ['frozen', 'hidden', 'force_default_on_freeze']
|
|
inverse = True
|
|
elif elt.attrib['name'] == 'mandatory_if_in':
|
|
actions = ['mandatory']
|
|
inverse = False
|
|
elif elt.attrib['name'] == 'mandatory_if_not_in':
|
|
actions = ['mandatory']
|
|
inverse = True
|
|
else:
|
|
raise CreoleLoaderError(_('unknown condition type {} for {}').format(elt.attrib['name'], elt.attrib['source']))
|
|
expected_values = []
|
|
options = []
|
|
for param in elt:
|
|
if param.tag == 'param':
|
|
expected_values.append(param.text)
|
|
elif param.tag == 'target':
|
|
if param.attrib['type'] in ['variable', 'family']:
|
|
if not self._check_extra(param.text, load_extra):
|
|
return
|
|
option = self.storage.get(param.text)
|
|
option_actions = actions
|
|
if 'force_store_value' in option.attrib.get('properties', []) and \
|
|
'force_default_on_freeze' in option_actions:
|
|
option_actions.remove('force_default_on_freeze')
|
|
options.append((param.text, option_actions))
|
|
source = self.storage.get(elt.attrib['source'])
|
|
for option, actions in options:
|
|
conditions = []
|
|
for action in actions:
|
|
for expected in expected_values:
|
|
conditions.append({'option': source, 'expected': expected,
|
|
'action': action, 'inverse': inverse})
|
|
self.storage.add_requires(option, conditions)
|
|
|
|
def _iter_help(self, xmlelt):
|
|
for elt in xmlelt:
|
|
self.storage.add_help(elt.attrib['name'], elt.text)
|
|
|
|
def _iter_master(self, master, subpath):
|
|
subpath = self._build_path(subpath, master)
|
|
family = Family(master, self.booleans)
|
|
family.set_master()
|
|
self.storage.add(subpath, family)
|
|
master_name = None
|
|
for var in master:
|
|
if master_name is None:
|
|
master_name = var.attrib['name']
|
|
self.groups[master_name] = []
|
|
else:
|
|
self.groups[master_name].append(var.attrib['name'])
|
|
self._iter_family(var, subpath=subpath, family=family)
|
|
return family
|
|
|
|
def _iter_family(self, child, subpath=None, family=None):
|
|
if child.tag not in ['family', 'variable', 'separators', 'master']:
|
|
raise CreoleLoaderError(_('unknown tag {}').format(child.tag))
|
|
if child.tag == 'family':
|
|
old_family = family
|
|
family = self._populate_family(child, subpath)
|
|
if old_family is not None:
|
|
old_family.add(family)
|
|
if child.tag == 'master':
|
|
master = self._iter_master(child, subpath)
|
|
family.add(master)
|
|
elif child.tag == 'separators':
|
|
self._parse_separators(child)
|
|
elif child.tag == 'variable':
|
|
if family is None:
|
|
raise CreoleLoaderError(_('variable without family'))
|
|
|
|
is_slave = False
|
|
is_master = False
|
|
if family.is_master:
|
|
if child.attrib['name'] != family.attrib['name']:
|
|
is_slave = True
|
|
else:
|
|
is_master = True
|
|
variable = self._populate_variable(child, subpath, is_slave, is_master)
|
|
family.add(variable)
|
|
elif len(child) != 0:
|
|
subpath = self._build_path(subpath, child)
|
|
for c in child:
|
|
self._iter_family(c, subpath, family)
|
|
|
|
def _parse_separators(self, separators):
|
|
for separator in separators:
|
|
elt = self.storage.get(separator.attrib['name'])
|
|
never_hidden = separator.attrib.get('never_hidden')
|
|
if never_hidden == 'True':
|
|
never_hidden = True
|
|
else:
|
|
never_hidden = None
|
|
info = (separator.text, never_hidden)
|
|
self.separators[separator.attrib['name']] = info
|
|
elt.add_information('separator', info)
|
|
|
|
def build(self, persistent=False, session_id=None, meta_config=False):
|
|
if meta_config:
|
|
optiondescription = self.storage.paths['.'].get()
|
|
config = MetaConfig([],
|
|
optiondescription=optiondescription,
|
|
persistent=persistent,
|
|
session_id=session_id)
|
|
mixconfig = MixConfig(children=[],
|
|
optiondescription=optiondescription,
|
|
persistent=persistent,
|
|
session_id='m_' + session_id)
|
|
config.config.add(mixconfig)
|
|
else:
|
|
config = Config(self.storage.paths['.'].get(),
|
|
persistent=persistent,
|
|
session_id=session_id)
|
|
config.information.set('force_store_vars', self.force_store_values)
|
|
config.information.set('force_store_values', list(self.force_store_values))
|
|
# XXX really usefull?
|
|
ro_append = frozenset(config.property.getdefault('read_only', 'append') - {'force_store_value'})
|
|
rw_append = frozenset(config.property.getdefault('read_write', 'append') - {'force_store_value'})
|
|
config.property.setdefault(ro_append, 'read_only', 'append')
|
|
config.property.setdefault(rw_append, 'read_write', 'append')
|
|
|
|
config.property.read_only()
|
|
_modes = list(modes_level)
|
|
_modes.append('hidden')
|
|
config.permissive.set(frozenset(_modes))
|
|
return config
|
|
|
|
|
|
class ElementStorage(object):
|
|
def __init__(self):
|
|
self.paths = {}
|
|
|
|
def add(self, path, elt):
|
|
if path in self.paths:
|
|
raise CreoleLoaderError(_('path already loaded {}').format(path))
|
|
self.paths[path] = elt
|
|
|
|
def add_help(self, path, text):
|
|
elt = self.get(path)
|
|
self.paths[path].add_information('help', text)
|
|
|
|
def add_callback(self, path, callback, callback_params):
|
|
elt = self.get(path)
|
|
elt.add_callback(callback, callback_params)
|
|
|
|
def add_information(self, path, name, information):
|
|
elt = self.get(path)
|
|
elt.add_information(name, information)
|
|
|
|
def add_validator(self, path, validator, validator_params):
|
|
elt = self.get(path)
|
|
elt.add_validator(validator, validator_params)
|
|
|
|
def add_consistency(self, path, consistence, variables, warnings_only, transitive):
|
|
elt = self.get(path)
|
|
elt.add_consistency(consistence, variables, warnings_only, transitive)
|
|
|
|
def add_requires(self, path, requires):
|
|
elt = self.get(path)
|
|
elt.add_requires(requires)
|
|
|
|
def get(self, path):
|
|
if path not in self.paths:
|
|
raise CreoleLoaderError(_('there is no element for path {}').format(path))
|
|
return self.paths[path]
|
|
|
|
|
|
class Variable(object):
|
|
def __init__(self, elt, booleans, storage, is_slave, is_master, eosfunc):
|
|
self.option = None
|
|
self.informations = {}
|
|
self.attrib = {}
|
|
self.callbacks = []
|
|
self.requires = []
|
|
self.validator = None
|
|
self.consistencies = []
|
|
self.attrib['properties'] = []
|
|
self.eosfunc = eosfunc
|
|
for key, value in elt.attrib.items():
|
|
if key in REMOVED_ATTRIB:
|
|
continue
|
|
#if key != 'name':
|
|
# value = unicode(value)
|
|
|
|
if key in booleans:
|
|
if value == 'True':
|
|
value = True
|
|
elif value == 'False':
|
|
value = False
|
|
else:
|
|
raise CreoleLoaderError(_('unknown value {} for {}').format(value, key))
|
|
self.attrib[key] = value
|
|
convert_option = CONVERT_OPTION[elt.attrib['type']]
|
|
self.object_type = convert_option['opttype']
|
|
if elt.attrib['type'] == 'choice':
|
|
if self.attrib.get('choice'):
|
|
self.attrib['values'] = getattr(self.eosfunc, self.attrib.get('choice'))
|
|
else:
|
|
self.attrib['values'] = []
|
|
for child in elt:
|
|
if child.tag == 'choice':
|
|
value = child.text
|
|
if 'type' in child.attrib and child.attrib['type'] == 'number':
|
|
value = int(value)
|
|
if value is None:
|
|
value = u''
|
|
self.attrib['values'].append(value)
|
|
self.attrib['values'] = tuple(self.attrib['values'])
|
|
for child in elt:
|
|
if "type" in child.attrib:
|
|
type_ = CONVERT_OPTION[child.attrib['type']]['opttype']
|
|
else:
|
|
type_ = self.object_type
|
|
if child.tag == 'property':
|
|
self.attrib['properties'].append(child.text)
|
|
elif child.tag == 'value':
|
|
if self.attrib['multi'] and not is_slave:
|
|
if 'default' not in self.attrib:
|
|
self.attrib['default'] = []
|
|
value = convert_tiramisu_value(child.text, type_)
|
|
self.attrib['default'].append(value)
|
|
if 'default_multi' not in self.attrib and not is_master:
|
|
self.attrib['default_multi'] = value
|
|
else:
|
|
if 'default' in self.attrib:
|
|
raise CreoleLoaderError(_('default value already set for {}'
|
|
'').format(self.attrib['path']))
|
|
value = convert_tiramisu_value(child.text, type_)
|
|
if value is None: # and (elt.attrib['type'] != 'choice' or value not in self.attrib['values']):
|
|
value = u''
|
|
if is_slave:
|
|
self.attrib['default_multi'] = value
|
|
else:
|
|
self.attrib['default'] = value
|
|
if 'initkwargs' in convert_option:
|
|
self.attrib.update(convert_option['initkwargs'])
|
|
self.attrib['properties'] = tuple(self.attrib['properties'])
|
|
if elt.attrib['type'] == 'symlink':
|
|
del self.attrib['properties']
|
|
del self.attrib['multi']
|
|
self.attrib['opt'] = storage.get(self.attrib['opt'])
|
|
|
|
def add_information(self, key, value):
|
|
if key in self.informations:
|
|
raise CreoleLoaderError(_('key already exists in information {}').format(key))
|
|
self.informations[key] = value
|
|
|
|
def add_callback(self, callback, callback_params):
|
|
self.callbacks.append((callback, callback_params))
|
|
|
|
def add_requires(self, requires):
|
|
self.requires.extend(requires)
|
|
|
|
def add_validator(self, validator, validator_params):
|
|
self.validator = (validator, validator_params)
|
|
|
|
def add_consistency(self, consistence, variables, warnings_only, transitive):
|
|
self.consistencies.append((consistence, variables, warnings_only, transitive))
|
|
|
|
def build_params(self, params):
|
|
if params != None:
|
|
new_params = Params()
|
|
for key, values in params.items():
|
|
new_values = []
|
|
for value in values:
|
|
if isinstance(value, list):
|
|
# retrieve object
|
|
value = ParamOption(value[0].get(), value[1])
|
|
elif value == (None,):
|
|
value = ParamContext()
|
|
else:
|
|
value = ParamValue(value)
|
|
if key == '':
|
|
args = list(new_params.args)
|
|
args.append(value)
|
|
new_params.args = tuple(args)
|
|
else:
|
|
new_params.kwargs[key] = value
|
|
return new_params
|
|
return params
|
|
|
|
def get(self):
|
|
if self.option is None:
|
|
if self.object_type is SymLinkOption:
|
|
self.attrib['opt'] = self.attrib['opt'].get()
|
|
for callback, callback_params in self.callbacks:
|
|
self.attrib['callback'] = callback
|
|
self.attrib['callback_params'] = self.build_params(callback_params)
|
|
for require in self.requires:
|
|
if isinstance(require['option'], Variable):
|
|
require['option'] = require['option'].get()
|
|
if self.requires != []:
|
|
self.attrib['requires'] = self.requires
|
|
if self.validator:
|
|
self.attrib['validator'] = self.validator[0]
|
|
self.attrib['validator_params'] = self.build_params(self.validator[1])
|
|
try:
|
|
option = self.object_type(**self.attrib)
|
|
except Exception as err:
|
|
import traceback
|
|
traceback.print_exc()
|
|
name = self.attrib['name']
|
|
raise CreoleLoaderError(_('cannot create option {}: {}').format(name, err))
|
|
for key, value in self.informations.items():
|
|
option.impl_set_information(key, value)
|
|
for consistency in self.consistencies:
|
|
options = []
|
|
for variable in consistency[1]:
|
|
options.append(variable.get())
|
|
try:
|
|
kwargs = {}
|
|
if consistency[2] == 'True':
|
|
kwargs['warnings_only'] = True
|
|
if consistency[3] == 'False':
|
|
kwargs['transitive'] = False
|
|
option.impl_add_consistency(consistency[0], *options, **kwargs)
|
|
except ConfigError as err:
|
|
name = self.attrib['name']
|
|
raise CreoleLoaderError(_('cannot load consistency for {}: {}').format(name, err))
|
|
self.option = option
|
|
return self.option
|
|
|
|
|
|
class Family(object):
|
|
def __init__(self, elt, booleans, force_icon=False):
|
|
self.requires = []
|
|
self.option = None
|
|
self.attrib = {}
|
|
self.is_master = False
|
|
if force_icon:
|
|
self.informations = {'icon': None}
|
|
else:
|
|
self.informations = {}
|
|
self.children = []
|
|
self.attrib['properties'] = []
|
|
for key, value in elt.attrib.items():
|
|
if key in REMOVED_ATTRIB:
|
|
continue
|
|
if key in booleans:
|
|
if value == 'True':
|
|
value = True
|
|
elif value == 'False':
|
|
value = False
|
|
else:
|
|
raise CreoleLoaderError(_('unknown value {} for {}').format(value, key))
|
|
if key == 'icon':
|
|
self.add_information('icon', value)
|
|
continue
|
|
elif key == 'hidden':
|
|
if value:
|
|
self.attrib['properties'].append(key)
|
|
elif key == 'mode':
|
|
self.attrib['properties'].append(value)
|
|
else:
|
|
self.attrib[key] = value
|
|
if 'doc' not in self.attrib:
|
|
self.attrib['doc'] = u''
|
|
self.attrib['properties'] = tuple(self.attrib['properties'])
|
|
|
|
def add(self, child):
|
|
self.children.append(child)
|
|
|
|
def add_information(self, key, value):
|
|
if key in self.informations and not (key == 'icon' and self.informations[key] is None):
|
|
raise CreoleLoaderError(_('key already exists in information {}').format(key))
|
|
self.informations[key] = value
|
|
|
|
def set_master(self):
|
|
self.is_master = True
|
|
|
|
def add_requires(self, requires):
|
|
self.requires.extend(requires)
|
|
|
|
def get(self):
|
|
if self.option is None:
|
|
self.attrib['children'] = []
|
|
for child in self.children:
|
|
self.attrib['children'].append(child.get())
|
|
for require in self.requires:
|
|
if isinstance(require['option'], Variable):
|
|
require['option'] = require['option'].get()
|
|
if self.requires != []:
|
|
self.attrib['requires'] = self.requires
|
|
try:
|
|
if not self.is_master:
|
|
option = OptionDescription(**self.attrib)
|
|
else:
|
|
option = Leadership(**self.attrib)
|
|
#option = OptionDescription(**self.attrib)
|
|
except Exception as err:
|
|
raise CreoleLoaderError(_('cannot create optiondescription {}: {}').format(self.attrib['name'], err))
|
|
for key, value in self.informations.items():
|
|
option.impl_set_information(key, value)
|
|
self.option = option
|
|
#if self.is_master:
|
|
# self.option.impl_set_group_type(groups.master)
|
|
|
|
return self.option
|
|
|
|
|
|
def _gen_eol_file(namespace):
|
|
if namespace == 'creole':
|
|
return configeol
|
|
else:
|
|
return join(eoleextraconfig, namespace, 'config.eol')
|
|
|
|
|
|
def creole_loader(load_values=True, rw=False, namespace='creole',
|
|
load_extra=False, reload_config=True, owner=None,
|
|
disable_mandatory=False, force_configeol=None,
|
|
try_upgrade=True, force_load_creole_owner=None,
|
|
force_dirs=None, warnings=None, force_instanciate=None,
|
|
force_dtdfile=None, force_flattened=None,
|
|
mandatory_permissive=True, from_zephir=None,
|
|
force_no_save=False, force_eoleextradico=None,
|
|
force_eoleextraconfig=None, only_load_flattened=False):
|
|
"""
|
|
Loads the Creole XML dictionnary files and return a tiramisu config object
|
|
|
|
:param bool load_values: Loads (or not) the :file:`config.eol` file
|
|
:param bool rw: Config's read/write flag
|
|
:param str namespace: Root's namespace for the config (example: "creole", "bacula", ...)
|
|
:param bool load_extra: Loads (or not) the extra dictionnaries (if `namespace='creole'`)
|
|
:param bool reload_config: This parameter is kept for compatibility reasons
|
|
:param str owner: forces the owner on a modified variable
|
|
:param bool disable_mandatory: disables the mandatory variables
|
|
:param str force_configeol: Forces the used configuration file
|
|
:param bool try_upgrade: tries to upgrade
|
|
:param force_load_creole_owner: Forces the owner for the loaded variables
|
|
:param str force_dirs: Forces the folder's name containing the dictionnaries
|
|
:param warnings: Shows the validation's warnings
|
|
:param bool force_instanciate: tells us if the server is already instanciated or not
|
|
:param force_dtdfile: None or dtd filename
|
|
:param force_flattened: None or flatened filename's name
|
|
:param only_load_flattened: boolean to desactivate generated of flattened file
|
|
"""
|
|
if namespace is not 'creole':
|
|
raise CreoleLoaderError(_('Only creole namespace is supported'))
|
|
#if reload_config is not True:
|
|
# raise CreoleLoaderError(_('Cannot reload the configuration'))
|
|
if force_flattened is None:
|
|
force_flattened = join(FLATTENED_CREOLE_DIR, 'flattened_creole.xml')
|
|
if force_dtdfile is None:
|
|
force_dtdfile = dtdfilename
|
|
if force_configeol is not None:
|
|
if not isfile(force_configeol):
|
|
raise CreoleLoaderError(_("Configuration file unexistent : {0}").format(
|
|
force_configeol))
|
|
if load_extra and force_eoleextraconfig is None:
|
|
# if force_configeol, cannot calculate extra configfile name
|
|
raise CreoleLoaderError(_('Unable to force_configeol with load_extra.'))
|
|
if force_dirs is not None and load_extra is True and force_eoleextradico is None:
|
|
raise CreoleLoaderError(_('If force_dirs is defined, namespace must be set to creole and '
|
|
'load_extra must be set to False.'))
|
|
if not only_load_flattened:
|
|
#should not load value now because create a Config
|
|
eolobj = CreoleObjSpace(force_dtdfile)
|
|
if force_dirs is not None:
|
|
dirs = force_dirs
|
|
else:
|
|
dirs = eoledirs
|
|
if from_zephir is not None and type(dirs) != list:
|
|
#if dirs is not a list, add subdirectory 'local'
|
|
#and 'variante'
|
|
orig_dir = dirs
|
|
dirs = [dirs]
|
|
for tdir in [join(orig_dir, 'local'),
|
|
join(orig_dir, 'variante')]:
|
|
if isdir(tdir):
|
|
dirs.append(tdir)
|
|
eolobj.create_or_populate_from_xml('creole', dirs, from_zephir=from_zephir)
|
|
|
|
if load_extra:
|
|
if force_eoleextradico == None:
|
|
force_eoleextradico = eoleextradico
|
|
extranames = _list_extras(force_eoleextradico)
|
|
extranames.sort()
|
|
if isdir(force_eoleextradico):
|
|
for directory in extranames:
|
|
if directory in forbiddenextra:
|
|
raise CreoleLoaderError(
|
|
_('Namespace {} for extra dictionary not allowed').format(directory))
|
|
dirname = join(force_eoleextradico, directory)
|
|
eolobj.create_or_populate_from_xml(directory, [dirname], from_zephir)
|
|
eolobj.space_visitor()
|
|
xmlroot = eolobj.save(force_flattened, force_no_save)
|
|
else:
|
|
with open(force_flattened, 'r') as fhd:
|
|
xmlroot = parse(fhd).getroot()
|
|
tiramisu_objects = PopulateTiramisuObjects()
|
|
tiramisu_objects.parse_dtd(force_dtdfile)
|
|
tiramisu_objects.make_tiramisu_objects(xmlroot)
|
|
config = tiramisu_objects.build()
|
|
if warnings is None:
|
|
# warnings is disabled in read-only mode and enabled in read-write mode by default
|
|
warnings = rw
|
|
if warnings is False:
|
|
config.cfgimpl_get_settings().remove('warnings')
|
|
if owner is not None:
|
|
if owner not in dir(owners):
|
|
owners.addowner(owner)
|
|
config.cfgimpl_get_settings().setowner(getattr(owners, owner))
|
|
#load values
|
|
if force_configeol is not None:
|
|
configfile = force_configeol
|
|
else:
|
|
configfile = _gen_eol_file(namespace)
|
|
if load_values and isfile(configfile):
|
|
disable_mandatory = False
|
|
load_config_eol(config, configfile=configfile, try_upgrade=try_upgrade,
|
|
force_load_owner=force_load_creole_owner,
|
|
force_instanciate=force_instanciate)
|
|
else:
|
|
config.impl_set_information(namespace, configfile)
|
|
if load_extra:
|
|
load_extras(config, load_values=load_values, mandatory_permissive=mandatory_permissive,
|
|
extradico=force_eoleextradico, force_eoleextraconfig=force_eoleextraconfig)
|
|
if rw:
|
|
config.read_write()
|
|
elif rw is False:
|
|
config.read_only()
|
|
|
|
if disable_mandatory:
|
|
config.cfgimpl_get_settings().remove('mandatory')
|
|
config.cfgimpl_get_settings().remove('empty')
|
|
if from_zephir is not None:
|
|
return tiramisu_objects.groups, tiramisu_objects.separators, config
|
|
else:
|
|
return config
|