def make_wsgi_app(settings_filepath=None, testing=False):
with start_action(action_type='morepath_scan'):
morepath.autoscan()
morepath.scan(ekklesia_portal)
if testing:
log_message(
message_type="testing",
msg="running in testing mode, not loading any config from file")
else:
with start_action(action_type='settings'):
settings = get_app_settings(settings_filepath)
App._loaded_settings = settings
App.init_settings(settings)
with start_action(action_type='make_app'):
App.commit()
app = App()
database.configure_sqlalchemy(app.settings.database, testing)
app.babel_init()
app.babel.localeselector(get_locale)
log_message(message_type="environment",
env=dict(os.environ),
encoding=locale.getpreferredencoding(),
default_locale=locale.getdefaultlocale())
return app
def run(): # pragma: no cover
engine = sqlalchemy.create_engine('sqlite:///morepath_sqlalchemy.db')
Session.configure(bind=engine)
Base.metadata.create_all(engine)
morepath.autoscan()
morepath.run(App())
def app(test_app_class):
morepath.autoscan()
test_app_class.init_settings(SETTINGS)
test_app_class.commit()
app = test_app_class()
return app
def wsgi_factory(): # pragma: no cover
morepath.autoscan()
App.commit()
setup_db()
return App()
def wsgi_factory(): # pragma: no cover
morepath.autoscan()
App.commit()
setup_db()
return App()
def get_client(app):
class Tapp(app):
pass
morepath.autoscan()
morepath.commit(Tapp)
c = Client(Tapp())
return c
def create_app(app,
settings,
sqlalchemy_session=Session,
sqlalchemy_bases=None):
sqlalchemy_bases = sqlalchemy_bases or []
register_session(sqlalchemy_session)
# initialize SQLAlchemy
if 'sqlalchemy' in settings:
cwd = os.getcwd()
engine = sqlalchemy.create_engine(settings['sqlalchemy']['dburi'] %
{'here': cwd})
sqlalchemy_session.configure(bind=engine)
# initialize app
app.init_settings(settings)
morepath.commit(app)
morepath.autoscan()
app.commit()
application = app()
# create tables
if 'sqlalchemy' in settings:
for base in sqlalchemy_bases:
base.metadata.create_all(engine)
return application
def wsgi_factory(): # pragma: no cover
morepath.autoscan()
if os.getenv("RUN_ENV") == "production":
ProductionApp.commit()
app = ProductionApp()
elif os.getenv("RUN_ENV") == "test":
TestApp.commit()
app = TestApp()
else:
App.commit()
app = App()
index = FileApp("build/index.html")
static = DirectoryApp("build", index_page=None)
setup_db(app)
@webob.dec.wsgify
def morepath_with_static_absorb(request):
popped = request.path_info_pop()
if popped == "api":
return request.get_response(app)
elif popped == "static":
return request.get_response(static)
else:
return request.get_response(index)
return morepath_with_static_absorb
def run(): # pragma: no cover
engine = sqlalchemy.create_engine("sqlite:///morepath_sqlalchemy.db")
Session.configure(bind=engine)
Base.metadata.create_all(engine)
morepath.autoscan()
morepath.run(App())
def assert_explicit_permissions(module, app_class):
morepath.autoscan()
app_class.commit()
for action, fn in dectate.Query('view')(app_class):
if fn.__module__.startswith('onegov'):
assert action.permission is not None, (
f'{fn.__module__}.{fn.__name__} has no permission')
def query_tool():
"""Usa dectate.query_tool() para consultar las rutas de la API."""
morepath.autoscan()
# Cargamos la configuración de la aplicación
with open('settings.json') as config:
settings_dict = json.load(config)
App.init_settings(settings_dict)
morepath.commit(App)
dectate.query_tool(App.commit())
def assert_explicit_permissions(module, app_class):
morepath.autoscan()
app_class.commit()
for action, fn in dectate.Query('view')(app_class):
if fn.__module__.startswith('onegov'):
assert action.permission is not None, (
f'{fn.__module__}.{fn.__name__} has no permission'
)
def app(test_app_class):
custom_settings = {**BABEL_SETTINGS, 'configure_jinja': False}
morepath.autoscan()
test_app_class.init_settings(dict(babel_i18n=custom_settings))
test_app_class.commit()
app = test_app_class()
app.babel_init()
return app
def get_client(app, config='settings.yml'):
if isinstance(config, str):
with open(os.path.join(os.path.dirname(__file__), config)) as f:
settings = yaml.load(f) or {}
else:
settings = config
morepath.autoscan()
app.init_settings(settings)
morepath.commit(app)
c = Client(app())
return c
def initdb():
click.echo('Initialize database...')
morepath.autoscan()
app = App()
app.commit()
# create database
dbsession = app.find_service(name='dbsession')
Base.metadata.create_all(dbsession.bind)
# add users
users = app.find_service(name='users')
with transaction.manager:
for user in USERS:
users.add(**user)
transaction.commit()
def run():
morepath.autoscan()
with open('settings/default.yaml') as defaults:
defaults_dict = yaml.load(defaults)
App.init_settings(defaults_dict)
App.commit()
app = App()
setup_db(app)
run_simple(app.settings.run.host,
app.settings.run.port,
DebuggedApplication(app, evalex=True),
use_reloader=True)
def make_wsgi_app(settings_filepath=None, testing=False):
with start_action(action_type='morepath_scan'):
morepath.autoscan()
morepath.scan(ekklesia_voting)
with start_action(action_type='settings'):
settings = get_app_settings(settings_filepath)
App.init_settings(settings)
with start_action(action_type='make_app'):
App.commit()
app = App()
database.configure_sqlalchemy(app.settings.database, testing)
app.babel_init()
app.babel.localeselector(get_locale)
return app
def run(): # pragma: no cover
morepath.autoscan()
index = FileApp('static/index.html')
static = DirectoryApp('static')
app = App()
@webob.dec.wsgify
def morepath_with_static_absorb(request):
popped = request.path_info_pop()
if popped == 'api':
return request.get_response(app)
elif popped == 'static':
return request.get_response(static)
else:
return request.get_response(index)
morepath.run(morepath_with_static_absorb)
def run(): # pragma: no cover
morepath.autoscan()
index = FileApp('static/index.html')
static = DirectoryApp('static')
app = App()
@webob.dec.wsgify
def morepath_with_static_absorb(request):
popped = request.path_info_pop()
if popped == 'api':
return request.get_response(app)
elif popped == 'static':
return request.get_response(static)
else:
return request.get_response(index)
morepath.run(morepath_with_static_absorb)
def run(): # pragma: no cover
# This is super-hacky, but whatever - this was always intended to be a
# temporary solution anyway
if len(argv) > 1:
# We clean the config filename off so as not to confuse morepath
config_settings(argv.pop())
else:
print('Need a list name (should be in form-data/)')
exit(1)
engine = sqlalchemy.create_engine('sqlite:///sf_app.db')
Session.configure(bind=engine)
Base.metadata.create_all(engine)
morepath.autoscan()
# Not entirely clear if I need this
morepath.commit(App)
morepath.run(App())
def run(): # pragma: no cover
morepath.autoscan()
index = FileApp('static/index.html')
static = DirectoryApp('static')
app = App()
@webob.dec.wsgify
def morepath_with_static(request):
if request.path_info_peek() == '':
return request.get_response(index)
popped = request.path_info_pop()
if popped == 'api':
return request.get_response(app)
elif popped == 'static':
return request.get_response(static)
raise HTTPNotFound()
morepath.run(morepath_with_static)
def run():
directive_logger = logging.getLogger('morepath.directive')
directive_logger.addHandler(logging.StreamHandler())
directive_logger.setLevel(logging.DEBUG)
with open('settings.yml') as config:
settings_dict = yaml.load(config)
App.init_settings(settings_dict)
morepath.autoscan()
morepath.commit(App)
app = App()
setup_db(app)
if os.getenv('RUN_ENV') == 'dev':
morepath.run(app, host='0.0.0.0', port='80')
else:
waitress_logger = logging.getLogger('waitress')
waitress_logger.setLevel(logging.INFO)
waitress.serve(app, listen="*:80")
def instance_app():
"""Crea una instancia de la aplicación"""
morepath.autoscan()
# Lo siguiente prepara el logger de pony.orm para que emita a un
# fichero todas las sentencias SQL que va enviando a la base de datos
# pony.orm.sql_debug(True)
# logger = logging.getLogger("pony.orm.sql")
# logger.setLevel(logging.INFO)
# channel = logging.FileHandler("/tmp/sql_commands.log")
# channel.setLevel(logging.INFO)
# logger.addHandler(channel)
# Hay que añadirle un handler a logging.root porque (según he visto
# en el código de pony) sql_log() comprueba que haya uno, y si no lo
# hay emite las cosas por la salida estándar haciendo caso omiso de la
# configuración de log. Pero como no me interesa que el logger raiz
# haga nada, le asigno el handler nulo
# logging.root.addHandler(logging.NullHandler())
env = os.getenv("RUN_ENV", "default")
filename = "settings/{}.yaml".format(env)
if not os.path.isfile(filename):
filename = "settings/default.yaml"
print("Usando configuración {}".format(filename))
# Cargamos la configuración de la aplicación
with open(filename) as config:
settings_dict = yaml.load(config)
App.init_settings(settings_dict)
# morepath.commit(App)
App.commit()
app = App()
setup_redis(app)
setup_db(app)
return app
def create_baseapp(app, settings, scan=True, **kwargs):
s = copy.deepcopy(default_settings)
for k in settings.keys():
if k in s.keys():
for j, v in settings[k].items():
s[k][j] = v
else:
s[k] = settings[k]
settings = s
# initialize app
if scan:
morepath.autoscan()
for scanmodpath in (settings['morpfw']['scan'] or []):
scanmod = importlib.import_module(scanmodpath)
morepath.scan(package=scanmod)
app_settings = settings['application']
authnpolicy_settings = app_settings['authn_policy_settings']
authnpol_mod, authnpol_clsname = (
app_settings['authn_policy'].strip().split(':'))
authnpolicy = getattr(importlib.import_module(authnpol_mod),
authnpol_clsname)(authnpolicy_settings)
get_identity_policy = authnpolicy.get_identity_policy
verify_identity = authnpolicy.verify_identity
mounted_apps = app_settings['mounted_apps']
if getattr(authnpolicy, 'app_cls', None):
mounted_apps.append({
'app_cls':
authnpolicy.app_cls,
'authn_policy':
app_settings['authn_policy'],
'authn_policy_settings':
app_settings['authn_policy_settings']
})
for iapp in mounted_apps:
if 'app_cls' in iapp.keys():
iapp_cls = iapp['app_cls']
else:
iapp_path = iapp['app']
iapp_mod, iapp_clsname = iapp_path.strip().split(':')
iapp_cls = getattr(importlib.import_module(iapp_mod), iapp_clsname)
if iapp.get('authn_policy', None):
iapp_authnpolicy_settings = iapp.get('authn_policy_settings', {})
iapp_authnpol_mod, iapp_authnpol_clsname = (
iapp['authn_policy'].strip().split(':'))
iapp_authnpolicy = getattr(
importlib.import_module(iapp_authnpol_mod),
iapp_authnpol_clsname)(iapp_authnpolicy_settings)
iapp_get_identity_policy = iapp_authnpolicy.get_identity_policy
iapp_verify_identity = iapp_authnpolicy.verify_identity
iapp_cls.identity_policy()(iapp_get_identity_policy)
iapp_cls.verify_identity()(iapp_verify_identity)
if getattr(iapp_cls, 'authn_provider', None):
iapp_cls.authn_provider()(iapp_authnpolicy.get_app)
else:
iapp_cls.identity_policy()(get_identity_policy)
iapp_cls.verify_identity()(verify_identity)
if getattr(iapp_cls, 'authn_provider', None):
iapp_cls.authn_provider()(authnpolicy.get_app)
iapp_cls.init_settings(settings)
iapp_cls._raw_settings = settings
iapp_cls.commit()
app.identity_policy()(get_identity_policy)
app.verify_identity()(verify_identity)
if authnpolicy.app_cls:
app.authn_provider()(lambda: authnpolicy.app_cls())
app.init_settings(settings)
app._raw_settings = settings
if settings['application']['development_mode']:
os.environ['MOREPATH_TEMPLATE_AUTO_RELOAD'] = "1"
app.commit()
celery_settings = settings['worker']['celery_settings']
app.celery.conf.update(**celery_settings)
application = app()
return application
def run(): # pragma: no cover
morepath.autoscan()
morepath.run(App())
def make_app():
morepath.autoscan()
App.commit()
return App()
def run(): # pragma: no cover
App.setting('storage', 'path')(default_storage_directory)
morepath.autoscan()
morepath.run(App())
def run():
morepath.autoscan()
morepath.run(App())
# for 'autogenerate' support. These must be set
# up to hold just those tables targeting a
# particular database. table.tometadata() may be
# helpful here in case a "copy" of
# a MetaData is needed.
# from myapp import mymodel
# target_metadata = {
# 'engine1':mymodel.metadata1,
# 'engine2':mymodel.metadata2
# }
from morpfw.crud.storage.sqlstorage import Base
import morpcc.tests.democms
import morepath
morepath.autoscan()
morepath.scan(morpcc.tests.democms)
target_metadata = {'default': Base.metadata}
# other values from the config, defined by the needs of env.py,
# can be acquired:
# my_important_option = config.get_main_option("my_important_option")
# ... etc.
def run_migrations_offline():
"""Run migrations in 'offline' mode.
This configures the context with just a URL
and not an Engine, though an Engine is acceptable
here as well. By skipping the Engine creation
def run(): # pragma: no cover
App.setting("storage", "path")(default_storage_directory)
morepath.autoscan()
morepath.run(App())
def app():
morepath.autoscan()
EkklesiaBrowserApp.commit()
app = EkklesiaBrowserApp()
app.babel_init()
return app
def wsgi_factory():
morepath.autoscan()
morepath.scan()
morepath.commit()
return App()
def paths():
morepath.autoscan()
App.commit()
path_tool(App)
def wsgi_factory():
morepath.autoscan()
morepath.scan()
App.commit()
return App()
def run(): # pragma: no cover
App.setting('storage', 'path')(default_storage_directory)
morepath.autoscan()
morepath.run(App())
