cubicweb: comparison server/hook.py

equal deleted inserted replaced

-:6397a9051f65
+:134613d3b353
 Operations
 ~~~~~~~~~~
 Operations are subclasses of the :class:`~cubicweb.server.hook.Operation` class
-that may be created by hooks and scheduled to happen just before (or after) the
+that may be created by hooks and scheduled to happen on `precommit`,
-`precommit`, `postcommit` or `rollback` event. Hooks are being fired immediately
+`postcommit` or `rollback` event (i.e. respectivly before/after a commit or
-on data operations, and it is sometime necessary to delay the actual work down
+before a rollback of a transaction).
-to a time where all other hooks have run. Also while the order of execution of
-hooks is data dependant (and thus hard to predict), it is possible to force an
+Hooks are being fired immediately on data operations, and it is sometime
-order on operations.
+necessary to delay the actual work down to a time where we can expect all
+information to be there, or when all other hooks have run (though take case
+since operations may themselves trigger hooks). Also while the order of
+execution of hooks is data dependant (and thus hard to predict), it is possible
+to force an order on operations.
+So, for such case where you may miss some information that may be set later in
+the transaction, you should instantiate an operation in the hook.
 Operations may be used to:
 * implements a validation check which needs that all relations be already set on
 an entity
 from warnings import warn
 from logging import getLogger
 from itertools import chain
-from logilab.common.decorators import classproperty
+from logilab.common.decorators import classproperty, cached
 from logilab.common.deprecation import deprecated, class_renamed
 from logilab.common.logging_ext import set_log_methods
 from cubicweb import RegistryNotFound
 from cubicweb.vregistry import classid
 from cubicweb.cwvreg import CWRegistry, VRegistry
 from cubicweb.selectors import (objectify_selector, lltrace, ExpectedValueSelector,
 is_instance)
-from cubicweb.appobject import AppObject
+from cubicweb.appobject import AppObject, NotSelector, OrSelector
 from cubicweb.server.session import security_enabled
 ENTITIES_HOOKS = set(('before_add_entity',    'after_add_entity',
 'before_update_entity', 'after_update_entity',
 'before_delete_entity', 'after_delete_entity'))
 entities = []
 eids_from_to = kwargs.pop('eids_from_to')
 else:
 entities = []
 eids_from_to = []
+pruned = self.get_pruned_hooks(session, event,
+entities, eids_from_to, kwargs)
 # by default, hooks are executed with security turned off
 with security_enabled(session, read=False):
 for _kwargs in _iter_kwargs(entities, eids_from_to, kwargs):
-hooks = sorted(self.possible_objects(session, **_kwargs),
+hooks = sorted(self.filtered_possible_objects(pruned, session, **_kwargs),
 key=lambda x: x.order)
 with security_enabled(session, write=False):
 for hook in hooks:
-#print hook.category, hook.__regid__
+hook()
-hook()
+def get_pruned_hooks(self, session, event, entities, eids_from_to, kwargs):
+"""return a set of hooks that should not be considered by filtered_possible objects
+the idea is to make a first pass over all the hooks in the
+registry and to mark put some of them in a pruned list. The
+pruned hooks are the one which:
+* are disabled at the session level
+* have a match_rtype or an is_instance selector which does not
+match the rtype / etype of the relations / entities for
+which we are calling the hooks. This works because the
+repository calls the hooks grouped by rtype or by etype when
+using the entities or eids_to_from keyword arguments
+Only hooks with a simple selector or an AndSelector of simple
+selectors are considered for disabling.
+"""
+if 'entity' in kwargs:
+entities = [kwargs['entity']]
+if len(entities):
+look_for_selector = is_instance
+etype = entities[0].__regid__
+elif 'rtype' in kwargs:
+look_for_selector = match_rtype
+etype = None
+else: # nothing to prune, how did we get there ???
+return set()
+cache_key = (event, kwargs.get('rtype'), etype)
+pruned = session.pruned_hooks_cache.get(cache_key)
+if pruned is not None:
+return pruned
+pruned = set()
+session.pruned_hooks_cache[cache_key] = pruned
+if look_for_selector is not None:
+for id, hooks in self.iteritems():
+for hook in hooks:
+enabled_cat, main_filter = hook.filterable_selectors()
+if enabled_cat is not None:
+if not enabled_cat(hook, session):
+pruned.add(hook)
+continue
+if main_filter is not None:
+if isinstance(main_filter, match_rtype) and \
+(main_filter.frometypes is not None  or \
+main_filter.toetypes is not None):
+continue
+first_kwargs = _iter_kwargs(entities, eids_from_to, kwargs).next()
+if not main_filter(hook, session, **first_kwargs):
+pruned.add(hook)
+return pruned
+def filtered_possible_objects(self, pruned, *args, **kwargs):
+for appobjects in self.itervalues():
+if pruned:
+filtered_objects = [obj for obj in appobjects if obj not in pruned]
+if not filtered_objects:
+continue
+else:
+filtered_objects = appobjects
+obj = self._select_best(filtered_objects,
+*args, **kwargs)
+if obj is None:
+continue
+yield obj
 class HooksManager(object):
 def __init__(self, vreg):
 self.vreg = vreg
 # XXX deprecated
 enabled = True
 # stop pylint from complaining about missing attributes in Hooks classes
 eidfrom = eidto = entity = rtype = None
+@classmethod
+@cached
+def filterable_selectors(cls):
+search = cls.__select__.search_selector
+if search((NotSelector, OrSelector)):
+return None, None
+enabled_cat = search(enabled_category)
+main_filter = search((is_instance, match_rtype))
+return enabled_cat, main_filter
 @classmethod
 def check_events(cls):
 try:
 for event in cls.events:
 takes a session object as first argument (accessible as `.session` from the
 operation instance), and optionally all keyword arguments needed by the
 operation. These keyword arguments will be accessible as attributes from the
 operation instance.
-An operation is triggered on connections pool events related to
+An operation is triggered on connections set events related to commit /
-commit / rollback transations. Possible events are:
+rollback transations. Possible events are:
 * `precommit`:
 the transaction is being prepared for commit. You can freely do any heavy
 computation, raise an exception if the commit can't go. or even add some
 % classid(self.__class__), DeprecationWarning)
 self.commit_event()
 getattr(self, event)()
 def precommit_event(self):
-"""the observed connections pool is preparing a commit"""
+"""the observed connections set is preparing a commit"""
 def revertprecommit_event(self):
 """an error went when pre-commiting this operation or a later one
 should revert pre-commit's changes but take care, they may have not
 been all considered if it's this operation which failed
 """
 def rollback_event(self):
-"""the observed connections pool has been rollbacked
+"""the observed connections set has been rollbacked
-do nothing by default, the operation will just be removed from the pool
+do nothing by default
-operation list
 """
 def postcommit_event(self):
-"""the observed connections pool has committed"""
+"""the observed connections set has committed"""
 @property
 @deprecated('[3.6] use self.session.user')
 def user(self):
 return self.session.user
 instead of giving them into the rql string.
 """
 data_key = 'neweids'
 def rollback_event(self):
-"""the observed connections pool has been rollbacked,
+"""the observed connections set has been rollbacked,
 remove inserted eid from repository type/source cache
 """
 try:
 self.session.repo.clear_caches(self.get_data())
 except KeyError:
 """on commit of delete query, we have to remove from repository's
 type/source cache eids of entities deleted in that transaction.
 """
 data_key = 'pendingeids'
 def postcommit_event(self):
-"""the observed connections pool has been rollbacked,
+"""the observed connections set has been rollbacked,
 remove inserted eid from repository type/source cache
 """
 try:
 self.session.repo.clear_caches(self.get_data())
 except KeyError:

branch	stable
changeset 7677	134613d3b353
parent 7638	cc7cde77184f
child 7879	9aae456abab5