def add_async_utility(self, key, config, loop=None):
if key in self._async_utilities:
logger.warn(
f'Utility already registered {key}')
return
interface = import_class(config['provides'])
factory = import_class(config['factory'])
try:
utility_object = lazy_apply(
factory, config.get('settings', {}),
loop=loop or self._loop)
except Exception:
logger.error('Error initializing utility {}'.format(repr(factory)),
exc_info=True)
raise
provide_utility(utility_object, interface)
if hasattr(utility_object, 'initialize'):
task = asyncio.ensure_future(
lazy_apply(utility_object.initialize, app=self.app),
loop=loop or self._loop)
else:
task = None
logger.warn(f'No initialize method found on {utility_object} object')
self.add_async_task(key, task, config)
def add_async_utility(self, key, config, loop=None):
if key in self._async_utilities:
logger.warn(f'Utility already registered {key}')
return
interface = import_class(config['provides'])
factory = import_class(config['factory'])
try:
utility_object = lazy_apply(factory,
config.get('settings', {}),
loop=loop or self._loop)
except Exception:
logger.error('Error initializing utility {}'.format(repr(factory)),
exc_info=True)
raise
provide_utility(utility_object, interface)
if hasattr(utility_object, 'initialize'):
task = asyncio.ensure_future(lazy_apply(utility_object.initialize,
app=self.app),
loop=loop or self._loop)
else:
task = None
logger.warn(
f'No initialize method found on {utility_object} object')
self.add_async_task(key, task, config)
def load_application(module, root, settings):
# includeme function
if hasattr(module, 'includeme'):
lazy_apply(module.includeme, root, settings)
# app_settings
if hasattr(module, 'app_settings') and app_settings != module.app_settings:
update_app_settings(module.app_settings)
# services
configure.load_all_configurations(root.config, module.__name__)
async def close_utilities(app):
for utility in getAllUtilitiesRegisteredFor(IAsyncUtility):
if hasattr(utility, 'finalize'):
asyncio.ensure_future(lazy_apply(utility.finalize, app=app),
loop=app.loop)
for db in app.router._root:
if IDatabase.providedBy(db[1]):
await db[1]._db.finalize()
def load_application(self, module):
# includeme function
if hasattr(module, 'includeme'):
lazy_apply(module.includeme, self.root, self.settings)
# app_settings
if hasattr(module, 'app_settings') and app_settings != module.app_settings:
update_app_settings(module.app_settings)
# exclude configuration from sub packages that are registered
# as applications
excluded_modules = [
module_name for module_name in
set(self.applications) - set([module.__name__])
if not module.__name__.startswith(module_name)]
# services
return configure.load_all_configurations(
self.root.config, module.__name__, excluded_modules)
def test_lazy_apply():
assert utils.lazy_apply(_test_empty_func, 'blah', foo='bar')
assert utils.lazy_apply(_test_some_args, 'foo', 'bar') == ('foo', 'bar')
assert utils.lazy_apply(_test_some_args, 'foo', 'bar', 'ldkfks', 'dsflk') == ('foo', 'bar')
assert utils.lazy_apply(_test_some_kwargs, 'foo', bar='bar') == ('foo', 'bar')
assert utils.lazy_apply(_test_some_kwargs, 'foo', bar='bar', rsdfk='ldskf') == ('foo', 'bar')
assert (utils.lazy_apply(_test_some_stars, 'foo', 'blah', bar='bar', another='another') ==
('foo', 'bar', {'another': 'another'}))
def load_application(self, module):
# includeme function
if hasattr(module, "includeme"):
lazy_apply(module.includeme, self.root, self.settings)
# app_settings
if hasattr(module,
"app_settings") and app_settings != module.app_settings:
update_app_settings(module.app_settings)
# exclude configuration from sub packages that are registered
# as applications
excluded_modules = [
module_name
for module_name in set(self.applications) - set([module.__name__])
if not module.__name__.startswith(module_name)
] + [
module_name for module_name in self.contrib_apps
if module_name != module.__name__
]
# services
return configure.load_all_configurations(self.root.config,
module.__name__,
excluded_modules)
def add_async_utility(
self,
key: str,
config: typing.Dict,
loop: typing.Optional[asyncio.AbstractEventLoop] = None
) -> typing.Optional[typing.Tuple[typing.Any,
typing.Optional[asyncio.Future]]]:
if key in self._async_utilities:
logger.warn(f'Utility already registered {key}')
return None
interface = import_class(config['provides'])
factory = import_class(config['factory'])
try:
utility_object = lazy_apply(factory,
config.get('settings', {}),
loop=loop or self._loop)
except Exception:
logger.error('Error initializing utility {}'.format(repr(factory)),
exc_info=True)
raise
alsoProvides(utility_object, interface)
kw = {}
if 'name' in config:
kw['name'] = config['name']
provide_utility(utility_object, interface, **kw)
if hasattr(utility_object, 'initialize'):
func = lazy_apply(utility_object.initialize, app=self.app)
task = asyncio.ensure_future(notice_on_error(key, func),
loop=loop or self._loop)
self.add_async_task(key, task, config)
return utility_object, task
else:
logger.info(
f'No initialize method found on {utility_object} object')
return None
def test_lazy_apply():
assert utils.lazy_apply(_test_empty_func, "blah", foo="bar")
assert utils.lazy_apply(_test_some_args, "foo", "bar") == ("foo", "bar")
assert utils.lazy_apply(_test_some_args, "foo", "bar", "ldkfks", "dsflk") == ("foo", "bar")
assert utils.lazy_apply(_test_some_kwargs, "foo", bar="bar") == ("foo", "bar")
assert utils.lazy_apply(_test_some_kwargs, "foo", bar="bar", rsdfk="ldskf") == ("foo", "bar")
assert utils.lazy_apply(_test_some_stars, "foo", "blah", bar="bar", another="another") == (
"foo",
"bar",
{"another": "another"},
)
def test_lazy_apply():
assert utils.lazy_apply(_test_empty_func, 'blah', foo='bar')
assert utils.lazy_apply(_test_some_args, 'foo', 'bar') == ('foo', 'bar')
assert utils.lazy_apply(_test_some_args, 'foo', 'bar', 'ldkfks',
'dsflk') == ('foo', 'bar')
assert utils.lazy_apply(
_test_some_kwargs, 'foo', bar='bar') == ('foo', 'bar')
assert utils.lazy_apply(
_test_some_kwargs, 'foo', bar='bar', rsdfk='ldskf') == ('foo', 'bar')
assert (utils.lazy_apply(
_test_some_stars, 'foo', 'blah', bar='bar',
another='another') == ('foo', 'bar', {
'another': 'another'
}))
async def _call_after_commit_hooks(self, status=True):
# Avoid to abort anything at the end if no hooks are registred.
if not self._after_commit:
return
# Call all hooks registered, allowing further registrations
# during processing. Note that calls to addAterCommitHook() may
# add additional hooks while hooks are running, and iterating over a
# growing list is well-defined in Python.
for hook, args, kws in self._after_commit:
# The first argument passed to the hook is a Boolean value,
# true if the commit succeeded, or false if the commit aborted.
try:
result = lazy_apply(hook, status, *args, **kws)
if asyncio.iscoroutine(result):
await result
except Exception:
# We need to catch the exceptions if we want all hooks
# to be called
logger.error("Error in after commit hook exec in %s ", hook, exc_info=sys.exc_info())
self._after_commit = []
async def _call_after_commit_hooks(self, status=True):
# Avoid to abort anything at the end if no hooks are registred.
if not self._after_commit:
return
# Call all hooks registered, allowing further registrations
# during processing. Note that calls to addAterCommitHook() may
# add additional hooks while hooks are running, and iterating over a
# growing list is well-defined in Python.
for hook, args, kws in self._after_commit:
# The first argument passed to the hook is a Boolean value,
# true if the commit succeeded, or false if the commit aborted.
try:
result = lazy_apply(hook, status, *args, **kws)
if asyncio.iscoroutine(result):
await result
except Exception:
# We need to catch the exceptions if we want all hooks
# to be called
logger.error("Error in after commit hook exec in %s ",
hook, exc_info=sys.exc_info())
self._after_commit = []
def get_settings():
settings = deepcopy(TESTING_SETTINGS)
for func in _configurators:
lazy_apply(func, settings, _configurators)
return settings
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
async def _call_before_commit_hooks(self):
for hook, args, kws in self._before_commit:
result = lazy_apply(hook, *args, **kws)
if asyncio.iscoroutine(result):
await result
self._before_commit = []
async def _call_before_commit_hooks(self):
for hook, args, kws in self._before_commit:
result = lazy_apply(hook, *args, **kws)
if asyncio.iscoroutine(result):
await result
self._before_commit = []
async def make_app(config_file=None,
settings=None,
loop=None,
server_app=None):
# reset app_settings
app_settings.clear()
app_settings.update(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()
import guillotina
import guillotina.db.factory
import guillotina.db.writer
import guillotina.db.db
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.exc_resp')
configure.scan('guillotina.fields')
load_application(guillotina, root, settings)
config.execute_actions()
config.commit()
configured = ['guillotina']
for module_name in settings.get('applications') or []:
configure_application(module_name, config, root, settings, configured)
apply_concrete_behaviors()
# 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
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 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(cleanup_app)
for util in app_settings['utilities']:
root.add_async_utility(util, loop=loop)
# Load cached Schemas
load_cached_schema()
await notify(ApplicationInitializedEvent(server_app, loop))
return server_app
