def test_sqlaudit_none(self, app): # GIVEN an empty configuration # WHEN I request an audit engine audit = getAudit(app.config) # THEN The engine is shared with the main database assert audit.engine and audit.engine == db.engine
def load_environment(global_conf, app_conf): """ Configure the Pylons environment via the ``pylons.config`` object """ # Pylons paths root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) paths = dict(root=root, controllers=os.path.join(root, 'controllers'), static_files=os.path.join(root, 'public'), templates=[app_conf.get('custom_templates', os.path.join(root, 'templates')), os.path.join(root, 'templates') ]) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='linotp', paths=paths) config['linotp.root'] = root config['routes.map'] = make_map() config['pylons.app_globals'] = app_globals.Globals() config['pylons.h'] = linotp.lib.helpers ## add per token a location for the mako template lookup ## @note: the location is defined in the .ini file by ## the entry [linotpTokenModules] directories = paths['templates'] ## add a template path for every token modules = get_token_module_list() for module in modules: mpath = os.path.dirname(module.__file__) directories.append(mpath) ## add a template path for every resolver modules = get_resolver_module_list() for module in modules: mpath = os.path.dirname(module.__file__) directories.append(mpath) unique_directories = _uniqify_list(directories) log.debug("[load_environment] Template directories: %r" % unique_directories) config['pylons.app_globals'].mako_lookup = TemplateLookup( directories=unique_directories, error_handler=handle_mako_error, module_directory=os.path.join(app_conf['cache_dir'], 'templates'), input_encoding='utf-8', default_filters=['escape'], imports=['from webhelpers.html import escape']) # Setup the SQLAlchemy database engine # If we load the linotp.model here, the pylons.config is loaded with # the entries from the config file. if it is loaded at the top of the file, #the pylons.config does not contain the config file, yet. from linotp.model import init_model engine = engine_from_config(config, 'sqlalchemy.') init_model(engine) # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) from linotp.lib.audit.base import getAudit audit = getAudit() config['audit'] = audit ## setup Security provider definition try: log.debug('[load_environment] loading token list definition') g = config['pylons.app_globals'] g.security_provider.load_config(config) except Exception as e: log.error("Failed to load security provider definition: %r" % e) raise e ## load the list of tokenclasses try: log.debug('[load_environment] loading token list definition') (tcl, tpl) = get_token_class_list() config['tokenclasses'] = tcl g.setTokenclasses(tcl) config['tokenprefixes'] = tpl g.setTokenprefixes(tpl) except Exception as e: log.error("Failed to load token class list: %r" % e) raise e ## load the list of resolvers try: log.debug('[load_environment] loading resolver list definition') (rclass, rname) = get_resolver_class_list() ## make this globaly avaliable g.setResolverClasses(rclass) g.setResolverTypes(rname) except Exception as exx: log.error("Faild to load the list of resolvers: %r" % exx) raise exx ## get the help url url = config.get("linotpHelp.url", None) if url == None: version = pkg_resources.get_distribution("linotp").version offline_url = "file:///usr/share/doc/linotpdoc/html/" # First try to get the help for this specific version url = "http://linotp.org/doc/%s/index.html" % version try: ## Try to open the online url with a timeout of 5 seconds ## If the system is definitively offline the request will return immediately urllib2.urlopen(url, timeout=5) except urllib2.HTTPError: # it seems the version does not exist, we set the latest url = "http://linotp.org/doc/latest/index.html" log.info("the Help URL for the version %s is not available, using the latest one: %s" % (version, url)) except urllib2.URLError: # it seems we are offline, using an offline url log.warning("it seems we are offline, so using the offline url %s" % offline_url) url = offline_url config['help_url'] = url log.debug("[load_environment] done") return
def test_sqlaudit_sqlaudit(self, app): audit = getAudit() # audit object should be a database audit assert isinstance(audit, Audit)
def test_sqlaudit_off(self, app): audit = getAudit() # audit object should be a dummy class without implementation assert isinstance(audit, AuditBase)
def load_environment(global_conf, app_conf): """ Configure the Pylons environment via the ``pylons.config`` object """ # Pylons paths root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) paths = dict(root=root, controllers=os.path.join(root, 'controllers'), static_files=os.path.join(root, 'public'), templates=[app_conf.get('custom_templates', os.path.join(root, 'templates')), os.path.join(root, 'templates')]) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='linotp', paths=paths) config['linotp.root'] = root config['routes.map'] = make_map(global_conf, app_conf) config['pylons.app_globals'] = app_globals.Globals() config['pylons.h'] = linotp.lib.helpers # add per token a location for the mako template lookup # @note: the location is defined in the .ini file by # the entry [linotpTokenModules] directories = paths['templates'] import linotp.tokens as token_package token_package_path = os.path.dirname(token_package.__file__) directories.append(token_package_path) for token_package_sub_path, _subdir, _files in os.walk(token_package_path): directories.append(token_package_sub_path) # add a template path for every resolver resolver_module_path = UserIdResolver.__file__ directories.append(resolver_module_path) unique_directories = _uniqify_list(directories) log.debug("[load_environment] Template directories: %r" % unique_directories) config['pylons.app_globals'].mako_lookup = TemplateLookup( directories=unique_directories, error_handler=handle_mako_error, module_directory=os.path.join(app_conf['cache_dir'], 'templates'), input_encoding='utf-8', default_filters=['escape'], imports=['from webhelpers.html import escape']) # Setup the SQLAlchemy database engine # If we load the linotp.model here, the pylons.config is loaded with # the entries from the config file. if it is loaded at the top of the file, # the pylons.config does not contain the config file, yet. from linotp.model import init_model engine = engine_from_config(config, 'sqlalchemy.') init_model(engine) # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) from linotp.lib.audit.base import getAudit audit = getAudit(config) config['audit'] = audit # setup Security provider definition try: log.debug('[load_environment] loading token list definition') g = config['pylons.app_globals'] g.security_provider.load_config(config) except Exception as e: log.exception("Failed to load security provider definition: %r" % e) raise e # get the help url url = config.get("linotpHelp.url", None) if url is None: version = pkg_resources.get_distribution("linotp").version # First try to get the help for this specific version url = "https://linotp.org/doc/%s/index.html" % version config['help_url'] = url log.debug("[load_environment] done") return config
def load_environment(global_conf, app_conf): """ Configure the Pylons environment via the ``pylons.config`` object """ # Pylons paths root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) paths = dict(root=root, controllers=os.path.join(root, 'controllers'), static_files=os.path.join(root, 'public'), templates=[ app_conf.get('custom_templates', os.path.join(root, 'templates')), os.path.join(root, 'templates') ]) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='linotp', paths=paths) config['linotp.root'] = root config['routes.map'] = make_map(global_conf, app_conf) config['pylons.app_globals'] = app_globals.Globals() config['pylons.h'] = linotp.lib.helpers # add per token a location for the mako template lookup # @note: the location is defined in the .ini file by # the entry [linotpTokenModules] directories = paths['templates'] # add a template path for every token modules = get_token_module_list() for module in modules: mpath = os.path.dirname(module.__file__) directories.append(mpath) # add a template path for every resolver modules = get_resolver_module_list() for module in modules: mpath = os.path.dirname(module.__file__) directories.append(mpath) unique_directories = _uniqify_list(directories) log.debug("[load_environment] Template directories: %r" % unique_directories) config['pylons.app_globals'].mako_lookup = TemplateLookup( directories=unique_directories, error_handler=handle_mako_error, module_directory=os.path.join(app_conf['cache_dir'], 'templates'), input_encoding='utf-8', default_filters=['escape'], imports=['from webhelpers.html import escape']) # Setup the SQLAlchemy database engine # If we load the linotp.model here, the pylons.config is loaded with # the entries from the config file. if it is loaded at the top of the file, # the pylons.config does not contain the config file, yet. from linotp.model import init_model engine = engine_from_config(config, 'sqlalchemy.') init_model(engine) # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) from linotp.lib.audit.base import getAudit audit = getAudit() config['audit'] = audit # setup Security provider definition try: log.debug('[load_environment] loading token list definition') g = config['pylons.app_globals'] g.security_provider.load_config(config) except Exception as e: log.error("Failed to load security provider definition: %r" % e) raise e # load the list of tokenclasses try: log.debug('[load_environment] loading token list definition') (tcl, tpl) = get_token_class_list() config['tokenclasses'] = tcl g.setTokenclasses(tcl) config['tokenprefixes'] = tpl g.setTokenprefixes(tpl) except Exception as e: log.error("Failed to load token class list: %r" % e) raise e # load the list of resolvers try: log.debug('[load_environment] loading resolver list definition') (rclass, rname) = get_resolver_class_list() # make this globaly avaliable g.setResolverClasses(rclass) g.setResolverTypes(rname) except Exception as exx: log.error("Faild to load the list of resolvers: %r" % exx) raise exx # get the help url url = config.get("linotpHelp.url", None) if url is None: version = pkg_resources.get_distribution("linotp").version # First try to get the help for this specific version url = "http://linotp.org/doc/%s/index.html" % version config['help_url'] = url log.debug("[load_environment] done") return config
def load_environment(global_conf, app_conf): """ Configure the Pylons environment via the ``pylons.config`` object """ # Pylons paths root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) paths = dict(root=root, controllers=os.path.join(root, 'controllers'), static_files=os.path.join(root, 'public'), templates=[ app_conf.get('custom_templates', os.path.join(root, 'templates')), os.path.join(root, 'templates') ]) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='linotp', paths=paths) config['linotp.root'] = root config['routes.map'] = make_map() config['pylons.app_globals'] = app_globals.Globals() config['pylons.h'] = linotp.lib.helpers ## add per token a location for the mako template lookup ## @note: the location is defined in the .ini file by ## the entry [linotpTokenModules] directories = paths['templates'] ## add a template path for every token modules = get_token_module_list() for module in modules: mpath = os.path.dirname(module.__file__) directories.append(mpath) ## add a template path for every resolver modules = get_resolver_module_list() for module in modules: mpath = os.path.dirname(module.__file__) directories.append(mpath) unique_directories = _uniqify_list(directories) log.debug("[load_environment] Template directories: %r" % unique_directories) config['pylons.app_globals'].mako_lookup = TemplateLookup( directories=unique_directories, error_handler=handle_mako_error, module_directory=os.path.join(app_conf['cache_dir'], 'templates'), input_encoding='utf-8', default_filters=['escape'], imports=['from webhelpers.html import escape']) # Setup the SQLAlchemy database engine # If we load the linotp.model here, the pylons.config is loaded with # the entries from the config file. if it is loaded at the top of the file, #the pylons.config does not contain the config file, yet. from linotp.model import init_model engine = engine_from_config(config, 'sqlalchemy.') init_model(engine) # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) from linotp.lib.audit.base import getAudit audit = getAudit() config['audit'] = audit ## setup Security provider definition try: log.debug('[load_environment] loading token list definition') g = config['pylons.app_globals'] g.security_provider.load_config(config) except Exception as e: log.error("Failed to load security provider definition: %r" % e) raise e ## load the list of tokenclasses try: log.debug('[load_environment] loading token list definition') (tcl, tpl) = get_token_class_list() config['tokenclasses'] = tcl g.setTokenclasses(tcl) config['tokenprefixes'] = tpl g.setTokenprefixes(tpl) except Exception as e: log.error("Failed to load token class list: %r" % e) raise e ## load the list of resolvers try: log.debug('[load_environment] loading resolver list definition') (rclass, rname) = get_resolver_class_list() ## make this globaly avaliable g.setResolverClasses(rclass) g.setResolverTypes(rname) except Exception as exx: log.error("Faild to load the list of resolvers: %r" % exx) raise exx ## get the help url url = config.get("linotpHelp.url", None) ## this is a quick hack for the test setup :-( ## the big one should handle the timeout when help button ## is pressed version = pkg_resources.get_distribution("linotp").version if not (url) and 'dev' in version: url = "file:///usr/share/doc/linotpdoc/html/" if url == None: version = pkg_resources.get_distribution("linotp").version offline_url = "file:///usr/share/doc/linotpdoc/html/" # First try to get the help for this specific version url = "http://linotp.org/doc/%s/index.html" % version try: ## Try to open the online url with a timeout of 5 seconds ## If the system is definitively offline the request will return immediately urllib2.urlopen(url, timeout=5) except urllib2.HTTPError: # it seems the version does not exist, we set the latest url = "http://linotp.org/doc/latest/index.html" log.info( "the Help URL for the version %s is not available, using the latest one: %s" % (version, url)) except urllib2.URLError: # it seems we are offline, using an offline url log.warning( "it seems we are offline, so using the offline url %s" % offline_url) url = offline_url config['help_url'] = url log.debug("[load_environment] done") return
def migrate_3_0_0_0(self) -> None: """Migrate to linotp3 - to python3+mysql. The major challenge for the linotp3 migration is the migration from python2+mysql where the mysql driver was using latin1 encoded data, though the database might already support utf8. Thus we can exclude all fresh created and non-mysql databases """ if self.is_db_untouched(): log.info("Fresh database - no migration required!") return # ----------------------------------------------------------------- -- # with linotp3 we drop all previous audit entries to fix audit signing from linotp.lib.audit.base import getAudit audit_obj = getAudit() audit_obj.delete_all_entries() log.info("All limotp2 audit entries deleted.") # ----------------------------------------------------------------- -- if not self.engine.url.drivername.startswith("mysql"): log.info( "Non mysql databases %r - no migration required.", self.engine.url.drivername, ) return # ----------------------------------------------------------------- -- # MYSQL Schema and Data Migration: # # In case of pre buster db (or restored by a backup), the tabel schema # is defined with charset latin1. Thus the schema must be updated first # othewise the data migration will fail. # # Which tables are converted is reported by the schema migration. # If no table was converted, we have to assume that the mysql db was # created newly (e.g. on buster) where this is done with charset=utf8. # # In case of a newly (buster) e.g. linotp2 created db, we cannot imply # that the data migration has to be done, we only can suggest this. log.info("Starting mysql migration") # before we adjust the schema, we have to close former sessions, # otherwise we would run into a database lock model.db.session.close() # now we can run the schema migration mysql_mig = MYSQL_Migration(self.engine) migrated_tables = mysql_mig.migrate_schema() mysql_mig.migrate_data(migrated_tables) if not migrated_tables: config_entry = model.Config( Key="utf8_conversion", Value="suggested" ) model.db.session.add(config_entry) log.warning( "Database conversion step suggested!\n" "Please run command:\n" " linotp admin fix-db-encoding" )