def includeme(root, settings):
factory = import_class(
settings.get('mailer', {}).get('utility',
app_settings['mailer']['utility']))
utility = factory()
provide_utility(utility, IMailer)
configure.scan('guillotina_mailer.api')
configure.scan('guillotina_mailer.utility')
def includeme(root, settings):
mailer_settings = settings.get("mailer") or app_settings.get("mailer")
factory = import_class(mailer_settings.get("utility"))
logger.debug(f"Setting Mail Utility: {mailer_settings['utility']}")
if settings.get("mailer", {}).get("default_sender", None) is None:
logger.warning(f"No sender mail configured on mailer.default_sender settings")
utility = factory()
provide_utility(utility, IMailer)
configure.scan("guillotina.contrib.mailer.utility")
def includeme(root, settings):
factory = import_class(
settings.get('mailer', {}).get('utility',
settings['mailer']['utility']))
logger.debug(f"Setting Mail Utility: {settings['mailer']['utility']}")
if settings.get('mailer', {}).get('default_sender', None) is None:
logger.warning(
f"No sender mail configured on mailer.default_sender settings")
utility = factory()
provide_utility(utility, IMailer)
configure.scan('guillotina.contrib.mailer.utility')
def includeme(root):
configure.scan('guillotina_elasticsearch.utility')
configure.scan('guillotina_elasticsearch.manager')
# add store true to guillotina indexes
for name, utility in get_utilities_for(IResourceFactory):
if not get_dotted_name(utility._callable).startswith('guillotina.'):
continue
for field_name, catalog_info in get_index_fields(name).items():
if field_name in ('id', 'path', 'uuid', 'type_name', 'tid',
'creators', 'contributors', 'access_roles',
'access_users', 'parent_uuid', 'title'):
catalog_info['store'] = True
def includeme(root):
"""
custom application initialization here
"""
configure.scan('guillotina_kafka.api')
configure.scan('guillotina_kafka.utilities')
configure.scan('guillotina_kafka.install')
configure.scan('guillotina_kafka.subscribers')
def includeme(root):
"""
custom application initialization here
"""
configure.scan('guillotina_hydraidp.api')
configure.scan('guillotina_hydraidp.join')
configure.scan('guillotina_hydraidp.storage')
configure.scan('guillotina_hydraidp.json_definitions')
def includeme(root):
"""
custom application initialization here
"""
configure.scan("guillotina_scootermpi.api")
configure.scan("guillotina_scootermpi.install")
configure.scan("guillotina_scootermpi.content")
def includeme(root):
"""
custom application initialization here
"""
configure.scan('guillotina_glex.api')
configure.scan('guillotina_glex.install')
configure.scan('guillotina_glex.utility')
def includeme(root):
configure.scan("guillotina_elasticsearch.utility")
configure.scan("guillotina_elasticsearch.manager")
configure.scan("guillotina_elasticsearch.parser")
# add store true to guillotina indexes
for name, utility in get_utilities_for(IResourceFactory):
if not get_dotted_name(utility._callable).startswith("guillotina."):
continue
for field_name, catalog_info in get_index_fields(name).items():
if field_name in (
"id",
"path",
"uuid",
"type_name",
"tid",
"creators",
"contributors",
"access_roles",
"access_users",
"parent_uuid",
"title",
"creation_date",
"modification_date",
"tags",
):
catalog_info["store"] = True
def includeme(root):
"""
custom application initialization here
"""
configure.scan('guillotina_linkintegrity.api')
configure.scan('guillotina_linkintegrity.storage')
configure.scan('guillotina_linkintegrity.subscribers')
def includeme(root):
"""
custom application initialization here
"""
configure.scan('guillotina_couchbase.api')
configure.scan('guillotina_couchbase.storage')
configure.scan('guillotina_couchbase.catalog')
def includeme(root):
"""
custom application initialization here
"""
configure.scan('twitter_project.api')
configure.scan('twitter_project.install')
configure.scan('twitter_project.content')
def includeme(root):
"""
custom application initialization here
"""
configure.scan('wiki.api')
configure.scan('wiki.install')
configure.scan('wiki.content')
def includeme(root, settings):
configure.scan('guillotina_dbusers.content.users')
configure.scan('guillotina_dbusers.content.groups')
configure.scan('guillotina_dbusers.install')
configure.scan('guillotina_dbusers.services')
configure.scan('guillotina_dbusers.subscribers')
async def make_app(config_file=None, settings=None, loop=None, server_app=None):
'''
Make application from configuration
:param config_file: path to configuration file to load
:param settings: dictionary of settings
:param loop: if not using with default event loop
:param settings: provide your own aiohttp application
'''
# reset app_settings
startup_vars = {}
for key in app_settings.keys():
if key[0] == '_':
startup_vars[key] = app_settings[key]
app_settings.clear()
app_settings.update(startup_vars)
app_settings.update(deepcopy(default_settings))
if loop is None:
loop = asyncio.get_event_loop()
# chainmap task factory is actually very important
# default task factory uses inheritance in a way
# that bubbles back down. So it's possible for a sub-task
# to clear out the request of the parent task
loop.set_task_factory(aiotask_context.chainmap_task_factory)
if config_file is not None:
with open(config_file, 'r') as config:
settings = json.load(config)
elif settings is None:
raise Exception('Neither configuration or settings')
# Create root Application
root = ApplicationRoot(config_file, loop)
provide_utility(root, IApplication, 'root')
# Initialize global (threadlocal) ZCA configuration
config = root.config = ConfigurationMachine()
app_configurator = ApplicationConfigurator(
settings.get('applications') or [],
config, root, settings
)
configure.scan('guillotina.renderers')
configure.scan('guillotina.api')
configure.scan('guillotina.content')
configure.scan('guillotina.registry')
configure.scan('guillotina.auth')
configure.scan('guillotina.json')
configure.scan('guillotina.behaviors')
configure.scan('guillotina.languages')
configure.scan('guillotina.permissions')
configure.scan('guillotina.security.security_local')
configure.scan('guillotina.security.policy')
configure.scan('guillotina.auth.participation')
configure.scan('guillotina.catalog.index')
configure.scan('guillotina.catalog.catalog')
configure.scan('guillotina.files')
configure.scan('guillotina.annotations')
configure.scan('guillotina.constraintypes')
configure.scan('guillotina.subscribers')
configure.scan('guillotina.db.strategies')
configure.scan('guillotina.db.cache')
configure.scan('guillotina.db.writer')
configure.scan('guillotina.db.factory')
configure.scan('guillotina.exc_resp')
configure.scan('guillotina.fields')
configure.scan('guillotina.migrations')
# always load guillotina
app_configurator.configure_application('guillotina')
app_configurator.configure_all_applications()
apply_concrete_behaviors()
# update *after* plugins loaded
update_app_settings(settings)
if 'logging' in app_settings:
try:
logging.config.dictConfig(app_settings['logging'])
except Exception:
logger.error('Could not setup logging configuration', exc_info=True)
# Make and initialize aiohttp app
if server_app is None:
server_app = make_aiohttp_application()
root.app = server_app
server_app.root = root
server_app.config = config
optimize_settings(app_settings)
await notify(ApplicationConfiguredEvent(server_app, loop))
for key, dbconfig in list_or_dict_items(app_settings['databases']):
factory = get_utility(
IDatabaseConfigurationFactory, name=dbconfig['storage'])
root[key] = await factory(key, dbconfig, loop)
await notify(DatabaseInitializedEvent(root[key]))
for key, file_path in list_or_dict_items(app_settings['static']):
path = resolve_path(file_path).resolve()
if not path.exists():
raise Exception('Invalid static directory {}'.format(file_path))
if path.is_dir():
root[key] = StaticDirectory(path)
else:
root[key] = StaticFile(path)
for key, file_path in list_or_dict_items(app_settings['jsapps']):
path = resolve_path(file_path).resolve()
if not path.exists() or not path.is_dir():
raise Exception('Invalid jsapps directory {}'.format(file_path))
root[key] = JavaScriptApplication(path)
root.set_root_user(app_settings['root_user'])
if app_settings.get('jwk') and\
app_settings.get('jwk').get('k') and\
app_settings.get('jwk').get('kty'):
key = jwk.JWK.from_json(json.dumps(app_settings.get('jwk')))
app_settings['jwk'] = key
# {"k":"QqzzWH1tYqQO48IDvW7VH7gvJz89Ita7G6APhV-uLMo","kty":"oct"}
if not app_settings.get('debug') and app_settings['jwt'].get('secret'):
# validate secret
secret = app_settings['jwt']['secret']
if secret == 'secret':
logger.warning(
'You are using a very insecure secret key in production mode. '
'It is strongly advised that you provide a better value for '
'`jwt.secret` in your config.')
elif not secure_passphrase(app_settings['jwt']['secret']):
logger.warning(
'You are using a insecure secret key in production mode. '
'It is recommended that you provide a more complex value for '
'`jwt.secret` in your config.')
# Set router root
server_app.router.set_root(root)
server_app.on_cleanup.append(cleanup_app)
for util in app_settings.get('utilities') or []:
logger.warn('Adding : ' + util['provides'])
root.add_async_utility(util['provides'], util, loop=loop)
for key, util in app_settings['load_utilities'].items():
logger.info('Adding ' + key + ' : ' + util['provides'])
root.add_async_utility(key, util, loop=loop)
# Load cached Schemas
load_cached_schema()
await notify(ApplicationInitializedEvent(server_app, loop))
return server_app
def includeme(root, settings):
configure.scan('guillotina_aiocache.cache_strategy')
def includeme(root):
"""
custom application initialization here
"""
configure.scan("guillotina_amqp.permissions")
configure.scan("guillotina_amqp.api")
def includeme():
configure.scan('measures.configuration')
async def make_app(config_file=None,
settings=None,
loop=None,
server_app=None):
"""
Make application from configuration
:param config_file: path to configuration file to load
:param settings: dictionary of settings
:param loop: if not using with default event loop
:param settings: provide your own aiohttp application
"""
# reset app_settings
startup_vars = {}
for key in app_settings.keys():
if key[0] == "_":
startup_vars[key] = app_settings[key]
app_settings.clear()
app_settings.update(startup_vars)
app_settings.update(deepcopy(default_settings))
if loop is None:
loop = asyncio.get_event_loop()
if config_file is not None:
with open(config_file, "r") as config:
settings = json.load(config)
elif settings is None:
raise Exception("Neither configuration or settings")
# Create root Application
root = ApplicationRoot(config_file, loop)
provide_utility(root, IApplication, "root")
# Initialize global (threadlocal) ZCA configuration
config = root.config = ConfigurationMachine()
app_configurator = ApplicationConfigurator(
settings.get("applications") or [], config, root, settings)
configure.scan("guillotina.renderers")
configure.scan("guillotina.api")
configure.scan("guillotina.content")
configure.scan("guillotina.registry")
configure.scan("guillotina.auth")
configure.scan("guillotina.json")
configure.scan("guillotina.behaviors")
configure.scan("guillotina.languages")
configure.scan("guillotina.permissions")
configure.scan("guillotina.security.security_local")
configure.scan("guillotina.security.policy")
configure.scan("guillotina.catalog.index")
configure.scan("guillotina.catalog.catalog")
configure.scan("guillotina.files")
configure.scan("guillotina.annotations")
configure.scan("guillotina.constraintypes")
configure.scan("guillotina.subscribers")
configure.scan("guillotina.db.strategies")
configure.scan("guillotina.db.storages.vacuum")
configure.scan("guillotina.db.cache")
configure.scan("guillotina.db.writer")
configure.scan("guillotina.db.factory")
configure.scan("guillotina.exc_resp")
configure.scan("guillotina.fields")
configure.scan("guillotina.migrations")
# always load guillotina
app_configurator.configure_application("guillotina")
app_configurator.configure_all_applications()
apply_concrete_behaviors()
# update *after* plugins loaded
update_app_settings(settings)
if "logging" in app_settings:
try:
logging.config.dictConfig(app_settings["logging"])
except Exception:
app_logger.error("Could not setup logging configuration",
exc_info=True)
# Make and initialize aiohttp app
if server_app is None:
server_app = make_aiohttp_application()
root.app = server_app
server_app.root = root
server_app.config = config
for k, v in _moved.items():
# for b/w compatibility, convert these
if k in app_settings:
app_settings[v] = app_settings[k]
del app_settings[k]
optimize_settings(app_settings)
await notify(ApplicationConfiguredEvent(server_app, loop))
for key, dbconfig in list_or_dict_items(app_settings["databases"]):
factory = get_utility(IDatabaseConfigurationFactory,
name=dbconfig["storage"])
root[key] = await factory(key, dbconfig, loop)
await notify(DatabaseInitializedEvent(root[key]))
for key, file_path in list_or_dict_items(app_settings["static"]):
path = resolve_path(file_path).resolve()
if not path.exists():
raise Exception("Invalid static directory {}".format(file_path))
if path.is_dir():
root[key] = StaticDirectory(path)
else:
root[key] = StaticFile(path)
for key, file_path in list_or_dict_items(app_settings["jsapps"]):
path = resolve_path(file_path).resolve()
if not path.exists() or not path.is_dir():
raise Exception("Invalid jsapps directory {}".format(file_path))
root[key] = JavaScriptApplication(path)
root.set_root_user(app_settings["root_user"])
if app_settings.get("jwk") and app_settings.get("jwk").get(
"k") and app_settings.get("jwk").get("kty"):
key = jwk.JWK.from_json(json.dumps(app_settings.get("jwk")))
app_settings["jwk"] = key
# {"k":"QqzzWH1tYqQO48IDvW7VH7gvJz89Ita7G6APhV-uLMo","kty":"oct"}
if not app_settings.get("debug") and app_settings["jwt"].get("secret"):
# validate secret
secret = app_settings["jwt"]["secret"]
if secret == "secret":
app_logger.warning(
"You are using a very insecure secret key in production mode. "
"It is strongly advised that you provide a better value for "
"`jwt.secret` in your config.")
elif not secure_passphrase(app_settings["jwt"]["secret"]):
app_logger.warning(
"You are using a insecure secret key in production mode. "
"It is recommended that you provide a more complex value for "
"`jwt.secret` in your config.")
# Set router root
server_app.router.set_root(root)
server_app.on_cleanup.append(cleanup_app)
for key, util in app_settings["load_utilities"].items():
app_logger.info("Adding " + key + " : " + util["provides"])
await notify(BeforeAsyncUtilityLoadedEvent(key, util))
result = root.add_async_utility(key, util, loop=loop)
if result is not None:
await notify(AfterAsyncUtilityLoadedEvent(key, util, *result))
# Load cached Schemas
load_cached_schema()
await notify(ApplicationInitializedEvent(server_app, loop))
return server_app
def includeme(root, settings):
configure.scan("guillotina.contrib.workflows.permissions")
configure.scan("guillotina.contrib.workflows.api")
configure.scan("guillotina.contrib.workflows.behavior")
configure.scan("guillotina.contrib.workflows.events")
configure.scan("guillotina.contrib.workflows.utility")
configure.scan("guillotina.contrib.workflows.subscriber")
configure.scan("guillotina.contrib.workflows.vocabularies")
def includeme(root):
"""
custom application initialization here
"""
configure.scan('guillotina_authentication.api')
def includeme(root, settings):
configure.scan("guillotina.contrib.cache.api")
configure.scan("guillotina.contrib.cache.strategy")
def includeme():
configure.scan('measures.configuration')
def includeme(root, settings):
configure.scan("guillotina.contrib.dyncontent.vocabularies")
configure.scan("guillotina.contrib.dyncontent.subscriber")
def includeme(root, settings):
configure.scan("guillotina.contrib.catalog.pg.parser")
configure.scan("guillotina.contrib.catalog.pg.utility")
def includeme(root, settings):
cache.setup(settings.get('groupcache', {}).get('addr', app_settings['groupcache']['addr']))
configure.scan('guillotina_groupcache.cache_strategy')
def includeme(root, settings):
configure.scan("guillotina.contrib.dbusers.content.users")
configure.scan("guillotina.contrib.dbusers.content.groups")
configure.scan("guillotina.contrib.dbusers.install")
configure.scan("guillotina.contrib.dbusers.services")
configure.scan("guillotina.contrib.dbusers.subscribers")
configure.scan("guillotina.contrib.dbusers.permissions")
configure.scan("guillotina.contrib.dbusers.serializers")
def includeme(root):
configure.scan('guillotina_cms.patch')
configure.scan('guillotina_cms.permissions')
configure.scan('guillotina_cms.api')
configure.scan('guillotina_cms.install')
configure.scan('guillotina_cms.json')
configure.scan('guillotina_cms.fields')
configure.scan('guillotina_cms.content')
configure.scan('guillotina_cms.validator')
def make_app(config_file=None, settings=None, loop=None, server_app=None):
app_settings.update(_delayed_default_settings)
if loop is None:
loop = asyncio.get_event_loop()
loop.set_task_factory(aiotask_context.task_factory)
if config_file is not None:
with open(config_file, 'r') as config:
settings = json.load(config)
elif settings is None:
raise Exception('Neither configuration or settings')
# Create root Application
root = ApplicationRoot(config_file)
provide_utility(root, IApplication, 'root')
# Initialize global (threadlocal) ZCA configuration
config = root.config = ConfigurationMachine()
import guillotina
import guillotina.db.factory
import guillotina.db.writer
import guillotina.db.db
configure.scan('guillotina.translation')
configure.scan('guillotina.renderers')
configure.scan('guillotina.api')
configure.scan('guillotina.content')
configure.scan('guillotina.registry')
configure.scan('guillotina.auth')
configure.scan('guillotina.json')
configure.scan('guillotina.behaviors')
configure.scan('guillotina.languages')
configure.scan('guillotina.permissions')
configure.scan('guillotina.security.security_local')
configure.scan('guillotina.security.policy')
configure.scan('guillotina.auth.participation')
configure.scan('guillotina.catalog.index')
configure.scan('guillotina.catalog.catalog')
configure.scan('guillotina.framing')
configure.scan('guillotina.files')
configure.scan('guillotina.annotations')
configure.scan('guillotina.constraintypes')
configure.scan('guillotina.subscribers')
configure.scan('guillotina.db.strategies')
configure.scan('guillotina.db.cache')
load_application(guillotina, root, settings)
config.execute_actions()
config.commit()
for module_name in settings.get('applications', []):
config.begin(module_name)
load_application(resolve_dotted_name(module_name), root, settings)
config.execute_actions()
config.commit()
# XXX we clear now to save some memory
# it's unclear to me if this is necesary or not but it seems to me that
# we don't need things registered in both components AND here.
configure.clear()
# update *after* plugins loaded
update_app_settings(settings)
if 'logging' in app_settings:
logging.config.dictConfig(app_settings['logging'])
# Make and initialize aiohttp app
if server_app is None:
server_app = make_aiohttp_application()
root.app = server_app
server_app.root = root
server_app.config = config
content_type = ContentNegotiatorUtility('content_type',
app_settings['renderers'].keys())
language = ContentNegotiatorUtility('language',
app_settings['languages'].keys())
provide_utility(content_type, IContentNegotiation, 'content_type')
provide_utility(language, IContentNegotiation, 'language')
for database in app_settings['databases']:
for key, dbconfig in database.items():
factory = get_utility(IDatabaseConfigurationFactory,
name=dbconfig['storage'])
if asyncio.iscoroutinefunction(factory):
future = asyncio.ensure_future(factory(key, dbconfig,
server_app),
loop=loop)
loop.run_until_complete(future)
root[key] = future.result()
else:
root[key] = factory(key, dbconfig)
for key, file_path in list_or_dict_items(app_settings['static']):
path = resolve_path(file_path).resolve()
if not path.exists():
raise Exception('Invalid static directory {}'.format(file_path))
if path.is_dir():
root[key] = StaticDirectory(path)
else:
root[key] = StaticFile(path)
for key, file_path in list_or_dict_items(app_settings['jsapps']):
path = resolve_path(file_path).resolve()
if not path.exists() or not path.is_dir():
raise Exception('Invalid jsapps directory {}'.format(file_path))
root[key] = JavaScriptApplication(path)
root.set_root_user(app_settings['root_user'])
if RSA is not None and not app_settings.get('rsa'):
key = RSA.generate(2048)
pub_jwk = {'k': key.publickey().exportKey('PEM')}
priv_jwk = {'k': key.exportKey('PEM')}
app_settings['rsa'] = {'pub': pub_jwk, 'priv': priv_jwk}
# Set router root
server_app.router.set_root(root)
for utility in get_all_utilities_registered_for(IAsyncUtility):
# In case there is Utilties that are registered
if hasattr(utility, 'initialize'):
task = asyncio.ensure_future(lazy_apply(utility.initialize,
app=server_app),
loop=loop)
root.add_async_task(utility, task, {})
else:
logger.warn(f'No initialize method found on {utility} object')
server_app.on_cleanup.append(close_utilities)
for util in app_settings['utilities']:
root.add_async_utility(util, loop=loop)
# Load cached Schemas
load_cached_schema()
optimize_settings(app_settings)
return server_app
def includeme(root, settings):
configure.scan('guillotina_declperm.hook')
configure.scan('guillotina_declperm.service')
def includeme(root):
configure.scan('guillotina_pgcatalog.api')
configure.scan('guillotina_pgcatalog.utility')
def includeme(root, settings):
configure.scan("guillotina_cms.interfaces")
configure.scan("guillotina_cms.api")
configure.scan("guillotina_cms.behaviors")
configure.scan("guillotina_cms.content")
configure.scan("guillotina_cms.fields")
configure.scan("guillotina_cms.json")
configure.scan("guillotina_cms.utilities")
configure.scan("guillotina_cms.vocabularies")
configure.scan("guillotina_cms.permissions")
configure.scan("guillotina_cms.install")
configure.scan("guillotina_cms.subscribers")
configure.scan("guillotina_cms.blocks")
if "guillotina_elasticsearch" in settings.get("applications", []):
if "load_utilities" not in settings:
settings["load_utilities"] = {}
from guillotina.contrib.catalog.pg import app_settings as pg_app_settings
settings["load_utilities"]["pg_catalog"] = {
**pg_app_settings["load_utilities"]["catalog"],
**{"name": "pg_catalog"},
}
