only one config

bootstrap.py

@@ -6,9 +6,10 @@ from os.path import isdir, join
 from shutil import rmtree
 from copy import copy
 
-from risotto.utils import CONFIGS, RISOTTO_CONFIG, SERVERS
+from risotto.utils import RISOTTO_CONFIG, SERVERS
-from risotto.image import load
+#from risotto.image import load
-from risotto.machine import templates
+from risotto.machine import templates, load, ROUGAIL_NAMESPACE
+from rougail.utils import normalize_family
 
 
 INSTALL_DIR = RISOTTO_CONFIG['directories']['dest']
@@ -34,53 +35,84 @@ async def main():
     if isdir(INSTALL_DIR):
         rmtree(INSTALL_DIR)
     makedirs(INSTALL_DIR)
-    module_infos = await load(display_name=tiramisu_display_name, clean_directories=True, copy_manual_dir=True)
+    try:
+        module_infos, rougailconfig, config = await load(display_name=tiramisu_display_name,
+                                                         clean_directories=True,
+                                                         copy_manual_dir=True,
+                                                         copy_tests=True,
+                                                         )
+    except Exception as err:
+#        import traceback
+#        traceback.print_exc()
+        print(err)
+        exit(1)
+    modules_done = []
     for server_name in SERVERS:
-        module_name = CONFIGS[server_name]['module_name']
+        module_name = SERVERS[server_name]['module']
-        add_srv = CONFIGS[server_name]['add_srv']
+        module_info = module_infos[module_name]
-        cfg = CONFIGS[server_name]['templates_informations']
+        subconfig = config.option(normalize_family(server_name))
-        cfg['tmp_dir'] = 'tmp'
+        try:
-        cfg['destinations_dir'] = join(INSTALL_DIR, module_name, CONFIG_DEST_DIR, server_name)
+            add_srv = await subconfig.option('machine.add_srv').value.get()
+        except AttributeError:
+            add_srv = False
+        rougailconfig['tmp_dir'] = 'tmp'
+        rougailconfig['destinations_dir'] = join(INSTALL_DIR, module_name, CONFIG_DEST_DIR, server_name)
+        rougailconfig['templates_dir'] = module_info['infos'].templates_dir
+        if module_name == 'host':
+            tmpfile = await subconfig.option(f'{ROUGAIL_NAMESPACE}.host_install_dir').value.get()
+            rougailconfig['tmpfile_dest_dir'] = f'{tmpfile}/host/configurations/{server_name}'
+            rougailconfig['default_systemd_directory'] = '/usr/local/lib/systemd'
+        else:
+            rougailconfig['tmpfile_dest_dir'] = '/usr/local/lib'
+            rougailconfig['default_systemd_directory'] = '/systemd'
+#        cfg['templates_dir'] = module_info['infos'].templates_dir
         if isdir('tmp'):
             rmtree('tmp')
-        makedirs(cfg['tmp_dir'])
+        makedirs(rougailconfig['tmp_dir'])
-        makedirs(cfg['destinations_dir'])
+        makedirs(rougailconfig['destinations_dir'])
         if add_srv:
             srv = join(INSTALL_DIR, SRV_DEST_DIR, server_name)
         else:
             srv = None
-        await templates(server_name, **CONFIGS[server_name],  srv=srv)
+        await templates(server_name,
-    for server_name in SERVERS:
+                        subconfig,
-        config = CONFIGS[server_name]['config']
+                        rougailconfig,
+                        srv=srv,
+                        )
+        #
         await config.property.read_write()
         try:
-#            pass
+            await subconfig.option('general.hide_secret').value.set(True)
-            await config.option('general.hide_secret').value.set(True)
+        except AttributeError as err:
-        except AttributeError:
+            # print(err)
-            # if rougail.general.hide_secret not exists
             pass
         await config.property.read_only()
-    for server_name in SERVERS:
+        rougailconfig['destinations_dir'] = join(INSTALL_DIR, module_name, CONFIG_DIFF_DIR, server_name)
-        config = CONFIGS[server_name]['config']
+        rmtree('tmp')
-        await config.value.dict()
+        makedirs(rougailconfig['tmp_dir'])
-    for server_name in SERVERS:
+        makedirs(rougailconfig['destinations_dir'])
-        module_name = CONFIGS[server_name]['module_name']
+        await templates(server_name,
-        destinations_dir = join(INSTALL_DIR, module_name, CONFIG_DIFF_DIR, server_name)
+                        subconfig,
-        makedirs(destinations_dir)
+                        rougailconfig,
-        CONFIGS[server_name]['templates_informations']['destinations_dir'] = destinations_dir
+                        )
-        await templates(server_name, **CONFIGS[server_name])
+        await config.property.read_write()
-    for module_name, cfg in module_infos.items():
+        try:
+            await subconfig.option('general.hide_secret').value.set(False)
+        except AttributeError as err:
+            pass
+        await config.property.read_only()
+        #
+        if module_name not in modules_done:
+            rougailconfig['destinations_dir'] = join(INSTALL_DIR, module_name, CONFIG_ORI_DIR)
+            rmtree('tmp')
+            makedirs(rougailconfig['tmp_dir'])
+            makedirs(rougailconfig['destinations_dir'])
+            await templates(server_name,
+                            subconfig,
+                            rougailconfig,
+                            just_copy=True,
+                            )
+            modules_done.append(module_name)
         with open(join(INSTALL_DIR, module_name, 'install_machines'), 'w') as fh:
-            for idx, server_name in enumerate(cfg['infos'].servers):
+            fh.write(f'./install_machine {module_name} {server_name}\n')
-                if not idx:
-                    destinations_dir = join(INSTALL_DIR, module_name, CONFIG_ORI_DIR)
-                    makedirs(destinations_dir)
-                    CONFIGS[server_name]['templates_informations']['destinations_dir'] = destinations_dir
-                    await templates(server_name,
-                                    **CONFIGS[server_name],
-                                    just_copy=True,
-                                    )
-                fh.write(f'./install_machine {module_name} {server_name}\n')
-
-
 run(main())

funcs.py

@@ -5,7 +5,7 @@ from secrets import token_urlsafe as _token_urlsafe
 
 from rougail.utils import normalize_family
 
-from risotto.utils import multi_function, DOMAINS, ZONES, load_zones, load_zones_server, load_domains, ZONES_SERVER
+from risotto.utils import multi_function, DOMAINS, ZONES, load_zones, load_zones_server, load_domains, SERVERS_JSON
 from risotto.x509 import gen_cert as _x509_gen_cert, gen_ca as _x509_gen_ca, gen_pub as _x509_gen_pub, has_pub as _x509_has_pub
 
 
@@ -19,7 +19,7 @@ def get_chain(authority_cn: str,
               ):
     if hide:
         return "XXXXX"
-    if not authority_name or authority_name is None:
+    if not authority_cn or not authority_name or authority_name is None:
         if isinstance(authority_name, list):
             return []
         return
@@ -142,7 +142,7 @@ def get_internal_zones() -> List[str]:
 def get_zones_info(type: str) -> str:
     load_zones_server()
     ret = []
-    for data in ZONES_SERVER['zones'].values():
+    for data in SERVERS_JSON['zones'].values():
         ret.append(data[type])
     return ret
 
@@ -160,19 +160,4 @@ def get_internal_zone_information(zone: str,
         return ZONES[zone]['gateway'] + '/' + ZONES[zone]['network'].split('/')[-1]
     return ZONES[zone][info]
 
-
-def get_internal_info_in_zone(zone: str,
-                              auto: bool,
-                              type: str,
-                              index: int=None,
-                              ) -> List[str]:
-    if not auto:
-        return
-    for domain_name, domain in DOMAINS.items():
-        if zone == domain_name:
-            if type == 'host':
-                return list(domain[0])
-            else:
-                return domain[1][index]
-
 # =============================================================

src/risotto/image.py

@@ -1,25 +1,30 @@
 from shutil import copy2, copytree, rmtree
 from os import listdir, makedirs
-from os.path import join, isdir, isfile
+from os.path import join, isdir, isfile, dirname
 from yaml import load as yaml_load, SafeLoader
 from json import load as json_load
-
+#
-from .utils import CONFIGS, RISOTTO_CONFIG, SERVERS, ZONES_SERVER, value_pprint
+from rougail import RougailConfig  # , RougailConvert
-from .machine import load_machine_config
+#
+from .utils import RISOTTO_CONFIG, SERVERS, MULTI_FUNCTIONS
 
 
-FUNCTIONS = 'funcs.py'
+FUNCTIONS_FILE = 'funcs.py'
 
 
 class ModuleCfg():
-    def __init__(self):
+    def __init__(self, module_name):
+        self.module_name = module_name
         self.dictionaries_dir = []
         self.modules = []
-        self.functions_file = [FUNCTIONS]
+        self.functions_file = [FUNCTIONS_FILE]
         self.templates_dir = []
         self.extra_dictionaries = {}
         self.servers = []
 
+    def __repr__(self):
+        return str(vars(self))
+
 
 def list_applications() -> dict:
     """
@@ -40,8 +45,6 @@ def list_applications() -> dict:
 def applicationservice_copy(src_file: str,
                             dst_file: str,
                             copy_if_not_exists: bool,
-                            manual_dir: str,
-                            filename: str,
                             ) -> None:
     if isdir(src_file):
         if not isdir(dst_file):
@@ -55,12 +58,13 @@ def applicationservice_copy(src_file: str,
                 else:
                     copytree(src, dst)
     elif not copy_if_not_exists or not isfile(dst_file):
-        src = join(manual_dir, filename)
+        dst = dirname(dst_file)
-        dst = dst_file
+        if not isdir(dst):
-        if isfile(src):
+            makedirs(dst)
-            copy2(src, dst)
+        if isfile(src_file):
+            copy2(src_file, dst_file)
         else:
-            copytree(src, dst)
+            copytree(src_file, dst_file)
 
 
 def load_applicationservice_cfg(appname: str,
@@ -68,6 +72,7 @@ def load_applicationservice_cfg(appname: str,
                                 install_dir: str,
                                 cfg: ModuleCfg,
                                 copy_manual_dir: bool,
+                                copy_tests: bool,
                                 ) -> None:
     cfg.modules.append(appname)
     # dictionaries
@@ -109,8 +114,16 @@ def load_applicationservice_cfg(appname: str,
                 applicationservice_copy(src_file,
                                         dst_file,
                                         copy_if_not_exists,
-                                        manual_dir,
+                                        )
-                                        filename,
+    if copy_tests:
+        tests_dir = join(as_dir, 'tests')
+        if isdir(tests_dir):
+            for filename in listdir(tests_dir):
+                src_file = join(tests_dir, filename)
+                dst_file = join(install_dir, 'tests', filename)
+                applicationservice_copy(src_file,
+                                        dst_file,
+                                        False,
                                         )
 
 
@@ -120,10 +133,12 @@ def load_applicationservice(appname: str,
                             cfg: ModuleCfg,
                             applications: dict,
                             copy_manual_dir: bool,
+                            copy_tests: bool,
                             providers: dict,
+                            suppliers: dict,
                             ) -> None:
     if appname not in applications:
-        raise Exception(f'cannot find application dependency "{appname}" in application "{module_name}"')
+        raise Exception(f'cannot find application dependency "{appname}"')
     as_dir = applications[appname]
     applicationservice_file = join(as_dir, 'applicationservice.yml')
     if not isfile(applicationservice_file):
@@ -133,6 +148,7 @@ def load_applicationservice(appname: str,
                                 install_dir,
                                 cfg,
                                 copy_manual_dir,
+                                copy_tests,
                                 )
     added.append(appname)
     with open(applicationservice_file) as yaml:
@@ -142,6 +158,11 @@ def load_applicationservice(appname: str,
         providers.setdefault(provider, [])
         if appname not in providers[provider]:
             providers[provider].append(appname)
+    supplier = app.get('supplier')
+    if supplier:
+        suppliers.setdefault(supplier, [])
+        if appname not in suppliers[supplier]:
+            suppliers[supplier].append(appname)
     for xml in app.get('depends', []):
         if xml in added:
             continue
@@ -151,17 +172,22 @@ def load_applicationservice(appname: str,
                                 cfg,
                                 applications,
                                 copy_manual_dir,
+                                copy_tests,
                                 providers,
+                                suppliers,
                                 )
 
 
-def load_image_informations(install_dir: str,
+def load_image_informations(module_name: str,
+                            install_dir: str,
                             datas: dict,
                             applications: dict,
                             copy_manual_dir: bool,
+                            copy_tests: bool,
                             providers: dict,
+                            suppliers: dict,
                             ) -> ModuleCfg:
-    cfg = ModuleCfg()
+    cfg = ModuleCfg(module_name)
     added = []
     for applicationservice in datas['applicationservices']:
         load_applicationservice(applicationservice,
@@ -170,53 +196,35 @@ def load_image_informations(install_dir: str,
                                 cfg,
                                 applications,
                                 copy_manual_dir,
+                                copy_tests,
                                 providers,
+                                suppliers,
                                 )
     return cfg
 
 
-async def load_informations(server_name, datas, config):
+async def valid_mandatories(config):
-    await config.information.set('server_name', server_name)
-    if 'informations' not in datas:
-        return
-    for information, value in datas['informations'].items():
-        await config.information.set(information, value)
-    if 'extra_domainnames' in datas['informations']:
-        for idx, extra_domainname in enumerate(datas['informations']['extra_domainnames']):
-            if extra_domainname in CONFIGS:
-                raise Exception(f'server "{server_name}" is duplicate')
-            value = list(CONFIGS[server_name])
-            value[4] = idx + 1
-            CONFIGS[extra_domainname] = tuple(value)
-
-
-async def set_values(server_name, config, datas):
-    try:
-        if 'values' in datas:
-            for path, value in datas['values'].items():
-                if isinstance(value, dict):
-                    for idx, val in value.items():
-                        await config.option(path, int(idx)).value.set(val)
-                else:
-                    await config.option(path).value.set(value)
-    except Exception as err:
-        await value_pprint(await config.value.dict(), config)
-        error_msg = f'cannot configure server "{server_name}": {err}'
-        raise Exception(error_msg) from err
-    #await config.value.dict()
-
-
-async def valid_mandatories(server_name, config):
     mandatories = await config.value.mandatory()
     if mandatories:
-        print()
+        server_name = None
-        print(f'=== Configuration: {server_name} ===')
+        for mandatory in mandatories:
-        await config.property.pop('mandatory')
+            path_server_name, path = mandatory.split('.', 1)
-        await value_pprint(await config.value.dict(), config)
+            var_server_name = await config.option(path_server_name).option.description()
-        raise Exception(f'server "{server_name}" has mandatories variables without values "{", ".join(mandatories)}"')
+            if server_name != var_server_name:
+                server_name = var_server_name
+                print()
+                print(f'=== Missing variables for {server_name} ===')
+            print(f' - {path}')
+            # await config.property.pop('mandatory')
+            # await value_pprint(await config.value.dict(), config)
+        exit(1)
+        #raise Exception('configuration has mandatories variables without values')
 
 
-def load_config(copy_manual_dir=False, clean_directories=False):
+def load_config(copy_manual_dir=False,
+                copy_tests=False,
+                clean_directories=False,
+                ):
     module_infos = {}
     applications = list_applications()
     with open('servers.json', 'r') as server_fh:
@@ -225,74 +233,46 @@ def load_config(copy_manual_dir=False, clean_directories=False):
         modules = jsonfile['modules']
     for module_name, datas in modules.items():
         providers = {}
+        suppliers = {}
         install_dir = join(RISOTTO_CONFIG['directories']['dest'], module_name)
         if clean_directories:
             if isdir(install_dir):
                 rmtree(install_dir)
             makedirs(install_dir)
-        module_infos[module_name] = {'infos': load_image_informations(install_dir,
+        module_infos[module_name] = {'infos': load_image_informations(module_name,
+                                                                      install_dir,
                                                                       datas,
                                                                       applications,
                                                                       copy_manual_dir,
+                                                                      copy_tests,
                                                                       providers,
+                                                                      suppliers,
                                                                       ),
                                      'providers': providers,
+                                     'suppliers': suppliers,
                                      'install_dir': install_dir,
                                      }
     return module_infos
-    
+#
-
+#
-
+def load_module_config(module_name: str,
-async def load(display_name=None,
+                       module_info: dict,
-               clean_directories=False,
+                       ):
-               copy_manual_dir=False,
+    cfg = RougailConfig.copy()
-               hide_secret=False,
+    cfg['variable_namespace'] = ROUGAIL_NAMESPACE
-               ):
+    cfg['variable_namespace_description'] = ROUGAIL_NAMESPACE_DESCRIPTION
-    # load images
+    if module_name == 'host':
-    module_infos = load_config(copy_manual_dir, clean_directories)
+        #FIXME server_name == host ?
-    # load machines
+        #FIXME cfg['tmpfile_dest_dir'] = datas['values'][f'{ROUGAIL_NAMESPACE}.host_install_dir'] + '/host/configurations/host'
-    ZONES_SERVER['providers'] = {}
+        cfg['default_systemd_directory'] = '/usr/local/lib/systemd'
-    for server_name, datas in SERVERS.items():
+    cfg['templates_dir'] = module_info['infos'].templates_dir
-        if server_name in CONFIGS:
+    cfg['dictionaries_dir'] = module_info['infos'].dictionaries_dir
-            raise Exception(f'server "{server_name}" is duplicate')
+    cfg['functions_file'] = module_info['infos'].functions_file
-        module_info = module_infos[datas['module']]
+    cfg['multi_functions'] = MULTI_FUNCTIONS
-        CONFIGS[server_name] = await load_machine_config(server_name,
+    cfg['extra_dictionaries'] = module_info['infos'].extra_dictionaries
-                                                         datas,
+    cfg['extra_annotators'] = ['risotto.rougail']
-                                                         module_info,
+    cfg['internal_functions'] = list(FUNCTIONS.keys())
-                                                         display_name=display_name,
+    cfg['force_convert_dyn_option_description'] = True
-                                                         )
+    cfg['module_name'] = module_name
-        if module_info['providers'] and  'informations' in datas and 'zones_name' in datas['informations']:
+    #cfg['patches_dir'] = join(test_dir, 'patches')
-            for zone_idx, zone_name in enumerate(datas['informations']['zones_name']):
+    return cfg
-                if not zone_idx:
-                    sname = server_name
-                else:
-                    sname = datas['informations']['extra_domainnames'][zone_idx - 1]
-                ZONES_SERVER['providers'].setdefault(zone_name, {})
-                for provider in module_info['providers']:
-                    ZONES_SERVER['providers'][zone_name].setdefault(provider, []).append(sname)
-    # set servers.json values
-    for server_name, datas in SERVERS.items():
-        config = CONFIGS[server_name]['config']
-        await load_informations(server_name, datas, config)
-        await config.property.read_write()
-        if hide_secret:
-            try:
-                await config.option('general.hide_secret').value.set(True)
-            except AttributeError:
-                pass
-        await set_values(server_name, config, datas)
-        await config.property.read_only()
-    # force calculates all values (for linked values)
-    for server_name in SERVERS:
-        config = CONFIGS[server_name]['config']
-        await config.property.pop('mandatory')
-        try:
-            await config.value.dict()
-        except Exception as err:
-            raise Exception(f'cannot display config for "{server_name}": {err}')
-        await config.property.add('mandatory')
-    # validate mandatories values
-    for server_name in SERVERS:
-        await valid_mandatories(server_name, CONFIGS[server_name]['config'])
-
-    return module_infos

src/risotto/machine.py

@@ -1,342 +1,31 @@
-from os import makedirs
+from .utils import SERVERS, SERVERS_JSON, MULTI_FUNCTIONS, load_domains
-from os.path import join, isdir
+from .image import load_config, valid_mandatories  # , load_modules_rougail_config
-from warnings import warn_explicit
-from typing import Any
-
-from tiramisu import Config
-from tiramisu.error import ValueWarning
 from rougail import RougailConfig, RougailConvert
-from .utils import MULTI_FUNCTIONS, CONFIGS, DOMAINS, value_pprint
+from .rougail.annotator import calc_providers, calc_providers_global, calc_providers_dynamic, calc_providers_dynamic_follower, calc_providers_follower
+from os import makedirs
+#
+from tiramisu import Config
+from .utils import value_pprint
 from rougail.utils import normalize_family
 from rougail import RougailSystemdTemplate
-
+#
-
+#
-ROUGAIL_NAMESPACE = 'general'
+async def set_values(server_name, config, datas):
-ROUGAIL_NAMESPACE_DESCRIPTION = 'Général'
+    if 'values' not in datas:
-
-
-async def set_linked_multi_variables(value: str,
-                                     linked_server: str=None,
-                                     variable_index: int=None,
-                                     linked_returns: str=None,
-                                     dynamic: str=None,
-                                     **kwargs: dict,
-                                     ) -> None:
-    if value is not None and linked_server is not None and 'linked_value_0' not in kwargs:
-        kwargs['linked_value_0'] = value
-    elif not linked_server:
-        linked_server = value
-    if not linked_server:
         return
-    if linked_server not in CONFIGS:
+    server_path = normalize_family(server_name)
-        warn_explicit(ValueWarning(f'cannot find linked server "{linked_server}"'),
+    for vpath, value in datas['values'].items():
-                      ValueWarning,
+        path = f'{server_path}.{vpath}'
-                      __file__,
-                      3,
-                      )
-        return
-    config = CONFIGS[linked_server]['config']
-    dico = {}
-    variables = {}
-    for key, kvalue in kwargs.items():
         try:
-            index = int(key.rsplit('_', 1)[-1])
+            if isinstance(value, dict):
-        except ValueError:
+                for idx, val in value.items():
-            raise Exception(f'unknown variable {key}')
+                    await config.option(path, int(idx)).value.set(val)
-        if kvalue is None and not kwargs.get(f'allow_none_{index}', False):
-            return
-        if f'linked_value_{index}' not in kwargs:
-            # value is disabled
-            continue
-        if key.startswith('linked_provider_'):
-            path = await config.information.get('provider:' + kvalue, None)
-            if not path:
-                return
-            if index not in variables:
-                variables[index] = {'path': None, 'value': None, 'variable_index': False}
-            variables[index]['path'] = path
-        elif key.startswith('linked_value_'):
-            index = int(key[13])
-            if index not in variables:
-                variables[index] = {'path': None, 'value': None, 'variable_index': False}
-            variables[index]['value'] = kvalue
-        elif key.startswith('variable_index_'):
-            index = int(key[15])
-            if index not in variables:
-                variables[index] = {'path': None, 'value': None, 'variable_index': False}
-            variables[index]['variable_index'] = True
-        elif key.startswith('allow_none_'):
-            pass
-        else:
-            raise AttributeError(f'unknown parameter {key}')
-    await config.property.read_write()
-    if not isinstance(variables[0]['value'], list):
-        variables[0]['value'] = [variables[0]['value']]
-    if dynamic:
-        dynamic = normalize_family(dynamic)
-    _dynamic = None
-    try:
-        if variables[0]['value']:
-            for first_idx, first_value in enumerate(variables[0]['value']):
-                slave_idxes = []
-                if dynamic:
-                    _dynamic = dynamic
-                else:
-                    _dynamic = normalize_family(first_value)
-                for index in sorted(list(variables)):
-                    path = variables[index]['path']
-                    if '{suffix}' in path:
-                        path = path.replace('{suffix}', _dynamic)
-                    elif first_idx != 0:
-                        continue
-                    vvalue = variables[index]['value']
-                    option = config.forcepermissive.option(path)
-                    if not await option.option.isfollower():
-                        #print('===>', path, vvalue, await option.option.ismulti(), await option.option.issubmulti())
-                        multi = await option.option.ismulti()
-                        if multi:
-                            isleader = await option.option.isleader()
-                            if not isinstance(vvalue, list):
-                                vvalue = [vvalue]
-    #                        elif isleader:
-    #                            raise Exception('leader must not be a multi from now ...')
-                            values = await option.value.get()
-                            for val in vvalue:
-                                if val not in values:
-                                    if isleader:
-                                        slave_idxes.append(len(values))
-                                    values.append(val)
-                                elif isleader:
-                                    slave_idxes.append(values.index(val))
-                            await option.value.set(values)
-                            await option.owner.set('link')
-                        else:
-                            if isinstance(vvalue, list) and len(vvalue) == 1:
-                                vvalue = vvalue[0]
-                            await option.value.set(vvalue)
-                            await option.owner.set('link')
-                    else:
-                        # print('===<', path, vvalue, await option.option.ismulti(), await option.option.issubmulti())
-                        if not slave_idxes:
-                            raise Exception('please declare the leader variable before the follower')
-                        if variables[index]['variable_index']:
-                            vvalue = vvalue[variable_index]
-                        if not isinstance(vvalue, list):
-                            vvalue = [vvalue] * len(slave_idxes)
-    #                    if isinstance(vvalue, list) and not await option.option.issubmulti():
-                        for idx, val in enumerate(vvalue):
-                            option = config.forcepermissive.option(path, slave_idxes[idx])
-                            await option.value.set(val)
-                            await option.owner.set('link')
-    except Exception as err:
-        await config.property.read_only()
-        raise err from err
-    await config.property.read_only()
-    if not dynamic:
-        dynamic = _dynamic
-
-
-    if linked_returns is not None:
-        linked_variable = await config.information.get('provider:' + linked_returns, None)
-        if not linked_variable:
-            warn_explicit(ValueWarning(f'cannot find linked variable "{linked_returns}" in linked server "{linked_server}"'),
-                          ValueWarning,
-                          __file__,
-                          0,
-                          )
-            return
-        if dynamic:
-            linked_variable = linked_variable.replace('{suffix}', normalize_family(dynamic))
-        elif '{suffix}' in linked_variable:
-            idx = CONFIGS[linked_server]['interface_index']
-            linked_variable = linked_variable.replace('{suffix}', str(idx))
-        ret = await config.forcepermissive.option(linked_variable).value.get()
-    else:
-        ret = get_ip_from_domain(linked_server)
-    return ret
-
-
-async def set_linked(linked_server: str,
-                     linked_provider: str,
-                     linked_value: str,
-                     linked_returns: str=None,
-                     dynamic: str=None,
-                     ):
-    if None in (linked_server, linked_provider, linked_value):
-        return
-    if linked_server not in CONFIGS:
-        warn_explicit(ValueWarning(f'cannot find linked server "{linked_server}"'),
-                      ValueWarning,
-                      __file__,
-                      0,
-                      )
-        return
-    config = CONFIGS[linked_server]['config']
-    path = await config.information.get('provider:' + linked_provider, None)
-    if not path:
-        warn_explicit(ValueWarning(f'cannot find provider "{linked_provider}" in linked server "{linked_server}"'),
-                      ValueWarning,
-                      __file__,
-                      0,
-                      )
-        return
-    await config.property.read_write()
-    try:
-        option = config.forcepermissive.option(path)
-        if await option.option.ismulti():
-            values = await option.value.get()
-            if linked_value not in values:
-                values.append(linked_value)
-                await option.value.set(values)
-                await option.owner.set('link')
-        else:
-            await option.value.set(linked_value)
-            await option.owner.set('link')
-    except Exception as err:
-        await config.property.read_only()
-        raise err from err
-    await config.property.read_only()
-    if linked_returns is not None:
-        linked_variable = await config.information.get('provider:' + linked_returns, None)
-        if not linked_variable:
-            warn_explicit(ValueWarning(f'cannot find linked variable "{linked_returns}" in linked server "{linked_server}"'),
-                          ValueWarning,
-                          __file__,
-                          0,
-                          )
-            return
-    else:
-        linked_variable = None
-    if linked_variable is not None:
-        if dynamic:
-            linked_variable = linked_variable.replace('{suffix}', normalize_family(dynamic))
-        elif '{suffix}' in linked_variable:
-            idx = CONFIGS[linked_server]['interface_index']
-            linked_variable = linked_variable.replace('{suffix}', str(idx))
-        ret = await config.forcepermissive.option(linked_variable).value.get()
-    else:
-        ret = normalize_family(linked_value)
-    return ret
-
-
-async def get_linked_configuration(linked_server: str,
-                                   linked_provider: str,
-                                   dynamic: str=None,
-                                   ):
-    if linked_server not in CONFIGS:
-        warn_explicit(ValueWarning(f'cannot find linked server "{linked_server}"'),
-                      ValueWarning,
-                      __file__,
-                      1,
-                      )
-        return
-    config = CONFIGS[linked_server]['config']
-    path = await config.information.get('provider:' + linked_provider, None)
-    if not path:
-        warn_explicit(ValueWarning(f'cannot find variable "{path}" in linked server "{linked_server}"'),
-                      ValueWarning,
-                      __file__,
-                      1,
-                      )
-        return
-    if dynamic:
-        path = path.replace('{suffix}', normalize_family(dynamic))
-    try:
-        return await config.forcepermissive.option(path).value.get()
-    except AttributeError as err:
-        warn_explicit(ValueWarning(f'cannot find get value of "{path}" in linked server "{linked_server}": {err}'),
-                      ValueWarning,
-                      __file__,
-                      1,
-                      )
-
-
-class Empty:
-    pass
-empty = Empty()
-
-
-async def set_linked_configuration(_linked_value: Any,
-                                   linked_server: str,
-                                   linked_provider: str,
-                                   linked_value: Any=empty,
-                                   dynamic: str=None,
-                                   leader_provider: str=None,
-                                   leader_value: Any=None,
-                                   leader_index: int=None,
-                                   ):
-    if linked_value is not empty:
-        _linked_value = linked_value
-    linked_value = _linked_value
-    if linked_server is None:
-        return
-    if linked_value is None or linked_server not in CONFIGS:
-        warn_explicit(ValueWarning(f'cannot find linked server "{linked_server}"'),
-                      ValueWarning,
-                      __file__,
-                      2,
-                      )
-        return
-    config = CONFIGS[linked_server]['config']
-    path = await config.information.get('provider:' + linked_provider, None)
-    if not path:
-        warn_explicit(ValueWarning(f'cannot find variable "{path}" in linked server "{linked_server}"'),
-                      ValueWarning,
-                      __file__,
-                      2,
-                      )
-        return
-    if dynamic:
-        path = path.replace('{suffix}', normalize_family(dynamic))
-    await config.property.read_write()
-    try:
-        if leader_provider is not None:
-            leader_path = await config.information.get('provider:' + leader_provider, None)
-            if not leader_path:
-                await config.property.read_only()
-                warn_explicit(ValueWarning(f'cannot find leader variable with leader_provider "{leader_provider}" in linked server "{linked_server}"'),
-                              ValueWarning,
-                              __file__,
-                              2,
-                              )
-                return
-            if dynamic:
-                leader_path = leader_path.replace('{suffix}', normalize_family(dynamic))
-            values = await config.forcepermissive.option(leader_path).value.get()
-            if not isinstance(leader_value, list):
-                leader_value = [leader_value]
-            for lv in leader_value:
-                if lv in values:
-                    slave_idx = values.index(lv)
-                    slave_option = config.forcepermissive.option(path, slave_idx)
-                    if await slave_option.option.issubmulti():
-                        slave_values = await slave_option.value.get()
-                        if linked_value not in slave_values:
-                            slave_values.append(linked_value)
-                            await slave_option.value.set(slave_values)
-                            await slave_option.owner.set('link')
-                    else:
-                        await slave_option.value.set(linked_value)
-                        await slave_option.owner.set('link')
-        else:
-            option = config.forcepermissive.option(path, leader_index)
-            if leader_index is None and await option.option.ismulti() and not isinstance(linked_value, list):
-                values = await option.value.get()
-                if linked_value not in values:
-                    values.append(linked_value)
-                    await option.value.set(values)
-                    await option.owner.set('link')
             else:
-                await option.value.set(linked_value)
+                await config.option(path).value.set(value)
-                await option.owner.set('link')
+        except Exception as err:
-    except AttributeError as err:
+            await value_pprint(await config.value.dict(), config)
-        if linked_provider == 'oauth2_external':
+            error_msg = f'cannot configure variable {vpath} for server "{server_name}": {err}'
-            raise ValueError(str(err)) from err
+            raise Exception(error_msg) from err
-        pass
-    except Exception as err:
-        await config.property.read_only()
-        raise err from err
-    await config.property.read_only()
 
 
 def get_ip_from_domain(domain):
@@ -344,59 +33,18 @@ def get_ip_from_domain(domain):
         return
     hostname, domainname = domain.split('.', 1)
     return DOMAINS[domainname][1][DOMAINS[domainname][0].index(hostname)]
+    return optiondescription['option_0']
 
 
-async def load_machine_config(server_name: str,
+ROUGAIL_NAMESPACE = 'general'
-                              datas: dict,
+ROUGAIL_NAMESPACE_DESCRIPTION = 'Général'
-                              module_info: dict,
+FUNCTIONS = {'get_ip_from_domain': get_ip_from_domain,
-                              display_name,
+             'calc_providers': calc_providers,
-                              ):
+             'calc_providers_global': calc_providers_global,
-    optiondescription = {'set_linked': set_linked,
+             'calc_providers_dynamic': calc_providers_dynamic,
-                         'set_linked_multi_variables': set_linked_multi_variables,
+             'calc_providers_dynamic_follower': calc_providers_dynamic_follower,
-                         'get_linked_configuration': get_linked_configuration,
+             'calc_providers_follower': calc_providers_follower,
-                         'set_linked_configuration': set_linked_configuration,
+             }
-                         'get_ip_from_domain': get_ip_from_domain,
-                         }
-    cfg = RougailConfig.copy()
-    module_info['infos'].servers.append(server_name)
-    cfg['variable_namespace'] = ROUGAIL_NAMESPACE
-    cfg['variable_namespace_description'] = ROUGAIL_NAMESPACE_DESCRIPTION
-    if datas['module'] == 'host':
-        cfg['tmpfile_dest_dir'] = datas['values'][f'{ROUGAIL_NAMESPACE}.host_install_dir'] + '/host/configurations/' + server_name
-    cfg['templates_dir'] = module_info['infos'].templates_dir
-    cfg['dictionaries_dir'] = module_info['infos'].dictionaries_dir
-    cfg['functions_file'] = module_info['infos'].functions_file
-    cfg['multi_functions'] = MULTI_FUNCTIONS
-    cfg['extra_dictionaries'] = module_info['infos'].extra_dictionaries
-    cfg['extra_annotators'].append('risotto.rougail')
-    cfg['internal_functions'] = list(optiondescription.keys())
-    try:
-        eolobj = RougailConvert(cfg)
-    except Exception as err:
-        print(f"Try to load {module_info['infos'].modules}")
-        raise err from err
-    tiram_obj = eolobj.save(None)
-#    if server_name == 'revprox.in.silique.fr':
-#        print(tiram_obj)
-    #cfg['patches_dir'] = join(test_dir, 'patches')
-    try:
-        exec(tiram_obj, None, optiondescription)
-    except Exception as err:
-        print(tiram_obj)
-        raise Exception(f'unknown error when load tiramisu object {err}') from err
-    config = await Config(optiondescription['option_0'], display_name=display_name)
-    await config.property.read_write()
-    try:
-        add_srv = await config.option('machine.add_srv').value.get()
-    except AttributeError:
-        add_srv = False
-    return {'config': config,
-            'templates_informations': cfg,
-            'interface_index': 0,
-            'module_name': datas['module'],
-            'add_srv': add_srv,
-            'providers': module_info['providers'],
-            }
 
 
 async def templates(server_name,
@@ -404,24 +52,100 @@ async def templates(server_name,
                     templates_informations,
                     srv=False,
                     just_copy=False,
-                    **kwargs,
                     ):
-    values = await config.value.dict()
     engine = RougailSystemdTemplate(config, templates_informations)
     if just_copy:
+        # for all engine to none
+        ori_engines = {}
         for eng in engine.engines:
-            if eng != 'none':
+            if eng == 'none':
-                engine.engines[eng] = engine.engines['none']
+                continue
-#    if server_name == 'dovecot.in.silique.fr':
+            ori_engines[eng] = engine.engines[eng]
-#        print()
+            engine.engines[eng] = engine.engines['none']
-#        print(f'=== Configuration: {server_name} ===')
-#        pprint(values)
     try:
         await engine.instance_files()
     except Exception as err:
         print()
         print(f'=== Configuration: {server_name} ===')
+        values = await config.value.dict()
         await value_pprint(values, config)
-        raise err from err
+        print(err)
+        print(await config.option('general.nginx.nginx_default_http').value.get())
+        exit(1)
+        #raise err from err
+    if just_copy:
+        for eng, old_engine in ori_engines.items():
+            engine.engines[eng] = old_engine
     if srv:
         makedirs(srv)
+
+
+
+async def load(display_name=None,
+               clean_directories=False,
+               copy_manual_dir=False,
+               copy_tests=False,
+               hide_secret=False,
+               ):
+    #load_zones()
+#    # load images
+    #FIXME useful
+    module_infos = load_config(copy_manual_dir, 
+                               copy_tests,
+                               clean_directories,
+                               )
+#    modules_rougail_config = load_modules_rougail_config(module_infos)
+    cfg = RougailConfig.copy()
+    cfg['variable_namespace'] = ROUGAIL_NAMESPACE
+    cfg['variable_namespace_description'] = ROUGAIL_NAMESPACE_DESCRIPTION
+    cfg['multi_functions'] = MULTI_FUNCTIONS
+    cfg['extra_annotators'] = ['risotto.rougail']
+    cfg['internal_functions'] = list(FUNCTIONS.keys())
+    cfg['force_convert_dyn_option_description'] = True
+#        cfg['module_name'] = module_name
+    functions_files = set()
+    load_domains()
+    for server_name, datas in SERVERS.items():
+        module_info = module_infos[datas['module']]
+        functions_files |= set(module_info['infos'].functions_file)
+    cfg['functions_file'] = list(functions_files)
+    eolobj = RougailConvert(cfg)
+    cfg['risotto_globals'] = {}
+    for server_name, datas in SERVERS.items():
+        module_info = module_infos[datas['module']]
+        cfg['dictionaries_dir'] = module_info['infos'].dictionaries_dir
+        cfg['extra_dictionaries'] = module_info['infos'].extra_dictionaries
+        informations = SERVERS_JSON['servers'][server_name].get('informations')
+        if informations:
+            cfg['risotto_globals'][server_name] = {'global:server_name': server_name,
+                                                   'global:zones_name': informations['zones_name'],
+                                                   'global:zones_list': list(range(len(informations['zones_name']))),
+                                                   }
+            values = []
+            for s_idx in cfg['risotto_globals'][server_name]['global:zones_list']:
+                if not s_idx:
+                    values.append(server_name)
+                else:
+                    values.append(informations['extra_domainnames'][s_idx - 1])
+            cfg['risotto_globals'][server_name]['global:server_names'] = values
+        else:
+            cfg['risotto_globals'][server_name] = {'global:server_name': server_name}
+        eolobj.load_dictionaries(path_prefix=server_name)
+    tiram_obj = eolobj.save(None)
+    optiondescription = FUNCTIONS.copy()
+    try:
+        exec(tiram_obj, None, optiondescription)
+    except Exception as err:
+        print(tiram_obj)
+        raise Exception(f'unknown error when load tiramisu object {err}') from err
+    config = await Config(optiondescription['option_0'],
+                          display_name=display_name,
+                          )
+    await config.property.pop('validator')
+    await config.property.pop('cache')
+    for server_name, datas in SERVERS.items():
+        await set_values(server_name, config, datas)
+    await config.property.read_only()
+    await config.property.add('cache')
+    await valid_mandatories(config)
+    return module_infos, cfg, config

src/risotto/rougail/annotator.py

@@ -1,5 +1,122 @@
 from rougail.annotator.variable import Walk
-from risotto.utils import _
+from risotto.utils import _, multi_function
+from warnings import warn
+
+
+
+def _parse_kwargs(provider, dns, kwargs, index=None):
+    values = {}
+    for key, value in kwargs.items():
+        if '_' not in key:
+            raise Exception(f'unknown attribute {key} in calc_providers_global with provider {provider}')
+        k, idx = key.rsplit('_', 1)
+        values.setdefault(idx, {})[k] = value
+    for idx, data in values.items():
+        if index is not None and int(idx) != index:
+            continue
+        if 'dns' not in data or (isinstance(data['dns'], list) and dns not in data['dns']) or (not isinstance(data['dns'], list) and data['dns'] != dns):
+            continue
+        del data['dns']
+        yield data
+
+
+@multi_function
+def calc_providers_global(provider, multi, value, suffix=None):
+    if suffix is not None:
+        return value[int(suffix)]
+    return value
+
+
+@multi_function
+def calc_providers_follower(provider, multi, dns, leader, index, **kwargs):
+    ret = []
+    for data in _parse_kwargs(provider, dns, kwargs):
+        if 'value' not in data:
+            continue
+        if 'leader' in data:
+            if isinstance(data['leader'], list):
+                for idx, leader_iter in enumerate(data['leader']):
+                    if leader_iter == leader:
+                        ret.append(data['value'][idx])
+            elif data['leader']== leader:
+                ret.extend(data['value'])
+        else:
+            if isinstance(data['value'], list):
+                for v in data['value']:
+                    if v not in ret:
+                        ret.append(v)
+            elif data['value'] not in ret:
+                ret.append(data['value'])
+    if multi: 
+        return ret
+    if ret:
+        return ret[0]
+
+
+@multi_function
+def calc_providers_dynamic_follower(provider, multi, dns, leader, index, suffix, **kwargs):
+    ret = []
+    for data in _parse_kwargs(provider, dns, kwargs):
+        if 'value' not in data:
+            continue
+        if data['dynamic'] != suffix:
+            continue
+        if 'leader' in data:
+            for idx, leader_iter in enumerate(data['leader']):
+                if leader_iter == leader:
+                    if isinstance(data['value'], list):
+                        ret.append(data['value'][idx])
+                    else:
+                        ret.append(data['value'])
+        else:
+            if isinstance(data['value'], list):
+                for v in data['value']:
+                    if v not in ret:
+                        ret.append(v)
+            elif data['value'] not in ret:
+                ret.append(data['value'])
+    if multi: 
+        return ret
+    if ret:
+        return ret[0]
+
+
+@multi_function
+def calc_providers_dynamic(provider, multi, dns, suffix, **kwargs):
+    ret = []
+    for data in _parse_kwargs(provider, dns, kwargs):
+        if 'value' not in data:
+            continue
+        if data['dynamic'] != suffix:
+            continue
+        if isinstance(data['value'], list):
+            for v in data['value']:
+                if v not in ret:
+                    ret.append(v)
+        elif data['value'] not in ret:
+            ret.append(data['value'])
+    if multi: 
+        return ret
+    if ret:
+        return ret[0]
+
+
+@multi_function
+def calc_providers(provider, multi, dns, suffix=None, **kwargs):
+    ret = []
+    for data in _parse_kwargs(provider, dns, kwargs):
+        if isinstance(data['value'], list):
+            for v in data['value']:
+                if v in ret:
+                    continue
+                ret.append(v)
+
+        elif data['value'] not in ret:
+            ret.append(data['value'])
+    if multi: 
+        return ret
+    if ret:
+        return ret[0]
 
 
 class Annotator(Walk):
@@ -10,48 +127,217 @@ class Annotator(Walk):
         self.objectspace = objectspace
 #        self.convert_get_linked_information()
 #        self.convert_provider()
+        self.set_suppliers()
+        self.convert_providers()
+        self.convert_suppliers()
 
-    def convert_get_linked_information(self):
+    def set_suppliers(self) -> dict:
-        if not hasattr(self.objectspace.space, 'constraints') or \
+        """ get supplier informations
-                not hasattr(self.objectspace.space.constraints, 'fill'):
+        return something like:
-            return
+        {'Host': ['host1.example.net', 'host2.example.net']}
-        for fill in self.objectspace.space.constraints.fill:
+        """
-            if fill.name == 'get_linked_configuration':
+        self.suppliers = {}
-                # add server_name
+        for variable in self.get_variables():
-                param = self.objectspace.param(fill.xmlfiles)
+            if not hasattr(variable, 'supplier') or ':' in variable.supplier:
-                param.name = 'server_name'
-                param.type = 'information'
-                param.text = 'server_name'
-                fill.param.append(param)
-                # add current_user
-                param = self.objectspace.param(fill.xmlfiles)
-                param.name = 'current_user'
-                param.type = 'information'
-                param.text = 'current_user'
-                fill.param.append(param)
-                # add test
-                param = self.objectspace.param(fill.xmlfiles)
-                param.name = 'test'
-                param.type = 'target_information'
-                param.text = 'test'
-                fill.param.append(param)
-
-    def convert_provider(self):
-        if not hasattr(self.objectspace.space, 'variables'):
-            return
-        for family in self.get_families():
-            if not hasattr(family, 'provider'):
                 continue
-            if 'dynamic' not in vars(family):
+            nf_dns = variable.path.split('.', 1)[0]
-                raise Exception(_(f'{family.name} is not a dynamic family so cannot have provider attribute'))
+            server_name = self.objectspace.space.variables[nf_dns].doc
-            if not hasattr(family, 'information'):
+            self.suppliers.setdefault(variable.supplier, []).append({'option': variable, 'dns': server_name, 'path_prefix': nf_dns, 'zones': set(self.objectspace.rougailconfig['risotto_globals'][server_name]['global:zones_name'])})
-                family.information = self.objectspace.information(family.xmlfiles)
+
-            family.information.provider = family.provider
+    def convert_suppliers(self):
-            del family.provider
+        for supplier, data in self.suppliers.items():
+            if supplier == 'Host':
+                continue
+            for s_dico in data:
+                if supplier not in self.providers:
+                    continue
+                for p_dico in self.providers[supplier]:
+                    if s_dico['zones'] & p_dico['zones']:
+                        s_dico['option'].value = p_dico['dns']
+                        new_value = self.objectspace.value(None)
+                        new_value.name = p_dico['dns']
+                        s_dico['option'].value = [new_value]
+                        break
+
+
+    def convert_providers(self):
+        self.providers = {}
         for variable in self.get_variables():
             if not hasattr(variable, 'provider'):
                 continue
-            if not hasattr(variable, 'information'):
+            nf_dns = variable.path.split('.', 1)[0]
-                variable.information = self.objectspace.information(variable.xmlfiles)
+            server_name = self.objectspace.space.variables[nf_dns].doc
-            variable.information.provider = variable.provider
+            provider_name = variable.provider
-            del variable.provider
+            if ':' in provider_name:
+                key_name, key_type = provider_name.rsplit(':', 1)
+                is_provider = False
+            else:
+                key_name = key_type = provider_name
+                is_provider = True
+                if provider_name != 'Host':
+                    self.providers.setdefault(provider_name, []).append({'option': variable, 'dns': server_name, 'path_prefix': nf_dns, 'zones': set(self.objectspace.rougailconfig['risotto_globals'][server_name]['global:zones_name'])})
+            if key_name != 'global' and key_name not in self.suppliers:
+                #warn(f'cannot find supplier "{key_name}" for "{server_name}"')
+                continue
+            # create a fill for this variable
+            fill = self.objectspace.fill(variable.xmlfiles)
+            new_target = self.objectspace.target(variable.xmlfiles)
+            new_target.name = variable
+            fill.target = [new_target]
+            if key_name == 'global':
+                fill.name = 'calc_providers_global'
+            elif self.objectspace.paths.is_dynamic(variable):
+                if self.objectspace.paths.is_follower(variable):
+                    fill.name = 'calc_providers_dynamic_follower'
+                else:
+                    fill.name = 'calc_providers_dynamic'
+            elif self.objectspace.paths.is_follower(variable):
+                fill.name = 'calc_providers_follower'
+            else:
+                fill.name = 'calc_providers'
+            fill.namespace = variable.namespace
+            fill.index = 0
+            # first parameter: the provider name (something link Host:incoming_ports)
+            param = self.objectspace.param(variable.xmlfiles)
+            param.name = 'provider'
+            param.text = provider_name
+            fill.param = [param]
+            # second parameter: current variable is a multi variable?
+            param = self.objectspace.param(variable.xmlfiles)
+            param.name = 'multi'
+            param.text = variable.multi
+            param.type = 'boolean'
+            fill.param.append(param)
+            if self.objectspace.paths.is_follower(variable):
+                param = self.objectspace.param(variable.xmlfiles)
+                param.name = 'leader'
+                param.text = self.objectspace.paths.get_leader(variable)
+                param.propertyerror = False
+                param.type = 'variable'
+                fill.param.append(param)
+                try:
+                    leader_provider = self.objectspace.paths.get_leader(variable).provider
+                except:
+                    leader_provider = None
+                #
+                param = self.objectspace.param(variable.xmlfiles)
+                param.name = 'index'
+                param.type = 'index'
+                fill.param.append(param)
+            if self.objectspace.paths.is_dynamic(variable):
+                # if dynamic: current suffix
+                # and add current DNS name, this is useful to known if supplier is link to this provider
+                param = self.objectspace.param(variable.xmlfiles)
+                param.name = 'suffix'
+                param.type = 'suffix'
+                fill.param.append(param)
+            if key_name != 'global':
+                param = self.objectspace.param(variable.xmlfiles)
+                param.name = 'dns'
+                param.text = server_name
+                fill.param.append(param)
+            if key_name == 'global':
+                param = self.objectspace.param(variable.xmlfiles)
+                param.text = self.objectspace.rougailconfig['risotto_globals'][server_name][provider_name]
+                param.name = 'value'
+                fill.param.append(param)
+            else:
+                # parse all supplier link to current provider
+                for idx, data in enumerate(self.suppliers[key_name]):
+                    option = data['option']
+                    dns = data['dns']
+                    # if not provider, get the true option that we want has value
+                    if not is_provider:
+                        path_prefix = data['path_prefix']
+                        try:
+                            supplier_option = self.objectspace.paths.get_supplier(f'supplier:{provider_name}', path_prefix)
+                        except KeyError:
+                            #warn(f'cannot find supplier "{provider_name}" for "{dns}"')
+                            continue
+                    # first of all, get the supplier name
+                    param = self.objectspace.param(variable.xmlfiles)
+                    param.name = f'dns_{idx}'
+                    param.text = option
+                    param.propertyerror = False
+                    param.type = 'variable'
+                    fill.param.append(param)
+                    if not is_provider and \
+                            self.objectspace.paths.is_follower(variable):
+                        param = self.objectspace.param(variable.xmlfiles)
+                        param.name = f'leader_{idx}'
+                        if fill.name == 'calc_providers_follower':
+                            param.text = dns
+                        else:
+                            if self.objectspace.paths.is_follower(supplier_option):
+                                param.text = self.objectspace.paths.get_leader(supplier_option)
+                            else:
+                                param.text = self.objectspace.paths.get_supplier(f'supplier:{leader_provider}', path_prefix)
+                            param.propertyerror = False
+                            param.type = 'variable'
+                        fill.param.append(param)
+                    # get the current DNS name for dynamic variable
+                    if self.objectspace.paths.is_dynamic(variable):
+                        param = self.objectspace.param(variable.xmlfiles)
+                        param.name = f'dynamic_{idx}'
+                        param.text = dns
+                        fill.param.append(param)
+                    # get the current value!
+                    param = self.objectspace.param(variable.xmlfiles)
+                    param.name = f'value_{idx}'
+                    if is_provider:
+                        param.text = dns
+                    else:
+                        param.text = supplier_option
+                        param.propertyerror = False
+                        param.type = 'variable'
+                    fill.param.append(param)
+            if not hasattr(self.objectspace.space.variables[nf_dns], 'constraints'):
+                self.objectspace.space.variables[nf_dns].constraints = self.objectspace.constraints(None)
+            if not hasattr(self.objectspace.space.variables[nf_dns].constraints, 'fill'):
+                self.objectspace.space.variables[nf_dns].constraints.fill = []
+            self.objectspace.space.variables[nf_dns].constraints.fill.append(fill)
+
+#    def convert_get_linked_information(self):
+#        if not hasattr(self.objectspace.space, 'constraints') or \
+#                not hasattr(self.objectspace.space.constraints, 'fill'):
+#            return
+#        for fill in self.objectspace.space.constraints.fill:
+#            if fill.name == 'get_linked_configuration':
+#                # add server_name
+#                param = self.objectspace.param(fill.xmlfiles)
+#                param.name = 'server_name'
+#                param.type = 'information'
+#                param.text = 'server_name'
+#                fill.param.append(param)
+#                # add current_user
+#                param = self.objectspace.param(fill.xmlfiles)
+#                param.name = 'current_user'
+#                param.type = 'information'
+#                param.text = 'current_user'
+#                fill.param.append(param)
+#                # add test
+#                param = self.objectspace.param(fill.xmlfiles)
+#                param.name = 'test'
+#                param.type = 'target_information'
+#                param.text = 'test'
+#                fill.param.append(param)
+#
+#    def convert_provider(self):
+#        if not hasattr(self.objectspace.space, 'variables'):
+#            return
+#        for family in self.get_families():
+#            if not hasattr(family, 'provider'):
+#                continue
+#            if 'dynamic' not in vars(family):
+#                raise Exception(_(f'{family.name} is not a dynamic family so cannot have provider attribute'))
+#            if not hasattr(family, 'information'):
+#                family.information = self.objectspace.information(family.xmlfiles)
+#            family.information.provider = family.provider
+#            del family.provider
+#        for variable in self.get_variables():
+#            if not hasattr(variable, 'provider'):
+#                continue
+#            if not hasattr(variable, 'information'):
+#                variable.information = self.objectspace.information(variable.xmlfiles)
+#            variable.information.provider = variable.provider
+#            del variable.provider

src/risotto/utils.py

@@ -6,12 +6,13 @@ from toml import load as toml_load
 from pprint import pprint
 
 
+SETTINGS = {'config': None}
 MULTI_FUNCTIONS = []
-CONFIGS = {}
 DOMAINS = {}
 ZONES = {}
-ZONES_SERVER = {}
+SERVERS_JSON = {}
 SERVERS = {}
+CONFIGS = {}
 
 
 with open(environ.get('CONFIG_FILE', 'risotto.conf'), 'r') as fh:
@@ -40,10 +41,10 @@ async def value_pprint(dico, config):
 
 
 def load_zones_server():
-    if 'zones' in ZONES_SERVER:
+    if 'zones' in SERVERS_JSON:
         return
     with open('servers.json', 'r') as server_fh:
-        ZONES_SERVER.update(load(server_fh))
+        SERVERS_JSON.update(load(server_fh))
 
 
 def load_zones():
@@ -52,8 +53,8 @@ def load_zones():
         return
 
     load_zones_server()
-    ZONES.update(ZONES_SERVER['zones'])
+    ZONES.update(SERVERS_JSON['zones'])
-    for server_name, server in ZONES_SERVER['servers'].items():
+    for server_name, server in SERVERS_JSON['servers'].items():
         if 'informations' not in server:
             continue
         server_zones = server['informations']['zones_name']
@@ -78,7 +79,7 @@ def load_domains():
     if DOMAINS:
         return
     load_zones()
-    for zone_name, zone in ZONES_SERVER['zones'].items():
+    for zone_name, zone in SERVERS_JSON['zones'].items():
         if 'domain_name' in zone:
             hosts = []
             ips = []
@@ -103,5 +104,4 @@ def _get_ip(server_name: str,
     if server_name not in zone['hosts']:
         raise ValueError(f"cannot set IP in unknown server '{server_name}'")
     server_index = zone['hosts'].index(server_name)
-#    print(server_name, zones_name, index, str(ip_address(zone['start_ip']) + server_index))
     return str(ip_address(zone['start_ip']) + server_index)

src/risotto/x509.py

@@ -155,7 +155,7 @@ def gen_cert_iter(cn,
         raise Exception(f'cannot find CA file "{cert_ca_name}"')
     if not isfile(cert_name):
         if not isfile(key_ca_name):
-            raise Exception(f"cannot find CA private key (\"{authority_cn}\") to sign certificat for \"{cn}\", is it a Let's Encrypt certification?")
+            raise Exception(f"cannot find CA private key (\"{authority_cn}\") to sign certificat for \"{cn}\" ({key_ca_name}), is it a Let's Encrypt certification?")
         if not isdir(dir_name):
             makedirs(dir_name)
         if isfile(sn_name):