def main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ # Database engine = sqlalchemy.engine_from_config(settings, 'sqlalchemy.') birda.models.DBSession.configure(bind=engine) # Authentication / Authorization session_factory = pyramid.session.UnencryptedCookieSessionFactoryConfig( settings['session.secret'] ) authn_policy = pyramid.authentication.SessionAuthenticationPolicy() authz_policy = pyramid.authorization.ACLAuthorizationPolicy() # Config creation config = pyramid.config.Configurator( settings=settings, root_factory=birda.models.acl.RootFactory, authentication_policy=authn_policy, authorization_policy=authz_policy, session_factory=session_factory ) # Disabling exception logger in order to avoid conflicts with cornice # (exc_logger will be removed in .ini sometime in the future...) config.add_settings(handle_exceptions=False) # Tailorization of default pyramid json renderer config.add_renderer('json', define_json_renderer(settings)) # Scan modules for cornice services #config.include("birda.services") config.include('cornice') config.scan("birda.services") # Add non JSON API routes birda.views.add_routes(config) config.scan() # Import all birda.models modules (necessary?) #config.scan('birda.models') config.add_subscriber(add_cors_headers_response_callback, pyramid.events.NewRequest) # Activate and set application wide services (singletons) forms_factory = FormsFactory(settings) individuals_factory = IndividualsFactory(settings, forms_factory) config.include('pyramid_services') config.register_service(forms_factory, iface=IFormsFactory, name='FormsFactory') config.register_service(individuals_factory, iface=IIndividualsFactory, name='IndividualsFactory') # Make and run the application return config.make_wsgi_app()
def _make_application(*, geoip, socket): """Construct a Pyramid WSGI application. This creates a central Pyramid configurator then adds all routes, views and Jinja2 configuration to it. :mod:`pyramid_jinja2` is included into the configuration. The search path for Jinja2 is set to the ``templates/`` directory. The Jinja2 syntax is modified so that it uses square brackets instead of curly ones. E.g. ``{{foo}}`` becomes ``[[foo]]``. This applies to Jinja2 statements as well as comments. A route and view is added for ``/`` which serves the Angular application. A default 'not found' view is also added which also serves the Angular application. This is so that the Angular ``$location`` service can use *HTML5 mode* routing. Because of this there is no guarantee that a matched route will be set for the current request inside the entry point template. E.g. you can't use ``request.current_route_url``. Static views are added for the ``external``, ``scripts``, ``styles``, ``images``, ``templates`` and ``data`` directories. These are all served directly from the route. E.g. templates are served from ``/templates/``. The configuration for Steam OpenID authentication and the location service is added. :param pathlib.Path geoip: the path to the GeoIP database to use for the location service. :param str socket: the websocket URL the UI should connect to. :return: a WSGI application. """ config = pyramid.config.Configurator(settings={ "pyramid.reload_templates": True, }) config.include("pyramid_jinja2") config.add_jinja2_search_path(__name__ + ":templates/") config.add_route("main", "/") config.add_view(route_name="main", renderer="main.jinja2") config.add_notfound_view(_404, renderer="main.jinja2") for static in ["external", "scripts", "styles", "images", "templates", "data"]: config.add_static_view(static, "{}:{}/".format(__name__, static)) _configure_authentication(config) _configure_location(config, geoip) config.commit() jinja2_env = config.get_jinja2_environment() jinja2_env.block_start_string = "[%" jinja2_env.block_end_string = "%]" jinja2_env.variable_start_string = "[[" jinja2_env.variable_end_string = "]]" jinja2_env.comment_start_string = "[#" jinja2_env.comment_end_string = "#]" jinja2_env.globals["socket"] = socket return config.make_wsgi_app()
def test_include_threadlocals_active(self): from pyramid.threadlocal import get_current_registry stack = [] def include(config): stack.append(get_current_registry()) config = self._makeOne() config.include(include) self.assertTrue(stack[0] is config.registry)
def application_factory(global_config, **kw): storage_dir = os.path.abspath(kw['storage-dir']) if not os.path.exists(storage_dir): os.mkdir(storage_dir) global FACILITY FACILITY = facility.KeyManagementFacility(storage_dir) config = pyramid.config.Configurator( root_factory=get_facility, package=keas.kmi) config.include('pyramid_zcml') config.load_zcml('configure.zcml') return config.make_wsgi_app()
def test_include_with_python_callable(self): from tests import test_config config = self._makeOne() config.include(dummy_include) after = config.action_state actions = after.actions self.assertEqual(len(actions), 1) action = actions[0] self.assertEqual(action['discriminator'], 'discrim') self.assertEqual(action['callable'], None) self.assertEqual(action['args'], test_config)
def test_include_with_module_defaults_to_includeme(self): from tests import test_config config = self._makeOne() config.include('tests.test_config') after = config.action_state actions = after.actions self.assertEqual(len(actions), 1) action = actions[0] self.assertEqual(action['discriminator'], 'discrim') self.assertEqual(action['callable'], None) self.assertEqual(action['args'], test_config)
def add_admin_interface(config: pyramid.config.Configurator) -> None: if config.get_settings().get("enable_admin_interface", False): config.add_request_method( lambda request: c2cgeoportal_commons.models.DBSession(), "dbsession", reify=True, ) config.add_view(c2cgeoportal_geoportal.views.add_ending_slash, route_name="admin_add_ending_slash") config.add_route("admin_add_ending_slash", "/admin", request_method="GET") config.include("c2cgeoportal_admin")
def add_getitfixed(config: pyramid.config.Configurator) -> None: if config.get_settings()["getitfixed"].get("enabled", False): for route_name, pattern in ( ("getitfixed_add_ending_slash", "/getitfixed"), ("getitfixed_admin_add_ending_slash", "/getitfixed_admin"), ): config.add_view(c2cgeoportal_geoportal.views.add_ending_slash, route_name=route_name) config.add_route(route_name, pattern, request_method="GET") config.include("getitfixed") # Register admin and getitfixed search paths together Form.set_zpt_renderer(c2cgeoform.default_search_paths, translator=translator)
def _init_repository(config: pyramid.config.Configurator) -> None: settings: Final = config.get_settings() settings['tm.manager_hook'] = 'pyramid_tm.explicit_manager' config.include('pyramid_tm') session_factory = sample.bootstrap.sqlalchemy_session_factory_factory() def request_method( request: pyramid.request.Request) -> sample.repository.Repository: session: Final = session_factory() zope.sqlalchemy.register(session, transaction_manager=request.tm) return sample.repository.Repository(session) config.add_request_method(request_method, 'repository', reify=True)
def test_include_constant_root_package(self): import tests from tests import test_config config = self._makeOne(root_package=tests) results = {} def include(config): results['package'] = config.package results['root_package'] = config.root_package config.include(include) self.assertEqual(results['root_package'], tests) self.assertEqual(results['package'], test_config)
def main(global_config, **settings): settings.setdefault("jinja2.filters", "") settings["jinja2.filters"] += "\n".join([ "", "to_json = asp.app:to_json_filter", ]) config = pyramid.config.Configurator(settings=settings) config.registry.games = {} config.registry.texts = json.loads( pkg_resources.resource_string(__name__, "texts.json") ) config.include("asp.www.home") config.scan("asp.www") return config.make_wsgi_app()
def includeme(config): """Set up standard configurator registrations. Use via: .. code-block:: python config = Configurator() config.include('pyramid_stripe') """ config.set_request_property(request.add_stripe_event, "stripe", reify=True) config.set_request_property(request.add_stripe_event_raw, "stripe_raw", reify=True) config.include(add_routes) config.scan("pyramid_stripe.views") if not stripe.api_key: stripe.api_key = config.get_settings()["stripe.api_key"]
def main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ config = pyramid.config.Configurator(settings=settings) # Add JSON as default renderer config.add_renderer(None, renderers.JSON()) config.include('pyramid_jwt') config.include('.security') config.include('.models') config.include('.resources') config.scan() return config.make_wsgi_app()
def app(): """Configure and return the WSGI app.""" config = pyramid.config.Configurator(settings=settings()) config.add_static_view(name="static", path="static") config.include("pyramid_jinja2") config.registry.settings["jinja2.filters"] = { "static_path": "pyramid_jinja2.filters:static_path_filter", "static_url": "pyramid_jinja2.filters:static_url_filter" } config.include("bouncer.search") config.include("bouncer.views") config.include("bouncer.sentry") return config.make_wsgi_app()
def includeme(config: pyramid.config.Configurator) -> None: """ Setup all the pyramid services and event handlers provided by this library. :param config: The pyramid Configuration """ sentry.init(config) config.add_settings(handle_exceptions=False) config.include(pyramid_tm.includeme) config.include(cornice.includeme) pretty_json.init(config) broadcast.init(config) stats_pyramid.init(config) request_tracking.init(config) redis_stats.init(config) logging_view.install_subscriber(config) sql_profiler.init(config) version.init(config) debug.init(config) errors.init(config) index.init(config)
def create_app(_=None, **settings): """Configure and return the WSGI app.""" config = pyramid.config.Configurator(settings=load_settings(settings)) config.include("pyramid_jinja2") config.include("via.views") config.include("h_pyramid_sentry") # Configure Pyramid so we can generate static URLs static_path = resource_filename("via", "static") cache_buster = PathCacheBuster(static_path) print(f"Cache buster salt: {cache_buster.salt}") config.add_static_view(name="static", path="via:static") config.add_cache_buster("via:static", cachebust=cache_buster) app = WhiteNoise( config.make_wsgi_app(), index_file=True, # Config for serving files at static/<salt>/path which are marked # as immutable root=static_path, prefix=cache_buster.immutable_path, immutable_file_test=cache_buster.get_immutable_file_test(), ) app.add_files( # Config for serving files at / which are marked as mutable. This is # for robots.txt and / -> index.html root=resource_filename("via", "static"), prefix="/", ) return app
def getPyramidConfigurator(is_dev_server=False): """ Get a pre-configurated Pyramid WSGI application. """ # Configure and create the WSGI application. config = pyramid.config.Configurator(authentication_policy=CustomAuthPolicy()) # Configuration settings. settings = dict() if is_dev_server: settings['pyramid.reload_templates'] = True config.add_settings(settings) # Include additional pyramid modules. config.include('pyramid_jinja2') # Scan the code for view declarations. config.scan(local) # Setup the views. config.add_route('index', '/') config.add_route('view.create_user', pattern='/users/create') config.add_route('view.search_users', pattern='/users/search') config.add_route('view.display_user', pattern='/users/{user_uid}') config.add_route('view.display_battles', pattern='/battles') # Setup the APIs. config.add_route('api.create_user', pattern='/api/users') config.add_route('api.modify_user', pattern='/api/users/{user_uid}') config.add_route('api.create_battle_log', pattern='/api/battles') config.add_route('api.list_users', pattern='/api/list_users') # Add static views config.add_static_view("styles", "local:site/styles/") return config
def test_include_with_missing_source_file(self): from pyramid.exceptions import ConfigurationError import inspect config = self._makeOne() class DummyInspect(object): def getmodule(self, c): return inspect.getmodule(c) def getsourcefile(self, c): return None config.inspect = DummyInspect() try: config.include('tests.test_config.dummy_include') except ConfigurationError as e: self.assertEqual( e.args[0], "No source file for module 'tests.test_config' (.py " "file must exist, refusing to use orphan .pyc or .pyo file).", ) else: # pragma: no cover raise AssertionError
from user import * from user import User from group import Group from supergroup import SuperGroup #Use pymongo from pymongo import MongoClient from mongokit import Document, Connection from bson import json_util from pyramid.renderers import JSON if __name__ == '__main__': my_session_factory = UnencryptedCookieSessionFactoryConfig('itsaseekreet') config = Configurator(session_factory = my_session_factory) config.include('pyramid_debugtoolbar') config.add_settings({'mako.directories':'templates/'}) config.add_static_view(name='static', path='static') config.add_route('home', '/') config.add_route('about', '/about') config.add_view(home, route_name='home') mgconnection = MongoClient() db = mgconnection.test # Clear database db.drop_collection('users') db.drop_collection('groups') connection = Connection() connection.register([User,Group,SuperGroup])
def configure(self): super(Portal, self).configure() self.configure_zca() mimetypes.add_type('application/font-woff', '.woff') mimetypes.add_type('application/x-font-ttf', '.ttf') registry = pyramid.registry.Registry( bases=(zope.component.getGlobalSiteManager(),)) if self.settings.get('sentry.dsn', None): version = sw.allotmentclub.version.__version__ sentry_sdk.init( release=f"sw-allotmentclub-backend@{version}", dsn=self.settings['sentry.dsn'], integrations=[PyramidIntegration(), SqlalchemyIntegration()]) self.config = config = pyramid.config.Configurator( settings=self.settings, registry=registry) config.setup_registry(settings=self.settings) config.include('pyramid_beaker') config.include('pyramid_exclog') config.include('pyramid_tm') if self.testing: config.include('pyramid_mailer.testing') elif config.registry.settings.get('mail.enable') == 'false': config.include('sw.allotmentclub.printmailer') else: config.include('sw.allotmentclub.logmailer') # self.add_csrf_check() config.add_renderer( 'json', risclog.sqlalchemy.serializer.json_renderer_factory( serializer=json_serializer)) config.set_default_permission('view') config.set_authentication_policy(SessionAuthenticationPolicy()) config.set_authorization_policy(ACLAuthorizationPolicy()) config.set_root_factory( sw.allotmentclub.browser.auth.get_default_context) config.add_request_method( sw.allotmentclub.browser.auth.get_user, 'user', property=True) self.add_routes() config.scan(package=sw.allotmentclub.browser, ignore=sw.allotmentclub.SCAN_IGNORE_TESTS)
def create_app(_=None, **settings): """Configure and return the WSGI app.""" config = pyramid.config.Configurator(settings=load_settings(settings)) config.include("pyramid_exclog") config.include("pyramid_jinja2") config.include("pyramid_services") config.include("h_pyramid_sentry") config.include("via.views") config.include("via.services") # Configure Pyramid so we can generate static URLs static_path = str(importlib_resources.files("via") / "static") cache_buster = PathCacheBuster(static_path) print(f"Cache buster salt: {cache_buster.salt}") config.add_static_view(name="static", path="via:static") config.add_cache_buster("via:static", cachebust=cache_buster) # Make the CheckmateClient object available as request.checkmate. config.add_request_method(ViaCheckmateClient, reify=True, name="checkmate") config.add_tween("via.tweens.robots_tween_factory") # Add this as near to the end of your config as possible: config.include("pyramid_sanity") app = WhiteNoise( config.make_wsgi_app(), index_file=True, # Config for serving files at static/<salt>/path which are marked # as immutable root=static_path, prefix=cache_buster.immutable_path, immutable_file_test=cache_buster.get_immutable_file_test(), ) app.add_files( # Config for serving files at / which are marked as mutable. This is # for / -> index.html root=static_path, prefix="/", ) return app
def app(): config = pyramid.config.Configurator() config.include('pyramid_scales') return config.make_wsgi_app()
def dummy_subapp(config): self.assertEqual(config.route_prefix, 'root/nested') config.include(dummy_subapp2) config.include(dummy_subapp3, route_prefix='nested2')
def main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ # Setup -------------------------------------------------------------------- # Db init_DBSession(settings) # Pyramid Global Settings config = pyramid.config.Configurator( settings=settings, root_factory=TraversalGlobalRootFactory) # , autocommit=True def assert_settings_keys(keys): for settings_key in key: assert config.registry.settings.get(settings_key) # Register Additional Includes --------------------------------------------- config.include( 'pyramid_mako' ) # The mako.directories value is updated in the scan for addons. We trigger the import here to include the correct folders. # Reload on template change - Dedicated from pserve #template_filenames = map(operator.attrgetter('absolute'), file_scan(config.registry.settings['mako.directories'])) #from pyramid.scripts.pserve import add_file_callback #add_file_callback(lambda: template_filenames) # Parse/Convert setting keys that have specified datatypes # Environment variables; capitalized and separated by underscores can override a settings key. # e.g. # export KARAKARA_TEMPLATE_TITLE=Test # can override 'karakara.template.title' for key in config.registry.settings.keys(): value = os.getenv( key.replace('.', '_').upper(), '' ) if config.registry.settings['karakara.server.mode'] != 'test' else '' value = value or config.registry.settings[key] config.registry.settings[key] = convert_str_with_type(value) # Session identity config.add_request_method(partial( session_identity, session_keys={'id', 'admin', 'faves', 'user'}), 'session_identity', reify=True) # Setup Cache Manager config in view setup_pyramid_cache_manager(config) # Setup Autoformat view processor setup_pyramid_autoformater(config) @post_view_dict_augmentation.register_pre_render_decorator() def add_paths_to_response_dict(request, response): response['paths'] = { 'context': pyramid.traversal.resource_path(request.context), 'queue': '', } try: queue_context = request.context.queue_context if queue_context: response['paths'].update( template_helpers.paths_for_queue(queue_context.id)) except AttributeError: pass # i18n config.add_translation_dirs( config.registry.settings['i18n.translation_dirs']) # Session Manager session_settings = extract_subkeys(config.registry.settings, 'session.') session_factory = SignedCookieSessionFactory(serializer=json_serializer, **session_settings) config.set_session_factory(session_factory) from .model.actions import last_track_db_update def _last_track_db_update(request): return last_track_db_update() # Track DB Version --------------------------------------------------------- config.add_request_method(_last_track_db_update, 'last_track_db_update', property=True, reify=True) # Cachebust etags ---------------------------------------------------------- # crude implementation; count the number of tags in db, if thats changed, the etags will invalidate if not config.registry.settings['server.etag.cache_buster']: config.registry.settings[ 'server.etag.cache_buster'] = 'last_update:{0}'.format( str(last_track_db_update())) # TODO: Where is this used? How is this related to karakara.tracks.version? # Global State ------------------------------------------------------------- config.registry.settings['karakara.tracks.version'] = random.randint( 0, 20000000) # Search Config ------------------------------------------------------------ import karakara.views.queue_search karakara.views.queue_search.search_config = read_json( config.registry.settings['karakara.search.view.config']) assert karakara.views.queue_search.search_config, 'search_config data required' # LogEvent ----------------------------------------------------------------- log_event_logger = logging.getLogger('json_log_event') def log_event(request, **data): """ It is expected that python's logging framework is used to output these events to the correct destination. Logstash can then read/process this log output for overview/stats """ event = data.get('event') try: event = request.matched_route.name except Exception: pass try: event = request.context.__name__ except Exception: pass data.update({ 'event': event, 'session_id': request.session.get('id'), 'ip': request.environ.get('REMOTE_ADDR'), 'timestamp': now(), }) log_event_logger.info(json_string(data)) config.add_request_method(log_event) # WebSocket ---------------------------------------------------------------- class NullAuthEchoServerManager(object): def recv(self, *args, **kwargs): pass socket_manager = NullAuthEchoServerManager() if config.registry.settings.get('karakara.websocket.port'): def authenticator(key): """Only admin authenticated keys can connect to the websocket""" cookie_name = config.registry.settings['session.cookie_name'] if cookie_name in key: cookie = key else: cookie = '{0}={1}'.format(cookie_name, key) request = pyramid.request.Request({'HTTP_COOKIE': cookie}) session_data = session_factory(request) return session_data and session_data.get('admin') def _int_or_none(setting_key): return int(config.registry.settings.get(setting_key) ) if config.registry.settings.get(setting_key) else None try: _socket_manager = AuthEchoServerManager( authenticator=authenticator, websocket_port=_int_or_none('karakara.websocket.port'), tcp_port=_int_or_none('karakara.tcp.port'), ) _socket_manager.start() socket_manager = _socket_manager except OSError: log.warn('Unable to setup websocket') def send_websocket_message(request, message): # TODO: This will have to be augmented with json and queue_id in future socket_manager.recv( message.encode('utf-8')) # TODO: ?um? new_line needed? config.add_request_method(send_websocket_message) #config.registry['socket_manager'] = socket_manager # Login Providers ---------------------------------------------------------- from .views.comunity_login import social_login social_login.user_store = ComunityUserStore() login_providers = config.registry.settings.get('login.provider.enabled') # Facebook if 'facebook' in login_providers: assert_settings_keys( ('login.facebook.appid', 'login.facebook.secret'), message= 'To use facebook as a login provider appid and secret must be provided' ) social_login.add_login_provider( FacebookLogin( appid=config.registry.settings.get('login.facebook.appid'), secret=config.registry.settings.get('login.facebook.secret'), permissions=config.registry.settings.get( 'login.facebook.permissions'), )) # Google if 'google' in login_providers: social_login.add_login_provider( GoogleLogin(client_secret_file=config.registry.settings.get( 'login.google.client_secret_file'), )) # Firefox Persona (Deprecated technology but a useful reference) #if 'persona' in login_providers: # social_login.add_login_provider(PersonaLogin( # site_url=config.registry.settings.get('server.url') # )) # No login provider if not login_providers and config.registry.settings.get( 'karakara.server.mode') != 'test': # Auto login if no service keys are provided social_login.add_login_provider(NullLoginProvider()) social_login.user_store = NullComunityUserStore() template_helpers.javascript_inline['comunity'] = social_login.html_includes # KaraKara request additions ----------------------------------------------- from unittest.mock import patch def call_sub_view(request, view_callable, acquire_cache_bucket_func): """ A wrapper for called view_callable's to allow subrequests to use correct cache_buckets """ if not hasattr(request, 'cache_bucket'): # FFS - don't ask questions ... just ... (sigh) ... patch can ONLY patch existing attributes setattr(request, 'cache_bucket', 'some placeholder s***e') _cache_bucket = acquire_cache_bucket_func(request) with patch.object(request, 'cache_bucket', _cache_bucket): assert request.cache_bucket == _cache_bucket return view_callable(request)['data'] config.add_request_method(call_sub_view) from .model_logic.queue_logic import QueueLogic config.add_request_method(QueueLogic, 'queue', reify=True) # Routes ------------------------------------------------------------------- def settings_path(key): path = os.path.join(os.getcwd(), config.registry.settings[key]) if not os.path.isdir(path): log.error('Unable to add_static_view {key}:{path}'.format( key=key, path=path)) #TODO: reaplce with formatstring return path # Static Routes config.add_static_view( name='ext', path=settings_path('static.externals')) # cache_max_age=3600 config.add_static_view( name='static', path=settings_path('static.assets')) # cache_max_age=3600 config.add_static_view(name='player', path=settings_path('static.player')) config.add_static_view(name='player2', path=settings_path('static.player2')) # AllanC - it's official ... static route setup and generation is a mess in pyramid #config.add_static_view(name=settings["static.media" ], path="karakara:media" ) config.add_static_view( name='files', path=config.registry.settings['static.processmedia2.config'] ['path_processed']) # View Routes config.add_route('inject_testdata', '/inject_testdata') # Upload extras ----- #config.add_static_view(name=settings['upload.route.uploaded'], path=settings['upload.path']) # the 'upload' route above always matchs first config.add_route('upload', '/upload{sep:/?}{name:.*}') # Events ------------------------------------------------------------------- config.add_subscriber(add_localizer_to_request, pyramid.events.NewRequest) config.add_subscriber(add_render_globals_to_template, pyramid.events.BeforeRender) # Tweens ------------------------------------------------------------------- if config.registry.settings.get( 'karakara.server.mode' ) == 'development' and config.registry.settings.get( 'karakara.server.postmortem'): config.add_tween('karakara.postmortem_tween_factory') # Return ------------------------------------------------------------------- config.scan(ignore='.tests') config.scan('calaldees.pyramid_helpers.views') return config.make_wsgi_app()
def main(global_config, **settings): config = pyramid.config.Configurator(settings={ **settings, **global_config }) config.include(_api) config.include(_cors) config.include(_db) config.include(_log) config.include(_processor) config.include(_renderers) config.include(_static) return config.make_wsgi_app()
def main(global_config, **settings): config = pyramid.config.Configurator(settings=settings) config.include("geekie.sms.messages") return config.make_wsgi_app()
def includeme(config: pyramid.config.Configurator) -> None: """ This function returns a Pyramid WSGI application. """ settings = config.get_settings() config.include("c2cgeoportal_commons") if "available_locale_names" not in settings: settings["available_locale_names"] = available_locale_names() call_hook(settings, "after_settings", settings) get_user_from_request = create_get_user_from_request(settings) config.add_request_method(get_user_from_request, name="user", property=True) config.add_request_method(get_user_from_request, name="get_user") # Configure 'locale' dir as the translation dir for c2cgeoportal app config.add_translation_dirs("c2cgeoportal_geoportal:locale/") config.include("c2cwsgiutils.pyramid.includeme") health_check = HealthCheck(config) config.registry["health_check"] = health_check metrics_config = config.registry.settings["metrics"] if metrics_config["memory_maps_rss"]: add_provider(MemoryMapProvider("rss")) if metrics_config["memory_maps_size"]: add_provider(MemoryMapProvider("size")) if metrics_config["memory_cache"]: add_provider( MemoryCacheSizeProvider( metrics_config.get("memory_cache_all", False))) if metrics_config["raster_data"]: add_provider(RasterDataSizeProvider()) if metrics_config["total_python_object_memory"]: add_provider(TotalPythonObjectMemoryProvider()) # Initialise DBSessions init_dbsessions(settings, config, health_check) checker.init(config, health_check) check_collector.init(config, health_check) # dogpile.cache configuration if "cache" in settings: register_backend("c2cgeoportal.hybrid", "c2cgeoportal_geoportal.lib.caching", "HybridRedisBackend") register_backend("c2cgeoportal.hybridsentinel", "c2cgeoportal_geoportal.lib.caching", "HybridRedisSentinelBackend") for name, cache_config in settings["cache"].items(): caching.init_region(cache_config, name) @zope.event.classhandler.handler(InvalidateCacheEvent) def handle(event: InvalidateCacheEvent) -> None: # pylint: disable=unused-variable del event caching.invalidate_region() if caching.MEMORY_CACHE_DICT: caching.get_region("std").delete_multi( caching.MEMORY_CACHE_DICT.keys()) caching.MEMORY_CACHE_DICT.clear() # Register a tween to get back the cache buster path. if "cache_path" not in config.get_settings(): config.get_settings()["cache_path"] = ["static"] config.add_tween( "c2cgeoportal_geoportal.lib.cacheversion.CachebusterTween") config.add_tween("c2cgeoportal_geoportal.lib.headers.HeadersTween") # Bind the mako renderer to other file extensions add_mako_renderer(config, ".html") add_mako_renderer(config, ".js") # Add the "geojson" renderer config.add_renderer("geojson", GeoJSON()) # Add the "xsd" renderer config.add_renderer("xsd", XSD(include_foreign_keys=True)) # Add the set_user_validator directive, and set a default user validator config.add_directive("set_user_validator", set_user_validator) config.set_user_validator(default_user_validator) config.add_route("dynamic", "/dynamic.json", request_method="GET") # Add routes to the mapserver proxy config.add_route_predicate("mapserverproxy", MapserverproxyRoutePredicate) config.add_route( "mapserverproxy", "/mapserv_proxy", mapserverproxy=True, pregenerator=C2CPregenerator(role=True), request_method="GET", ) config.add_route( "mapserverproxy_post", "/mapserv_proxy", mapserverproxy=True, pregenerator=C2CPregenerator(role=True), request_method="POST", ) add_cors_route(config, "/mapserv_proxy", "mapserver") # Add route to the tinyows proxy config.add_route("tinyowsproxy", "/tinyows_proxy", pregenerator=C2CPregenerator(role=True)) # Add routes to the entry view class config.add_route("base", "/", static=True) config.add_route("loginform", "/login.html", request_method="GET") add_cors_route(config, "/login", "login") config.add_route("login", "/login", request_method="POST") add_cors_route(config, "/logout", "login") config.add_route("logout", "/logout", request_method="GET") add_cors_route(config, "/loginchangepassword", "login") config.add_route("change_password", "/loginchangepassword", request_method="POST") add_cors_route(config, "/loginresetpassword", "login") config.add_route("loginresetpassword", "/loginresetpassword", request_method="POST") add_cors_route(config, "/loginuser", "login") config.add_route("loginuser", "/loginuser", request_method="GET") config.add_route("testi18n", "/testi18n.html", request_method="GET") config.add_renderer(".map", AssetRendererFactory) config.add_renderer(".css", AssetRendererFactory) config.add_renderer(".ico", AssetRendererFactory) config.add_route("localejson", "/locale.json", request_method="GET") def add_static_route(name: str, attr: str, path: str, renderer: str) -> None: config.add_route(name, path, request_method="GET") config.add_view(Entry, attr=attr, route_name=name, renderer=renderer) add_static_route("favicon", "favicon", "/favicon.ico", "/etc/geomapfish/static/images/favicon.ico") add_static_route("robot.txt", "robot_txt", "/robot.txt", "/etc/geomapfish/static/robot.txt") add_static_route("apijs", "apijs", "/api.js", "/etc/static-ngeo/api.js") add_static_route("apijsmap", "apijsmap", "/api.js.map", "/etc/static-ngeo/api.js.map") add_static_route("apicss", "apicss", "/api.css", "/etc/static-ngeo/api.css") add_static_route("apihelp", "apihelp", "/apihelp/index.html", "/etc/geomapfish/static/apihelp/index.html") c2cgeoportal_geoportal.views.add_redirect(config, "apihelp_redirect", "/apihelp.html", "apihelp") config.add_route("themes", "/themes", request_method="GET", pregenerator=C2CPregenerator(role=True)) config.add_route("invalidate", "/invalidate", request_method="GET") # Print proxy routes config.add_route("printproxy", "/printproxy", request_method="HEAD") add_cors_route(config, "/printproxy/*all", "print") config.add_route( "printproxy_capabilities", "/printproxy/capabilities.json", request_method="GET", pregenerator=C2CPregenerator(role=True), ) config.add_route( "printproxy_report_create", "/printproxy/report.{format}", request_method="POST", header=JSON_CONTENT_TYPE, ) config.add_route("printproxy_status", "/printproxy/status/{ref}.json", request_method="GET") config.add_route("printproxy_cancel", "/printproxy/cancel/{ref}", request_method="DELETE") config.add_route("printproxy_report_get", "/printproxy/report/{ref}", request_method="GET") # Full-text search routes add_cors_route(config, "/search", "fulltextsearch") config.add_route("fulltextsearch", "/search", request_method="GET") # Access to raster data add_cors_route(config, "/raster", "raster") config.add_route("raster", "/raster", request_method="GET") add_cors_route(config, "/profile.json", "profile") config.add_route("profile.json", "/profile.json", request_method="POST") # Shortener add_cors_route(config, "/short/create", "shortener") config.add_route("shortener_create", "/short/create", request_method="POST") config.add_route("shortener_get", "/s/{ref}", request_method="GET") # Geometry processing config.add_route("difference", "/difference", request_method="POST") # PDF report tool config.add_route("pdfreport", "/pdfreport/{layername}/{ids}", request_method="GET") # Add routes for the "layers" web service add_cors_route(config, "/layers/*all", "layers") config.add_route("layers_count", "/layers/{layer_id:\\d+}/count", request_method="GET") config.add_route( "layers_metadata", "/layers/{layer_id:\\d+}/md.xsd", request_method="GET", pregenerator=C2CPregenerator(role=True), ) config.add_route("layers_read_many", "/layers/{layer_id:\\d+,?(\\d+,)*\\d*$}", request_method="GET") # supports URLs like /layers/1,2,3 config.add_route("layers_read_one", "/layers/{layer_id:\\d+}/{feature_id}", request_method="GET") config.add_route("layers_create", "/layers/{layer_id:\\d+}", request_method="POST", header=GEOJSON_CONTENT_TYPE) config.add_route( "layers_update", "/layers/{layer_id:\\d+}/{feature_id}", request_method="PUT", header=GEOJSON_CONTENT_TYPE, ) config.add_route("layers_delete", "/layers/{layer_id:\\d+}/{feature_id}", request_method="DELETE") config.add_route( "layers_enumerate_attribute_values", "/layers/{layer_name}/values/{field_name}", request_method="GET", pregenerator=C2CPregenerator(), ) # There is no view corresponding to that route, it is to be used from # mako templates to get the root of the "layers" web service config.add_route("layers_root", "/layers", request_method="HEAD") # Resource proxy (load external url, useful when loading non https content) config.add_route("resourceproxy", "/resourceproxy", request_method="GET") # Dev config.add_route("dev", "/dev/*path", request_method="GET") # Used memory in caches config.add_route("memory", "/memory", request_method="GET") # Scan view decorator for adding routes config.scan(ignore=[ "c2cgeoportal_geoportal.lib", "c2cgeoportal_geoportal.scaffolds", "c2cgeoportal_geoportal.scripts", ]) add_admin_interface(config) add_getitfixed(config) # Add the project static view with cache buster config.add_static_view( name="static", path="/etc/geomapfish/static", cache_max_age=int(config.get_settings()["default_max_age"]), ) config.add_cache_buster("/etc/geomapfish/static", version_cache_buster) # Add the project static view without cache buster config.add_static_view( name="static-ngeo", path="/etc/static-ngeo", cache_max_age=int(config.get_settings()["default_max_age"]), ) # Handles the other HTTP errors raised by the views. Without that, # the client receives a status=200 without content. config.add_view(error_handler, context=HTTPException) c2cwsgiutils.index.additional_title = ( '<div class="row"><div class="col-lg-3"><h2>GeoMapFish</h2></div><div class="col-lg">' ) c2cwsgiutils.index.additional_auth.extend([ '<a href="../tiles/admin/">TileCloud chain admin</a><br>', '<a href="../tiles/c2c/">TileCloud chain c2c tools</a><br>', '<a href="../invalidate">Invalidate the cache</a><br>', '<a href="../memory">Memory status</a><br>', ]) if config.get_settings().get("enable_admin_interface", False): c2cwsgiutils.index.additional_noauth.append( '<a href="../admin/">Admin</a><br>') c2cwsgiutils.index.additional_noauth.append( '</div></div><div class="row"><div class="col-lg-3"><h3>Interfaces</h3></div><div class="col-lg">' ) c2cwsgiutils.index.additional_noauth.append( '<a href="../">Default</a><br>') for interface in config.get_settings().get("interfaces", []): if not interface.get("default", False): c2cwsgiutils.index.additional_noauth.append( '<a href="../{interface}">{interface}</a><br>'.format( interface=interface["name"])) c2cwsgiutils.index.additional_noauth.append( '<a href="../apihelp/index.html">API help</a><br>') c2cwsgiutils.index.additional_noauth.append("</div></div><hr>")
def test_includeme(): import pyramid.config import stucco_auth config = pyramid.config.Configurator() config.testing_securitypolicy() config.include(stucco_auth.includeme)
def includeme(config: pyramid.config.Configurator) -> None: """ Initialize all the pyramid services and event handlers provided by this library. Arguments: config: The pyramid Configuration """ logging.captureWarnings(True) config.include(coverage_setup.includeme) config.include(sentry.includeme) config.add_settings(handle_exceptions=False) config.include(pyramid_tm.includeme) config.include(cornice.includeme) config.include(pretty_json.includeme) config.include(broadcast.includeme) config.include(stats_pyramid.includeme) config.include(request_tracking.includeme) config.include(redis_stats.includeme) config.include(db_maintenance_view.includeme) config.include(logging_view.includeme) config.include(sql_profiler.includeme) config.include(version.includeme) config.include(debug.includeme) config.include(metrics.includeme) config.include(errors.includeme) config.include(index.includeme)