def reindex_object(obj, catalog=''):
"""Reindex given object into catalog"""
LOGGER.debug("Re-indexing object {0!r}".format(obj))
intids = query_utility(IIntIds)
if intids is not None:
object_id = intids.queryId(obj)
if object_id is not None:
if isinstance(catalog, str):
catalog = query_utility(ICatalog, name=catalog)
if catalog is not None:
get_pyramid_registry().notify(BeforeObjectIndexEvent(obj))
catalog.reindex_doc(object_id, obj)
def revoke_role(self, role_id, principal_ids):
"""Revoke role to selected principals"""
registry = get_pyramid_registry()
if IRole.providedBy(role_id):
role_id = role_id.id
if isinstance(principal_ids, str):
principal_ids = {principal_ids}
role_principals = self._principals_by_role.get(role_id) or set()
for principal_id in principal_ids.copy():
if IPrincipalInfo.providedBy(principal_id):
principal_id = principal_id.id
if principal_id in role_principals:
principal_roles = self._roles_by_principal.get(
principal_id) or set()
if principal_id in role_principals:
role_principals.remove(principal_id)
if role_id in principal_roles:
principal_roles.remove(role_id)
if principal_roles:
self._roles_by_principal[principal_id] = principal_roles
elif principal_id in self._roles_by_principal:
del self._roles_by_principal[principal_id]
if role_principals:
self._principals_by_role[role_id] = role_principals
elif role_id in self._principals_by_role:
del self._principals_by_role[role_id]
registry.notify(RevokedRoleEvent(self, role_id, principal_id))
def index_object(obj, catalog='', ignore_notyet=False):
"""Index given object into catalog"""
LOGGER.debug("Indexing object {0!r}".format(obj))
intids = query_utility(IIntIds)
if intids is not None:
try:
object_id = intids.register(obj)
except NotYet:
if not ignore_notyet:
raise
else:
if isinstance(catalog, str):
catalog = query_utility(ICatalog, name=catalog)
if catalog is not None:
get_pyramid_registry().notify(BeforeObjectIndexEvent(obj))
catalog.index_doc(object_id, obj)
def register_widget_template(template,
widget,
settings,
provides,
registry=None):
"""Register new widget template"""
if not os.path.isfile(template):
raise ConfigurationError("No such file", template)
content_type = settings.get('content_type', 'text/html')
macro = settings.get('macro')
factory = WidgetTemplateFactory(template, content_type, macro)
provides = settings.get('provides', provides)
directlyProvides(factory, provides)
# check context
required = (settings.get('context',
Interface), settings.get('layer', IFormLayer),
settings.get('form', None), settings.get('field',
None), widget)
# update registry
if registry is None:
registry = settings.get('registry')
if registry is None:
registry = get_pyramid_registry()
registry.registerAdapter(factory, required, provides,
settings.get('mode', INPUT_MODE))
def clone_action(wf, context): # pylint: disable=invalid-name,unused-argument
"""Create new version"""
result = copy(context)
locate(result, context.__parent__)
registry = get_pyramid_registry()
registry.notify(ObjectClonedEvent(result, context))
return result
def get_socket():
"""Open ØMQ socket"""
registry = get_pyramid_registry()
handler = registry.settings.get(SCHEDULER_HANDLER_KEY, False)
if handler:
return zmq_socket(handler,
auth=registry.settings.get(SCHEDULER_AUTH_KEY))
return None
def get_permissions(self, principal_id):
"""Get permissions for given principal"""
registry = get_pyramid_registry()
result = set()
for role_id in self.get_roles(principal_id):
role = registry.queryUtility(IRole, role_id)
result |= role.permissions or set()
return result
def get_schema(cls):
"""Class table schema getter"""
settings_name = cls.get_schema_settings_name()
if settings_name:
registry = get_pyramid_registry()
if hasattr(registry, 'settings'):
return {
'schema': registry.settings.get(settings_name,
cls.__schema__)
}
return {'schema': cls.__schema__}
def run(self):
"""Sets up everything and starts the event loop on process startup"""
signal.signal(signal.SIGTERM, self.exit)
# Setup ZeroMQ IO loop
try:
self.setup()
except zmq.error.ZMQError:
self.exit()
else:
registry = get_pyramid_registry()
registry.notify(ZMQProcessStartedEvent(self)) # pylint: disable=no-member
self.loop.start()
def execute(self, task, action, job_id, registry=None):
"""Execute scheduler action"""
scheduler = query_utility(IScheduler)
if scheduler is not None:
registry = registry if registry is not None else get_pyramid_registry()
handler = registry.settings.get(SCHEDULER_HANDLER_KEY, False)
if handler:
zmq_settings = {
'zodb_name': scheduler.zodb_name,
'task_name': task.__name__,
'job_id': job_id
}
LOGGER.debug(f"Starting '{action}' on task {task.name} with {zmq_settings!r}")
socket = zmq_socket(handler, auth=registry.settings.get(SCHEDULER_AUTH_KEY))
socket.send_json([action, zmq_settings])
zmq_response(socket)
def grant_role(self, role_id, principal_ids):
"""Grant role to selected principals"""
registry = get_pyramid_registry()
if IRole.providedBy(role_id):
role_id = role_id.id
if isinstance(principal_ids, str):
principal_ids = {principal_ids}
role_principals = self._principals_by_role.get(role_id) or set()
for principal_id in principal_ids:
if IPrincipalInfo.providedBy(principal_id):
principal_id = principal_id.id
if principal_id not in role_principals:
principal_roles = self._roles_by_principal.get(
principal_id) or set()
role_principals.add(principal_id)
principal_roles.add(role_id)
self._roles_by_principal[principal_id] = principal_roles
self._principals_by_role[role_id] = role_principals
registry.notify(GrantedRoleEvent(self, role_id, principal_id))
def register_template(template, view, settings, provides, registry=None):
"""Register new template"""
if not os.path.isfile(template):
raise ConfigurationError("No such file", template)
content_type = settings.get('content_type', 'text/html')
macro = settings.get('macro')
factory = TemplateFactory(template, content_type, macro)
provides = settings.get('provides', provides)
directlyProvides(factory, provides)
# check context
required = (settings.get('context', None), settings.get('layer',
IRequest), view)
# update registry
if registry is None:
registry = settings.get('registry')
if registry is None:
registry = get_pyramid_registry()
registry.registerAdapter(factory, required, provides,
settings.get('name', ''))
def handle_new_application(event): # pylint: disable=unused-argument,too-many-locals,too-many-branches
"""Start scheduler process when application is created"""
# Check for PyAMS command line script
cmdline = os.path.split(sys.argv[0])[-1]
if cmdline.startswith('pyams_'):
return
registry = get_pyramid_registry()
settings = registry.settings
start_handler = asbool(settings.get(SCHEDULER_STARTER_KEY, False))
if not start_handler:
return
# check if port is available
handler_address = settings.get(SCHEDULER_HANDLER_KEY, '127.0.0.1:5555')
hostname, port = handler_address.split(':')
if is_port_in_use(int(port), hostname):
LOGGER.warning("Scheduler port already used, aborting...")
return
# get database connection
connection = get_connection_from_settings(settings)
root = connection.root()
# get application
application_name = settings.get(PYAMS_APPLICATION_SETTINGS_KEY,
PYAMS_APPLICATION_DEFAULT_NAME)
application = root.get(application_name)
if application is None:
return
process = None
sm = application.getSiteManager() # pylint: disable=invalid-name
set_local_registry(sm)
try:
scheduler_util = sm.get(SCHEDULER_NAME)
if scheduler_util is None:
return
try:
zodb_name = scheduler_util.zodb_name
except ComponentLookupError:
pass
else:
# create scheduler process
process = SchedulerProcess(handler_address,
SchedulerMessageHandler,
settings.get(SCHEDULER_AUTH_KEY),
settings.get(SCHEDULER_CLIENTS_KEY),
registry)
# load tasks
for task in scheduler_util.values():
if not task.is_runnable():
continue
trigger = task.get_trigger()
LOGGER.debug(
"Adding scheduler job for task '{0.name}'".format(task))
process.scheduler.add_job(task,
trigger,
id=str(task.internal_id),
name=task.name,
kwargs={
'zodb_name': zodb_name,
'registry': registry
})
# start process
LOGGER.info("Starting tasks scheduler {0!r}...".format(process))
process.start()
if process.is_alive():
atexit.register(process_exit_func, process=process)
LOGGER.info("Started tasks scheduler with PID {0}.".format(
process.pid))
finally:
if process and not process.is_alive():
process.terminate()
process.join()
set_local_registry(None)
