1887 lines
78 KiB
Python
1887 lines
78 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Copyright (C) 2017-2021 Team tiramisu (see AUTHORS for all contributors)
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify it
|
|
# under the terms of the GNU Lesser General Public License as published by the
|
|
# Free Software Foundation, either version 3 of the License, or (at your
|
|
# option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
|
|
# details.
|
|
#
|
|
# You should have received a copy of the GNU Lesser General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
# ____________________________________________________________
|
|
from inspect import ismethod, getdoc, signature
|
|
from time import time
|
|
from typing import List, Set, Any, Optional, Callable, Union, Dict
|
|
from warnings import catch_warnings, simplefilter
|
|
from functools import wraps
|
|
|
|
|
|
from .error import APIError, ConfigError, LeadershipError, PropertiesOptionError, ValueErrorWarning
|
|
from .i18n import _
|
|
from .setting import ConfigBag, OptionBag, owners, groups, Undefined, undefined, \
|
|
FORBIDDEN_SET_PROPERTIES, SPECIAL_PROPERTIES, EXPIRATION_TIME
|
|
from .storage import default_storage
|
|
from .config import KernelConfig, SubConfig, KernelGroupConfig, KernelMetaConfig, KernelMixConfig
|
|
from .option import RegexpOption, OptionDescription
|
|
from .todict import TiramisuDict
|
|
from .asyncinit import asyncinit
|
|
|
|
|
|
TIRAMISU_VERSION = 3
|
|
|
|
|
|
class TiramisuHelp:
|
|
_tmpl_help = ' {0}\t{1}'
|
|
|
|
def help(self,
|
|
_display: bool=True) -> List[str]:
|
|
def display(doc=''):
|
|
if _display: # pragma: no cover
|
|
print(doc)
|
|
options = []
|
|
all_modules = dir(self)
|
|
modules = []
|
|
max_len = 0
|
|
force = False
|
|
for module_name in all_modules:
|
|
if module_name in ['forcepermissive', 'unrestraint']:
|
|
force = True
|
|
max_len = max(max_len, len('forcepermissive'))
|
|
elif module_name != 'help' and not module_name.startswith('_'):
|
|
modules.append(module_name)
|
|
max_len = max(max_len, len(module_name))
|
|
modules.sort()
|
|
|
|
display(_(getdoc(self)))
|
|
display()
|
|
if force:
|
|
display(_('Settings:'))
|
|
display(self._tmpl_help.format('forcepermissive', _('Access to option without verifying permissive properties')).expandtabs(max_len + 10))
|
|
display(self._tmpl_help.format('unrestraint', _('Access to option without property restriction')).expandtabs(max_len + 10))
|
|
display()
|
|
if isinstance(self, TiramisuDispatcherOption):
|
|
doc = _(getdoc(self.__call__))
|
|
display(_('Call: {}').format(doc))
|
|
display()
|
|
display(_('Commands:'))
|
|
for module_name in modules:
|
|
module = getattr(self, module_name)
|
|
doc = _(getdoc(module))
|
|
display(self._tmpl_help.format(module_name, doc).expandtabs(max_len + 10))
|
|
display()
|
|
|
|
def __dir__(self):
|
|
if '_registers' in super().__dir__():
|
|
return list(self._registers.keys())
|
|
return super().__dir__()
|
|
|
|
|
|
class CommonTiramisu(TiramisuHelp):
|
|
_allow_optiondescription = True
|
|
_validate_properties = True
|
|
|
|
async def _get_option(self,
|
|
connection) -> Any:
|
|
config_bag = self._option_bag.config_bag
|
|
if not self._subconfig:
|
|
try:
|
|
subconfig, name = await config_bag.context.cfgimpl_get_home_by_path(self._option_bag.path,
|
|
config_bag,
|
|
validate_properties=self._validate_properties)
|
|
except AssertionError as err:
|
|
raise APIError(str(err))
|
|
except Exception as err:
|
|
raise err
|
|
self._subconfig = subconfig
|
|
self._name = name
|
|
option = self._option_bag.option
|
|
if option is None:
|
|
option = await self._subconfig.cfgimpl_get_description().get_child(self._name,
|
|
config_bag,
|
|
self._subconfig.cfgimpl_get_path())
|
|
self._option_bag.option = option
|
|
self._option_bag.config_bag.connection = connection
|
|
# Calculate option's properties
|
|
|
|
settings = config_bag.context.cfgimpl_get_settings()
|
|
self._option_bag.properties = await settings.getproperties(self._option_bag)
|
|
if self._validate_properties:
|
|
await settings.validate_properties(self._option_bag)
|
|
index = self._option_bag.index
|
|
if index is not None:
|
|
if option.impl_is_optiondescription() or not option.impl_is_follower():
|
|
self._option_bag.option = None
|
|
raise APIError('index must be set only with a follower option')
|
|
self._length = await self._subconfig.cfgimpl_get_length_leadership(self._option_bag)
|
|
if index >= self._length:
|
|
self._option_bag.option = None
|
|
raise LeadershipError(_('index "{}" is greater than the leadership length "{}" '
|
|
'for option "{}"').format(index,
|
|
self._length,
|
|
option.impl_get_display_name()))
|
|
if not self._allow_optiondescription and option.impl_is_optiondescription():
|
|
self._option_bag.option = None
|
|
raise APIError(_('option must not be an optiondescription'))
|
|
return option
|
|
|
|
|
|
class CommonTiramisuOption(CommonTiramisu):
|
|
_allow_optiondescription = False
|
|
_follower_need_index = True
|
|
_validate_properties = False
|
|
|
|
def __init__(self,
|
|
option_bag: OptionBag) -> None:
|
|
self._option_bag = option_bag
|
|
self._subconfig = None
|
|
|
|
def __getattr__(self, name):
|
|
raise APIError(_('unknown method "{}" in "{}"').format(name, self.__class__.__name__))
|
|
|
|
|
|
def option_and_connection(func):
|
|
async def wrapped(self, *args, **kwargs):
|
|
config_bag = self._option_bag.config_bag
|
|
async with config_bag.context.getconnection() as connection:
|
|
config_bag.connection = connection
|
|
option = await self._get_option(connection)
|
|
ret = await func(self, *args, **kwargs)
|
|
del config_bag.connection
|
|
return ret
|
|
return wrapped
|
|
|
|
|
|
class _TiramisuOptionOptionDescription(CommonTiramisuOption):
|
|
"""Manage option"""
|
|
_allow_optiondescription = True
|
|
_follower_need_index = False
|
|
_validate_properties = False
|
|
|
|
def __init__(self,
|
|
option_bag: OptionBag):
|
|
super().__init__(option_bag)
|
|
self._config = option_bag.config_bag.context
|
|
|
|
@option_and_connection
|
|
async def get(self):
|
|
"""Get Tiramisu option"""
|
|
return self._option_bag.option
|
|
|
|
@option_and_connection
|
|
async def type(self):
|
|
return self._option_bag.option.impl_get_group_type()
|
|
|
|
@option_and_connection
|
|
async def isleadership(self):
|
|
"""Test if option is a leader or a follower"""
|
|
return self._option_bag.option.impl_is_leadership()
|
|
|
|
@option_and_connection
|
|
async def doc(self):
|
|
"""Get option document"""
|
|
return self._option_bag.option.impl_get_display_name()
|
|
|
|
@option_and_connection
|
|
async def description(self):
|
|
"""Get option description"""
|
|
return self._option_bag.option.impl_get_information('doc', None)
|
|
|
|
@option_and_connection
|
|
async def name(self,
|
|
follow_symlink: bool=False) -> str:
|
|
"""Get option name"""
|
|
if not follow_symlink or \
|
|
self._option_bag.option.impl_is_optiondescription() or \
|
|
not self._option_bag.option.impl_is_symlinkoption():
|
|
return self._option_bag.option.impl_getname()
|
|
else:
|
|
return self._option_bag.option.impl_getopt().impl_getname()
|
|
|
|
@option_and_connection
|
|
async def path(self) -> str:
|
|
"""Get option path"""
|
|
return self._option_bag.path
|
|
|
|
@option_and_connection
|
|
async def has_dependency(self, self_is_dep=True):
|
|
"""Test if option has dependency"""
|
|
return self._option_bag.option.impl_has_dependency(self_is_dep)
|
|
|
|
@option_and_connection
|
|
async def dependencies(self):
|
|
"""Get dependencies from this option"""
|
|
options = []
|
|
for option in self._option_bag.option._get_dependencies(self._option_bag.config_bag.context):
|
|
options.append(TiramisuOption(option().impl_getpath(),
|
|
None,
|
|
self._option_bag.config_bag,
|
|
))
|
|
return options
|
|
|
|
@option_and_connection
|
|
async def isoptiondescription(self):
|
|
"""Test if option is an optiondescription"""
|
|
return self._option_bag.option.impl_is_optiondescription()
|
|
|
|
@option_and_connection
|
|
async def properties(self,
|
|
only_raises=False,
|
|
uncalculated=False):
|
|
"""Get properties for an option"""
|
|
settings = self._option_bag.config_bag.context.cfgimpl_get_settings()
|
|
if uncalculated:
|
|
return await settings.getproperties(self._option_bag,
|
|
uncalculated=True)
|
|
if not only_raises:
|
|
return await settings.getproperties(self._option_bag,
|
|
apply_requires=False)
|
|
# do not check cache properties/permissives which are not save (unrestraint, ...)
|
|
return await settings.calc_raises_properties(self._option_bag,
|
|
apply_requires=False,
|
|
uncalculated=uncalculated)
|
|
|
|
def __call__(self,
|
|
name: str,
|
|
index: Optional[int]=None) -> 'TiramisuOption':
|
|
"""Select an option by path"""
|
|
path = self._option_bag.path + '.' + name
|
|
return TiramisuOption(path,
|
|
index,
|
|
self._option_bag.config_bag)
|
|
|
|
|
|
class TiramisuOptionOption(_TiramisuOptionOptionDescription):
|
|
"""Manage option"""
|
|
@option_and_connection
|
|
async def ismulti(self):
|
|
"""Test if option could have multi value"""
|
|
return self._option_bag.option.impl_is_multi()
|
|
|
|
@option_and_connection
|
|
async def issubmulti(self):
|
|
"""Test if option could have submulti value"""
|
|
return self._option_bag.option.impl_is_submulti()
|
|
|
|
@option_and_connection
|
|
async def isleader(self):
|
|
"""Test if option is a leader"""
|
|
return self._option_bag.option.impl_is_leader()
|
|
|
|
@option_and_connection
|
|
async def isfollower(self):
|
|
"""Test if option is a follower"""
|
|
return self._option_bag.option.impl_is_follower()
|
|
|
|
@option_and_connection
|
|
async def issymlinkoption(self) -> bool:
|
|
return self._option_bag.option.impl_is_symlinkoption()
|
|
|
|
@option_and_connection
|
|
async def default(self):
|
|
"""Get default value for an option (not for optiondescription)"""
|
|
return self._option_bag.option.impl_getdefault()
|
|
|
|
@option_and_connection
|
|
async def defaultmulti(self):
|
|
"""Get default value when added a value for a multi option (not for optiondescription)"""
|
|
option = self._option_bag.option
|
|
ret = option.impl_getdefault_multi()
|
|
if ret is None and option.impl_is_multi() and option.impl_has_callback() and not self.isfollower():
|
|
callback, callback_params = option.impl_get_callback()
|
|
values = self._option_bag.config_bag.context.cfgimpl_get_values()
|
|
value = await values.carry_out_calculation(self._option_bag,
|
|
callback,
|
|
callback_params)
|
|
if not isinstance(value, list):
|
|
ret = value
|
|
return ret
|
|
|
|
@option_and_connection
|
|
async def callbacks(self):
|
|
"""Get callbacks for an option (not for optiondescription)"""
|
|
return self._option_bag.option.impl_get_callback()
|
|
|
|
@option_and_connection
|
|
async def validator(self):
|
|
"""Get validator for an option (not for optiondescription)"""
|
|
return self._option_bag.option.impl_get_validator()
|
|
|
|
@option_and_connection
|
|
async def type(self):
|
|
return self._option_bag.option.get_type()
|
|
|
|
@option_and_connection
|
|
async def pattern(self) -> str:
|
|
option = self._option_bag.option
|
|
type = option.get_type()
|
|
if isinstance(option, RegexpOption):
|
|
return option._regexp.pattern
|
|
if type == 'integer':
|
|
# FIXME negative too!
|
|
return r'^[0-9]+$'
|
|
if type == 'domainname':
|
|
return option.impl_get_extra('_domain_re').pattern
|
|
if type in ['ip', 'network', 'netmask']:
|
|
#FIXME only from 0.0.0.0 to 255.255.255.255
|
|
return r'^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$'
|
|
|
|
|
|
class TiramisuOptionOwner(CommonTiramisuOption):
|
|
#FIXME optiondescription must not have Owner!
|
|
"""Manage option's owner"""
|
|
|
|
def __init__(self,
|
|
option_bag: OptionBag) -> None:
|
|
|
|
super().__init__(option_bag)
|
|
if option_bag is not None:
|
|
# for help()
|
|
self._values = self._option_bag.config_bag.context.cfgimpl_get_values()
|
|
|
|
@option_and_connection
|
|
async def get(self):
|
|
"""Get owner for a specified option"""
|
|
return await self._values.getowner(self._option_bag)
|
|
|
|
@option_and_connection
|
|
async def isdefault(self):
|
|
"""Is option has defaut value"""
|
|
return await self._values.is_default_owner(self._option_bag)
|
|
|
|
@option_and_connection
|
|
async def set(self, owner):
|
|
"""Get owner for a specified option"""
|
|
try:
|
|
obj_owner = getattr(owners, owner)
|
|
except AttributeError:
|
|
owners.addowner(owner)
|
|
obj_owner = getattr(owners, owner)
|
|
await self._values.setowner(obj_owner,
|
|
self._option_bag)
|
|
|
|
|
|
class TiramisuOptionProperty(CommonTiramisuOption):
|
|
"""Manage option's property"""
|
|
_allow_optiondescription = True
|
|
_follower_need_index = False
|
|
_validate_properties = False
|
|
|
|
def __init__(self,
|
|
option_bag: OptionBag) -> None:
|
|
super().__init__(option_bag)
|
|
if option_bag and option_bag.config_bag:
|
|
self._settings = option_bag.config_bag.context.cfgimpl_get_settings()
|
|
|
|
@option_and_connection
|
|
async def get(self,
|
|
only_raises=False,
|
|
uncalculated=False):
|
|
"""Get properties for an option"""
|
|
if not only_raises:
|
|
return self._option_bag.properties
|
|
# do not check cache properties/permissives which are not save (unrestraint, ...)
|
|
ret = await self._settings.calc_raises_properties(self._option_bag,
|
|
uncalculated=uncalculated)
|
|
return ret
|
|
|
|
@option_and_connection
|
|
async def add(self, prop):
|
|
"""Add new property for an option"""
|
|
if prop in FORBIDDEN_SET_PROPERTIES:
|
|
raise ConfigError(_('cannot add this property: "{0}"').format(
|
|
' '.join(prop)))
|
|
props = await self._settings._p_.getproperties(self._option_bag.config_bag.connection,
|
|
self._option_bag.path,
|
|
self._option_bag.index,
|
|
self._option_bag.option.impl_getproperties())
|
|
await self._settings.setproperties(self._option_bag.path,
|
|
props | {prop},
|
|
self._option_bag,
|
|
self._option_bag.config_bag.context)
|
|
|
|
@option_and_connection
|
|
async def pop(self, prop):
|
|
"""Remove new property for an option"""
|
|
props = await self._settings._p_.getproperties(self._option_bag.config_bag.connection,
|
|
self._option_bag.path,
|
|
self._option_bag.index,
|
|
self._option_bag.option.impl_getproperties())
|
|
await self._settings.setproperties(self._option_bag.path,
|
|
props - {prop},
|
|
self._option_bag,
|
|
self._option_bag.config_bag.context)
|
|
|
|
@option_and_connection
|
|
async def reset(self):
|
|
"""Reset all personalised properties"""
|
|
await self._settings.reset(self._option_bag,
|
|
self._option_bag.config_bag)
|
|
|
|
|
|
class TiramisuOptionPermissive(CommonTiramisuOption):
|
|
"""Manage option's permissive"""
|
|
_allow_optiondescription = True
|
|
_follower_need_index = False
|
|
|
|
def __init__(self,
|
|
option_bag: OptionBag) -> None:
|
|
super().__init__(option_bag)
|
|
if option_bag and option_bag.config_bag:
|
|
self._settings = option_bag.config_bag.context.cfgimpl_get_settings()
|
|
|
|
@option_and_connection
|
|
async def get(self):
|
|
"""Get permissives value"""
|
|
return await self._settings.getpermissives(self._option_bag)
|
|
|
|
@option_and_connection
|
|
async def set(self, permissives):
|
|
"""Set permissives value"""
|
|
await self._settings.setpermissives(self._option_bag,
|
|
permissives=permissives)
|
|
|
|
@option_and_connection
|
|
async def reset(self):
|
|
"""Reset all personalised permissive"""
|
|
await self._settings.reset_permissives(self._option_bag,
|
|
self._option_bag.config_bag)
|
|
|
|
|
|
class TiramisuOptionInformation(CommonTiramisuOption):
|
|
"""Manage option's informations"""
|
|
_allow_optiondescription = True
|
|
_follower_need_index = False
|
|
|
|
def __init__(self,
|
|
option_bag: OptionBag) -> None:
|
|
super().__init__(option_bag)
|
|
|
|
@option_and_connection
|
|
async def get(self, key, default=undefined):
|
|
"""Get information"""
|
|
values = self._option_bag.config_bag.context.cfgimpl_get_values()
|
|
return await values.get_information(self._option_bag.config_bag,
|
|
self._option_bag,
|
|
key,
|
|
default,
|
|
)
|
|
|
|
@option_and_connection
|
|
async def set(self, key, value):
|
|
"""Set information"""
|
|
path = self._option_bag.path
|
|
values = self._option_bag.config_bag.context.cfgimpl_get_values()
|
|
await values.set_information(self._option_bag.config_bag,
|
|
self._option_bag,
|
|
key,
|
|
value,
|
|
)
|
|
|
|
@option_and_connection
|
|
async def reset(self,
|
|
key: str,
|
|
) -> None:
|
|
"""Remove information"""
|
|
path = self._option_bag.path
|
|
values = self._option_bag.config_bag.context.cfgimpl_get_values()
|
|
await values.del_information(self._option_bag.config_bag.connection,
|
|
key,
|
|
path=path)
|
|
|
|
@option_and_connection
|
|
async def list(self):
|
|
"""List information's keys"""
|
|
path = self._option_bag.path
|
|
values = self._option_bag.config_bag.context.cfgimpl_get_values()
|
|
return await values.list_information(self._option_bag.config_bag.connection,
|
|
path)
|
|
#
|
|
# async def len(self):
|
|
# """Length of leadership"""
|
|
# option = await self._get_option()
|
|
# # for example if index is None
|
|
# if '_length' not in vars(self):
|
|
# self._length = self._subconfig.cfgimpl_get_length()
|
|
# return self._length
|
|
|
|
|
|
def option_type(typ):
|
|
if not isinstance(typ, list):
|
|
types = [typ]
|
|
else:
|
|
types = typ
|
|
|
|
def wrapper(func):
|
|
@wraps(func)
|
|
async def wrapped(*args, **kwargs):
|
|
config_bag = args[0]._option_bag.config_bag
|
|
async with config_bag.context.getconnection() as connection:
|
|
for typ in types:
|
|
if typ == 'group':
|
|
if args[0]._option_bag.config_bag.context.impl_type == 'group':
|
|
config_bag.connection = connection
|
|
ret = await func(*args, **kwargs, is_group=True)
|
|
del config_bag.connection
|
|
return ret
|
|
else:
|
|
config_bag.connection = connection
|
|
option = await args[0]._get_option(connection)
|
|
if typ == 'option':
|
|
if option.impl_is_optiondescription():
|
|
del config_bag.connection
|
|
raise APIError(_('please specify a valid sub function ({})').format(func.__name__))
|
|
elif typ == 'optiondescription':
|
|
if not option.impl_is_optiondescription():
|
|
del config_bag.connection
|
|
raise APIError(_('please specify a valid sub function ({})').format(func.__name__))
|
|
elif typ == 'leader':
|
|
if not option.impl_is_leader():
|
|
del config_bag.connection
|
|
raise APIError(_('please specify a valid sub function ({})').format(func.__name__))
|
|
elif typ == 'follower':
|
|
if not option.impl_is_follower() and not option.impl_is_leader():
|
|
del config_bag.connection
|
|
raise APIError(_('please specify a valid sub function ({})').format(func.__name__))
|
|
elif typ == 'choice':
|
|
if not option.get_type() == 'choice':
|
|
del config_bag.connection
|
|
raise APIError(_('please specify a valid sub function ({})').format(func.__name__))
|
|
ret = await func(*args, **kwargs)
|
|
del config_bag.connection
|
|
return ret
|
|
return wrapped
|
|
return wrapper
|
|
|
|
|
|
class TiramisuOptionValue(CommonTiramisuOption):
|
|
"""Manage option's value"""
|
|
_allow_optiondescription = True
|
|
_follower_need_index = True
|
|
_validate_properties = True
|
|
|
|
@option_type('optiondescription')
|
|
async def dict(self,
|
|
flatten=False,
|
|
withwarning: bool=False,
|
|
fullpath=False,
|
|
leader_to_list=False):
|
|
"""Dict with path as key and value"""
|
|
name = self._option_bag.option.impl_getname()
|
|
subconfig = await self._subconfig.get_subconfig(self._option_bag)
|
|
config_bag = self._option_bag.config_bag
|
|
if not withwarning and config_bag.properties and 'warnings' in config_bag.properties:
|
|
config_bag = config_bag.copy()
|
|
config_bag.remove_warnings()
|
|
return await subconfig.make_dict(config_bag=config_bag,
|
|
flatten=flatten,
|
|
fullpath=fullpath,
|
|
leader_to_list=leader_to_list)
|
|
|
|
@option_type('option')
|
|
async def get(self):
|
|
"""Get option's value"""
|
|
if self._option_bag.option.impl_is_follower() and self._option_bag.index is None:
|
|
raise APIError('index must be set with a follower option')
|
|
return await self._subconfig.getattr(self._name,
|
|
self._option_bag)
|
|
|
|
@option_type('option')
|
|
async def set(self, value):
|
|
"""Change option's value"""
|
|
if self._option_bag.option.impl_is_follower() and \
|
|
self._option_bag.index is None:
|
|
raise APIError('index must be set with a follower option')
|
|
values = self._option_bag.config_bag.context.cfgimpl_get_values()
|
|
if isinstance(value, list):
|
|
while undefined in value:
|
|
idx = value.index(undefined)
|
|
soption_bag = self._option_bag.copy()
|
|
soption_bag.index = idx
|
|
value[idx] = await values.getdefaultvalue(soption_bag)
|
|
elif value == undefined:
|
|
value = await values.getdefaultvalue(self._option_bag)
|
|
await self._subconfig.setattr(value,
|
|
self._option_bag)
|
|
|
|
@option_type(['group', 'option'])
|
|
async def reset(self,
|
|
is_group: bool=False):
|
|
"""Reset value for an option"""
|
|
if is_group:
|
|
await self._option_bag.config_bag.context.reset(self._option_bag.config_bag.connection,
|
|
self._option_bag.path)
|
|
else:
|
|
if self._option_bag.option.impl_is_follower() and self._option_bag.index is None:
|
|
raise APIError('index must be set with a follower option')
|
|
await self._subconfig.delattr(self._option_bag)
|
|
|
|
@option_type('option')
|
|
async def default(self):
|
|
"""Get default value (default of option or calculated value)"""
|
|
option = self._option_bag.option
|
|
values = self._option_bag.config_bag.context.cfgimpl_get_values()
|
|
if option.impl_is_follower() and self._option_bag.index is None:
|
|
value = []
|
|
length = await self._subconfig.cfgimpl_get_length_leadership(self._option_bag)
|
|
settings = self._option_bag.config_bag.context.cfgimpl_get_settings()
|
|
for idx in range(length):
|
|
soption_bag = OptionBag()
|
|
soption_bag.set_option(option,
|
|
idx,
|
|
self._option_bag.config_bag)
|
|
soption_bag.properties = await settings.getproperties(soption_bag)
|
|
value.append(await values.getdefaultvalue(soption_bag))
|
|
return value
|
|
else:
|
|
return await values.getdefaultvalue(self._option_bag)
|
|
|
|
@option_type('option')
|
|
async def valid(self):
|
|
try:
|
|
with catch_warnings(record=True) as warns:
|
|
simplefilter("always", ValueErrorWarning)
|
|
await self.get()
|
|
for warn in warns:
|
|
if isinstance(warns.message, ValueErrorWarning):
|
|
return False
|
|
except ValueError:
|
|
return False
|
|
return True
|
|
|
|
@option_type('choice')
|
|
async def list(self):
|
|
"""All values available for a ChoiceOption"""
|
|
return await self._option_bag.option.impl_get_values(self._option_bag)
|
|
|
|
@option_type('leader')
|
|
async def pop(self, index):
|
|
"""Pop a value"""
|
|
if self._option_bag.option.impl_is_follower() and self._option_bag.index is None:
|
|
raise APIError('index must be set with a follower option')
|
|
option_bag = self._option_bag
|
|
assert not option_bag.option.impl_is_symlinkoption(), _("can't delete a SymLinkOption")
|
|
await option_bag.config_bag.context.cfgimpl_get_values().reset_leadership(index,
|
|
option_bag,
|
|
self._subconfig)
|
|
|
|
@option_type('follower')
|
|
async def len(self):
|
|
"""Length of follower option"""
|
|
# for example if index is None
|
|
if '_length' not in vars(self):
|
|
self._length = await self._subconfig.cfgimpl_get_length_leadership(self._option_bag)
|
|
return self._length
|
|
|
|
|
|
def _registers(_registers: Dict[str, type],
|
|
prefix: str,
|
|
extra_type: Optional[type]=None):
|
|
for module_name in globals().keys():
|
|
if module_name != prefix and module_name.startswith(prefix): # and \
|
|
module = globals()[module_name]
|
|
func_name = module_name[len(prefix):].lower()
|
|
_registers[func_name] = module
|
|
#__________________________________________________________________________________________________
|
|
#
|
|
|
|
|
|
class TiramisuConfig(TiramisuHelp):
|
|
def __init__(self,
|
|
config_bag: ConfigBag,
|
|
orig_config_bags: Optional[List[OptionBag]]) -> None:
|
|
self._config_bag = config_bag
|
|
self._orig_config_bags = orig_config_bags
|
|
|
|
async def _return_config(self,
|
|
config,
|
|
storage):
|
|
if isinstance(config, KernelConfig):
|
|
return await Config(config,
|
|
storage=storage)
|
|
if isinstance(config, KernelMetaConfig):
|
|
return await MetaConfig(config,
|
|
storage=storage)
|
|
if isinstance(config, KernelMixConfig):
|
|
return await MixConfig([],
|
|
config,
|
|
storage=storage)
|
|
if isinstance(config, KernelGroupConfig):
|
|
return await GroupConfig(config)
|
|
raise Exception(_('unknown config type {}').format(type(config)))
|
|
|
|
async def _reset_config_properties(self,
|
|
connection):
|
|
config = self._config_bag.context
|
|
settings = config.cfgimpl_get_settings()
|
|
properties = await settings.get_context_properties(connection,
|
|
config._impl_properties_cache)
|
|
permissives = await settings.get_context_permissives(connection)
|
|
self._config_bag.properties = properties
|
|
self._config_bag.permissives = permissives
|
|
if self._orig_config_bags:
|
|
for config_bag in self._orig_config_bags:
|
|
config_bag.properties = properties
|
|
config_bag.permissives = permissives
|
|
|
|
|
|
class TiramisuOption(CommonTiramisu, TiramisuConfig):
|
|
"""Manage selected option"""
|
|
_validate_properties = False
|
|
_registers = {}
|
|
def __init__(self,
|
|
path: Optional[str]=None,
|
|
index: Optional[int]=None,
|
|
config_bag: Optional[ConfigBag]=None) -> None:
|
|
self._option_bag = OptionBag()
|
|
self._option_bag.config_bag = config_bag
|
|
self._option_bag.path = path
|
|
self._option_bag.index = index
|
|
self._subconfig = None
|
|
self._tiramisu_dict = None
|
|
if not self._registers:
|
|
_registers(self._registers, 'TiramisuOption')
|
|
|
|
def __getattr__(self, subfunc: str) -> Any:
|
|
if subfunc in self._registers:
|
|
return self._registers[subfunc](self._option_bag)
|
|
raise APIError(_('please specify a valid sub function ({})').format(subfunc)) # pragma: no cover
|
|
|
|
@option_type('optiondescription')
|
|
async def find(self,
|
|
name: str,
|
|
value=undefined,
|
|
type=None,
|
|
first: bool=False):
|
|
"""find an option by name (only for optiondescription)"""
|
|
if not first:
|
|
ret = []
|
|
option = self._option_bag.option
|
|
config_bag = self._option_bag.config_bag
|
|
oname = option.impl_getname()
|
|
path = self._subconfig._get_subpath(oname)
|
|
option_bag = OptionBag()
|
|
option_bag.set_option(option,
|
|
None,
|
|
config_bag)
|
|
subconfig = await self._subconfig.get_subconfig(option_bag)
|
|
async for path in subconfig.find(byname=name,
|
|
byvalue=value,
|
|
bytype=type,
|
|
_subpath=option_bag.path,
|
|
config_bag=config_bag):
|
|
t_option = TiramisuOption(path,
|
|
None, # index for a follower ?
|
|
config_bag)
|
|
if first:
|
|
return t_option
|
|
ret.append(t_option)
|
|
return ret
|
|
|
|
@option_type('optiondescription')
|
|
async def group_type(self):
|
|
"""Get type for an optiondescription (only for optiondescription)"""
|
|
return self._option_bag.option.impl_get_group_type()
|
|
|
|
async def _filter(self,
|
|
opt,
|
|
subconfig,
|
|
config_bag):
|
|
settings = config_bag.context.cfgimpl_get_settings()
|
|
option_bag = OptionBag()
|
|
option_bag.set_option(opt,
|
|
None,
|
|
config_bag)
|
|
option_bag.properties = await settings.getproperties(option_bag)
|
|
if opt.impl_is_optiondescription():
|
|
await settings.validate_properties(option_bag)
|
|
return await subconfig.get_subconfig(option_bag)
|
|
await subconfig.getattr(opt.impl_getname(),
|
|
option_bag)
|
|
|
|
@option_type('optiondescription')
|
|
async def list(self,
|
|
type='option',
|
|
group_type=None):
|
|
"""List options (by default list only option)"""
|
|
assert type in ('all', 'option', 'optiondescription'), _('unknown list type {}').format(type)
|
|
assert group_type is None or isinstance(group_type, groups.GroupType), \
|
|
_("unknown group_type: {0}").format(group_type)
|
|
config_bag = self._option_bag.config_bag
|
|
if config_bag.properties and 'warnings' in config_bag.properties:
|
|
config_bag = config_bag.copy()
|
|
config_bag.remove_warnings()
|
|
option = self._option_bag.option
|
|
option_bag = OptionBag()
|
|
option_bag.set_option(option,
|
|
None,
|
|
config_bag)
|
|
subconfig = await self._subconfig.get_subconfig(option_bag)
|
|
options = []
|
|
for opt in await option.get_children(config_bag):
|
|
try:
|
|
await self._filter(opt,
|
|
subconfig,
|
|
config_bag)
|
|
except PropertiesOptionError:
|
|
continue
|
|
if opt.impl_is_optiondescription():
|
|
if type == 'option' or (type == 'optiondescription' and \
|
|
group_type and opt.impl_get_group_type() != group_type):
|
|
continue
|
|
elif type == 'optiondescription':
|
|
continue
|
|
options.append(TiramisuOption(opt.impl_getpath(),
|
|
None,
|
|
self._option_bag.config_bag))
|
|
return options
|
|
|
|
async def _load_dict(self,
|
|
clearable: str="all",
|
|
remotable: str="minimum"):
|
|
root = self._option_bag.option.impl_getpath()
|
|
config = self._option_bag.config_bag.context
|
|
self._tiramisu_dict = TiramisuDict(await self._return_config(config,
|
|
config._storage),
|
|
root=root,
|
|
clearable=clearable,
|
|
remotable=remotable)
|
|
|
|
@option_type('optiondescription')
|
|
async def dict(self,
|
|
clearable: str="all",
|
|
remotable: str="minimum",
|
|
form: List=[],
|
|
force: bool=False) -> Dict:
|
|
"""convert config and option to tiramisu format"""
|
|
if force or self._tiramisu_dict is None:
|
|
await self._load_dict(clearable, remotable)
|
|
return await self._tiramisu_dict.todict(form)
|
|
|
|
@option_type('optiondescription')
|
|
async def updates(self,
|
|
body: List) -> Dict:
|
|
"""updates value with tiramisu format"""
|
|
if self._tiramisu_dict is None:
|
|
await self._load_dict()
|
|
return await self._tiramisu_dict.set_updates(body)
|
|
|
|
|
|
def connection(func):
|
|
async def wrapped(self, *args, **kwargs):
|
|
config_bag = self._config_bag
|
|
async with config_bag.context.getconnection() as connection:
|
|
config_bag.connection = connection
|
|
ret = await func(self, *args, **kwargs)
|
|
del config_bag.connection
|
|
return ret
|
|
return wrapped
|
|
|
|
|
|
class TiramisuContextInformation(TiramisuConfig):
|
|
"""Manage config informations"""
|
|
@connection
|
|
async def get(self,
|
|
name,
|
|
default=undefined,
|
|
):
|
|
"""Get an information"""
|
|
values = self._config_bag.context.cfgimpl_get_values()
|
|
return await values.get_information(self._config_bag,
|
|
None,
|
|
name,
|
|
default,
|
|
)
|
|
|
|
@connection
|
|
async def set(self,
|
|
name,
|
|
value,
|
|
):
|
|
"""Set an information"""
|
|
await self._config_bag.context.impl_set_information(self._config_bag,
|
|
name,
|
|
value,
|
|
)
|
|
|
|
@connection
|
|
async def reset(self,
|
|
name,
|
|
):
|
|
"""Remove an information"""
|
|
await self._config_bag.context.impl_del_information(self._config_bag.connection,
|
|
name,
|
|
)
|
|
|
|
@connection
|
|
async def list(self):
|
|
"""List information's keys"""
|
|
return await self._config_bag.context.impl_list_information(self._config_bag.connection)
|
|
|
|
@connection
|
|
async def exportation(self):
|
|
"""Export all informations"""
|
|
return await self._config_bag.context.cfgimpl_get_values()._p_.exportation_informations(self._config_bag.connection)
|
|
|
|
@connection
|
|
async def importation(self, informations):
|
|
"""Import informations"""
|
|
return await self._config_bag.context.cfgimpl_get_values()._p_.importation_informations(self._config_bag.connection, informations)
|
|
|
|
|
|
class TiramisuContextValue(TiramisuConfig):
|
|
"""Manage config value"""
|
|
@connection
|
|
async def mandatory(self):
|
|
"""Return path of options with mandatory property without any value"""
|
|
options = []
|
|
async for option in self._config_bag.context.cfgimpl_get_values().mandatory_warnings(self._config_bag):
|
|
options.append(option)
|
|
return options
|
|
|
|
# FIXME should be only for group/meta
|
|
@connection
|
|
async def set(self,
|
|
path: str,
|
|
value,
|
|
index=None,
|
|
only_config=undefined,
|
|
force_default=undefined,
|
|
force_default_if_same=undefined,
|
|
force_dont_change_value=undefined):
|
|
"""Set a value in config or children for a path"""
|
|
kwargs = {}
|
|
if only_config is not undefined:
|
|
kwargs['only_config'] = only_config
|
|
if force_default is not undefined:
|
|
kwargs['force_default'] = force_default
|
|
if force_default_if_same is not undefined:
|
|
kwargs['force_default_if_same'] = force_default_if_same
|
|
if force_dont_change_value is not undefined:
|
|
kwargs['force_dont_change_value'] = force_dont_change_value
|
|
return await self._config_bag.context.set_value(path,
|
|
index,
|
|
value,
|
|
self._config_bag,
|
|
**kwargs)
|
|
|
|
# FIXME should be only for group/meta
|
|
@connection
|
|
async def reset(self,
|
|
path: str,
|
|
only_children: bool=False):
|
|
"""Reset value"""
|
|
await self._config_bag.context.reset(path,
|
|
only_children,
|
|
self._config_bag)
|
|
|
|
@connection
|
|
async def dict(self,
|
|
flatten=False,
|
|
withwarning: bool=False,
|
|
fullpath=False,
|
|
leader_to_list=False):
|
|
"""Dict with path as key and value"""
|
|
config_bag = self._config_bag
|
|
if not withwarning and 'warnings' in config_bag.properties:
|
|
config_bag = config_bag.copy()
|
|
config_bag.remove_warnings()
|
|
return await config_bag.context.make_dict(config_bag,
|
|
flatten=flatten,
|
|
fullpath=fullpath,
|
|
leader_to_list=leader_to_list)
|
|
|
|
@connection
|
|
async def exportation(self,
|
|
with_default_owner: bool=False):
|
|
"""Export all values"""
|
|
exportation = await self._config_bag.context.cfgimpl_get_values()._p_.exportation(self._config_bag.connection)
|
|
if not with_default_owner:
|
|
exportation = [list(exportation[0]), list(exportation[1]), list(exportation[2]), list(exportation[3])]
|
|
index = exportation[0].index(None)
|
|
exportation[0].pop(index)
|
|
exportation[1].pop(index)
|
|
exportation[2].pop(index)
|
|
exportation[3].pop(index)
|
|
return exportation
|
|
|
|
@connection
|
|
async def importation(self, values):
|
|
"""Import values"""
|
|
cvalues = self._config_bag.context.cfgimpl_get_values()
|
|
connection = self._config_bag.connection
|
|
if None not in values[0]:
|
|
context_owner = await cvalues.get_context_owner(connection)
|
|
else:
|
|
context_owner = None
|
|
await cvalues._p_.importation(connection,
|
|
values)
|
|
await self._config_bag.context.cfgimpl_reset_cache(None, None)
|
|
if context_owner is not None:
|
|
await cvalues._p_.setvalue(connection,
|
|
None,
|
|
None,
|
|
context_owner,
|
|
None,
|
|
True)
|
|
|
|
|
|
class TiramisuContextSession(TiramisuConfig):
|
|
"""Manage Config session"""
|
|
async def reset(self):
|
|
await self._config_bag.context.cfgimpl_get_values()._p_._storage.delete_session()
|
|
await self._config_bag.context.cfgimpl_get_settings()._p_._storage.delete_session()
|
|
|
|
async def list(self):
|
|
return await self._config_bag.context.cfgimpl_get_values()._p_._storage.list_sessions()
|
|
|
|
async def id(self):
|
|
"""Get config name"""
|
|
return self._config_bag.context.impl_getname()
|
|
|
|
|
|
class TiramisuContextOwner(TiramisuConfig):
|
|
"""Global owner"""
|
|
@connection
|
|
async def get(self):
|
|
"""Get owner"""
|
|
return await self._config_bag.context.cfgimpl_get_values().get_context_owner(self._config_bag.connection)
|
|
|
|
@connection
|
|
async def set(self, owner):
|
|
"""Set owner"""
|
|
try:
|
|
obj_owner = getattr(owners, owner)
|
|
except AttributeError:
|
|
owners.addowner(owner)
|
|
obj_owner = getattr(owners, owner)
|
|
values = self._config_bag.context.cfgimpl_get_values()
|
|
await values.set_context_owner(self._config_bag.connection,
|
|
obj_owner)
|
|
|
|
|
|
class TiramisuContextProperty(TiramisuConfig):
|
|
"""Manage config properties"""
|
|
@connection
|
|
async def read_only(self):
|
|
"""Set config to read only mode"""
|
|
old_props = self._config_bag.properties
|
|
settings = self._config_bag.context.cfgimpl_get_settings()
|
|
await settings.read_only(self._config_bag)
|
|
await self._reset_config_properties(self._config_bag.connection)
|
|
if 'force_store_value' not in old_props and \
|
|
'force_store_value' in self._config_bag.properties:
|
|
await self._force_store_value()
|
|
|
|
@connection
|
|
async def read_write(self):
|
|
"""Set config to read and write mode"""
|
|
old_props = self._config_bag.properties
|
|
settings = self._config_bag.context.cfgimpl_get_settings()
|
|
connection = self._config_bag.connection
|
|
await settings.read_write(self._config_bag)
|
|
or_properties = settings.rw_append - settings.ro_append - SPECIAL_PROPERTIES
|
|
permissives = frozenset(await settings.get_context_permissives(connection) | or_properties)
|
|
await settings.set_context_permissives(connection,
|
|
permissives)
|
|
await self._reset_config_properties(connection)
|
|
if 'force_store_value' not in old_props and \
|
|
'force_store_value' in self._config_bag.properties:
|
|
await self._force_store_value()
|
|
|
|
@connection
|
|
async def add(self, prop):
|
|
"""Add a config property"""
|
|
settings = self._config_bag.context.cfgimpl_get_settings()
|
|
props = set(await self.get())
|
|
if prop not in props:
|
|
props.add(prop)
|
|
await self._set(self._config_bag.connection, frozenset(props))
|
|
|
|
@connection
|
|
async def pop(self, prop):
|
|
"""Remove a config property"""
|
|
props = set(await self.get())
|
|
if prop in props:
|
|
props.remove(prop)
|
|
await self._set(self._config_bag.connection, frozenset(props))
|
|
|
|
async def get(self,
|
|
default=False):
|
|
"""Get all config properties"""
|
|
if default:
|
|
config = self._config_bag.context
|
|
async with config.getconnection() as connection:
|
|
properties = await config.cfgimpl_get_settings().get_context_properties(connection,
|
|
config._impl_properties_cache)
|
|
return self._config_bag.properties
|
|
|
|
async def _set(self,
|
|
connection,
|
|
props):
|
|
"""Personalise config properties"""
|
|
if 'force_store_value' in props:
|
|
force_store_value = 'force_store_value' not in self._config_bag.properties
|
|
else:
|
|
force_store_value = False
|
|
context = self._config_bag.context
|
|
await context.cfgimpl_get_settings().set_context_properties(self._config_bag.connection,
|
|
props,
|
|
self._config_bag.context)
|
|
await self._reset_config_properties(connection)
|
|
if force_store_value:
|
|
await self._force_store_value()
|
|
|
|
@connection
|
|
async def reset(self):
|
|
"""Remove config properties"""
|
|
context = self._config_bag.context
|
|
await context.cfgimpl_get_settings().reset(None,
|
|
self._config_bag)
|
|
await self._reset_config_properties(self._config_bag.connection)
|
|
|
|
@connection
|
|
async def exportation(self):
|
|
"""Export config properties"""
|
|
return await self._config_bag.context.cfgimpl_get_settings()._p_.exportation(self._config_bag.connection)
|
|
|
|
@connection
|
|
async def importation(self, properties):
|
|
"""Import config properties"""
|
|
if 'force_store_value' in properties.get(None, {}).get(None, []):
|
|
force_store_value = 'force_store_value' not in self._config_bag.properties
|
|
else:
|
|
force_store_value = False
|
|
settings = self._config_bag.context.cfgimpl_get_settings()
|
|
connection = self._config_bag.connection
|
|
await self._config_bag.context.cfgimpl_get_settings()._p_.importation(connection,
|
|
properties)
|
|
await self._config_bag.context.cfgimpl_reset_cache(None, None)
|
|
await self._reset_config_properties(connection)
|
|
if force_store_value:
|
|
await self._force_store_value()
|
|
|
|
async def _force_store_value(self):
|
|
descr = self._config_bag.context.cfgimpl_get_description()
|
|
await descr.impl_build_force_store_values(self._config_bag)
|
|
|
|
async def setdefault(self,
|
|
properties: Set[str],
|
|
type: Optional[str]=None,
|
|
when: Optional[str]=None) -> None:
|
|
if not isinstance(properties, frozenset):
|
|
raise TypeError(_('properties must be a frozenset'))
|
|
setting = self._config_bag.context.cfgimpl_get_settings()
|
|
if type is None and when is None:
|
|
setting.default_properties = properties
|
|
else:
|
|
if when not in ['append', 'remove']:
|
|
raise ValueError(_('unknown when {} (must be in append or remove)').format(when))
|
|
if type == 'read_only':
|
|
if when == 'append':
|
|
setting.ro_append = properties
|
|
else:
|
|
setting.ro_remove = properties
|
|
elif type == 'read_write':
|
|
if when == 'append':
|
|
setting.rw_append = properties
|
|
else:
|
|
setting.rw_remove = properties
|
|
else:
|
|
raise ValueError(_('unknown type {}').format(type))
|
|
|
|
async def getdefault(self,
|
|
type: Optional[str]=None,
|
|
when: Optional[str]=None) -> Set[str]:
|
|
setting = self._config_bag.context.cfgimpl_get_settings()
|
|
if type is None and when is None:
|
|
return setting.default_properties
|
|
|
|
if when not in ['append', 'remove']:
|
|
raise ValueError(_('unknown when {} (must be in append or remove)').format(when))
|
|
if type == 'read_only':
|
|
if when == 'append':
|
|
return setting.ro_append
|
|
else:
|
|
return setting.ro_remove
|
|
elif type == 'read_write':
|
|
if when == 'append':
|
|
return setting.rw_append
|
|
else:
|
|
return setting.rw_remove
|
|
else:
|
|
raise ValueError(_('unknown type {}').format(type))
|
|
|
|
|
|
class TiramisuContextPermissive(TiramisuConfig):
|
|
"""Manage config permissives"""
|
|
@connection
|
|
async def get(self):
|
|
"""Get config permissives"""
|
|
return await self._get()
|
|
|
|
async def _get(self):
|
|
return await self._config_bag.context.cfgimpl_get_settings().get_context_permissives(self._config_bag.connection)
|
|
|
|
async def _set(self,
|
|
permissives):
|
|
"""Set config permissives"""
|
|
connection = self._config_bag.connection
|
|
await self._config_bag.context.cfgimpl_get_settings().set_context_permissives(connection, permissives)
|
|
await self._reset_config_properties(connection)
|
|
|
|
@connection
|
|
async def exportation(self):
|
|
"""Export config permissives"""
|
|
return await self._config_bag.context.cfgimpl_get_settings()._pp_.exportation(self._config_bag.connection)
|
|
|
|
@connection
|
|
async def importation(self, permissives):
|
|
"""Import config permissives"""
|
|
settings = self._config_bag.context.cfgimpl_get_settings()
|
|
connection = self._config_bag.connection
|
|
await settings._pp_.importation(connection,
|
|
permissives)
|
|
await self._config_bag.context.cfgimpl_reset_cache(None,
|
|
None)
|
|
await self._reset_config_properties(connection)
|
|
|
|
@connection
|
|
async def reset(self):
|
|
"""Remove config permissives"""
|
|
context = self._config_bag.context
|
|
settings = context.cfgimpl_get_settings()
|
|
connection = self._config_bag.connection
|
|
await settings.reset_permissives(None,
|
|
self._config_bag)
|
|
await self._reset_config_properties(connection)
|
|
|
|
@connection
|
|
async def add(self, prop):
|
|
"""Add a config permissive"""
|
|
props = set(await self._get())
|
|
props.add(prop)
|
|
await self._set(frozenset(props))
|
|
|
|
@connection
|
|
async def pop(self, prop):
|
|
"""Remove a config permissive"""
|
|
props = set(await self._get())
|
|
if prop in props:
|
|
props.remove(prop)
|
|
await self._set(frozenset(props))
|
|
|
|
|
|
class TiramisuContextOption(TiramisuConfig):
|
|
def __init__(self,
|
|
*args,
|
|
**kwargs) -> None:
|
|
self._tiramisu_dict = None
|
|
super().__init__(*args, **kwargs)
|
|
|
|
@connection
|
|
async def find(self,
|
|
name,
|
|
value=undefined,
|
|
type=None,
|
|
first=False):
|
|
"""Find an or a list of options"""
|
|
options = []
|
|
context = self._config_bag.context
|
|
async for path in context.find(byname=name,
|
|
byvalue=value,
|
|
bytype=type,
|
|
config_bag=self._config_bag):
|
|
option = TiramisuOption(path,
|
|
None,
|
|
self._config_bag)
|
|
if first:
|
|
return option
|
|
options.append(option)
|
|
return options
|
|
|
|
async def _filter(self,
|
|
opt,
|
|
subconfig,
|
|
config_bag):
|
|
option_bag = OptionBag()
|
|
option_bag.set_option(opt,
|
|
None,
|
|
config_bag)
|
|
settings = config_bag.context.cfgimpl_get_settings()
|
|
option_bag.properties = await settings.getproperties(option_bag)
|
|
if opt.impl_is_optiondescription():
|
|
await settings.validate_properties(option_bag)
|
|
return await subconfig.get_subconfig(option_bag)
|
|
await subconfig.getattr(opt.impl_getname(),
|
|
option_bag)
|
|
|
|
async def _walk(self,
|
|
option,
|
|
recursive,
|
|
type_,
|
|
group_type,
|
|
config_bag,
|
|
subconfig):
|
|
options = []
|
|
for opt in await option.get_children(config_bag):
|
|
try:
|
|
subsubconfig = await self._filter(opt,
|
|
subconfig,
|
|
config_bag)
|
|
except PropertiesOptionError:
|
|
continue
|
|
if opt.impl_is_optiondescription():
|
|
if recursive:
|
|
options.extend(await self._walk(opt,
|
|
recursive,
|
|
type_,
|
|
group_type,
|
|
config_bag,
|
|
subsubconfig))
|
|
if type_ == 'option' or (type_ == 'optiondescription' and \
|
|
group_type and opt.impl_get_group_type() != group_type):
|
|
continue
|
|
elif type_ == 'optiondescription':
|
|
continue
|
|
options.append(TiramisuOption(opt.impl_getpath(),
|
|
None,
|
|
self._config_bag))
|
|
return options
|
|
|
|
@connection
|
|
async def list(self,
|
|
type='option',
|
|
group_type=None,
|
|
recursive=False):
|
|
"""List options (by default list only option)"""
|
|
assert type in ('all', 'option', 'optiondescription'), _('unknown list type {}').format(type)
|
|
assert group_type is None or isinstance(group_type, groups.GroupType), \
|
|
_("unknown group_type: {0}").format(group_type)
|
|
config_bag = self._config_bag
|
|
if config_bag.properties and 'warnings' in config_bag.properties:
|
|
config_bag = config_bag.copy()
|
|
config_bag.remove_warnings()
|
|
option = config_bag.context.cfgimpl_get_description()
|
|
options = []
|
|
for opt in await self._walk(option,
|
|
recursive,
|
|
type,
|
|
group_type,
|
|
config_bag,
|
|
config_bag.context):
|
|
options.append(opt)
|
|
return options
|
|
|
|
async def _load_dict(self,
|
|
clearable="all",
|
|
remotable="minimum"):
|
|
self._tiramisu_dict = TiramisuDict(await self._return_config(self._config_bag.context,
|
|
self._config_bag.context._storage),
|
|
root=None,
|
|
clearable=clearable,
|
|
remotable=remotable)
|
|
|
|
async def dict(self,
|
|
clearable="all",
|
|
remotable="minimum",
|
|
form=[],
|
|
force=False):
|
|
"""convert config and option to tiramisu format"""
|
|
if force or self._tiramisu_dict is None:
|
|
await self._load_dict(clearable, remotable)
|
|
return await self._tiramisu_dict.todict(form)
|
|
|
|
async def updates(self,
|
|
body: List) -> Dict:
|
|
"""updates value with tiramisu format"""
|
|
if self._tiramisu_dict is None:
|
|
await self._load_dict()
|
|
return await self._tiramisu_dict.set_updates(body)
|
|
|
|
|
|
class _TiramisuContextConfigReset():
|
|
@connection
|
|
async def reset(self):
|
|
"""Remove all datas to current config (informations, values, properties, ...)"""
|
|
# Option's values
|
|
settings = self._config_bag.context.cfgimpl_get_settings()
|
|
connection = self._config_bag.connection
|
|
context_owner = await self._config_bag.context.cfgimpl_get_values().get_context_owner(connection)
|
|
await self._config_bag.context.cfgimpl_get_values()._p_.importation(connection, ([], [], [], []))
|
|
await self._config_bag.context.cfgimpl_get_values()._p_.setvalue(connection,
|
|
None,
|
|
None,
|
|
context_owner,
|
|
None,
|
|
True)
|
|
# Option's informations
|
|
await self._config_bag.context.cfgimpl_get_values()._p_.del_informations(connection)
|
|
# Option's properties
|
|
await self._config_bag.context.cfgimpl_get_settings()._p_.importation(connection, {})
|
|
# Option's permissives
|
|
await self._config_bag.context.cfgimpl_get_settings()._pp_.importation(connection, {})
|
|
# Remove cache
|
|
await self._config_bag.context.cfgimpl_reset_cache(None, None)
|
|
|
|
|
|
class _TiramisuContextConfig(TiramisuConfig, _TiramisuContextConfigReset):
|
|
"""Actions to Config"""
|
|
async def type(self):
|
|
"""Type a Config"""
|
|
return 'config'
|
|
|
|
async def copy(self,
|
|
session_id=None,
|
|
storage=None):
|
|
"""Copy current config"""
|
|
if storage is None:
|
|
storage = self._config_bag.context._storage
|
|
async with self._config_bag.context.getconnection() as connection:
|
|
config = await self._config_bag.context.duplicate(connection,
|
|
session_id,
|
|
storage=storage)
|
|
return await self._return_config(config,
|
|
storage)
|
|
|
|
async def deepcopy(self,
|
|
session_id=None,
|
|
storage=None,
|
|
metaconfig_prefix=None):
|
|
"""Copy current config with all parents"""
|
|
if storage is None:
|
|
storage = self._config_bag.context._storage
|
|
async with self._config_bag.context.getconnection() as connection:
|
|
config = await self._config_bag.context.duplicate(connection,
|
|
session_id,
|
|
storage=storage,
|
|
metaconfig_prefix=metaconfig_prefix,
|
|
deep=[])
|
|
return await self._return_config(config,
|
|
storage)
|
|
|
|
async def metaconfig(self):
|
|
"""Get first meta configuration (obsolete please use parents)"""
|
|
parent = await self.parents()
|
|
if not parent:
|
|
return None
|
|
return parent[0]
|
|
|
|
async def parents(self):
|
|
"""Get all parents of current config"""
|
|
ret = []
|
|
for parent in self._config_bag.context.get_parents():
|
|
ret.append(await self._return_config(parent,
|
|
parent._storage))
|
|
return ret
|
|
|
|
async def path(self):
|
|
"""Get path from config (all parents name)"""
|
|
return self._config_bag.context.cfgimpl_get_config_path()
|
|
|
|
|
|
class _TiramisuContextGroupConfig(TiramisuConfig):
|
|
"""Actions to GroupConfig"""
|
|
async def type(self):
|
|
"""Type a Config"""
|
|
return 'groupconfig'
|
|
|
|
async def list(self):
|
|
"""List children's config"""
|
|
ret = []
|
|
for child in self._config_bag.context.cfgimpl_get_children():
|
|
ret.append(await self._return_config(child,
|
|
child._storage))
|
|
return ret
|
|
|
|
@connection
|
|
async def find(self,
|
|
name: str,
|
|
value=undefined):
|
|
"""Find an or a list of config with finding option"""
|
|
return await GroupConfig(await self._config_bag.context.find_group(byname=name,
|
|
byvalue=value,
|
|
config_bag=self._config_bag))
|
|
|
|
def __call__(self,
|
|
path: Optional[str]):
|
|
"""select a child Tiramisu config"""
|
|
spaths = path.split('.')
|
|
config = self._config_bag.context
|
|
for spath in spaths:
|
|
config = config.getconfig(spath)
|
|
if isinstance(config, KernelGroupConfig):
|
|
return self._return_config(config,
|
|
None)
|
|
return self._return_config(config,
|
|
config._storage)
|
|
|
|
|
|
async def copy(self,
|
|
session_id=None,
|
|
storage=None):
|
|
if storage is None:
|
|
storage = self._config_bag.context._storage
|
|
async with self._config_bag.context.getconnection() as connection:
|
|
config = await self._config_bag.context.duplicate(connection,
|
|
session_id,
|
|
storage=storage)
|
|
return await self._return_config(config,
|
|
storage)
|
|
|
|
async def deepcopy(self,
|
|
session_id=None,
|
|
storage=None,
|
|
metaconfig_prefix=None):
|
|
if storage is None:
|
|
storage = self._config_bag.context._storage
|
|
async with self._config_bag.context.getconnection() as connection:
|
|
config = await self._config_bag.context.duplicate(connection,
|
|
session_id,
|
|
storage=storage,
|
|
metaconfig_prefix=metaconfig_prefix,
|
|
deep=[])
|
|
return await self._return_config(config,
|
|
storage)
|
|
|
|
async def path(self):
|
|
return self._config_bag.context.cfgimpl_get_config_path()
|
|
|
|
async def get(self,
|
|
name: str) -> 'Config':
|
|
config = self._config_bag.context.getconfig(name)
|
|
return await self._return_config(config,
|
|
config._storage)
|
|
|
|
|
|
class _TiramisuContextMixConfig(_TiramisuContextGroupConfig, _TiramisuContextConfigReset):
|
|
"""Actions to MixConfig"""
|
|
async def type(self):
|
|
"""Type a Config"""
|
|
return 'mixconfig'
|
|
|
|
async def new(self,
|
|
session_id,
|
|
storage=None,
|
|
type='config'):
|
|
"""Create and add a new config"""
|
|
config = self._config_bag.context
|
|
if storage is None:
|
|
storage = config._storage
|
|
storage_obj = await storage.get()
|
|
async with storage_obj.Connection() as connection:
|
|
new_config = await config.new_config(connection,
|
|
session_id=session_id,
|
|
storage=storage,
|
|
type_=type,
|
|
)
|
|
return await self._return_config(new_config,
|
|
storage)
|
|
|
|
async def load(self,
|
|
session_id,
|
|
storage=None,
|
|
type='config',
|
|
):
|
|
"""Create and add a new config"""
|
|
config = self._config_bag.context
|
|
if storage is None:
|
|
storage = config._storage
|
|
storage_obj = await storage.get()
|
|
async with storage_obj.Connection() as connection:
|
|
new_config = await config.load_config(connection,
|
|
session_id=session_id,
|
|
storage=storage,
|
|
type_=type,
|
|
)
|
|
return await self._return_config(new_config,
|
|
storage)
|
|
|
|
async def pop(self,
|
|
session_id=None,
|
|
config=None):
|
|
"""Remove config from MetaConfig"""
|
|
if __debug__ and None not in [session_id, config]:
|
|
raise APIError(_('cannot set session_id and config together'))
|
|
pop_config = await self._config_bag.context.pop_config(session_id=session_id, config=config)
|
|
return await self._return_config(pop_config,
|
|
pop_config._storage)
|
|
|
|
async def add(self,
|
|
config):
|
|
"""Add config from MetaConfig"""
|
|
await self._config_bag.context.add_config(config)
|
|
|
|
async def parents(self):
|
|
"""Get all parents of current config"""
|
|
ret = []
|
|
for parent in self._config_bag.context.get_parents():
|
|
ret.append(await self._return_config(parent,
|
|
parent._storage))
|
|
return ret
|
|
|
|
|
|
class _TiramisuContextMetaConfig(_TiramisuContextMixConfig):
|
|
"""Actions to MetaConfig"""
|
|
async def type(self):
|
|
"""Type a Config"""
|
|
return 'metaconfig'
|
|
|
|
|
|
class TiramisuContextCache(TiramisuConfig):
|
|
async def reset(self):
|
|
await self._config_bag.context.cfgimpl_reset_cache(None, None)
|
|
|
|
async def set_expiration_time(self,
|
|
time: int) -> None:
|
|
self._config_bag.expiration_time = time
|
|
|
|
async def get_expiration_time(self) -> int:
|
|
return self._config_bag.expiration_time
|
|
|
|
|
|
class TiramisuAPI(TiramisuHelp):
|
|
_registers = {}
|
|
|
|
def __init__(self,
|
|
config_bag,
|
|
orig_config_bags=None) -> None:
|
|
self._config_bag = config_bag
|
|
self._orig_config_bags = orig_config_bags
|
|
if not self._registers:
|
|
_registers(self._registers, 'TiramisuContext')
|
|
|
|
def __getattr__(self, subfunc: str) -> Any:
|
|
if subfunc == 'option':
|
|
config_bag = self._config_bag
|
|
return TiramisuDispatcherOption(config_bag,
|
|
self._orig_config_bags)
|
|
elif subfunc == 'forcepermissive':
|
|
config_bag = self._config_bag.copy()
|
|
config_bag.set_permissive()
|
|
if self._orig_config_bags is None:
|
|
orig_config_bags = []
|
|
else:
|
|
orig_config_bags = self._orig_config_bags
|
|
orig_config_bags.append(self._config_bag)
|
|
return TiramisuAPI(config_bag, orig_config_bags)
|
|
elif subfunc == 'unrestraint':
|
|
config_bag = self._config_bag.copy()
|
|
config_bag.unrestraint()
|
|
if self._orig_config_bags is None:
|
|
orig_config_bags = []
|
|
else:
|
|
orig_config_bags = self._orig_config_bags
|
|
orig_config_bags.append(self._config_bag)
|
|
return TiramisuAPI(config_bag, orig_config_bags)
|
|
elif subfunc == 'config':
|
|
config_type = self._config_bag.context.impl_type
|
|
if config_type == 'group':
|
|
config = _TiramisuContextGroupConfig
|
|
elif config_type == 'meta':
|
|
config = _TiramisuContextMetaConfig
|
|
elif config_type == 'mix':
|
|
config = _TiramisuContextMixConfig
|
|
else:
|
|
config = _TiramisuContextConfig
|
|
return config(self._config_bag,
|
|
self._orig_config_bags)
|
|
elif subfunc in self._registers:
|
|
config_bag = self._config_bag
|
|
# del config_bag.permissives
|
|
return self._registers[subfunc](config_bag,
|
|
self._orig_config_bags)
|
|
raise APIError(_('please specify a valid sub function ({})').format(subfunc))
|
|
|
|
def __dir__(self):
|
|
return list(self._registers.keys()) + ['unrestraint', 'forcepermissive', 'config']
|
|
|
|
|
|
class TiramisuDispatcherOption(TiramisuContextOption):
|
|
"""Select an option"""
|
|
def __call__(self,
|
|
path: str,
|
|
index: Optional[int]=None) -> TiramisuOption:
|
|
"""Select an option by path"""
|
|
return TiramisuOption(path,
|
|
index,
|
|
self._config_bag)
|
|
|
|
async def __getattr__(self,
|
|
subfunc: str) -> Any:
|
|
if subfunc == 'unrestraint':
|
|
config_bag = self._config_bag.copy()
|
|
config_bag.unrestraint()
|
|
return TiramisuDispatcherOption(config_bag)
|
|
|
|
|
|
@asyncinit
|
|
class Config(TiramisuAPI):
|
|
"""Root config object that enables us to handle the configuration options"""
|
|
async def __init__(self,
|
|
descr: OptionDescription,
|
|
session_id: str=None,
|
|
delete_old_session: bool=False,
|
|
storage=None,
|
|
display_name=None) -> None:
|
|
if storage is None:
|
|
storage = default_storage
|
|
storage_obj = await storage.get()
|
|
async with storage_obj.Connection() as connection:
|
|
if isinstance(descr, KernelConfig):
|
|
config = descr
|
|
else:
|
|
config = await KernelConfig(descr,
|
|
connection=connection,
|
|
session_id=session_id,
|
|
delete_old_session=delete_old_session,
|
|
storage=storage,
|
|
display_name=display_name)
|
|
settings = config.cfgimpl_get_settings()
|
|
properties = await settings.get_context_properties(connection,
|
|
config._impl_properties_cache)
|
|
permissives = await settings.get_context_permissives(connection)
|
|
config_bag = ConfigBag(config,
|
|
properties=properties,
|
|
permissives=permissives)
|
|
super().__init__(config_bag)
|
|
|
|
async def __aenter__(self):
|
|
return self
|
|
|
|
async def __aexit__(self, exc_type, exc, tb):
|
|
await self._config_bag.context.cfgimpl_get_values()._p_._storage.delete_session()
|
|
await self._config_bag.context.cfgimpl_get_settings()._p_._storage.delete_session()
|
|
|
|
def __del__(self):
|
|
try:
|
|
del self._config_bag.context
|
|
del self._config_bag
|
|
del self._orig_config_bags
|
|
except:
|
|
pass
|
|
|
|
|
|
@asyncinit
|
|
class MetaConfig(TiramisuAPI):
|
|
"""MetaConfig object that enables us to handle the sub configuration's options"""
|
|
async def __init__(self,
|
|
children: 'Config'=[],
|
|
session_id: Union[str, None]=None,
|
|
delete_old_session: bool=False,
|
|
optiondescription: Optional[OptionDescription]=None,
|
|
storage=None,
|
|
display_name=None) -> None:
|
|
if storage is None:
|
|
storage = default_storage
|
|
storage_obj = await storage.get()
|
|
async with storage_obj.Connection() as connection:
|
|
if isinstance(children, KernelMetaConfig):
|
|
config = children
|
|
else:
|
|
_children = []
|
|
for child in children:
|
|
if isinstance(child, TiramisuAPI):
|
|
_children.append(child._config_bag.context)
|
|
else:
|
|
_children.append(child)
|
|
|
|
config = await KernelMetaConfig(_children,
|
|
connection=connection,
|
|
session_id=session_id,
|
|
delete_old_session=delete_old_session,
|
|
optiondescription=optiondescription,
|
|
display_name=display_name,
|
|
storage=storage)
|
|
settings = config.cfgimpl_get_settings()
|
|
properties = await settings.get_context_properties(connection,
|
|
config._impl_properties_cache)
|
|
permissives = await settings.get_context_permissives(connection)
|
|
config_bag = ConfigBag(config,
|
|
properties=properties,
|
|
permissives=permissives)
|
|
super().__init__(config_bag)
|
|
|
|
async def __aenter__(self):
|
|
return self
|
|
|
|
async def __aexit__(self, exc_type, exc, tb):
|
|
await self._config_bag.context.cfgimpl_get_values()._p_._storage.delete_session()
|
|
await self._config_bag.context.cfgimpl_get_settings()._p_._storage.delete_session()
|
|
|
|
|
|
@asyncinit
|
|
class MixConfig(TiramisuAPI):
|
|
"""MetaConfig object that enables us to handle the sub configuration's options"""
|
|
async def __init__(self,
|
|
optiondescription: OptionDescription,
|
|
children: List[Config],
|
|
session_id: Optional[str]=None,
|
|
delete_old_session: bool=False,
|
|
storage=None,
|
|
display_name: Callable=None) -> None:
|
|
if storage is None:
|
|
storage = default_storage
|
|
storage_obj = await storage.get()
|
|
async with storage_obj.Connection() as connection:
|
|
if isinstance(children, KernelMixConfig):
|
|
config = children
|
|
else:
|
|
_children = []
|
|
for child in children:
|
|
if isinstance(child, TiramisuAPI):
|
|
_children.append(child._config_bag.context)
|
|
else:
|
|
_children.append(child)
|
|
|
|
config = await KernelMixConfig(optiondescription,
|
|
_children,
|
|
session_id=session_id,
|
|
delete_old_session=delete_old_session,
|
|
storage=storage,
|
|
connection=connection,
|
|
display_name=display_name)
|
|
settings = config.cfgimpl_get_settings()
|
|
properties = await settings.get_context_properties(connection,
|
|
config._impl_properties_cache)
|
|
permissives = await settings.get_context_permissives(connection)
|
|
config_bag = ConfigBag(config,
|
|
properties=properties,
|
|
permissives=permissives)
|
|
super().__init__(config_bag)
|
|
|
|
async def __aenter__(self):
|
|
return self
|
|
|
|
async def __aexit__(self, exc_type, exc, tb):
|
|
await self._config_bag.context.cfgimpl_get_values()._p_._storage.delete_session()
|
|
await self._config_bag.context.cfgimpl_get_settings()._p_._storage.delete_session()
|
|
|
|
|
|
@asyncinit
|
|
class GroupConfig(TiramisuAPI):
|
|
"""GroupConfig that enables us to access the Config"""
|
|
async def __init__(self,
|
|
children,
|
|
session_id: Optional[str]=None) -> None:
|
|
if isinstance(children, KernelGroupConfig):
|
|
config = children
|
|
else:
|
|
_children = []
|
|
for child in children:
|
|
if isinstance(child, TiramisuAPI):
|
|
_children.append(child._config_bag.context)
|
|
else:
|
|
_children.append(child)
|
|
|
|
config = await KernelGroupConfig(_children,
|
|
session_id=session_id)
|
|
config_bag = ConfigBag(config,
|
|
properties=None,
|
|
permissives=None)
|
|
super().__init__(config_bag)
|