155 lines
8.0 KiB
Python
155 lines
8.0 KiB
Python
from ..i18n import _
|
|
from ..utils import normalize_family
|
|
from ..error import DictConsistencyError
|
|
|
|
|
|
CONVERT_OPTION = {'number': dict(opttype="IntOption", func=int),
|
|
'float': dict(opttype="FloatOption", func=float),
|
|
'choice': dict(opttype="ChoiceOption"),
|
|
'string': dict(opttype="StrOption"),
|
|
'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': False}),
|
|
'hostname': 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"),
|
|
'cidr': dict(opttype="IPOption", initkwargs={'cidr': True}),
|
|
'network_cidr': dict(opttype="NetworkOption", initkwargs={'cidr': True}),
|
|
}
|
|
|
|
|
|
FORCE_CHOICE = {'oui/non': ['oui', 'non'],
|
|
'on/off': ['on', 'off'],
|
|
'yes/no': ['yes', 'no'],
|
|
'schedule': ['none', 'daily', 'weekly', 'monthly'],
|
|
'schedulemod': ['pre', 'post']}
|
|
|
|
|
|
RENAME_ATTIBUTES = {'description': 'doc'}
|
|
|
|
|
|
class VariableAnnotator:
|
|
def __init__(self,
|
|
objectspace,
|
|
):
|
|
self.objectspace = objectspace
|
|
self.convert_variable()
|
|
self.convert_separators()
|
|
|
|
def convert_variable(self):
|
|
def _convert_variable(variable,
|
|
variable_type,
|
|
):
|
|
if not hasattr(variable, 'type'):
|
|
variable.type = 'string'
|
|
if variable.type != 'symlink' and not hasattr(variable, 'description'):
|
|
variable.description = variable.name
|
|
if hasattr(variable, 'value'):
|
|
for value in variable.value:
|
|
if not hasattr(value, 'type'):
|
|
value.type = variable.type
|
|
value.name = CONVERT_OPTION.get(value.type, {}).get('func', str)(value.name)
|
|
for key, value in RENAME_ATTIBUTES.items():
|
|
setattr(variable, value, getattr(variable, key))
|
|
setattr(variable, key, None)
|
|
if variable_type == 'follower':
|
|
if variable.multi is True:
|
|
variable.multi = 'submulti'
|
|
else:
|
|
variable.multi = True
|
|
|
|
def _convert_valid_enum(namespace,
|
|
variable,
|
|
path,
|
|
):
|
|
if variable.type in FORCE_CHOICE:
|
|
check = self.objectspace.check(variable.xmlfiles)
|
|
check.name = 'valid_enum'
|
|
check.target = path
|
|
check.namespace = namespace
|
|
check.param = []
|
|
for value in FORCE_CHOICE[variable.type]:
|
|
param = self.objectspace.param(variable.xmlfiles)
|
|
param.text = value
|
|
check.param.append(param)
|
|
if not hasattr(self.objectspace.space, 'constraints'):
|
|
self.objectspace.space.constraints = self.objectspace.constraints(variable.xmlfiles)
|
|
self.objectspace.space.constraints.namespace = namespace
|
|
if not hasattr(self.objectspace.space.constraints, 'check'):
|
|
self.objectspace.space.constraints.check = []
|
|
self.objectspace.space.constraints.check.append(check)
|
|
variable.type = 'string'
|
|
|
|
def _valid_type(variable):
|
|
if variable.type not in CONVERT_OPTION:
|
|
xmlfiles = self.objectspace.display_xmlfiles(variable.xmlfiles)
|
|
raise DictConsistencyError(_(f'unvalid type "{variable.type}" for variable "{variable.name}" in {xmlfiles}'), 36)
|
|
|
|
if not hasattr(self.objectspace.space, 'variables'):
|
|
return
|
|
for families in self.objectspace.space.variables.values():
|
|
namespace = families.name
|
|
if hasattr(families, 'family'):
|
|
families.doc = families.name
|
|
for family in families.family.values():
|
|
family.doc = family.name
|
|
family.name = normalize_family(family.name)
|
|
if hasattr(family, 'variable'):
|
|
for variable in family.variable.values():
|
|
if isinstance(variable, self.objectspace.leadership):
|
|
for idx, follower in enumerate(variable.variable):
|
|
if idx == 0:
|
|
variable_type = 'master'
|
|
else:
|
|
variable_type = 'follower'
|
|
path = '{}.{}.{}.{}'.format(namespace, normalize_family(family.name), variable.name, follower.name)
|
|
_convert_variable(follower,
|
|
variable_type,
|
|
)
|
|
_convert_valid_enum(namespace,
|
|
follower,
|
|
path,
|
|
)
|
|
_valid_type(follower)
|
|
else:
|
|
path = '{}.{}.{}'.format(namespace, normalize_family(family.name), variable.name)
|
|
_convert_variable(variable,
|
|
'variable',
|
|
)
|
|
_convert_valid_enum(namespace,
|
|
variable,
|
|
path,
|
|
)
|
|
_valid_type(variable)
|
|
|
|
def convert_separators(self): # pylint: disable=C0111,R0201
|
|
if not hasattr(self.objectspace.space, 'variables'):
|
|
return
|
|
for family in self.objectspace.space.variables.values():
|
|
if not hasattr(family, 'separators'):
|
|
continue
|
|
if hasattr(family.separators, 'separator'):
|
|
for idx, separator in enumerate(family.separators.separator):
|
|
option = self.objectspace.paths.get_variable_obj(separator.name)
|
|
if hasattr(option, 'separator'):
|
|
subpath = self.objectspace.paths.get_variable_path(separator.name,
|
|
separator.namespace,
|
|
)
|
|
xmlfiles = self.objectspace.display_xmlfiles(separator.xmlfiles)
|
|
raise DictConsistencyError(_(f'{subpath} already has a separator in {xmlfiles}'), 35)
|
|
option.separator = separator.text
|
|
del family.separators
|
|
|