def load_environment(global_conf, app_conf): """Configure the Pylons environment via the ``pylons.config`` object """ config = PylonsConfig() # 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=[os.path.join(root, 'templates')]) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='desio', paths=paths) config['routes.map'] = make_map(config) config['pylons.app_globals'] = app_globals.Globals(config) config['pylons.h'] = desio.lib.helpers config['pylons.strict_tmpl_context'] = False config['beaker.session.cookie_expires'] = None # Setup cache object as early as possible import pylons pylons.cache._push_object(config['pylons.app_globals'].cache) # Create the Mako TemplateLookup, with the default auto-escaping config['pylons.app_globals'].mako_lookup = TemplateLookup( directories=paths['templates'], 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 config['pylons.app_globals'].sa_default_engine = engine_from_config( config, 'sqlalchemy.default.', proxy=TimerProxy()) init_model(config['pylons.app_globals'].sa_default_engine) config['pylons.errorware']['smtp_username'] = config.get('smtp_username') config['pylons.errorware']['smtp_password'] = config.get('smtp_password') config['pylons.errorware']['smtp_use_tls'] = config.get('smtp_use_tls') config['pylons.errorware']['smtp_port'] = config.get('smtp_port') # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) fs.setup_directories(config) setup_turbomail(config) return config
def load_environment(global_conf, app_conf): """Configure the Pylons environment via the ``pylons.config`` object """ config = PylonsConfig() # 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=[os.path.join(root, 'templates')]) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='desio', paths=paths) config['routes.map'] = make_map(config) config['pylons.app_globals'] = app_globals.Globals(config) config['pylons.h'] = desio.lib.helpers config['pylons.strict_tmpl_context'] = False config['beaker.session.cookie_expires'] = None # Setup cache object as early as possible import pylons pylons.cache._push_object(config['pylons.app_globals'].cache) # Create the Mako TemplateLookup, with the default auto-escaping config['pylons.app_globals'].mako_lookup = TemplateLookup( directories=paths['templates'], 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 config['pylons.app_globals'].sa_default_engine = engine_from_config(config, 'sqlalchemy.default.', proxy=TimerProxy()) init_model(config['pylons.app_globals'].sa_default_engine) config['pylons.errorware']['smtp_username'] = config.get('smtp_username') config['pylons.errorware']['smtp_password'] = config.get('smtp_password') config['pylons.errorware']['smtp_use_tls'] = config.get('smtp_use_tls') config['pylons.errorware']['smtp_port'] = config.get('smtp_port') # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) fs.setup_directories(config) setup_turbomail(config) return config
def load_environment(global_conf, app_conf, with_db=True): """Configure the Pylons environment via the ``pylons.config`` object """ # Pylons paths conf_copy = global_conf.copy() conf_copy.update(app_conf) site_templates = create_site_subdirectory('templates', app_conf=conf_copy) root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) client_containing = app_conf.get('adhocracy.client_location') if client_containing: client_root = os.path.join(client_containing, 'adhocracy_client') sys.path.insert(0, client_containing) import adhocracy_client.static sys.modules['adhocracy.static'] = adhocracy_client.static else: client_root = root import adhocracy.static paths = dict(root=root, controllers=os.path.join(root, 'controllers'), static_files=os.path.join(client_root, 'static'), templates=[site_templates, os.path.join(client_root, 'templates')]) # Initialize config with the basic options config = PylonsConfig() config.init_app(global_conf, app_conf, package='adhocracy', paths=paths) config['routes.map'] = make_map(config) config['pylons.app_globals'] = app_globals.Globals(config) config['pylons.h'] = adhocracy.lib.helpers # Create the Mako TemplateLookup, with the default auto-escaping config['pylons.app_globals'].mako_lookup = TemplateLookup( directories=paths['templates'], error_handler=handle_mako_error, module_directory=os.path.join(app_conf['cache_dir'], 'templates'), input_encoding='utf-8', default_filters=['escape'], imports=['from markupsafe import escape']) config['pylons.strict_tmpl_context'] = False # Setup the SQLAlchemy database engine engineOpts = {} if asbool(config.get('adhocracy.debug.sql', False)): engineOpts['connectionproxy'] = TimerProxy() engine = engine_from_config(config, 'sqlalchemy.', **engineOpts) init_model(engine) # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) init_site(config) if with_db: init_search() init_democracy() RQConfig.setup_from_config(config) return config
def load_environment(global_conf, app_conf): """Configure the Pylons environment via the ``pylons.config`` object """ config = PylonsConfig() # 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=[os.path.join(root, 'templates')]) # import our private.ini that holds keys, etc imp = global_conf.get('import') if imp: cp = ConfigParser() cp.read(imp) global_conf.update(cp.defaults()) if cp.has_section('APP'): app_conf.update(cp.items('APP')) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='linkdrop', paths=paths) config['routes.map'] = make_map(config) config['pylons.app_globals'] = app_globals.Globals(config) import linkdrop.lib.helpers as h config['pylons.h'] = h # Setup cache object as early as possible import pylons pylons.cache._push_object(config['pylons.app_globals'].cache) # Create the Mako TemplateLookup, with the default auto-escaping config['pylons.app_globals'].mako_lookup = TemplateLookup( directories=paths['templates'], 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 engine = engine_from_config(config, 'sqlalchemy.') init_model(engine) # sqlalchemy auto migration if asbool(config.get('migrate.auto')): try: # managed upgrades cschema = schema.ControlledSchema.create(engine, config['migrate.repository']) cschema.update_db_from_model(meta.Base.metadata) except exceptions.InvalidRepositoryError, e: # unmanaged upgrades diff = schemadiff.getDiffOfModelAgainstDatabase( meta.Base.metadata, engine, excludeTables=None) genmodel.ModelGenerator(diff).applyModel()
def load_environment(global_conf, app_conf): """Configure the Pylons environment via the ``pylons.config`` object """ config = PylonsConfig() root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) paths = dict( root=root, controllers=os.path.join(root, 'controllers'), data=os.path.join(root, 'data'), static_files=os.path.join(root, 'public'), templates=os.path.join(root, 'templates'), ) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='muse', paths=paths) config['routes.map'] = make_map(config) config['pylons.app_globals'] = app_globals.Globals(config) config['pylons.h'] = muse.lib.helpers # Setup cache object as early as possible pylons.cache._push_object(config['pylons.app_globals'].cache) # Setup cache options dict to pass to @cache.beaker_cache. config['cache_options'] = { 'query_args': True, 'expire': config.get('cache_expire', 3600), 'invalidate_on_startup': True } config['cache_options_nonpage'] = { 'expire': config.get('cache_expire', 3600), 'invalidate_on_startup': True } # Setup SQLAlchemy config['pylons.app_globals'].sa_engine = engine_from_config(config, 'sqlalchemy.' ) model.init_model(config['pylons.app_globals'].sa_engine) # Create tables if they don't already exist. model.metadata.create_all(bind=model.meta.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=[os.path.join(root, 'templates')]) # Initialize config with the basic options if is_pylons_0: config = pylons_config else: config = PylonsConfig() config.init_app(global_conf, app_conf, package='fts3rest', paths=paths) config['routes.map'] = make_map(config) config['pylons.app_globals'] = app_globals.Globals(config) config['pylons.h'] = fts3rest.lib.helpers # Setup cache object as early as possible import pylons pylons.cache._push_object(config['pylons.app_globals'].cache) # If fts3.config is set, load configuration from there fts3_config_file = config.get('fts3.config') if fts3_config_file: fts3cfg = fts3_config.fts3_config_load(fts3_config_file) # Let the database be overriden by fts3rest.ini if 'sqlalchemy.url' in config and 'sqlalchemy.url' in fts3cfg: del fts3cfg['sqlalchemy.url'] config.update(fts3cfg) # Setup the SQLAlchemy database engine engine = engine_from_config(config, 'sqlalchemy.', pool_recycle = 7200) init_model(engine) # Mako templating config['pylons.app_globals'].mako_lookup = TemplateLookup( directories=paths['templates'], ) # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) return config
def load_environment(global_conf, app_conf, initial=False, test_env=None, test_index=None): """ Configure the Pylons environment via the ``pylons.config`` object """ config = PylonsConfig() # 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=[os.path.join(root, 'templates')]) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='kallithea', paths=paths) # store some globals into kallithea kallithea.CELERY_ON = str2bool(config['app_conf'].get('use_celery')) kallithea.CELERY_EAGER = str2bool( config['app_conf'].get('celery.always.eager')) config['routes.map'] = make_map(config) config['pylons.app_globals'] = app_globals.Globals(config) config['pylons.h'] = helpers kallithea.CONFIG = config load_rcextensions(root_path=config['here']) # Setup cache object as early as possible import pylons pylons.cache._push_object(config['pylons.app_globals'].cache) # Create the Mako TemplateLookup, with the default auto-escaping config['pylons.app_globals'].mako_lookup = TemplateLookup( directories=paths['templates'], 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']) # sets the c attribute access when don't existing attribute are accessed config['pylons.strict_tmpl_context'] = True test = os.path.split(config['__file__'])[-1] == 'test.ini' if test: if test_env is None: test_env = not int(os.environ.get('KALLITHEA_NO_TMP_PATH', 0)) if test_index is None: test_index = not int( os.environ.get('KALLITHEA_WHOOSH_TEST_DISABLE', 0)) if os.environ.get('TEST_DB'): # swap config if we pass enviroment variable config['sqlalchemy.db1.url'] = os.environ.get('TEST_DB') from kallithea.lib.utils import create_test_env, create_test_index from kallithea.tests import TESTS_TMP_PATH #set KALLITHEA_NO_TMP_PATH=1 to disable re-creating the database and #test repos if test_env: create_test_env(TESTS_TMP_PATH, config) #set KALLITHEA_WHOOSH_TEST_DISABLE=1 to disable whoosh index during tests if test_index: create_test_index(TESTS_TMP_PATH, config, True) DbManage.check_waitress() # MULTIPLE DB configs # Setup the SQLAlchemy database engine sa_engine_db1 = engine_from_config(config, 'sqlalchemy.db1.') init_model(sa_engine_db1) set_available_permissions(config) repos_path = make_ui('db').configitems('paths')[0][1] config['base_path'] = repos_path set_app_settings(config) instance_id = kallithea.CONFIG.get('instance_id') if instance_id == '*': instance_id = '%s-%s' % (platform.uname()[1], os.getpid()) kallithea.CONFIG['instance_id'] = instance_id # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) # store config reference into our module to skip import magic of # pylons kallithea.CONFIG.update(config) set_vcs_config(kallithea.CONFIG) #check git version check_git_version() if str2bool(config.get('initial_repo_scan', True)): repo2db_mapper(ScmModel().repo_scan(repos_path), remove_obsolete=False, install_git_hook=False) return config
def load_environment(global_conf, app_conf, initial=False): """ Configure the Pylons environment via the ``pylons.config`` object """ config = PylonsConfig() # 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=[os.path.join(root, 'templates')] ) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='rhodecode', paths=paths) # store some globals into rhodecode rhodecode.CELERY_ON = str2bool(config['app_conf'].get('use_celery')) rhodecode.CELERY_EAGER = str2bool(config['app_conf'].get('celery.always.eager')) config['routes.map'] = make_map(config) config['pylons.app_globals'] = app_globals.Globals(config) config['pylons.h'] = helpers rhodecode.CONFIG = config load_rcextensions(root_path=config['here']) # Setup cache object as early as possible import pylons pylons.cache._push_object(config['pylons.app_globals'].cache) # Create the Mako TemplateLookup, with the default auto-escaping config['pylons.app_globals'].mako_lookup = TemplateLookup( directories=paths['templates'], 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']) # sets the c attribute access when don't existing attribute are accessed config['pylons.strict_tmpl_context'] = True test = os.path.split(config['__file__'])[-1] == 'test.ini' if test: if os.environ.get('TEST_DB'): # swap config if we pass enviroment variable config['sqlalchemy.db1.url'] = os.environ.get('TEST_DB') from rhodecode.lib.utils import create_test_env, create_test_index from rhodecode.tests import TESTS_TMP_PATH # set RC_NO_TMP_PATH=1 to disable re-creating the database and # test repos if not int(os.environ.get('RC_NO_TMP_PATH', 0)): create_test_env(TESTS_TMP_PATH, config) # set RC_WHOOSH_TEST_DISABLE=1 to disable whoosh index during tests if not int(os.environ.get('RC_WHOOSH_TEST_DISABLE', 0)): create_test_index(TESTS_TMP_PATH, config, True) DbManage.check_waitress() # MULTIPLE DB configs # Setup the SQLAlchemy database engine sa_engine_db1 = engine_from_config(config, 'sqlalchemy.db1.') init_model(sa_engine_db1) set_available_permissions(config) repos_path = make_ui('db').configitems('paths')[0][1] config['base_path'] = repos_path set_rhodecode_config(config) instance_id = rhodecode.CONFIG.get('instance_id') if instance_id == '*': instance_id = '%s-%s' % (os.uname()[1], os.getpid()) rhodecode.CONFIG['instance_id'] = instance_id # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) # store config reference into our module to skip import magic of # pylons rhodecode.CONFIG.update(config) set_vcs_config(rhodecode.CONFIG) #check git version check_git_version() if str2bool(config.get('initial_repo_scan', True)): repo2db_mapper(ScmModel().repo_scan(repos_path), remove_obsolete=False, install_git_hook=False) return config
def load_environment(global_conf, app_conf, with_db=True): """Configure the Pylons environment via the ``pylons.config`` object """ # Pylons paths conf_copy = global_conf.copy() conf_copy.update(app_conf) site_templates = create_site_subdirectory('templates', app_conf=conf_copy) root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) client_containing = app_conf.get('adhocracy.client_location') if client_containing: client_root = os.path.join(client_containing, 'adhocracy_client') sys.path.insert(0, client_containing) import adhocracy_client.static sys.modules['adhocracy.static'] = adhocracy_client.static else: client_root = root import adhocracy.static paths = dict( root=root, controllers=os.path.join(root, 'controllers'), static_files=os.path.join(client_root, 'static'), templates=[site_templates, os.path.join(client_root, 'templates')]) # Initialize config with the basic options config = PylonsConfig() config.init_app(global_conf, app_conf, package='adhocracy', paths=paths) config['routes.map'] = make_map(config) config['pylons.app_globals'] = app_globals.Globals(config) config['pylons.h'] = adhocracy.lib.helpers # Create the Mako TemplateLookup, with the default auto-escaping config['pylons.app_globals'].mako_lookup = TemplateLookup( directories=paths['templates'], error_handler=handle_mako_error, module_directory=os.path.join(app_conf['cache_dir'], 'templates'), input_encoding='utf-8', default_filters=['escape'], imports=['from markupsafe import escape']) config['pylons.strict_tmpl_context'] = False # Setup the SQLAlchemy database engine engineOpts = {} if asbool(config.get('adhocracy.debug.sql', False)): engineOpts['connectionproxy'] = TimerProxy() engine = engine_from_config(config, 'sqlalchemy.', **engineOpts) init_model(engine) # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) init_site(config) if with_db: init_search() init_democracy() RQConfig.setup_from_config(config) return config
def load_environment(global_conf, app_conf): """ Configure the Pylons environment via the ``pylons.config`` object """ config = PylonsConfig() beaker.cache.clsmap['ext:redis'] = redis_.RedisManager # 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=[os.path.join(root, 'templates')]) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='civicboom', paths=paths) config['routes.map'] = make_map(config) config['pylons.app_globals'] = app_globals.Globals(config) #pylons.cache._push_object(config['pylons.app_globals'].cache) config['pylons.h'] = civicboom.lib.helpers # Create the Mako TemplateLookup, with the default auto-escaping config['pylons.app_globals'].mako_lookup = TemplateLookup( directories=paths['templates'], 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 engine = engine_from_config(config, 'sqlalchemy.main.') init_model(engine) # Global translator setup #log.info("Init global i18n as en") #import gettext #langs = { # "en": gettext.translation("civicboom", "./civicboom/i18n", languages=['en']), #} #langs["en"].install() # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) config_type_replacement(config) # Replace known string values in the config with actual type converted values # websetup.py tries to access pylons.config before it is # officially ready -- so make it unofficially ready and pray (HACK) for k, v in list(config.items()): pylons.config[k] = v # configure modules that used to require pylons.config wh.configure(pylons.config) # AllanC - unneeds as imports worker config directly #import civicboom.lib.communication.email_lib as email #email.configure(pylons.config) # AllanC changed it from worker.config=pylons.config because = replaces the reference. If worker.config is imported BEFORE this code is run then the importing class only access the empty original dict worker.config.update(pylons.config) # WARNING!!! # AllanC - NOTE!!! this update is fine AS LONG AS THE CONFIG IS NEVER CHANGED WHILE THE SITE IS RUNNING! # in production this is never changed ... howver .. in testing we alter the state of the config to test ... even if most tests pass we could have some horrible hard to track down bugs because of this .update fix # set up worker processors if pylons.config['worker.queue.type'] in ["inline", "threads"]: from civicboom.worker import init_worker_functions init_worker_functions(worker) # set up worker queue if pylons.config['worker.queue.type'] == "inline": worker.init_queue(None) elif pylons.config['worker.queue.type'] == "threads": # pragma: no cover worker.start_worker() elif pylons.config['worker.queue.type'] == "redis": # pragma: no cover worker.init_queue(redis_.RedisQueue(redis_.redis_from_url(config['worker.queue.url']), platform.node())) else: # pragma: no cover log.error("Invalid worker type: %s" % pylons.config['worker.queue.type']) # set up cache from civicboom.lib.cache import init_cache init_cache(config) # set up cbtv import cbutils.cbtv as t if config.get('telemetry'): # pragma: no cover -- telemetry is disabled during coverage test t.set_log(config['telemetry']) init_model_extra() # This will trigger a set of additional initalizers return config
def load_environment(global_conf, app_conf, initial=False, test_env=None, test_index=None): """ Configure the Pylons environment via the ``pylons.config`` object """ config = PylonsConfig() # Pylons paths root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) paths = { 'root': root, 'controllers': os.path.join(root, 'controllers'), 'static_files': os.path.join(root, 'public'), 'templates': [os.path.join(root, 'templates')], } # Initialize config with the basic options config.init_app(global_conf, app_conf, package='rhodecode', paths=paths) # store some globals into rhodecode rhodecode.CELERY_ENABLED = str2bool(config['app_conf'].get('use_celery')) rhodecode.CELERY_EAGER = str2bool( config['app_conf'].get('celery.always.eager')) config['routes.map'] = make_map(config) if asbool(config.get('generate_js_files', 'false')): jsroutes = config['routes.map'].jsroutes() jsroutes_file_content = generate_jsroutes_content(jsroutes) jsroutes_file_path = os.path.join(paths['static_files'], 'js', 'rhodecode', 'routes.js') with io.open(jsroutes_file_path, 'w', encoding='utf-8') as f: f.write(jsroutes_file_content) config['pylons.app_globals'] = app_globals.Globals(config) config['pylons.h'] = helpers rhodecode.CONFIG = config load_rcextensions(root_path=config['here']) # Setup cache object as early as possible import pylons pylons.cache._push_object(config['pylons.app_globals'].cache) # Create the Mako TemplateLookup, with the default auto-escaping config['pylons.app_globals'].mako_lookup = TemplateLookup( directories=paths['templates'], 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']) # sets the c attribute access when don't existing attribute are accessed config['pylons.strict_tmpl_context'] = True # Limit backends to "vcs.backends" from configuration backends = config['vcs.backends'] = aslist(config.get( 'vcs.backends', 'hg,git'), sep=',') for alias in rhodecode.BACKENDS.keys(): if alias not in backends: del rhodecode.BACKENDS[alias] log.info("Enabled backends: %s", backends) # initialize vcs client and optionally run the server if enabled vcs_server_uri = config.get('vcs.server', '') vcs_server_enabled = str2bool(config.get('vcs.server.enable', 'true')) start_server = (str2bool(config.get('vcs.start_server', 'false')) and not int(os.environ.get('RC_VCSSERVER_TEST_DISABLE', '0'))) if vcs_server_enabled and start_server: log.info("Starting vcsserver") start_vcs_server(server_and_port=vcs_server_uri, protocol=utils.get_vcs_server_protocol(config), log_level=config['vcs.server.log_level']) set_available_permissions(config) db_cfg = make_db_config(clear_session=True) repos_path = list(db_cfg.items('paths'))[0][1] config['base_path'] = repos_path config['vcs.hooks.direct_calls'] = _use_direct_hook_calls(config) config['vcs.hooks.protocol'] = _get_vcs_hooks_protocol(config) # store db config also in main global CONFIG set_rhodecode_config(config) # configure instance id utils.set_instance_id(config) # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) # store config reference into our module to skip import magic of pylons rhodecode.CONFIG.update(config) utils.configure_pyro4(config) utils.configure_vcs(config) if vcs_server_enabled: connect_vcs(vcs_server_uri, utils.get_vcs_server_protocol(config)) import_on_startup = str2bool(config.get('startup.import_repos', False)) if vcs_server_enabled and import_on_startup: repo2db_mapper(ScmModel().repo_scan(repos_path), remove_obsolete=False) return config
def load_environment(global_conf, app_conf): """Configure the Pylons environment""" config = PylonsConfig() # 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={}, content_files=[], templates=[os.path.join(root, 'templates')]) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='spline', paths=paths) extra_plugins = {} config_dir = os.path.dirname(global_conf['__file__']) paths['local'] = config_dir if config_dir != root: # This app isn't running out of a vanilla spline checkout. See if it # publishes its own local plugin class, and if not, create a generic # one original_path = sys.path sys.path = [config_dir] try: local_module = __import__('plugin') plugin_class = local_module.LocalPlugin except: plugin_class = LocalPlugin finally: # Restore path no matter what! sys.path = original_path extra_plugins['local'] = plugin_class(config_dir) # Load plugins before routing so we have a list of controllers load_plugins(config, paths, extra_plugins) # Add our static directory paths['static_files']['spline'] = os.path.join(root, 'public') config['routes.map'] = make_map(config, content_dirs=paths['content_files']) config['pylons.app_globals'] = app_globals.Globals(config) pylons.cache._push_object(config['pylons.app_globals'].cache) config['pylons.h'] = spline.lib.helpers # Create the Mako TemplateLookup, with the default auto-escaping module_directory = {} if 'cache_dir' in app_conf: module_directory['module_directory'] \ = os.path.join(app_conf['cache_dir'], 'templates') config['pylons.app_globals'].mako_lookup = TemplateLookup( directories=paths['templates'], error_handler=handle_mako_error, input_encoding='utf-8', output_encoding='utf-8', imports=['from webhelpers.html import escape'], default_filters=['escape'], filesystem_checks=asbool(config.get('mako.filesystem_checks', True)), preprocessor=spline.lib.makoext.i18n_preprocessor, **module_directory) # Set up SQLAlchemy database engine engine = engine_from_config(config, 'sqlalchemy.') init_model(engine) # Set up our timer events # We attach them globally to the Engine class so we can automatically track # any other database connections used by the app. *coughpokedexcough* config['spline.sql_debugging'] = asbool( config.get('spline.sql_debugging', False)) spline.lib.base.attach_timer(Engine) if config['spline.sql_debugging']: spline.lib.base.attach_query_log(Engine) # Backwards compatibility config['spline._sqlalchemy_proxy'] = None # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) # Use strict templating; none of this default-to-empty-string nonsense config['pylons.strict_c'] = True # Remove any stale cron lock del config['pylons.app_globals'].cache.get_cache('spline:cron')['LOCK'] return config
def load_environment(global_conf, app_conf): """Configure the Pylons environment via the ``pylons.config`` object """ config = PylonsConfig() # 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=[os.path.join(root, "templates")], ) # Initialize config with the basic options config.init_app(global_conf, app_conf, package="mediacore", paths=paths) config["routes.map"] = make_map(config) config["pylons.app_globals"] = app_globals.Globals(config) config["pylons.h"] = mediacore.lib.helpers # Setup cache object as early as possible import pylons pylons.cache._push_object(config["pylons.app_globals"].cache) translator = Translator(ugettext) def enable_i18n_for_template(template): template.filters.insert(0, translator) # Create the Genshi TemplateLoader config["pylons.app_globals"].genshi_loader = TemplateLoader( search_path=paths["templates"], auto_reload=True, callback=enable_i18n_for_template ) # Setup the SQLAlchemy database engine engine = engine_from_config(config, "sqlalchemy.") init_model(engine, config.get("db_table_prefix", None)) # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) # TODO: Move as many of these custom options into an .ini file, or at least # to somewhere more friendly. # TODO: rework templates not to rely on this line: # See docstring in pylons.configuration.PylonsConfig for details. config["pylons.strict_tmpl_context"] = False # Genshi Default Search Path config["genshi_search_path"] = paths["templates"][0] config["thumb_sizes"] = { # the dimensions (in pixels) to scale thumbnails Media._thumb_dir: {"s": (128, 72), "m": (160, 90), "l": (560, 315)}, Podcast._thumb_dir: {"s": (128, 128), "m": (160, 160), "l": (600, 600)}, } # The max number of results to return for any api listing config["api_media_max_results"] = 50 # END CUSTOM CONFIGURATION OPTIONS return config
def load_environment(global_conf, app_conf): """Configure the Pylons environment via the ``pylons.config`` object""" config = PylonsConfig() # 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=[os.path.join(root, 'templates')]) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='mediadrop', paths=paths) env_dir = os.path.normpath(os.path.join(config['media_dir'], '..')) config.setdefault('env_dir', env_dir) # Initialize the plugin manager to load all active plugins plugin_mgr = PluginManager(config) mapper = create_mapper(config, plugin_mgr.controller_scan) events.Environment.before_route_setup(mapper) add_routes(mapper) events.Environment.after_route_setup(mapper) config['routes.map'] = mapper globals_ = Globals(config) globals_.plugin_mgr = plugin_mgr globals_.events = events config['pylons.app_globals'] = globals_ config['pylons.h'] = mediadrop.lib.helpers # Setup cache object as early as possible pylons.cache._push_object(globals_.cache) i18n_env_dir = os.path.join(config['env_dir'], 'i18n') config['locale_dirs'] = plugin_mgr.locale_dirs() config['locale_dirs'].update({ 'mediadrop': (os.path.join(root, 'i18n'), i18n_env_dir), 'FormEncode': (get_formencode_localedir(), i18n_env_dir), }) def enable_i18n_for_template(template): translations = Translator(pylons.translator) translations.setup(template) # Create the Genshi TemplateLoader globals_.genshi_loader = TemplateLoader( search_path=paths['templates'] + plugin_mgr.template_loaders(), auto_reload=True, max_cache_size=100, callback=enable_i18n_for_template, ) # Setup the SQLAlchemy database engine engine = engine_from_config(config, 'sqlalchemy.') init_model(engine, config.get('db_table_prefix', None)) events.Environment.init_model() # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) # TODO: Move as many of these custom options into an .ini file, or at least # to somewhere more friendly. # TODO: Rework templates not to rely on this line: # See docstring in pylons.configuration.PylonsConfig for details. config['pylons.strict_tmpl_context'] = False config['thumb_sizes'] = { # the dimensions (in pixels) to scale thumbnails Media._thumb_dir: { 's': (128, 72), 'm': (160, 90), 'l': (560, 315), }, Podcast._thumb_dir: { 's': (128, 128), 'm': (160, 160), 'l': (600, 600), }, } # END CUSTOM CONFIGURATION OPTIONS events.Environment.loaded(config) return config
def load_environment(global_conf, app_conf): """Configure the Pylons environment via the ``pylons.config`` object""" config = PylonsConfig() # 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=[os.path.join(root, 'templates')]) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='mediadrop', paths=paths) env_dir = os.path.normpath(os.path.join(config['media_dir'], '..')) config.setdefault('env_dir', env_dir) # Initialize the plugin manager to load all active plugins plugin_mgr = PluginManager(config) mapper = create_mapper(config, plugin_mgr.controller_scan) events.Environment.before_route_setup(mapper) add_routes(mapper) events.Environment.after_route_setup(mapper) config['routes.map'] = mapper config['pylons.app_globals'] = app_globals.Globals(config) config['pylons.app_globals'].plugin_mgr = plugin_mgr config['pylons.app_globals'].events = events config['pylons.h'] = mediadrop.lib.helpers # Setup cache object as early as possible pylons.cache._push_object(config['pylons.app_globals'].cache) i18n_env_dir = os.path.join(config['env_dir'], 'i18n') config['locale_dirs'] = plugin_mgr.locale_dirs() config['locale_dirs'].update({ 'mediadrop': (os.path.join(root, 'i18n'), i18n_env_dir), 'FormEncode': (get_formencode_localedir(), i18n_env_dir), }) def enable_i18n_for_template(template): translations = Translator(translator) translations.setup(template) # Create the Genshi TemplateLoader config['pylons.app_globals'].genshi_loader = TemplateLoader( search_path=paths['templates'] + plugin_mgr.template_loaders(), auto_reload=True, max_cache_size=100, callback=enable_i18n_for_template, ) # Setup the SQLAlchemy database engine engine = engine_from_config(config, 'sqlalchemy.') init_model(engine, config.get('db_table_prefix', None)) events.Environment.init_model() # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) # TODO: Move as many of these custom options into an .ini file, or at least # to somewhere more friendly. # TODO: Rework templates not to rely on this line: # See docstring in pylons.configuration.PylonsConfig for details. config['pylons.strict_tmpl_context'] = False config['thumb_sizes'] = { # the dimensions (in pixels) to scale thumbnails Media._thumb_dir: { 's': (128, 72), 'm': (160, 90), 'l': (560, 315), }, Podcast._thumb_dir: { 's': (128, 128), 'm': (160, 160), 'l': (600, 600), }, } # END CUSTOM CONFIGURATION OPTIONS events.Environment.loaded(config) 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=[os.path.join(root, 'templates')]) # Initialize config with the basic options if is_pylons_0: config = pylons_config else: config = PylonsConfig() config.init_app(global_conf, app_conf, package='fts3rest', paths=paths) config['routes.map'] = make_map(config) config['pylons.app_globals'] = app_globals.Globals(config) config['pylons.h'] = fts3rest.lib.helpers # Setup cache object as early as possible import pylons pylons.cache._push_object(config['pylons.app_globals'].cache) # If fts3.config is set, load configuration from there fts3_config_file = config.get('fts3.config') if fts3_config_file: fts3cfg = fts3_config_load(fts3_config_file) # Let the database be overriden by fts3rest.ini if 'sqlalchemy.url' in config and 'sqlalchemy.url' in fts3cfg: del fts3cfg['sqlalchemy.url'] config.update(fts3cfg) # Setup the SQLAlchemy database engine kwargs = dict() if config['sqlalchemy.url'].startswith('mysql://'): import MySQLdb.cursors kwargs['connect_args'] = {'cursorclass': MySQLdb.cursors.SSCursor} engine = engine_from_config(config, 'sqlalchemy.', pool_recycle=7200, **kwargs) init_model(engine) # Disable for sqlite the isolation level to work around issues with savepoints if config['sqlalchemy.url'].startswith('sqlite'): @event.listens_for(engine, "connect") def do_connect(dbapi_connection, connection_record): dbapi_connection.isolation_level = None # Catch dead connections event.listens_for(engine, 'checkout')(connection_validator) event.listens_for(engine, 'connect')(connection_set_sqlmode) # Mako templating config['pylons.app_globals'].mako_lookup = TemplateLookup( directories=paths['templates'], ) # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) return config