def create_module_config(module_name, mod_path=None, build=True): """ Create the frontend config """ if not mod_path: mod_path = str(GN_EXTERNAL_MODULE / module_name) manifest_path = os.path.join(mod_path, 'manifest.toml') # Create the frontend config for a module and rebuild if build=True conf_manifest = utilstoml.load_and_validate_toml(manifest_path, ManifestSchemaProdConf) # import du module dans le sys.path module_parent_dir = str(Path(mod_path).parent) module_schema_conf = "{}.config.conf_schema_toml".format( Path(mod_path).name) # noqa sys.path.insert(0, module_parent_dir) module = __import__(module_schema_conf, globals=globals()) front_module_conf_file = os.path.join(mod_path, 'config/conf_gn_module.toml') # noqa config_module = utilstoml.load_and_validate_toml( front_module_conf_file, module.config.conf_schema_toml.GnModuleSchemaConf) frontend_config_path = os.path.join( mod_path, 'frontend/app/module.config.ts') # noqa try: with open(str(ROOT_DIR / frontend_config_path), 'w') as outputfile: outputfile.write("export const ModuleConfig = ") json.dump(config_module, outputfile, indent=True, sort_keys=True) except FileNotFoundError: log.info('No frontend config file') if build: build_geonature_front()
def import_legacy_module(module_object): sys.path.insert( 0, str(GN_EXTERNAL_MODULE)) # to be able to import non-packaged modules try: # module dist is module_code.lower() because the symlink is created like this # in utils.gn_module_import.copy_in_external_mods module_dist = module_object.module_code.lower() module_dir = GN_EXTERNAL_MODULE / module_dist manifest_path = module_dir / 'manifest.toml' if not manifest_path.is_file(): raise NoManifestFound() module_manifest = load_and_validate_toml(manifest_path, ManifestSchemaProdConf) module_blueprint = import_module( f'{module_dist}.backend.blueprint').blueprint module_config = { 'ID_MODULE': module_object.id_module, 'MODULE_CODE': module_object.module_code, 'MODULE_URL': '/' + module_object.module_path.replace(' ', ''), 'FRONTEND_PATH': str(module_dir / 'frontend'), } module_schema = import_module( f'{module_object.module_code.lower()}.config.conf_schema_toml' ).GnModuleSchemaConf config_path = module_dir / "config/conf_gn_module.toml" module_config.update(load_and_validate_toml(config_path, module_schema)) module_blueprint.config = module_config return module_config, module_blueprint finally: sys.path.pop(0)
def list_and_import_gn_modules(app, mod_path=GN_EXTERNAL_MODULE): """ Get all the module enabled from gn_commons.t_modules register the configuration and import the module programaticly """ with app.app_context(): from geonature.core.gn_commons.models import TModules modules = DB.session.query(TModules).filter(TModules.active_backend == True) module_info = {} enabled_modules_name = [] for mod in modules: enabled_modules_name.append(mod.module_code) module_info[mod.module_code] = { "ID_MODULE": mod.id_module, "MODULE_URL": "/" + mod.module_path.replace(" ", ""), "MODULE_CODE": mod.module_code, } # iter over external_modules dir # and import only modules which are enabled for f in mod_path.iterdir(): if f.is_dir(): conf_manifest = load_and_validate_toml( str(f / "manifest.toml"), ManifestSchemaProdConf ) # set module code upper because module call is always upper in gn_commons.t_modules module_code = conf_manifest["module_code"].upper() if module_code in enabled_modules_name: # import du module dans le sys.path module_path = Path(GN_EXTERNAL_MODULE / module_code.lower()) module_parent_dir = str(module_path.parent) module_import_name = "{}.config.conf_schema_toml".format( module_path.name ) sys.path.insert(0, module_parent_dir) module = __import__(module_import_name) # get and validate the module config class GnModuleSchemaProdConf( module.config.conf_schema_toml.GnModuleSchemaConf ): pass conf_module = load_and_validate_toml( str(f / "config/conf_gn_module.toml"), GnModuleSchemaProdConf ) # add id_module and url_path to the module config update_module_config = dict(conf_module, **module_info.get(module_code)) # register the module conf in the app config app.config[module_code] = update_module_config # import the blueprint python_module_name = "{}.backend.blueprint".format(module_path.name) module_blueprint = __import__(python_module_name, globals=globals()) # register the confif in bluprint.config module.backend.blueprint.blueprint.config = update_module_config sys.path.pop(0) yield update_module_config, conf_manifest, module_blueprint
def load_config(config_file=None): """ Load the geonature configuration from a given file """ # load and validate configuration configs_py = load_and_validate_toml(str(get_config_file_path(config_file)), GnPySchemaConf) # Settings also exported to backend configs_gn = load_and_validate_toml(str(get_config_file_path(config_file)), GnGeneralSchemaConf) return ChainMap({}, configs_py, configs_gn)
def run_install_gn_module(app, module_path, module_name, url): ''' Installation du module en executant : configurations install_env.sh installation des dépendances python install_db.py install_app.py ''' # configs try: from conf_schema_toml import GnModuleSchemaConf load_and_validate_toml( Path(module_path) / "config/conf_gn_module.toml", GnModuleSchemaConf) except ImportError: log.info('No specific config file') pass # requirements gn_module_import_requirements(module_path) # ENV gn_file = Path(module_path) / "install_env.sh" log.info("run install_env.sh") try: subprocess.call([str(gn_file)], cwd=str(module_path)) log.info("...%s\n", MSG_OK) except FileNotFoundError: pass except OSError as ex: if ex.errno == 8: raise GNModuleInstallError( ("Unable to execute '{}'. One possible reason is " "the lack of shebang line.").format(gn_file)) if os.access(str(gn_file), os.X_OK): # TODO: try to make it executable # TODO: change exception type # TODO: make error message # TODO: change print to log raise GNModuleInstallError("File {} not excecutable".format( str(gn_file))) # APP gn_file = Path(module_path) / "install_gn_module.py" if gn_file.is_file(): log.info("run install_gn_module.py") from install_gn_module import gnmodule_install_app gnmodule_install_app(DB, app) log.info("...%s\n", MSG_OK)
def load_config(config_file=None): """ Load the geonature configuration from a given file """ # load and validate configuration configs_py = load_and_validate_toml( str(get_config_file_path(config_file)), GnPySchemaConf ) # Settings also exported to backend configs_gn = load_and_validate_toml( str(get_config_file_path(config_file)), GnGeneralSchemaConf ) return ChainMap({}, configs_py, configs_gn)
def import_gn_module(mod): sys.path.insert( 0, str(GN_EXTERNAL_MODULE)) # to be able to import non-packaged modules try: module_name = mod.module_path module = import_module(module_name) module_path = Path(module.__file__).parent manifest_path = module_path / 'manifest.toml' module_config = { 'ID_MODULE': mod.id_module, 'MODULE_CODE': mod.module_code, 'BACKEND_PATH': str(module_path / 'backend'), 'FRONTEND_PATH': str(module_path / 'frontend'), } if manifest_path.is_file(): # non-packaged module module_manifest = load_and_validate_toml( module_path / 'manifest.toml', ManifestSchemaProdConf) module_schema = import_module( f'{module_name}.config.conf_schema_toml').GnModuleSchemaConf module_blueprint = import_module( f'{module_name}.backend.blueprint').blueprint config_path = str(module_path / "config/conf_gn_module.toml") module_config.update({ 'MODULE_URL': '/' + mod.module_path.replace(' ', ''), }) else: module_blueprint = load_entry_point(module_name, 'gn_module', 'blueprint') module_schema = load_entry_point(module_name, 'gn_module', 'config_schema') config_path = os.environ.get( f'GEONATURE_{mod.module_code}_CONFIG_FILE') if not config_path: # fallback to legacy conf path guessing # .parent.parent goes up 'backend/{module_name}' config_path = str(module_path.parent.parent / 'config/conf_gn_module.toml') module_config.update({ 'MODULE_URL': '/' + mod.module_code.lower(), }) module_config.update(load_and_validate_toml(config_path, module_schema)) #app.config[mod.module_code] = module_config module_blueprint.config = module_config return module, module_blueprint finally: sys.path.pop(0)
def check_manifest(module_path): """ Verification de la version de geonature par rapport au manifest Retourne le code du module en majuscule """ log.info("checking manifest") configs_py = utilstoml.load_and_validate_toml( str(Path(module_path) / "manifest.toml"), ManifestSchemaConf ) gn_v = version.parse(GEONATURE_VERSION) if gn_v < version.parse( configs_py["min_geonature_version"] ) and gn_v > version.parse(configs_py["max_geonature_version"]): raise GeoNatureError( "Geonature version {} is imcompatible with module".format(GEONATURE_VERSION) ) for e_gn_v in configs_py["exclude_geonature_versions"]: if gn_v == version.parse(e_gn_v): raise GeoNatureError( "Geonature version {} is imcompatible with module".format( GEONATURE_VERSION ) ) log.info("...%s\n", MSG_OK) return configs_py["module_code"].upper()
def check_manifest(module_path): """ Verification de la version de geonature par rapport au manifest Retourne le code du module en majuscule """ log.info("checking manifest") configs_py = utilstoml.load_and_validate_toml( str(Path(module_path) / "manifest.toml"), ManifestSchemaConf ) gn_v = version.parse(GEONATURE_VERSION) if gn_v < version.parse( configs_py["min_geonature_version"] ) and gn_v > version.parse(configs_py["max_geonature_version"]): raise GeoNatureError( "Geonature version {} is imcompatible with module".format( GEONATURE_VERSION) ) for e_gn_v in configs_py["exclude_geonature_versions"]: if gn_v == version.parse(e_gn_v): raise GeoNatureError( "Geonature version {} is imcompatible with module".format( GEONATURE_VERSION ) ) log.info("...%s\n", MSG_OK) return configs_py["module_code"].upper()
def import_packaged_module(module_dist, module_object): module_code = module_object.module_code module_dir = GN_EXTERNAL_MODULE / module_object.module_path frontend_path = os.environ.get(f'GEONATURE_{module_code}_FRONTEND_PATH', str(module_dir / 'frontend')) module_config = { 'MODULE_CODE': module_code, 'MODULE_URL': '/' + module_object.module_path, 'FRONTEND_PATH': frontend_path, } try: module_schema = load_entry_point(module_dist, 'gn_module', 'config_schema') except ImportError: pass else: config_path = os.environ.get( f'GEONATURE_{module_object.module_code}_CONFIG_FILE') if not config_path: # fallback to legacy conf path guessing config_path = str(module_dir / 'config/conf_gn_module.toml') module_config.update(load_and_validate_toml(config_path, module_schema)) blueprint_entry_point = get_entry_info(module_dist, 'gn_module', 'blueprint') if blueprint_entry_point: module_blueprint = blueprint_entry_point.load() module_blueprint.config = module_config else: module_blueprint = None return (module_object, module_config, module_blueprint)
def create_frontend_config(conf_file): configs_gn = load_and_validate_toml(conf_file, GnGeneralSchemaConf) with open(str(ROOT_DIR / 'frontend/src/conf/app.config.ts'), 'w') as outputfile: outputfile.write("export const AppConfig = ") json.dump(configs_gn, outputfile, indent=True)
def create_frontend_config(conf_file): log.info("Generating configuration") configs_gn = load_and_validate_toml(conf_file, GnGeneralSchemaConf) with open(str(ROOT_DIR / "frontend/src/conf/app.config.ts"), "w") as outputfile: outputfile.write("export const AppConfig = ") json.dump(configs_gn, outputfile, indent=True) log.info("...%s\n", MSG_OK)
def create_frontend_config(conf_file): log.info('Generating configuration') configs_gn = load_and_validate_toml(conf_file, GnGeneralSchemaConf) with open( str(ROOT_DIR / 'frontend/src/conf/app.config.ts'), 'w' ) as outputfile: outputfile.write("export const AppConfig = ") json.dump(configs_gn, outputfile, indent=True) log.info("...%s\n", MSG_OK)
def list_and_import_gn_modules(app, mod_path=GN_EXTERNAL_MODULE): """ Get all the module enabled from gn_commons.t_modules """ with app.app_context(): data = DB.session.query(TModules).filter( TModules.active_backend == True) enabled_modules = [d.as_dict()['module_name'] for d in data] # iter over external_modules dir # and import only modules which are enabled for f in mod_path.iterdir(): if f.is_dir(): conf_manifest = load_and_validate_toml(str(f / 'manifest.toml'), ManifestSchemaProdConf) module_name = conf_manifest['module_name'] if module_name in enabled_modules: # TODO CHECK WHAT MODULE NAME BELOW MEAN # import du module dans le sys.path module_path = Path(GN_EXTERNAL_MODULE / module_name) module_parent_dir = str(module_path.parent) module_name = "{}.config.conf_schema_toml".format( module_path.name) sys.path.insert(0, module_parent_dir) module = __import__(module_name, globals=globals()) module_name = "{}.backend.blueprint".format(module_path.name) module_blueprint = __import__(module_name, globals=globals()) sys.path.pop(0) class GnModuleSchemaProdConf( module.config.conf_schema_toml.GnModuleSchemaConf, GnModuleProdConf): pass conf_module = load_and_validate_toml( str(f / 'config/conf_gn_module.toml'), GnModuleSchemaProdConf) yield conf_module, conf_manifest, module_blueprint
def create_module_config(app, module_code, mod_path=None, build=True): """ Create the frontend config """ from geonature.core.gn_commons.models import TModules with app.app_context(): if not mod_path: # get the symlink location to write the config file mod_path = os.readlink( str(GN_EXTERNAL_MODULE / module_code.lower())) # fetch the module in the DB from its name module_object = ( DB.session.query(TModules) .filter(TModules.module_code == module_code.upper()) .one() ) # import du module dans le sys.path module_parent_dir = str(Path(mod_path).parent) module_schema_conf = "{}.config.conf_schema_toml".format( Path(mod_path).name ) # noqa sys.path.insert(0, module_parent_dir) module = __import__(module_schema_conf, globals=globals()) front_module_conf_file = os.path.join( mod_path, "config/conf_gn_module.toml" ) # noqa config_module = utilstoml.load_and_validate_toml( front_module_conf_file, module.config.conf_schema_toml.GnModuleSchemaConf ) # set id_module and module_code config_module["ID_MODULE"] = module_object.id_module config_module["MODULE_CODE"] = module_object.module_code config_module["MODULE_URL"] = module_object.module_path.replace( " ", "") frontend_config_path = os.path.join( mod_path, "frontend/app/module.config.ts" ) # noqa try: with open(str(ROOT_DIR / frontend_config_path), "w") as outputfile: outputfile.write("export const ModuleConfig = ") json.dump(config_module, outputfile, indent=True, sort_keys=True) except FileNotFoundError: log.info("No frontend config file") if build: build_geonature_front()
def create_frontend_config(conf_file): log.info("Generating configuration") configs_gn = load_and_validate_toml(conf_file, GnGeneralSchemaConf) with open(str(ROOT_DIR / "frontend/src/conf/app.config.ts.sample"), "r") as input_file: template = Template(input_file.read()) parameters = json.dumps(configs_gn, indent=True) app_config_template = template.render(parameters=parameters) with open(str(ROOT_DIR / "frontend/src/conf/app.config.ts"), "w") as output_file: output_file.write(app_config_template) log.info("...%s\n", MSG_OK)
def list_frontend_enabled_modules(mod_path=GN_EXTERNAL_MODULE): """ Get all the module frontend enabled from gn_commons.t_modules """ from geonature.utils.command import get_app_for_cmd from geonature.core.gn_commons.models import TModules app = get_app_for_cmd(DEFAULT_CONFIG_FILE, with_external_mods=False) with app.app_context(): data = DB.session.query(TModules).filter( TModules.active_frontend == True).all() enabled_modules = [d.as_dict()['module_name'] for d in data] for f in mod_path.iterdir(): if f.is_dir(): conf_manifest = load_and_validate_toml(str(f / 'manifest.toml'), ManifestSchemaProdConf) class GnModuleSchemaProdConf(GnModuleProdConf): pass conf_module = load_and_validate_toml( str(f / 'config/conf_gn_module.toml'), GnModuleSchemaProdConf) if conf_manifest['module_name'] in enabled_modules: yield conf_module, conf_manifest
def create_module_config(app, module_code, mod_path=None, build=True): """ Create the frontend config """ from geonature.core.gn_commons.models import TModules with app.app_context(): if not mod_path: mod_path = str(GN_EXTERNAL_MODULE / module_code.lower()) # fetch the module in the DB from its name module_object = ( DB.session.query(TModules) .filter(TModules.module_code == module_code.upper()) .one() ) # import du module dans le sys.path module_parent_dir = str(Path(mod_path).parent) module_schema_conf = "{}.config.conf_schema_toml".format( Path(mod_path).name ) # noqa sys.path.insert(0, module_parent_dir) module = __import__(module_schema_conf, globals=globals()) front_module_conf_file = os.path.join( mod_path, "config/conf_gn_module.toml" ) # noqa config_module = utilstoml.load_and_validate_toml( front_module_conf_file, module.config.conf_schema_toml.GnModuleSchemaConf ) # set id_module and module_code config_module["ID_MODULE"] = module_object.id_module config_module["MODULE_CODE"] = module_object.module_code config_module["MODULE_URL"] = module_object.module_path.replace(" ", "") frontend_config_path = os.path.join( mod_path, "frontend/app/module.config.ts" ) # noqa try: with open(str(ROOT_DIR / frontend_config_path), "w") as outputfile: outputfile.write("export const ModuleConfig = ") json.dump(config_module, outputfile, indent=True, sort_keys=True) except FileNotFoundError: log.info("No frontend config file") if build: build_geonature_front()
def check_manifest(module_path): ''' Verification de la version de geonature par rapport au manifest Retourne le nom du module ''' log.info("checking manifest") configs_py = utilstoml.load_and_validate_toml( str(Path(module_path) / "manifest.toml"), ManifestSchemaConf) gn_v = version.parse(GEONATURE_VERSION) if (gn_v < version.parse(configs_py['min_geonature_version']) and gn_v > version.parse(configs_py['max_geonature_version'])): raise GeoNatureError( "Geonature version {} is imcompatible with module".format( GEONATURE_VERSION)) for e_gn_v in configs_py['exclude_geonature_versions']: if gn_v == version.parse(e_gn_v): raise GeoNatureError( "Geonature version {} is imcompatible with module".format( GEONATURE_VERSION)) log.info("...%s\n", MSG_OK) return configs_py['module_name']
import os from collections import ChainMap from geonature.utils.config_schema import ( GnGeneralSchemaConf, GnPySchemaConf, ) from geonature.utils.utilstoml import load_and_validate_toml from geonature.utils.env import DEFAULT_CONFIG_FILE config_path = os.environ.get("GEONATURE_CONFIG_FILE", DEFAULT_CONFIG_FILE) config_backend = load_and_validate_toml(config_path, GnPySchemaConf) config_frontend = load_and_validate_toml(config_path, GnGeneralSchemaConf) config = ChainMap({}, config_frontend, config_backend)
def get_module_id(module_name): conf_path = '{}/{}/config/conf_gn_module.toml'.format( GN_EXTERNAL_MODULE, module_name) return load_and_validate_toml(conf_path, GnModuleProdConf)['id_application']