def test_mapper_plugin_fired(self): config['ckan.plugins'] = 'mapper_plugin' plugins.load_all(config) CreateTestData.create_arbitrary([{'name':u'testpkg'}]) mapper_plugin = PluginGlobals.env().plugin_registry['MapperPlugin'].__instance__ assert len(mapper_plugin.added) == 2 # resource group table added automatically assert mapper_plugin.added[0].name == 'testpkg'
def test_plugin_loading_order(self): """ Check that plugins are loaded in the order specified in the config """ from ckantestplugin import MapperPlugin, MapperPlugin2, PluginObserverPlugin observerplugin = PluginObserverPlugin() config[ 'ckan.plugins'] = 'test_observer_plugin mapper_plugin mapper_plugin2' expected_order = MapperPlugin, MapperPlugin2 plugins.load_all(config) assert observerplugin.before_load.calls == [((p, ), {}) for p in expected_order] assert observerplugin.after_load.calls == [ ((p.__instance__, ), {}) for p in (observerplugin, ) + expected_order ] config[ 'ckan.plugins'] = 'test_observer_plugin mapper_plugin2 mapper_plugin' expected_order = MapperPlugin2, MapperPlugin observerplugin.reset_calls() plugins.load_all(config) assert observerplugin.before_load.calls == [((p, ), {}) for p in expected_order] assert observerplugin.after_load.calls == [ ((p.__instance__, ), {}) for p in (observerplugin, ) + expected_order ]
def _plugin_setup(): from ckan.tests.test_plugins import install_ckantestplugin _saved_plugins_config = config.get('ckan.plugins', '') install_ckantestplugin() config['ckan.plugins'] = 'authorizer_plugin' plugins.load_all(config) return _saved_plugins_config
def teardown_class(cls): plugins.unload_all() config['ckan.plugins'] = cls._saved_plugins_config if plugins.toolkit.check_ckan_version(min_version='2.6.0'): plugins.load_all() else: plugins.load_all(config)
def pytest_runtestloop(session): """When all the tests collected, extra plugin may be enabled because python interpreter visits their files. Make sure only configured plugins are active when test loop starts. """ plugins.load_all()
def test_auth_plugin_override(self): plugins.load_all(config) package_list_original = new_authz.is_authorized('package_list', {}) plugins.load('auth_plugin') assert new_authz.is_authorized('package_list', {}) != package_list_original plugins.unload('auth_plugin') assert new_authz.is_authorized('package_list', {}) == package_list_original
def test_action_plugin_override(self): plugins.load_all(config) status_show_original = logic.get_action('status_show')(None, {}) plugins.load('action_plugin') assert logic.get_action('status_show')(None, {}) != status_show_original plugins.unload('action_plugin') assert logic.get_action('status_show')(None, {}) == status_show_original
def setup_class(cls): reset_db() plugins.unload_all() cls._saved_plugins_config = config.get('ckan.plugins', '') config['ckan.plugins'] = 'archiver' if plugins.toolkit.check_ckan_version(min_version='2.6.0'): plugins.load_all() else: plugins.load_all(config)
def test_mapper_plugin_fired(self): config['ckan.plugins'] = 'mapper_plugin' plugins.load_all(config) CreateTestData.create_arbitrary([{'name': u'testpkg'}]) mapper_plugin = PluginGlobals.env_registry['pca'].plugin_registry[ 'MapperPlugin'].__instance__ assert len(mapper_plugin.added ) == 2 # resource group table added automatically assert mapper_plugin.added[0].name == 'testpkg'
def load_environment(global_conf, app_conf): """ Configure the Pylons environment via the ``pylons.config`` object. This code should only need to be run once. """ # this must be run at a time when the env is semi-setup, thus inlined here. # Required by the deliverance plugin and iATI from pylons.wsgiapp import PylonsApp import pkg_resources find_controller_generic = PylonsApp.find_controller # This is from pylons 1.0 source, will monkey-patch into 0.9.7 def find_controller(self, controller): if controller in self.controller_classes: return self.controller_classes[controller] # Check to see if its a dotted name if '.' in controller or ':' in controller: ep = pkg_resources.EntryPoint.parse('x={0}'.format(controller)) if hasattr(ep, 'resolve'): # setuptools >= 10.2 mycontroller = ep.resolve() else: # setuptools >= 11.3 mycontroller = ep.load(False) self.controller_classes[controller] = mycontroller return mycontroller return find_controller_generic(self, controller) PylonsApp.find_controller = find_controller os.environ['CKAN_CONFIG'] = global_conf['__file__'] # 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=[]) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='ckan', paths=paths) # Setup the SQLAlchemy database engine # Suppress a couple of sqlalchemy warnings msgs = [ '^Unicode type received non-unicode bind param value', "^Did not recognize type 'BIGINT' of column 'size'", "^Did not recognize type 'tsvector' of column 'search_vector'" ] for msg in msgs: warnings.filterwarnings('ignore', msg, sqlalchemy.exc.SAWarning) # load all CKAN plugins p.load_all(config)
def test_plugins_load(monkeypatch): monkeypatch.setitem(config, "ckan.plugins", "mapper_plugin routes_plugin") plugins.load_all() # synchronous_search automatically gets loaded current_plugins = set([ plugins.get_plugin(p) for p in ["mapper_plugin", "routes_plugin", "synchronous_search"] + find_system_plugins() ]) assert set(plugins.core._PLUGINS_SERVICE.values()) == current_plugins
def load_environment(conf): """ Configure the Pylons environment via the ``pylons.config`` object. This code should only need to be run once. """ os.environ['CKAN_CONFIG'] = conf['__file__'] # Pylons paths root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) valid_base_public_folder_names = ['public'] static_files = conf.get('ckan.base_public_folder', 'public') conf['ckan.base_public_folder'] = static_files if static_files not in valid_base_public_folder_names: raise CkanConfigurationException( 'You provided an invalid value for ckan.base_public_folder. ' 'Possible values are: "public".' ) log.info('Loading static files from %s' % static_files) paths = dict(root=root, controllers=os.path.join(root, 'controllers'), static_files=os.path.join(root, static_files), templates=[]) # Initialize main CKAN config object config.update(conf) # Setup the SQLAlchemy database engine # Suppress a couple of sqlalchemy warnings msgs = ['^Unicode type received non-unicode bind param value', "^Did not recognize type 'BIGINT' of column 'size'", "^Did not recognize type 'tsvector' of column 'search_vector'" ] for msg in msgs: warnings.filterwarnings('ignore', msg, sqlalchemy.exc.SAWarning) # load all CKAN plugins p.load_all() # Check Redis availability if not is_redis_available(): log.critical('Could not connect to Redis.') app_globals.reset() # issue #3260: remove idle transaction # Session that was used for getting all config params nor committed, # neither removed and we have idle connection as result model.Session.commit() # Build JavaScript translations. Must be done after plugins have # been loaded. build_js_translations()
def load_environment(global_conf, app_conf): """ Configure the Pylons environment via the ``pylons.config`` object. This code should only need to be run once. """ # this must be run at a time when the env is semi-setup, thus inlined here. # Required by the deliverance plugin and iATI from pylons.wsgiapp import PylonsApp import pkg_resources find_controller_generic = PylonsApp.find_controller # This is from pylons 1.0 source, will monkey-patch into 0.9.7 def find_controller(self, controller): if controller in self.controller_classes: return self.controller_classes[controller] # Check to see if its a dotted name if '.' in controller or ':' in controller: ep = pkg_resources.EntryPoint.parse('x={0}'.format(controller)) if hasattr(ep, 'resolve'): # setuptools >= 10.2 mycontroller = ep.resolve() else: # setuptools >= 11.3 mycontroller = ep.load(False) self.controller_classes[controller] = mycontroller return mycontroller return find_controller_generic(self, controller) PylonsApp.find_controller = find_controller os.environ['CKAN_CONFIG'] = global_conf['__file__'] # 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=[]) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='ckan', paths=paths) # Setup the SQLAlchemy database engine # Suppress a couple of sqlalchemy warnings msgs = ['^Unicode type received non-unicode bind param value', "^Did not recognize type 'BIGINT' of column 'size'", "^Did not recognize type 'tsvector' of column 'search_vector'" ] for msg in msgs: warnings.filterwarnings('ignore', msg, sqlalchemy.exc.SAWarning) # load all CKAN plugins p.load_all(config)
def test_plugins_load(self): config['ckan.plugins'] = 'mapper_plugin routes_plugin' plugins.load_all(config) # Imported after call to plugins.load_all to ensure that we test the # plugin loader starting from a blank slate. from ckantestplugin import MapperPlugin, MapperPlugin2, RoutesPlugin system_plugins = set(plugin() for plugin in find_system_plugins()) assert PluginGlobals.env().services == set([MapperPlugin(), RoutesPlugin()]) | system_plugins
def load_environment(global_conf, app_conf): """Configure the Pylons environment via the ``pylons.config`` object. This code should only need to be run once. """ ###### Pylons monkey-patch # this must be run at a time when the env is semi-setup, thus inlined here. # Required by the deliverance plugin and iATI from pylons.wsgiapp import PylonsApp import pkg_resources find_controller_generic = PylonsApp.find_controller # This is from pylons 1.0 source, will monkey-patch into 0.9.7 def find_controller(self, controller): if controller in self.controller_classes: return self.controller_classes[controller] # Check to see if its a dotted name if "." in controller or ":" in controller: mycontroller = pkg_resources.EntryPoint.parse("x=%s" % controller).load(False) self.controller_classes[controller] = mycontroller return mycontroller return find_controller_generic(self, controller) PylonsApp.find_controller = find_controller ###### END evil monkey-patch os.environ["CKAN_CONFIG"] = global_conf["__file__"] # 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=[], ) # Initialize config with the basic options config.init_app(global_conf, app_conf, package="ckan", paths=paths) # Setup the SQLAlchemy database engine # Suppress a couple of sqlalchemy warnings msgs = [ "^Unicode type received non-unicode bind param value", "^Did not recognize type 'BIGINT' of column 'size'", "^Did not recognize type 'tsvector' of column 'search_vector'", ] for msg in msgs: warnings.filterwarnings("ignore", msg, sqlalchemy.exc.SAWarning) # load all CKAN plugins p.load_all(config)
def test_plugins_load(self): config_plugins = config['ckan.plugins'] config['ckan.plugins'] = 'mapper_plugin routes_plugin' plugins.load_all() # synchronous_search automatically gets loaded current_plugins = {plugins.get_plugin(p) for p in ['mapper_plugin', 'routes_plugin', 'synchronous_search'] + find_system_plugins()} assert set(plugins.core._PLUGINS_SERVICE.values()) == current_plugins # cleanup config['ckan.plugins'] = config_plugins plugins.load_all()
def test_plugins_load(self): config_plugins = config['ckan.plugins'] config['ckan.plugins'] = 'mapper_plugin routes_plugin' plugins.load_all(config) # synchronous_search automatically gets loaded current_plugins = set([plugins.get_plugin(p) for p in ['mapper_plugin', 'routes_plugin', 'synchronous_search'] + find_system_plugins()]) assert PluginGlobals.env().services == current_plugins # cleanup config['ckan.plugins'] = config_plugins plugins.load_all(config)
def test_plugins_load(self): config['ckan.plugins'] = 'mapper_plugin routes_plugin' plugins.load_all(config) # Imported after call to plugins.load_all to ensure that we test the # plugin loader starting from a blank slate. from ckantestplugin import MapperPlugin, MapperPlugin2, RoutesPlugin system_plugins = set(plugin() for plugin in find_system_plugins()) assert PluginGlobals.env().services == set( [MapperPlugin(), RoutesPlugin()]) | system_plugins
def test_only_configured_plugins_loaded(self): config['ckan.plugins'] = 'mapper_plugin' plugins.load_all(config) from ckantestplugin import MapperPlugin, MapperPlugin2, RoutesPlugin from ckan.model.extension import PluginMapperExtension from ckan.config.routing import routing_plugins # MapperPlugin should be loaded as it is listed in config['ckan.plugins'] assert MapperPlugin() in iter(PluginMapperExtension.observers) # MapperPlugin2 and RoutesPlugin should NOT be loaded assert MapperPlugin2() not in iter(PluginMapperExtension.observers) assert RoutesPlugin() not in routing_plugins
def load_environment(conf: Union[Config, CKANConfig]): """ Configure the Pylons environment via the ``pylons.config`` object. This code should only need to be run once. """ os.environ['CKAN_CONFIG'] = cast(str, conf['__file__']) valid_base_public_folder_names = ['public', 'public-bs3'] static_files = conf.get('ckan.base_public_folder', 'public') conf['ckan.base_public_folder'] = static_files if static_files not in valid_base_public_folder_names: raise CkanConfigurationException( 'You provided an invalid value for ckan.base_public_folder. ' 'Possible values are: "public" and "public-bs3".') log.info('Loading static files from %s' % static_files) # Initialize main CKAN config object config.update(conf) # Setup the SQLAlchemy database engine # Suppress a couple of sqlalchemy warnings msgs = [ '^Unicode type received non-unicode bind param value', "^Did not recognize type 'BIGINT' of column 'size'", "^Did not recognize type 'tsvector' of column 'search_vector'" ] for msg in msgs: warnings.filterwarnings('ignore', msg, sqlalchemy.exc.SAWarning) # load all CKAN plugins p.load_all() # Check Redis availability if not is_redis_available(): log.critical('Could not connect to Redis.') app_globals.reset() # Build JavaScript translations. Must be done after plugins have # been loaded. build_js_translations()
def test_plugin_loading_order(self): """ Check that plugins are loaded in the order specified in the config """ config_plugins = config['ckan.plugins'] config['ckan.plugins'] = 'test_observer_plugin mapper_plugin mapper_plugin2' plugins.load_all(config) observerplugin = plugins.get_plugin('test_observer_plugin') expected_order = _make_calls(plugins.get_plugin('mapper_plugin'), plugins.get_plugin('mapper_plugin2')) assert observerplugin.before_load.calls[:2] == expected_order expected_order = _make_calls(plugins.get_plugin('test_observer_plugin'), plugins.get_plugin('mapper_plugin'), plugins.get_plugin('mapper_plugin2')) assert observerplugin.after_load.calls[:3] == expected_order config['ckan.plugins'] = 'test_observer_plugin mapper_plugin2 mapper_plugin' plugins.load_all(config) expected_order = _make_calls(plugins.get_plugin('mapper_plugin2'), plugins.get_plugin('mapper_plugin')) assert observerplugin.before_load.calls[:2] == expected_order expected_order = _make_calls(plugins.get_plugin('test_observer_plugin'), plugins.get_plugin('mapper_plugin2'), plugins.get_plugin('mapper_plugin')) assert observerplugin.after_load.calls[:3] == expected_order # cleanup config['ckan.plugins'] = config_plugins plugins.load_all(config)
def test_plugin_loading_order(self): """ Check that plugins are loaded in the order specified in the config """ from ckantestplugin import MapperPlugin, MapperPlugin2, PluginObserverPlugin observerplugin = PluginObserverPlugin() config['ckan.plugins'] = 'test_observer_plugin mapper_plugin mapper_plugin2' expected_order = MapperPlugin, MapperPlugin2 plugins.load_all(config) assert observerplugin.before_load.calls == [((p,), {}) for p in expected_order] assert observerplugin.after_load.calls == [((p.__instance__,), {}) for p in (observerplugin,) + expected_order] config['ckan.plugins'] = 'test_observer_plugin mapper_plugin2 mapper_plugin' expected_order = MapperPlugin2, MapperPlugin observerplugin.reset_calls() plugins.load_all(config) assert observerplugin.before_load.calls == [((p,), {}) for p in expected_order] assert observerplugin.after_load.calls == [((p.__instance__,), {}) for p in (observerplugin,) + expected_order]
def test_plugin_loading_order(self): """ Check that plugins are loaded in the order specified in the config """ config_plugins = config["ckan.plugins"] config[ "ckan.plugins" ] = "test_observer_plugin mapper_plugin mapper_plugin2" plugins.load_all() observerplugin = plugins.get_plugin("test_observer_plugin") expected_order = _make_calls( plugins.get_plugin("mapper_plugin"), plugins.get_plugin("mapper_plugin2"), ) assert observerplugin.before_load.calls[:2] == expected_order expected_order = _make_calls( plugins.get_plugin("test_observer_plugin"), plugins.get_plugin("mapper_plugin"), plugins.get_plugin("mapper_plugin2"), ) assert observerplugin.after_load.calls[:3] == expected_order config[ "ckan.plugins" ] = "test_observer_plugin mapper_plugin2 mapper_plugin" plugins.load_all() expected_order = _make_calls( plugins.get_plugin("mapper_plugin2"), plugins.get_plugin("mapper_plugin"), ) assert observerplugin.before_load.calls[:2] == expected_order expected_order = _make_calls( plugins.get_plugin("test_observer_plugin"), plugins.get_plugin("mapper_plugin2"), plugins.get_plugin("mapper_plugin"), ) assert observerplugin.after_load.calls[:3] == expected_order # cleanup config["ckan.plugins"] = config_plugins plugins.load_all()
def load_environment(global_conf, app_conf): """Configure the Pylons environment via the ``pylons.config`` object """ ###### Pylons monkey-patch # this must be run at a time when the env is semi-setup, thus inlined here. # Required by the deliverance plugin and iATI from pylons.wsgiapp import PylonsApp import pkg_resources find_controller_generic = PylonsApp.find_controller # This is from pylons 1.0 source, will monkey-patch into 0.9.7 def find_controller(self, controller): if controller in self.controller_classes: return self.controller_classes[controller] # Check to see if its a dotted name if '.' in controller or ':' in controller: mycontroller = pkg_resources \ .EntryPoint \ .parse('x=%s' % controller).load(False) self.controller_classes[controller] = mycontroller return mycontroller return find_controller_generic(self, controller) PylonsApp.find_controller = find_controller ###### END evil monkey-patch os.environ['CKAN_CONFIG'] = global_conf['__file__'] # 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=[]) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='ckan', paths=paths) # load all CKAN plugins p.load_all(config) # Load the synchronous search plugin, unless already loaded or # explicitly disabled if not 'synchronous_search' in config.get('ckan.plugins',[]) and \ asbool(config.get('ckan.search.automatic_indexing', True)): log.debug('Loading the synchronous search plugin') p.load('synchronous_search') for plugin in p.PluginImplementations(p.IConfigurer): # must do update in place as this does not work: # config = plugin.update_config(config) plugin.update_config(config) # This is set up before globals are initialized site_id = os.environ.get('CKAN_SITE_ID') if site_id: config['ckan.site_id'] = site_id site_url = config.get('ckan.site_url', '') ckan_host = config['ckan.host'] = urlparse(site_url).netloc if config.get('ckan.site_id') is None: if ':' in ckan_host: ckan_host, port = ckan_host.split(':') assert ckan_host, 'You need to configure ckan.site_url or ' \ 'ckan.site_id for SOLR search-index rebuild to work.' config['ckan.site_id'] = ckan_host # ensure that a favicon has been set favicon = config.get('ckan.favicon', '/images/icons/ckan.ico') config['ckan.favicon'] = favicon # Init SOLR settings and check if the schema is compatible #from ckan.lib.search import SolrSettings, check_solr_schema_version # lib.search is imported here as we need the config enabled and parsed import ckan.lib.search as search search.SolrSettings.init(config.get('solr_url'), config.get('solr_user'), config.get('solr_password')) search.check_solr_schema_version() config['routes.map'] = routing.make_map() config['routes.named_routes'] = routing.named_routes config['pylons.app_globals'] = app_globals.app_globals # initialise the globals config['pylons.app_globals']._init() # add helper functions helpers = _Helpers(h) config['pylons.h'] = helpers ## redo template setup to use genshi.search_path ## (so remove std template setup) legacy_templates_path = os.path.join(root, 'templates_legacy') jinja2_templates_path = os.path.join(root, 'templates') if asbool(config.get('ckan.legacy_templates', 'no')): # We want the new template path for extra snippets like the # dataviewer and also for some testing stuff template_paths = [legacy_templates_path, jinja2_templates_path] else: template_paths = [jinja2_templates_path, legacy_templates_path] extra_template_paths = config.get('extra_template_paths', '') if extra_template_paths: # must be first for them to override defaults template_paths = extra_template_paths.split(',') + template_paths config['pylons.app_globals'].template_paths = template_paths # Translator (i18n) translator = Translator(pylons.translator) def template_loaded(template): translator.setup(template) # Markdown ignores the logger config, so to get rid of excessive # markdown debug messages in the log, set it to the level of the # root logger. logging.getLogger("MARKDOWN").setLevel(logging.getLogger().level) # Create the Genshi TemplateLoader config['pylons.app_globals'].genshi_loader = TemplateLoader( template_paths, auto_reload=True, callback=template_loaded) ################################################################# # # # HORRIBLE GENSHI HACK # # # ################################################################# # # # Genshi does strange things to get stuff out of the template # # variables. This stops it from handling properties in the # # correct way as it returns the property rather than the actual # # value of the property. # # # # By overriding lookup_attr() in the LookupBase class we are # # able to get the required behaviour. Using @property allows # # us to move functionality out of templates whilst maintaining # # backwards compatability. # # # ################################################################# ''' This code is based on Genshi code Copyright © 2006-2012 Edgewall Software All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ''' from genshi.template.eval import LookupBase @classmethod def genshi_lookup_attr(cls, obj, key): __traceback_hide__ = True try: val = getattr(obj, key) except AttributeError: if hasattr(obj.__class__, key): raise else: try: val = obj[key] except (KeyError, TypeError): val = cls.undefined(key, owner=obj) if isinstance(val, property): val = val.fget() return val setattr(LookupBase, 'lookup_attr', genshi_lookup_attr) del genshi_lookup_attr del LookupBase ################################################################# # # # END OF GENSHI HACK # # # ################################################################# # Create Jinja2 environment env = lib.jinja_extensions.Environment( loader=lib.jinja_extensions.CkanFileSystemLoader(template_paths), autoescape=True, extensions=[ 'jinja2.ext.do', 'jinja2.ext.with_', lib.jinja_extensions.SnippetExtension, lib.jinja_extensions.CkanExtend, lib.jinja_extensions.CkanInternationalizationExtension, lib.jinja_extensions.LinkForExtension, lib.jinja_extensions.ResourceExtension, lib.jinja_extensions.UrlForStaticExtension, lib.jinja_extensions.UrlForExtension ]) env.install_gettext_callables(_, ungettext, newstyle=True) # custom filters env.filters['empty_and_escape'] = lib.jinja_extensions.empty_and_escape env.filters['truncate'] = lib.jinja_extensions.truncate config['pylons.app_globals'].jinja_env = env # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) # Setup the SQLAlchemy database engine # Suppress a couple of sqlalchemy warnings msgs = [ '^Unicode type received non-unicode bind param value', "^Did not recognize type 'BIGINT' of column 'size'", "^Did not recognize type 'tsvector' of column 'search_vector'" ] for msg in msgs: warnings.filterwarnings('ignore', msg, sqlalchemy.exc.SAWarning) ckan_db = os.environ.get('CKAN_DB') if ckan_db: config['sqlalchemy.url'] = ckan_db # for postgresql we want to enforce utf-8 sqlalchemy_url = config.get('sqlalchemy.url', '') if sqlalchemy_url.startswith('postgresql://'): extras = {'client_encoding': 'utf8'} else: extras = {} engine = sqlalchemy.engine_from_config(config, 'sqlalchemy.', **extras) if not model.meta.engine: model.init_model(engine) for plugin in p.PluginImplementations(p.IConfigurable): plugin.configure(config)
def teardown_class(cls): plugins.unload_all() config['ckan.plugins'] = cls._saved_plugins_config plugins.load_all(config)
def _plugin_teardown(_saved_plugins_config): plugins.unload_all() config['ckan.plugins'] = _saved_plugins_config plugins.load_all(config)
def setup_class(cls): reset_db() plugins.unload_all() cls._saved_plugins_config = config.get("ckan.plugins", "") config["ckan.plugins"] = "archiver" plugins.load_all(config)
def load_environment(global_conf, app_conf): """Configure the Pylons environment via the ``pylons.config`` object. This code should only need to be run once. """ ###### Pylons monkey-patch # this must be run at a time when the env is semi-setup, thus inlined here. # Required by the deliverance plugin and iATI from pylons.wsgiapp import PylonsApp import pkg_resources find_controller_generic = PylonsApp.find_controller # This is from pylons 1.0 source, will monkey-patch into 0.9.7 def find_controller(self, controller): if controller in self.controller_classes: return self.controller_classes[controller] # Check to see if its a dotted name if '.' in controller or ':' in controller: mycontroller = pkg_resources \ .EntryPoint \ .parse('x=%s' % controller).load(False) self.controller_classes[controller] = mycontroller return mycontroller return find_controller_generic(self, controller) PylonsApp.find_controller = find_controller ###### END evil monkey-patch os.environ['CKAN_CONFIG'] = global_conf['__file__'] # 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=[]) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='ckan', paths=paths) ################################################################# # # # HORRIBLE GENSHI HACK # # # ################################################################# # # # Genshi does strange things to get stuff out of the template # # variables. This stops it from handling properties in the # # correct way as it returns the property rather than the actual # # value of the property. # # # # By overriding lookup_attr() in the LookupBase class we are # # able to get the required behaviour. Using @property allows # # us to move functionality out of templates whilst maintaining # # backwards compatability. # # # ################################################################# ''' This code is based on Genshi code Copyright © 2006-2012 Edgewall Software All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ''' from genshi.template.eval import LookupBase @classmethod def genshi_lookup_attr(cls, obj, key): __traceback_hide__ = True try: val = getattr(obj, key) except AttributeError: if hasattr(obj.__class__, key): raise else: try: val = obj[key] except (KeyError, TypeError): val = cls.undefined(key, owner=obj) if isinstance(val, property): val = val.fget() return val setattr(LookupBase, 'lookup_attr', genshi_lookup_attr) del genshi_lookup_attr del LookupBase ################################################################# # # # END OF GENSHI HACK # # # ################################################################# # Setup the SQLAlchemy database engine # Suppress a couple of sqlalchemy warnings msgs = ['^Unicode type received non-unicode bind param value', "^Did not recognize type 'BIGINT' of column 'size'", "^Did not recognize type 'tsvector' of column 'search_vector'" ] for msg in msgs: warnings.filterwarnings('ignore', msg, sqlalchemy.exc.SAWarning) # load all CKAN plugins p.load_all(config)
def load_environment(global_conf, app_conf): """Configure the Pylons environment via the ``pylons.config`` object """ ###### Pylons monkey-patch # this must be run at a time when the env is semi-setup, thus inlined here. # Required by the deliverance plugin and iATI from pylons.wsgiapp import PylonsApp import pkg_resources find_controller_generic = PylonsApp.find_controller # This is from pylons 1.0 source, will monkey-patch into 0.9.7 def find_controller(self, controller): if controller in self.controller_classes: return self.controller_classes[controller] # Check to see if its a dotted name if '.' in controller or ':' in controller: mycontroller = pkg_resources.EntryPoint.parse( 'x=%s' % controller).load(False) self.controller_classes[controller] = mycontroller return mycontroller return find_controller_generic(self, controller) PylonsApp.find_controller = find_controller ###### END evil monkey-patch os.environ['CKAN_CONFIG'] = global_conf['__file__'] # 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='ckan', paths=paths) # load all CKAN plugins plugins.load_all(config) from ckan.plugins import PluginImplementations from ckan.plugins.interfaces import IConfigurer for plugin in PluginImplementations(IConfigurer): # must do update in place as this does not work: # config = plugin.update_config(config) plugin.update_config(config) # This is set up before globals are initialized site_url = config.get('ckan.site_url', '') ckan_host = config['ckan.host'] = urlparse(site_url).netloc if config.get('ckan.site_id') is None: if ':' in ckan_host: ckan_host, port = ckan_host.split(':') assert ckan_host, 'You need to configure ckan.site_url or ' \ 'ckan.site_id for SOLR search-index rebuild to work.' config['ckan.site_id'] = ckan_host # Check if SOLR schema is compatible from ckan.lib.search import check_solr_schema_version check_solr_schema_version() config['routes.map'] = make_map() config['pylons.app_globals'] = app_globals.Globals() config['pylons.h'] = ckan.lib.helpers ## redo template setup to use genshi.search_path (so remove std template setup) template_paths = [paths['templates'][0]] extra_template_paths = config.get('extra_template_paths', '') if extra_template_paths: # must be first for them to override defaults template_paths = extra_template_paths.split(',') + template_paths # Translator (i18n) translator = Translator(pylons.translator) def template_loaded(template): translator.setup(template) # Markdown ignores the logger config, so to get rid of excessive # markdown debug messages in the log, set it to the level of the # root logger. logging.getLogger("MARKDOWN").setLevel(logging.getLogger().level) # Create the Genshi TemplateLoader # config['pylons.app_globals'].genshi_loader = TemplateLoader( # paths['templates'], auto_reload=True) # tmpl_options["genshi.loader_callback"] = template_loaded config['pylons.app_globals'].genshi_loader = TemplateLoader( template_paths, auto_reload=True, callback=template_loaded) # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) # Setup the SQLAlchemy database engine engine = engine_from_config(config, 'sqlalchemy.') if not model.meta.engine: model.init_model(engine) from ckan.plugins import PluginImplementations from ckan.plugins.interfaces import IConfigurable for plugin in PluginImplementations(IConfigurable): plugin.configure(config)
def load_environment(global_conf, app_conf): """ Configure the Pylons environment via the ``pylons.config`` object. This code should only need to be run once. """ # this must be run at a time when the env is semi-setup, thus inlined here. # Required by the deliverance plugin and iATI from pylons.wsgiapp import PylonsApp import pkg_resources find_controller_generic = PylonsApp.find_controller # This is from pylons 1.0 source, will monkey-patch into 0.9.7 def find_controller(self, controller): if controller in self.controller_classes: return self.controller_classes[controller] # Check to see if its a dotted name if '.' in controller or ':' in controller: ep = pkg_resources.EntryPoint.parse('x={0}'.format(controller)) if hasattr(ep, 'resolve'): # setuptools >= 10.2 mycontroller = ep.resolve() else: # setuptools >= 11.3 mycontroller = ep.load(False) self.controller_classes[controller] = mycontroller return mycontroller return find_controller_generic(self, controller) PylonsApp.find_controller = find_controller os.environ['CKAN_CONFIG'] = global_conf['__file__'] # 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=[]) # Initialize main CKAN config object config.update(global_conf) config.update(app_conf) # Initialize Pylons own config object pylons_config.init_app(global_conf, app_conf, package='ckan', paths=paths) # Update the main CKAN config object with the Pylons specific stuff, as it # quite hard to keep them separated. This should be removed once Pylons # support is dropped config.update(pylons_config) # Setup the SQLAlchemy database engine # Suppress a couple of sqlalchemy warnings msgs = [ '^Unicode type received non-unicode bind param value', "^Did not recognize type 'BIGINT' of column 'size'", "^Did not recognize type 'tsvector' of column 'search_vector'" ] for msg in msgs: warnings.filterwarnings('ignore', msg, sqlalchemy.exc.SAWarning) # Check Redis availability if not is_redis_available(): log.critical('Could not connect to Redis.') # load all CKAN plugins p.load_all() app_globals.reset() # Build JavaScript translations. Must be done after plugins have # been loaded. build_js_translations()
def load_environment(conf): """ Configure the Pylons environment via the ``pylons.config`` object. This code should only need to be run once. """ if six.PY2: # this must be run at a time when the env is semi-setup, thus inlined # here. Required by the deliverance plugin and iATI from pylons.wsgiapp import PylonsApp import pkg_resources find_controller_generic = getattr(PylonsApp.find_controller, '_old_find_controller', PylonsApp.find_controller) # This is from pylons 1.0 source, will monkey-patch into 0.9.7 def find_controller(self, controller): if controller in self.controller_classes: return self.controller_classes[controller] # Check to see if its a dotted name if '.' in controller or ':' in controller: ep = pkg_resources.EntryPoint.parse('x={0}'.format(controller)) if hasattr(ep, 'resolve'): # setuptools >= 10.2 mycontroller = ep.resolve() else: # setuptools >= 11.3 mycontroller = ep.load(False) self.controller_classes[controller] = mycontroller return mycontroller return find_controller_generic(self, controller) find_controller._old_find_controller = find_controller_generic PylonsApp.find_controller = find_controller os.environ['CKAN_CONFIG'] = conf['__file__'] # Pylons paths root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) valid_base_public_folder_names = ['public'] static_files = conf.get('ckan.base_public_folder', 'public') conf['ckan.base_public_folder'] = static_files if static_files not in valid_base_public_folder_names: raise CkanConfigurationException( 'You provided an invalid value for ckan.base_public_folder. ' 'Possible values are: "public".') log.info('Loading static files from %s' % static_files) paths = dict(root=root, controllers=os.path.join(root, 'controllers'), static_files=os.path.join(root, static_files), templates=[]) # Initialize main CKAN config object config.update(conf) if six.PY2: # Initialize Pylons own config object pylons_config.init_app(conf['global_conf'], conf, package='ckan', paths=paths) # Update the main CKAN config object with the Pylons specific stuff, # as it is quite hard to keep them separated. This should be removed # once Pylons support is dropped config.update(pylons_config) # Setup the SQLAlchemy database engine # Suppress a couple of sqlalchemy warnings msgs = [ '^Unicode type received non-unicode bind param value', "^Did not recognize type 'BIGINT' of column 'size'", "^Did not recognize type 'tsvector' of column 'search_vector'" ] for msg in msgs: warnings.filterwarnings('ignore', msg, sqlalchemy.exc.SAWarning) # load all CKAN plugins p.load_all() if not p.plugin_loaded('managed_search_schema'): search.check_solr_schema_version() # Check Redis availability if not is_redis_available(): log.critical('Could not connect to Redis.') app_globals.reset() # issue #3260: remove idle transaction # Session that was used for getting all config params nor committed, # neither removed and we have idle connection as result model.Session.commit() # Build JavaScript translations. Must be done after plugins have # been loaded. build_js_translations()
def load_environment(global_conf, app_conf): """Configure the Pylons environment via the ``pylons.config`` object """ ###### Pylons monkey-patch # this must be run at a time when the env is semi-setup, thus inlined here. # Required by the deliverance plugin and iATI from pylons.wsgiapp import PylonsApp import pkg_resources find_controller_generic = PylonsApp.find_controller # This is from pylons 1.0 source, will monkey-patch into 0.9.7 def find_controller(self, controller): if controller in self.controller_classes: return self.controller_classes[controller] # Check to see if its a dotted name if '.' in controller or ':' in controller: mycontroller = pkg_resources \ .EntryPoint \ .parse('x=%s' % controller).load(False) self.controller_classes[controller] = mycontroller return mycontroller return find_controller_generic(self, controller) PylonsApp.find_controller = find_controller ###### END evil monkey-patch os.environ['CKAN_CONFIG'] = global_conf['__file__'] # 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=[]) # Initialize config with the basic options config.init_app(global_conf, app_conf, package='ckan', paths=paths) # load all CKAN plugins p.load_all(config) # Load the synchronous search plugin, unless already loaded or # explicitly disabled if not 'synchronous_search' in config.get('ckan.plugins',[]) and \ asbool(config.get('ckan.search.automatic_indexing', True)): log.debug('Loading the synchronous search plugin') p.load('synchronous_search') for plugin in p.PluginImplementations(p.IConfigurer): # must do update in place as this does not work: # config = plugin.update_config(config) plugin.update_config(config) # This is set up before globals are initialized site_id = os.environ.get('CKAN_SITE_ID') if site_id: config['ckan.site_id'] = site_id site_url = config.get('ckan.site_url', '') ckan_host = config['ckan.host'] = urlparse(site_url).netloc if config.get('ckan.site_id') is None: if ':' in ckan_host: ckan_host, port = ckan_host.split(':') assert ckan_host, 'You need to configure ckan.site_url or ' \ 'ckan.site_id for SOLR search-index rebuild to work.' config['ckan.site_id'] = ckan_host # ensure that a favicon has been set favicon = config.get('ckan.favicon', '/images/icons/ckan.ico') config['ckan.favicon'] = favicon # Init SOLR settings and check if the schema is compatible #from ckan.lib.search import SolrSettings, check_solr_schema_version # lib.search is imported here as we need the config enabled and parsed import ckan.lib.search as search search.SolrSettings.init(config.get('solr_url'), config.get('solr_user'), config.get('solr_password')) search.check_solr_schema_version() config['routes.map'] = routing.make_map() config['routes.named_routes'] = routing.named_routes config['pylons.app_globals'] = app_globals.app_globals # initialise the globals config['pylons.app_globals']._init() # add helper functions helpers = _Helpers(h) config['pylons.h'] = helpers ## redo template setup to use genshi.search_path ## (so remove std template setup) legacy_templates_path = os.path.join(root, 'templates_legacy') jinja2_templates_path = os.path.join(root, 'templates') if asbool(config.get('ckan.legacy_templates', 'no')): # We want the new template path for extra snippets like the # dataviewer and also for some testing stuff template_paths = [legacy_templates_path, jinja2_templates_path] else: template_paths = [jinja2_templates_path, legacy_templates_path] extra_template_paths = config.get('extra_template_paths', '') if extra_template_paths: # must be first for them to override defaults template_paths = extra_template_paths.split(',') + template_paths config['pylons.app_globals'].template_paths = template_paths # Translator (i18n) translator = Translator(pylons.translator) def template_loaded(template): translator.setup(template) # Markdown ignores the logger config, so to get rid of excessive # markdown debug messages in the log, set it to the level of the # root logger. logging.getLogger("MARKDOWN").setLevel(logging.getLogger().level) # Create the Genshi TemplateLoader config['pylons.app_globals'].genshi_loader = TemplateLoader( template_paths, auto_reload=True, callback=template_loaded) ################################################################# # # # HORRIBLE GENSHI HACK # # # ################################################################# # # # Genshi does strange things to get stuff out of the template # # variables. This stops it from handling properties in the # # correct way as it returns the property rather than the actual # # value of the property. # # # # By overriding lookup_attr() in the LookupBase class we are # # able to get the required behaviour. Using @property allows # # us to move functionality out of templates whilst maintaining # # backwards compatability. # # # ################################################################# ''' This code is based on Genshi code Copyright © 2006-2012 Edgewall Software All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ''' from genshi.template.eval import LookupBase @classmethod def genshi_lookup_attr(cls, obj, key): __traceback_hide__ = True try: val = getattr(obj, key) except AttributeError: if hasattr(obj.__class__, key): raise else: try: val = obj[key] except (KeyError, TypeError): val = cls.undefined(key, owner=obj) if isinstance(val, property): val = val.fget() return val setattr(LookupBase, 'lookup_attr', genshi_lookup_attr) del genshi_lookup_attr del LookupBase ################################################################# # # # END OF GENSHI HACK # # # ################################################################# # Create Jinja2 environment env = jinja_extensions.Environment( loader=jinja_extensions.CkanFileSystemLoader(template_paths), autoescape=True, extensions=['jinja2.ext.do', 'jinja2.ext.with_', jinja_extensions.SnippetExtension, jinja_extensions.CkanExtend, jinja_extensions.CkanInternationalizationExtension, jinja_extensions.LinkForExtension, jinja_extensions.ResourceExtension, jinja_extensions.UrlForStaticExtension, jinja_extensions.UrlForExtension] ) env.install_gettext_callables(_, ungettext, newstyle=True) # custom filters env.filters['empty_and_escape'] = jinja_extensions.empty_and_escape env.filters['truncate'] = jinja_extensions.truncate config['pylons.app_globals'].jinja_env = env # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) # Setup the SQLAlchemy database engine # Suppress a couple of sqlalchemy warnings msgs = ['^Unicode type received non-unicode bind param value', "^Did not recognize type 'BIGINT' of column 'size'", "^Did not recognize type 'tsvector' of column 'search_vector'" ] for msg in msgs: warnings.filterwarnings('ignore', msg, sqlalchemy.exc.SAWarning) ckan_db = os.environ.get('CKAN_DB') if ckan_db: config['sqlalchemy.url'] = ckan_db # for postgresql we want to enforce utf-8 sqlalchemy_url = config.get('sqlalchemy.url', '') if sqlalchemy_url.startswith('postgresql://'): extras = {'client_encoding': 'utf8'} else: extras = {} engine = sqlalchemy.engine_from_config(config, 'sqlalchemy.', **extras) if not model.meta.engine: model.init_model(engine) for plugin in p.PluginImplementations(p.IConfigurable): plugin.configure(config)
def tearDown(self): # Ideally this would remove the ckantestplugin_dist from the working # set, but I can't find a way to do that in setuptools. plugins.unload_all() config['ckan.plugins'] = self._saved_plugins_config plugins.load_all(config)
def load_environment(global_conf, app_conf): """ Configure the Pylons environment via the ``pylons.config`` object. This code should only need to be run once. """ # this must be run at a time when the env is semi-setup, thus inlined here. # Required by the deliverance plugin and iATI from pylons.wsgiapp import PylonsApp import pkg_resources find_controller_generic = PylonsApp.find_controller # This is from pylons 1.0 source, will monkey-patch into 0.9.7 def find_controller(self, controller): if controller in self.controller_classes: return self.controller_classes[controller] # Check to see if its a dotted name if '.' in controller or ':' in controller: ep = pkg_resources.EntryPoint.parse('x={0}'.format(controller)) if hasattr(ep, 'resolve'): # setuptools >= 10.2 mycontroller = ep.resolve() else: # setuptools >= 11.3 mycontroller = ep.load(False) self.controller_classes[controller] = mycontroller return mycontroller return find_controller_generic(self, controller) PylonsApp.find_controller = find_controller os.environ['CKAN_CONFIG'] = global_conf['__file__'] # Pylons paths root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) valid_base_public_folder_names = ['public', 'public-bs2'] static_files = app_conf.get('ckan.base_public_folder', 'public') app_conf['ckan.base_public_folder'] = static_files if static_files not in valid_base_public_folder_names: raise CkanConfigurationException( 'You provided an invalid value for ckan.base_public_folder. ' 'Possible values are: "public" and "public-bs2".' ) log.info('Loading static files from %s' % static_files) paths = dict(root=root, controllers=os.path.join(root, 'controllers'), static_files=os.path.join(root, static_files), templates=[]) # Initialize main CKAN config object config.update(global_conf) config.update(app_conf) # Initialize Pylons own config object pylons_config.init_app(global_conf, app_conf, package='ckan', paths=paths) # Update the main CKAN config object with the Pylons specific stuff, as it # quite hard to keep them separated. This should be removed once Pylons # support is dropped config.update(pylons_config) # Setup the SQLAlchemy database engine # Suppress a couple of sqlalchemy warnings msgs = ['^Unicode type received non-unicode bind param value', "^Did not recognize type 'BIGINT' of column 'size'", "^Did not recognize type 'tsvector' of column 'search_vector'" ] for msg in msgs: warnings.filterwarnings('ignore', msg, sqlalchemy.exc.SAWarning) # load all CKAN plugins p.load_all() # Check Redis availability if not is_redis_available(): log.critical('Could not connect to Redis.') app_globals.reset() # issue #3260: remove idle transaction # Session that was used for getting all config params nor committed, # neither removed and we have idle connection as result model.Session.commit() # Build JavaScript translations. Must be done after plugins have # been loaded. build_js_translations()
def setup_class(cls): plugins.unload_all() cls._saved_plugins_config = config.get('ckan.plugins', '') config['ckan.plugins'] = 'archiver' plugins.load_all(config)
def load_environment(global_conf, app_conf): """Configure the Pylons environment via the ``pylons.config`` object """ ###### Pylons monkey-patch # this must be run at a time when the env is semi-setup, thus inlined here. # Required by the deliverance plugin and iATI from pylons.wsgiapp import PylonsApp import pkg_resources find_controller_generic = PylonsApp.find_controller # This is from pylons 1.0 source, will monkey-patch into 0.9.7 def find_controller(self, controller): if controller in self.controller_classes: return self.controller_classes[controller] # Check to see if its a dotted name if "." in controller or ":" in controller: mycontroller = pkg_resources.EntryPoint.parse("x=%s" % controller).load(False) self.controller_classes[controller] = mycontroller return mycontroller return find_controller_generic(self, controller) PylonsApp.find_controller = find_controller ###### END evil monkey-patch os.environ["CKAN_CONFIG"] = global_conf["__file__"] # 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="ckan", paths=paths) # load all CKAN plugins p.load_all(config) # Load the synchronous search plugin, unless already loaded or # explicitly disabled if not "synchronous_search" in config.get("ckan.plugins", []) and asbool( config.get("ckan.search.automatic_indexing", True) ): log.debug("Loading the synchronous search plugin") p.load("synchronous_search") for plugin in p.PluginImplementations(p.IConfigurer): # must do update in place as this does not work: # config = plugin.update_config(config) plugin.update_config(config) # This is set up before globals are initialized site_id = os.environ.get("CKAN_SITE_ID") if site_id: config["ckan.site_id"] = site_id site_url = config.get("ckan.site_url", "") ckan_host = config["ckan.host"] = urlparse(site_url).netloc if config.get("ckan.site_id") is None: if ":" in ckan_host: ckan_host, port = ckan_host.split(":") assert ckan_host, ( "You need to configure ckan.site_url or " "ckan.site_id for SOLR search-index rebuild to work." ) config["ckan.site_id"] = ckan_host # Init SOLR settings and check if the schema is compatible # from ckan.lib.search import SolrSettings, check_solr_schema_version search.SolrSettings.init(config.get("solr_url"), config.get("solr_user"), config.get("solr_password")) search.check_solr_schema_version() config["routes.map"] = routing.make_map() config["pylons.app_globals"] = app_globals.Globals() # add helper functions restrict_helpers = asbool(config.get("ckan.restrict_template_vars", "true")) helpers = _Helpers(h, restrict_helpers) config["pylons.h"] = helpers # Redo template setup to use genshi.search_path # (so remove std template setup) template_paths = [paths["templates"][0]] extra_template_paths = config.get("extra_template_paths", "") if extra_template_paths: # must be first for them to override defaults template_paths = extra_template_paths.split(",") + template_paths # Translator (i18n) translator = Translator(pylons.translator) def template_loaded(template): translator.setup(template) # Markdown ignores the logger config, so to get rid of excessive # markdown debug messages in the log, set it to the level of the # root logger. logging.getLogger("MARKDOWN").setLevel(logging.getLogger().level) # Create the Genshi TemplateLoader config["pylons.app_globals"].genshi_loader = TemplateLoader( template_paths, auto_reload=True, callback=template_loaded ) ################################################################# # # # HORRIBLE GENSHI HACK # # # ################################################################# # # # Genshi does strange things to get stuff out of the template # # variables. This stops it from handling properties in the # # correct way as it returns the property rather than the actual # # value of the property. # # # # By overriding lookup_attr() in the LookupBase class we are # # able to get the required behaviour. Using @property allows # # us to move functionality out of templates whilst maintaining # # backwards compatability. # # # ################################################################# """ This code is based on Genshi code Copyright © 2006-2012 Edgewall Software All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ from genshi.template.eval import LookupBase @classmethod def genshi_lookup_attr(cls, obj, key): __traceback_hide__ = True try: val = getattr(obj, key) except AttributeError: if hasattr(obj.__class__, key): raise else: try: val = obj[key] except (KeyError, TypeError): val = cls.undefined(key, owner=obj) if isinstance(val, property): val = val.fget() return val setattr(LookupBase, "lookup_attr", genshi_lookup_attr) del genshi_lookup_attr del LookupBase ################################################################# # # # END OF GENSHI HACK # # # ################################################################# # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) # Setup the SQLAlchemy database engine # Suppress a couple of sqlalchemy warnings msgs = [ "^Unicode type received non-unicode bind param value", "^Did not recognize type 'BIGINT' of column 'size'", "^Did not recognize type 'tsvector' of column 'search_vector'", ] for msg in msgs: warnings.filterwarnings("ignore", msg, sqlalchemy.exc.SAWarning) ckan_db = os.environ.get("CKAN_DB") if ckan_db: config["sqlalchemy.url"] = ckan_db # for postgresql we want to enforce utf-8 sqlalchemy_url = config.get("sqlalchemy.url", "") if sqlalchemy_url.startswith("postgresql://"): extras = {"client_encoding": "utf8"} else: extras = {} engine = sqlalchemy.engine_from_config(config, "sqlalchemy.", **extras) if not model.meta.engine: model.init_model(engine) for plugin in p.PluginImplementations(p.IConfigurable): plugin.configure(config)
def load_environment(global_conf, app_conf): """Configure the Pylons environment via the ``pylons.config`` object """ ###### Pylons monkey-patch # this must be run at a time when the env is semi-setup, thus inlined here. # Required by the deliverance plugin and iATI from pylons.wsgiapp import PylonsApp import pkg_resources find_controller_generic = PylonsApp.find_controller # This is from pylons 1.0 source, will monkey-patch into 0.9.7 def find_controller(self, controller): if controller in self.controller_classes: return self.controller_classes[controller] # Check to see if its a dotted name if '.' in controller or ':' in controller: mycontroller = pkg_resources.EntryPoint.parse('x=%s' % controller).load(False) self.controller_classes[controller] = mycontroller return mycontroller return find_controller_generic(self, controller) PylonsApp.find_controller = find_controller ###### END evil monkey-patch os.environ['CKAN_CONFIG'] = global_conf['__file__'] # 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='ckan', paths=paths) # load all CKAN plugins plugins.load_all(config) from ckan.plugins import PluginImplementations from ckan.plugins.interfaces import IConfigurer for plugin in PluginImplementations(IConfigurer): # must do update in place as this does not work: # config = plugin.update_config(config) plugin.update_config(config) # This is set up before globals are initialized site_url = config.get('ckan.site_url', '') ckan_host = config['ckan.host'] = urlparse(site_url).netloc if config.get('ckan.site_id') is None: if ':' in ckan_host: ckan_host, port = ckan_host.split(':') assert ckan_host, 'You need to configure ckan.site_url or ' \ 'ckan.site_id for SOLR search-index rebuild to work.' config['ckan.site_id'] = ckan_host # Init SOLR settings and check if the schema is compatible from ckan.lib.search import SolrSettings, check_solr_schema_version SolrSettings.init(config.get('solr_url'), config.get('solr_user'), config.get('solr_password')) check_solr_schema_version() config['routes.map'] = make_map() config['pylons.app_globals'] = app_globals.Globals() config['pylons.h'] = ckan.lib.helpers ## redo template setup to use genshi.search_path (so remove std template setup) template_paths = [paths['templates'][0]] extra_template_paths = config.get('extra_template_paths', '') if extra_template_paths: # must be first for them to override defaults template_paths = extra_template_paths.split(',') + template_paths # Translator (i18n) translator = Translator(pylons.translator) def template_loaded(template): translator.setup(template) # Markdown ignores the logger config, so to get rid of excessive # markdown debug messages in the log, set it to the level of the # root logger. logging.getLogger("MARKDOWN").setLevel(logging.getLogger().level) # Create the Genshi TemplateLoader # config['pylons.app_globals'].genshi_loader = TemplateLoader( # paths['templates'], auto_reload=True) # tmpl_options["genshi.loader_callback"] = template_loaded config['pylons.app_globals'].genshi_loader = TemplateLoader( template_paths, auto_reload=True, callback=template_loaded) # CONFIGURATION OPTIONS HERE (note: all config options will override # any Pylons config options) # Setup the SQLAlchemy database engine engine = engine_from_config(config, 'sqlalchemy.') if not model.meta.engine: model.init_model(engine) from ckan.plugins import PluginImplementations from ckan.plugins.interfaces import IConfigurable for plugin in PluginImplementations(IConfigurable): plugin.configure(config)