def main(global_config, **settings):
config = Configurator(settings=settings)
config.set_authentication_policy(AuthenticationPolicy(None))
config.set_authorization_policy(AuthorizationPolicy())
config.add_renderer('prettyjson', JSON(indent=4))
config.add_renderer('jsonp', JSONP(param_name='opt_jsonp'))
config.add_renderer('prettyjsonp', JSONP(indent=4, param_name='opt_jsonp'))
config.add_subscriber(set_renderer, NewRequest)
config.include("cornice")
config.route_prefix = '/api/{}'.format(VERSION)
config.scan("openprocurement.api.views")
# CouchDB connection
server = Server(settings.get('couchdb.url'))
config.registry.couchdb_server = server
db_name = os.environ.get('DB_NAME', settings['couchdb.db_name'])
if db_name not in server:
server.create(db_name)
config.registry.db = server[db_name]
# sync couchdb views
sync_design(config.registry.db)
# migrate data
migrate_data(config.registry.db)
# S3 connection
if 'aws.access_key' in settings and 'aws.secret_key' in settings and 'aws.bucket' in settings:
connection = S3Connection(settings['aws.access_key'], settings['aws.secret_key'])
config.registry.s3_connection = connection
bucket_name = settings['aws.bucket']
if bucket_name not in [b.name for b in connection.get_all_buckets()]:
connection.create_bucket(bucket_name, location=Location.EU)
config.registry.bucket_name = bucket_name
return config.make_wsgi_app()
def main(*args, **settings):
from pyramid.config import Configurator
from pyramid.events import NewRequest, ContextFound
from pyramid.authentication import BasicAuthAuthenticationPolicy
from pyramid.authorization import ACLAuthorizationPolicy
from pyramid.renderers import JSON, JSONP
logger.info('Start registry api...')
read_users(settings['auth.file'])
config = Configurator(autocommit=True,
settings=settings,
authentication_policy=BasicAuthAuthenticationPolicy(
auth_check, __name__),
authorization_policy=ACLAuthorizationPolicy(),
root_factory=Root,
route_prefix=ROUTE_PREFIX)
config.include('pyramid_exclog')
config.add_forbidden_view(forbidden)
config.add_request_method(request_params, 'params', reify=True)
config.add_request_method(authenticated_role, reify=True)
config.add_renderer('prettyjson', JSON(indent=4))
config.add_renderer('jsonp', JSONP(param_name='opt_jsonp'))
config.add_renderer('prettyjsonp', JSONP(indent=4, param_name='opt_jsonp'))
config.add_subscriber(add_logging_context, NewRequest)
config.add_subscriber(set_logging_context, ContextFound)
config.add_subscriber(set_renderer, NewRequest)
config.add_route('health', '/health')
config.add_route('registry', '/registry/{param}.json')
config.scan('openprocurement.medicines.registry.api.views')
return config.make_wsgi_app()
def main(global_config, **settings):
from openprocurement.integrations.edr.auth import (authenticated_role)
from openprocurement.integrations.edr.utils import (
forbidden, add_logging_context, set_logging_context, request_params,
set_renderer, Root, read_users)
from openprocurement.integrations.edr.utils import auth_check
from pyramid.authentication import BasicAuthAuthenticationPolicy
from pyramid.authorization import ACLAuthorizationPolicy
from pyramid.config import Configurator
from pyramid.events import NewRequest, ContextFound
from pyramid.renderers import JSON, JSONP
LOGGER.info('Start edr api')
read_users(settings['auth.file'])
config = Configurator(
autocommit=True,
settings=settings,
authentication_policy=BasicAuthAuthenticationPolicy(
auth_check, __name__),
authorization_policy=ACLAuthorizationPolicy(),
root_factory=Root,
route_prefix=ROUTE_PREFIX,
)
config.include('pyramid_exclog')
config.add_forbidden_view(forbidden)
config.add_request_method(request_params, 'params', reify=True)
config.add_request_method(authenticated_role, reify=True)
config.add_renderer('prettyjson', JSON(indent=4))
config.add_renderer('jsonp', JSONP(param_name='opt_jsonp'))
config.add_renderer('prettyjsonp', JSONP(indent=4, param_name='opt_jsonp'))
config.add_renderer(
'yaml', 'openprocurement.integrations.edr.renderers.YAMLRenderer')
config.add_subscriber(add_logging_context, NewRequest)
config.add_subscriber(set_logging_context, ContextFound)
config.add_subscriber(set_renderer, NewRequest)
# Init edr connection
config.registry.edr_client = EdrClient(
settings.get('edr_api_server'), settings.get('edr_api_token'),
int(settings.get('edr_api_port')),
float(settings.get('edr_timeout_min', 1)),
float(settings.get('edr_timeout_max', 60)),
float(settings.get('edr_timeout_step', 2)),
settings.get('edr_timeout_mode', 'mult'))
config.registry.cache_db = Db(settings)
config.registry.time_to_live = settings.get("time_to_live", 300)
config.registry.time_to_live_negative = settings.get(
"time_to_live_negative", 30)
LOGGER.info("SANDBOX_MODE = {}".format(SANDBOX_MODE))
# Include views
config.add_route('verify', '/verify')
config.add_route('details', '/details/{id}')
config.add_route('health', '/health')
config.scan("openprocurement.integrations.edr.views")
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
# Engine configuration #
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
my_session_factory = SignedCookieSessionFactory('spencersgeruchallenge')
config = Configurator(settings=settings,
session_factory=my_session_factory,
root_factory='.models.Root')
config.include('pyramid_jinja2')
config.include('pyramid_chameleon')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_renderer('jsonp', JSONP(param_name='callback'))
# Endpoint routes
config.add_route('home', '/')
config.add_route('quotes', '/quotes')
config.add_route('random', '/quotes/random')
config.add_route('test_db', '/test_db')
config.add_route('quote_by_num', '/quotes/{quoteNum}')
config.add_route('query', '/api_query')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
initialize_sql(engine)
authentication_policy = AuthenticationPolicy(settings['auth.secret'],
cookie_name='frostcms',
callback=groupfinder)
authorization_policy = ACLAuthorizationPolicy()
my_session_factory = UnencryptedCookieSessionFactoryConfig('1@3$msT')
config = Configurator(settings=settings,
root_factory='frostcms.security.RootFactory',
authentication_policy=authentication_policy,
authorization_policy=authorization_policy,
session_factory=my_session_factory,
request_factory=MainRequest)
jsonp_renderer = JSONP(param_name='callback')
config.add_renderer('jsonp', jsonp_renderer)
config.add_static_view('static', 'frostcms:static', cache_max_age=3600)
config.add_static_view('upload', 'frostcms:upload')
config.include("frostcms.views")
config.include("frostcms.assignment")
config.include("frostcms.user")
config.include("frostcms.mentor")
config.include("frostcms.student")
config.include("frostcms.faculty")
config.include("frostcms.location")
config.include("frostcms.college")
config.include("frostcms.semester")
config.include("frostcms.clazz")
config.include("frostcms.public")
config.include("frostcms.lesson")
config.include("frostcms.course")
config.include("frostcms.courseware")
return config.make_wsgi_app()
def yeastgenome_frontend(backend_url, heritage_url, log_directory, **configs):
chosen_frontend = YeastgenomeFrontend(backend_url, heritage_url, log_directory)
settings = dict(configs)
settings.setdefault('jinja2.i18n.domain', 'myproject')
configurator = Configurator(settings=settings)
configurator.add_translation_dirs('locale/')
configurator.include('pyramid_jinja2')
# set global template var asset_root to read from cloudfront or local, depending on .ini value, default to False
production_assets = configs.get('production_assets', False)
if production_assets == 'True':
file_path = os.path.dirname(os.path.realpath(__file__)) + '/../../../../production_asset_url.json'
asset_root = json.load(open(file_path, 'r'))['url']
else:
asset_root = '/static'
# put query string in global template variable
def add_template_global(event):
event['asset_root'] = asset_root
configurator.add_subscriber(add_template_global, 'pyramid.events.BeforeRender')
# cache everything for 1 month on browser
configurator.add_static_view('static', 'src:sgd/frontend/yeastgenome/static', cache_max_age=2629740)
configurator.add_static_view('img-domain', 'src:sgd/frontend/yeastgenome/img-domain', cache_max_age=2629740)
configurator.add_renderer('jsonp', JSONP(param_name='callback'))
return chosen_frontend, configurator
def setUp(self):
from pyramid.renderers import JSONP
self.config = testing.setUp()
self.config.add_renderer("jsonp", JSONP(param_name="callback"))
self.config.include("cornice")
self.config.registry.server_id = uuid4().hex
self.config.add_request_method(check_accreditations)
self.authz_policy = ACLAuthorizationPolicy()
self.config.set_authorization_policy(self.authz_policy)
self.config.add_subscriber(add_logging_context, NewRequest)
self.config.add_subscriber(set_logging_context, ContextFound)
self.config.add_request_method(authenticated_role, reify=True)
self.config.include(
"openprocurement.historical.core.includeme.includeme")
self.config.registry.db = db
self.authn_policy = AuthenticationPolicy(
"{}/auth.ini".format(os.path.dirname(os.path.abspath(__file__))),
__name__)
self.config.set_authentication_policy(self.authn_policy)
self.config.scan("openprocurement.historical.core.tests.utils")
self.app = TestApp(self.config.make_wsgi_app())
self.app.authorization = ("Basic", ("broker", ""))
def setUp(self):
from pyramid.renderers import JSONP
self.config = testing.setUp()
self.config.add_renderer('jsonp', JSONP(param_name='callback'))
self.config.include("cornice")
self.authz_policy = ACLAuthorizationPolicy()
self.config.set_authorization_policy(self.authz_policy)
self.authn_policy = AuthTktAuthenticationPolicy('$3kr1t')
self.config.set_authentication_policy(self.authn_policy)
add_view(ThingImp.collection_get, permission='read')
thing_resource = add_resource(ThingImp,
collection_path='/thing',
path='/thing/{id}',
name='thing_service',
collection_acl=my_collection_acl)
add_view(UserImp.get, renderer='json')
add_view(UserImp.get, renderer='jsonp')
add_view(UserImp.collection_post, renderer='json', accept='text/json')
user_resource = add_resource(UserImp,
collection_path='/users',
path='/users/{id}',
name='user_service',
factory=dummy_factory)
self.config.add_cornice_resource(thing_resource)
self.config.add_cornice_resource(user_resource)
self.app = TestApp(CatchErrors(self.config.make_wsgi_app()))
def setUpClass(cls):
cls.config = testing.setUp()
cls.config.add_renderer('jsonp', JSONP(param_name='callback'))
cls.config.include("cornice")
cls.authz_policy = ACLAuthorizationPolicy()
cls.authn_policy = AuthenticationPolicy(
"{}/auth.ini".format(os.path.dirname(os.path.abspath(__file__))),
__name__)
cls.config.set_authorization_policy(cls.authz_policy)
cls.config.set_authentication_policy(cls.authn_policy)
cls.config.registry.db = MagicMock()
cls.config.registry.db.save.return_value = [
'', '1-{}'.format(uuid.uuid4().hex)
]
cls.config.registry.server_id = uuid.uuid4().hex
cls.config.registry.docservice_key = MagicMock()
cls.config.context = munchify(tender.serialize.return_value)
cls.config.registry.decr_box = Box("b" * 32, "c" * 32)
cls.config.add_subscriber(add_logging_context, NewRequest)
cls.config.add_subscriber(MagicMock(), ContextFound)
cls.config.add_subscriber(MagicMock(), NewRequest)
cls.config.add_subscriber(MagicMock(), BeforeRender)
cls.config.scan("openprocurement.archivarius.core.tests.utils")
cls.app = TestApp(CatchErrors(cls.config.make_wsgi_app()))
def setUp(self):
from pyramid.renderers import JSONP
self.config = testing.setUp(autocommit=False)
self.config.add_renderer('jsonp', JSONP(param_name='callback'))
self.config.include("cornice")
self.config.scan("cornice.tests.test_resource")
self.app = TestApp(CatchErrors(self.config.make_wsgi_app()))
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
app_version = settings.get('app_version')
settings['app_version'] = app_version
config = Configurator(settings=settings)
# init raster files for height/profile and preload COMB file
init_rasterfiles(settings.get('dtm_base_path'), ['COMB'])
# renderers
config.add_renderer(
'jsonp',
JSONP(param_name='callback', indent=None, separators=(',', ':')))
config.add_renderer('csv', CSVRenderer)
# route definitions
config.add_route('profile_json', '/rest/services/profile.json')
config.add_route('profile_csv', '/rest/services/profile.csv')
config.add_route('height', '/rest/services/height')
config.add_route('checker', '/checker')
config.add_route('checker_dev', '/checker_dev')
config.add_static_view('static', 'alti:static')
config.add_static_view('/', 'alti:static/')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
# Update the settings with the current app root path
settings['app_root'] = abspath(dirname(dirname(__file__)))
initialize_sql(settings)
authn_policy = AuthTktAuthenticationPolicy(
settings.get('auth.secret'), callback=UserMgr.auth_groupfinder)
authz_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings,
root_factory='bookie.RootFactory',
authentication_policy=authn_policy,
authorization_policy=authz_policy)
config.set_request_factory(RequestWithUserAttribute)
config = build_routes(config)
config.add_static_view('static', 'bookie:static')
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.scan('bookie.views')
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
setup_logging(global_config['__file__'])
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.add_renderer('ujson', factory='app.renderers.UjsonRenderer')
config.add_static_view('static', 'static', cache_max_age=3600)
# initialise a connection to mongo on startup and store the client
# in the registry which will be injected into each request
conf = appConfig(config.registry.settings.get('app.config'))
config.registry.app_config = conf.app_config
config.registry.app_config['mongodb']['client'] = init_mongodb_connection(config.registry.app_config['mongodb'])
config.add_route('home', '/')
config.add_route('health-check', '/health-check')
config.add_route('network-stats', '/stats/{code}/{explore}')
config.add_route('network-build', '/network/{code}/{explore}')
config.add_route('network-build-status', '/network/{code}/{explore}/status')
config.add_route('entity-data', '/entity/{code}/data')
config.add_route('entity-build', '/entity/{code}/{id}')
config.add_route('entity-build-status', '/entity/{code}/{id}/status')
config.add_route('convert-graph', '/convert/{code}')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
db = models.DBConnect(**settings)
db.connect()
# A very simple default Authentication Policy
authn_policy = AuthTktAuthenticationPolicy('somesecret',
callback=security.groupfinder)
# A very simple default ACL Authorization Policy
authz_policy = ACLAuthorizationPolicy()
# Setting up the config settings to the application config
config = Configurator(settings=settings,
root_factory='qrevent.security.RootFactory',
authentication_policy=authn_policy,
authorization_policy=authz_policy)
config.add_renderer('jsonp', JSONP(param_name='callback'))
# Setup pyramid_beaker as session factory
session_factory = session_factory_from_settings(settings)
# Set session factory to the pyramid_beaker session factory
config.set_session_factory(session_factory)
config.add_static_view('static', 'qrevent:static')
config.include('qrevent.api.api_include')
config.include('qrevent.web.web_include')
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
config.include('nurl.pyramid_nurl')
# renderers
config.add_renderer('jsonp', JSONP(param_name='callback'))
# URL patterns
config.add_static_view(path='nurl.webapp:static',
name='static',
cache_max_age=3600)
config.add_route('home', '/')
config.add_route('shortened', '/{short_ref}')
# restful endpoints
config.add_route('shortener_v1', '/api/v1/shorten')
css = webassets.Bundle('bootstrap.min.css',
webassets.Bundle('styles.css', filters='yui_css'),
output='bundle.min.css')
config.add_webasset('css', css)
config.registry.settings['webassets_env'] = config.get_webassets_env()
config.add_subscriber(add_webassets_env, NewRequest)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
config = Configurator(settings=settings)
config.include('pyramid_mako')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.add_route('crow_provider', '/provider')
config.add_route('crow_layers', '/layers')
config.add_route('crow_environment_json', '/datasets')
config.add_route('layer_kml', '/kml')
db_url = urlparse(settings['mongo_uri'])
config.registry.db = pymongo.Connection(host=db_url.hostname,
port=db_url.port)
def add_db(request):
db = config.registry.db[db_url.path[1:]]
if db_url.username and db_url.password:
db.authenticate(db_url.username, db_url.password)
return db
config.add_request_method(add_db, 'db', reify=True)
config.scan("compsrest.views")
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
authn_policy = AuthTktAuthenticationPolicy(
settings['auth.secret'],
secure=True,
http_only=True,
timeout=int(settings['auth.timeout']),
max_age=int(settings['auth.timeout']),
callback=groupfinder)
authz_policy = ACLAuthorizationPolicy()
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings,
authentication_policy=authn_policy,
authorization_policy=authz_policy,
root_factory=Root)
if config.get_settings().get('cors.preflight', None) == 'true':
config.include('.cors')
config.add_cors_preflight_handler()
config.include("cornice")
config.include('pyramid_mako')
config.add_static_view('static', 'static', cache_max_age=3600)
upload_dir = os.path.abspath(settings['upload_dir'])
config.add_static_view('upload', upload_dir, cache_max_age=3600)
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.scan(ignore=['modmod.scripts', 'modmod.tests'])
config.include('.config')
config.include('modmod.views')
config.include('modmod.views.util')
safile_settings = {
'file.storages': ['fs:' + settings['upload_dir']],
'fs.' + settings['upload_dir'] + '.asset_path': '/upload/',
}
pyramid_safile.init_factory(safile_settings)
init_worker(settings, safile_settings)
stripe.api_key = settings['stripe.api_key']
if not "CI" in os.environ and os.path.isfile(
'secret/fbServiceAccountKey.json'):
cred = credentials.Certificate('secret/fbServiceAccountKey.json')
default_firebase_app = firebase_admin.initialize_app(cred)
signal.signal(signal.SIGINT, sigint_handler)
signal.signal(signal.SIGTERM, sigint_handler)
signal.signal(signal.SIGHUP, sigint_handler)
return config.make_wsgi_app()
def main(global_config, **settings):
version = settings.get('api_version')
route_prefix = '/api/{}'.format(version)
config = Configurator(
autocommit=True,
settings=settings,
route_prefix=route_prefix,
)
config.include('pyramid_exclog')
config.include("cornice")
config.add_request_method(request_params, 'params', reify=True)
config.add_renderer('prettyjson', JSON(indent=4))
config.add_renderer('jsonp', JSONP(param_name='opt_jsonp'))
config.add_renderer('prettyjsonp', JSONP(indent=4, param_name='opt_jsonp'))
config.add_subscriber(add_logging_context, NewRequest)
config.add_subscriber(set_logging_context, ContextFound)
config.add_subscriber(set_renderer, NewRequest)
config.add_subscriber(beforerender, BeforeRender)
config.scan("openprocurement.edge.views.spore")
config.scan("openprocurement.edge.views.health")
resources = settings.get('resources') and settings['resources'].split(',')
couch_url = settings.get('couchdb.url') + settings.get('couchdb.db_name')
for resource in resources:
config.scan("openprocurement.edge.views." + resource)
prepare_couchdb_views(couch_url, resource, LOGGER)
LOGGER.info('Push couch {} views successful.'.format(resource))
LOGGER.info('{} resource initialized successful.'.format(
resource.title()))
# CouchDB connection
server = Server(settings.get('couchdb.url'),
session=Session(retry_delays=range(10)))
config.registry.couchdb_server = server
config.registry.db = prepare_couchdb(settings.get('couchdb.url'),
settings.get('couchdb.db_name'),
LOGGER)
config.registry.server_id = settings.get('id', '')
config.registry.health_threshold = float(
settings.get('health_threshold', 99))
config.registry.api_version = version
config.registry.update_after = asbool(settings.get('update_after', True))
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
config.include('pyramid_chameleon')
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a WSGI application. """
my_session_factory = UnencryptedCookieSessionFactoryConfig("itsaseekreet")
config = Configurator(settings=settings, root_factory=Root,
session_factory=my_session_factory)
config.include("cornice")
config.scan("lembrar.service")
config.add_renderer('jsonp', JSONP(param_name='callback'))
# config.add_view("lembrar.views.list.list_view",
# context="lembrar:resources.Root",
# renderer="lembrar:templates/list.pt")
# config.add_route("thumb", pattern="{id}/thumb")
# config.add_view("lembrar.views.list.thumb", route_name="thumb")
# config.add_route("image", pattern="{id}/image")
# config.add_view("lembrar.views.list.image", route_name="image")
# config.add_route("del", pattern="{id}/delete")
# config.add_view("lembrar.views.list.delete", route_name="del",
# renderer="json")
# config.add_view("lembrar.views.add.add", name="add",
# context="lembrar:resources.Root", renderer="json")
# config.add_view("lembrar.views.add.human_add", name="human_add",
# context="lembrar:resources.Root",
# renderer="lembrar:templates/add.pt")
# config.add_view("lembrar.views.maintenance.upgrade", name="upgrade",
# renderer="json")
# config.add_route("edit", pattern="{id}/edit")
# config.add_view("lembrar.views.edit.edit", route_name="edit",
# renderer="lembrar:templates/edit.pt",
# request_method="GET")
# config.add_view("lembrar.views.edit.edit_post", route_name="edit",
# request_method="POST")
config.add_static_view("", "lembrar:static")
config.add_subscriber(add_base_template, "pyramid.events.BeforeRender")
# MongoDB
def add_mongo_db(event):
settings = event.request.registry.settings
db_name = settings["mongodb_db"]
db = settings["mongodb_conn"][db_name]
event.request.db = db
db_uri = settings["mongodb_dsn"]
conn = pymongo.Connection(db_uri)
config.registry.settings["mongodb_conn"] = conn
db = conn[config.registry.settings["mongodb_db"]]
db.authenticate(config.registry.settings['mongodb_user'],
config.registry.settings['mongodb_password'])
db.docs.ensure_index("created")
config.add_subscriber(add_mongo_db, NewRequest)
# registry
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
css = webassets.Bundle('bootstrap.min.css',
webassets.Bundle('styles.css', filters='yui_css'),
output='bundle.min.css')
config.add_webasset('css', css)
config.registry.settings['webassets_env'] = config.get_webassets_env()
config.add_subscriber(add_webassets_env, NewRequest)
db_uri = settings['mongodb.db_uri']
conn = pymongo.Connection(db_uri)
config.registry.settings['db_conn'] = conn
try:
if asbool(settings.get('nurl.check_whitelist', False)):
with open(os.path.join(APP_PATH, '..',
'whitelist.txt')) as whitelist:
config.registry.settings['nurl.whitelist'] = get_whitelist(
whitelist,
asbool(settings.get('nurl.check_whitelist_auto_www',
False)))
except IOError:
config.registry.settings['nurl.check_whitelist'] = False
config.add_subscriber(add_mongo_db, NewRequest)
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('shortened', '/{short_ref}')
#rest api version 1
config.add_route('shortener_v1', '/api/v1/shorten')
config.scan()
application = config.make_wsgi_app()
#newrelic agent
try:
if asbool(settings.get('newrelic.enable', False)):
newrelic.agent.initialize(
os.path.join(APP_PATH, '..', 'newrelic.ini'),
settings['newrelic.environment'])
return newrelic.agent.wsgi_application()(application)
else:
return application
except IOError:
config.registry.settings['newrelic.enable'] = False
return application
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
with Configurator(settings=settings) as config:
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.include('pyramid_jinja2')
config.include('.routes')
config.include('.database')
config.include('.callbacks')
config.scan()
return config.make_wsgi_app()
def setUp(self):
from pyramid.renderers import JSONP
self.config = testing.setUp()
self.config.add_renderer('jsonp', JSONP(param_name='callback'))
self.config.include("cornice")
self.authz_policy = ACLAuthorizationPolicy()
self.config.set_authorization_policy(self.authz_policy)
self.authn_policy = AuthTktAuthenticationPolicy('$3kr1t')
self.config.set_authentication_policy(self.authn_policy)
self.config.scan("cornice.tests.test_resource")
self.app = TestApp(CatchErrors(self.config.make_wsgi_app()))
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
[1]: This views are responding for requests with any methods except GET,
so have a work-around with multiple routes path to attend with or without trailing slash.
Reference:
http://docs.pylonsproject.org/projects/pyramid/en/latest/narr/urldispatch.html#redirecting-to-slash-appended-routes
"""
config = Configurator(settings=settings)
config.add_renderer('jsonp', JSONP(param_name='callback', indent=4))
db_dsn = os.environ.get('MONGODB_HOST',
settings.get('mongo_uri', '127.0.0.1:27017'))
db_client = controller.get_dbconn(db_dsn)
def add_databroker(request):
"""Add a databroker to all incoming request"""
return controller.DataBroker(db_client)
config.add_route('index', '/')
# collections - GET method:
config.add_route('collection', '/api/v1/collection/')
config.add_route('identifiers_collection',
'/api/v1/collection/identifiers/')
# journals - GET method:
config.add_route('journal', '/api/v1/journal/')
config.add_route('identifiers_journal', '/api/v1/journal/identifiers/')
config.add_route('exists_journal', '/api/v1/journal/exists/')
# issues - GET method:
config.add_route('get_issue', '/api/v1/issue/')
config.add_route('get_issues', '/api/v1/issues/')
config.add_route('identifiers_issue', '/api/v1/issue/identifiers/')
config.add_route('exists_issue', '/api/v1/issue/exists/')
# articles - GET method:
config.add_route('get_article', '/api/v1/article/')
config.add_route('get_articles', '/api/v1/articles/')
config.add_route('identifiers_article', '/api/v1/article/identifiers/')
config.add_route('exists_article', '/api/v1/article/exists/')
# press releases - GET method:
config.add_route('identifiers_press_release',
'/api/v1/press_release/identifiers/')
# logs historychanges - GET method:
config.add_route('list_historychanges_article', '/api/v1/article/history/')
config.add_route('list_historychanges_journal', '/api/v1/journal/history/')
config.add_route('list_historychanges_issue', '/api/v1/issue/history/')
# others
config.add_request_method(add_databroker, 'databroker', reify=True)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
config.add_renderer('jsonp', JSONP(param_name='callback', indent=4))
config.include('pyramid_mako')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view('files', XML_FILES, cache_max_age=3600)
config.add_route('home', '/')
config.add_route('packages', '/packages')
config.add_route('editor', '/editor')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings)
config.include('pyramid_chameleon')
config.include('pyramid_tm')
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('org', '/org')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
config.add_renderer('jsonp', JSONP(param_name='callback', indent=4))
def add_controller(request):
es = os.environ.get(
'ELASTICSEARCH_HOST',
settings.get('elasticsearch_host', '127.0.0.1:9200'))
es_index = os.environ.get(
'ELASTICSEARCH_INDEX',
settings.get('elasticsearch_index', 'citations'))
return controller.controller(aslist(es),
sniff_on_connection_fail=True,
timeout=600).set_base_index(es_index)
config.add_route('index', '/')
config.add_route('status', '/_status/')
config.add_route('citedby_pid', '/api/v1/pid/')
config.add_route('citedby_doi', '/api/v1/doi/')
config.add_route('citedby_meta', '/api/v1/meta/')
config.add_request_method(add_controller, 'controller', reify=True)
# Cache Settings Config
memcached_host = os.environ.get('MEMCACHED_HOST',
settings.get('memcached_host', None))
memcached_expiration_time = os.environ.get(
'MEMCACHED_EXPIRATION_TIME',
settings.get('memcached_expiration_time', 2592000) # a month cache
)
if 'memcached_host' is not None:
cache_config = {}
cache_config['expiration_time'] = int(memcached_expiration_time)
cache_config['arguments'] = {'url': memcached_host, 'binary': True}
controller_cache_region.configure('dogpile.cache.pylibmc',
**cache_config)
else:
controller_cache_region.configure('dogpile.cache.null')
config.scan()
return config.make_wsgi_app()
def _register_common_templates(config):
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.include('pyramid_jinja2')
env = config.get_jinja2_environment()
env.filters['skipautoescape'] = skipautoescape
env.filters['jsonify'] = jsonify
config.add_view('flow.site.views.errors.http404',
renderer='flow:templates/http404.jinja2',
context='pyramid.exceptions.NotFound')
config.testing_add_renderer('templates/login.jinja2')
config.testing_add_renderer('templates/toolbar.jinja2')
config.testing_add_renderer('templates/cloud.jinja2')
config.testing_add_renderer('templates/latest.jinja2')
config.testing_add_renderer('templates/sparql_query.jinja2')
def setUp(self):
from pyramid.renderers import JSONP
self.config = testing.setUp(autocommit=False)
self.config.add_renderer('jsonp', JSONP(param_name='callback'))
self.config.include("cornice")
add_view(UserImp.get, renderer='json')
add_view(UserImp.get, renderer='jsonp')
add_view(UserImp.collection_post, renderer='json', accept='text/json')
user_resource = add_resource(UserImp,
collection_path='/users',
path='/users/{id}',
name='user_service',
factory=dummy_factory)
self.config.add_cornice_resource(user_resource)
self.app = TestApp(CatchErrors(self.config.make_wsgi_app()))
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
config.add_renderer('jsonp', JSONP(param_name='callback', indent=4))
hosts = aslist(settings['elasticsearch'])
def add_index(request):
return controller.stats(hosts=hosts, sniff_on_connection_fail=True)
config.include('pyramid_chameleon')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('index', '/')
config.add_route('journals', '/api/v1/journals')
config.add_route('documents', '/api/v1/documents')
config.add_request_method(add_index, 'index', reify=True)
config.scan()
return config.make_wsgi_app()
