cubicweb: comparison cubicweb/hooks/syncsession.py

equal deleted inserted replaced

-:9ea50837bc58
+:b48020a80dc3
 from cubicweb import _
 from cubicweb import UnknownProperty, BadConnectionId, validation_error
 from cubicweb.predicates import is_instance
 from cubicweb.server import hook
+from cubicweb.entities.authobjs import user_session_cache_key
 def get_user_sessions(repo, ueid):
 for session in repo._sessions.values():
 if ueid == session.user.eid:
 yield session
+class CachedValueMixin(object):
+"""Mixin class providing methods to retrieve some value, specified through
+`value_name` attribute, in session data.
+"""
+value_name = None
+session = None  # make pylint happy
+@property
+def cached_value(self):
+"""Return cached value for the user, or None"""
+key = user_session_cache_key(self.session.user.eid, self.value_name)
+return self.session.data.get(key, None)
+def update_cached_value(self, value):
+"""Update cached value for the user (modifying the set returned by cached_value may not be
+necessary depending on session data implementation, e.g. redis)
+"""
+key = user_session_cache_key(self.session.user.eid, self.value_name)
+self.session.data[key] = value
 class SyncSessionHook(hook.Hook):
 __abstract__ = True
 category = 'syncsession'
 # user/groups synchronisation #################################################
-class _GroupOperation(hook.Operation):
+class _GroupOperation(CachedValueMixin, hook.Operation):
-"""base class for group operation"""
+"""Base class for group operation"""
-cnxuser = None # make pylint happy
+value_name = 'groups'
 def __init__(self, cnx, *args, **kwargs):
-"""override to get the group name before actual groups manipulation:
+"""Override to get the group name before actual groups manipulation
 we may temporarily loose right access during a commit event, so
 no query should be emitted while comitting
 """
 rql = 'Any N WHERE G eid %(x)s, G name N'
-result = cnx.execute(rql, {'x': kwargs['geid']}, build_descr=False)
+result = cnx.execute(rql, {'x': kwargs['group_eid']}, build_descr=False)
 hook.Operation.__init__(self, cnx, *args, **kwargs)
 self.group = result[0][0]
 class _DeleteGroupOp(_GroupOperation):
 """Synchronize user when a in_group relation has been deleted"""
 def postcommit_event(self):
-"""the observed connections set has been commited"""
+cached_groups = self.cached_value
-groups = self.cnxuser.groups
+if cached_groups is not None:
-try:
+cached_groups.remove(self.group)
-groups.remove(self.group)
+self.update_cached_value(cached_groups)
-except KeyError:
-self.error('user %s not in group %s',  self.cnxuser, self.group)
 class _AddGroupOp(_GroupOperation):
 """Synchronize user when a in_group relation has been added"""
 def postcommit_event(self):
-"""the observed connections set has been commited"""
+cached_groups = self.cached_value
-groups = self.cnxuser.groups
+if cached_groups is not None:
-if self.group in groups:
+cached_groups.add(self.group)
-self.warning('user %s already in group %s', self.cnxuser,
+self.update_cached_value(cached_groups)
-self.group)
-else:
-groups.add(self.group)
 class SyncInGroupHook(SyncSessionHook):
 """Watch addition/removal of in_group relation to synchronize living sessions accordingly"""
 __regid__ = 'syncingroup'
 if self.event == 'after_delete_relation':
 opcls = _DeleteGroupOp
 else:
 opcls = _AddGroupOp
 for session in get_user_sessions(self._cw.repo, self.eidfrom):
-opcls(self._cw, cnxuser=session.user, geid=self.eidto)
+opcls(self._cw, session=session, group_eid=self.eidto)
-class _DelUserOp(hook.Operation):
+class _CloseSessionOp(hook.Operation):
-"""close associated user's session when it is deleted"""
+"""Close user's session when it has been deleted"""
-def __init__(self, cnx, sessionid):
-self.sessionid = sessionid
-hook.Operation.__init__(self, cnx)
 def postcommit_event(self):
 try:
-self.cnx.repo.close(self.sessionid)
+# remove cached groups for the user
+key = user_session_cache_key(self.session.user.eid, 'groups')
+self.session.data.pop(key, None)
+self.session.repo.close(self.session.sessionid)
 except BadConnectionId:
 pass  # already closed
-class CloseDeletedUserSessionsHook(SyncSessionHook):
+class UserDeletedHook(SyncSessionHook):
+"""Watch deletion of user to close its opened session"""
 __regid__ = 'closession'
 __select__ = SyncSessionHook.__select__ & is_instance('CWUser')
 events = ('after_delete_entity',)
 def __call__(self):
 for session in get_user_sessions(self._cw.repo, self.entity.eid):
-_DelUserOp(self._cw, session.sessionid)
+_CloseSessionOp(self._cw, session=session)
 # CWProperty hooks #############################################################
-class _DelCWPropertyOp(hook.Operation):
-"""a user's custom properties has been deleted"""
+class _UserPropertyOperation(CachedValueMixin, hook.Operation):
-cwpropdict = key = None # make pylint happy
+"""Base class for property operation"""
+value_name = 'properties'
-def postcommit_event(self):
+key = None  # make pylint happy
-"""the observed connections set has been commited"""
-try:
-del self.cwpropdict[self.key]
+class _ChangeUserCWPropertyOp(_UserPropertyOperation):
-except KeyError:
+"""Synchronize cached user's properties when one has been added/updated"""
-self.error('%s has no associated value', self.key)
+value = None  # make pylint happy
+def postcommit_event(self):
-class _ChangeCWPropertyOp(hook.Operation):
+cached_props = self.cached_value
-"""a user's custom properties has been added/changed"""
+if cached_props is not None:
-cwpropdict = key = value = None # make pylint happy
+cached_props[self.key] = self.value
+self.update_cached_value(cached_props)
-def postcommit_event(self):
-"""the observed connections set has been commited"""
-self.cwpropdict[self.key] = self.value
+class _DelUserCWPropertyOp(_UserPropertyOperation):
+"""Synchronize cached user's properties when one has been deleted"""
-class _AddCWPropertyOp(hook.Operation):
+def postcommit_event(self):
-"""a user's custom properties has been added/changed"""
+cached_props = self.cached_value
-cwprop = None # make pylint happy
+if cached_props is not None:
+cached_props.pop(self.key, None)
-def postcommit_event(self):
+self.update_cached_value(cached_props)
-"""the observed connections set has been commited"""
+class _ChangeSiteWideCWPropertyOp(hook.Operation):
+"""Synchronize site wide properties when one has been added/updated"""
+cwprop = None  # make pylint happy
+def postcommit_event(self):
 cwprop = self.cwprop
 if not cwprop.for_user:
 self.cnx.vreg['propertyvalues'][cwprop.pkey] = \
 self.cnx.vreg.typed_value(cwprop.pkey, cwprop.value)
-# if for_user is set, update is handled by a ChangeCWPropertyOp operation
+# if for_user is set, update is handled by a ChangeUserCWPropertyOp operation
+class _DelSiteWideCWPropertyOp(hook.Operation):
+"""Synchronize site wide properties when one has been deleted"""
+key = None  # make pylint happy
+def postcommit_event(self):
+self.cnx.vreg['propertyvalues'].pop(self.key, None)
 class AddCWPropertyHook(SyncSessionHook):
 __regid__ = 'addcwprop'
 __select__ = SyncSessionHook.__select__ & is_instance('CWProperty')
 value = cnx.vreg.typed_value(key, value)
 except UnknownProperty:
 msg = _('unknown property key %s')
 raise validation_error(self.entity, {('pkey', 'subject'): msg}, (key,))
 except ValueError as ex:
-raise validation_error(self.entity,
+raise validation_error(self.entity, {('value', 'subject'): str(ex)})
-{('value', 'subject'): str(ex)})
+if cnx.user.matching_groups('managers'):
-if not cnx.user.matching_groups('managers'):
+_ChangeSiteWideCWPropertyOp(cnx, cwprop=self.entity)
+else:
 cnx.add_relation(self.entity.eid, 'for_user', cnx.user.eid)
-else:
-_AddCWPropertyOp(cnx, cwprop=self.entity)
 class UpdateCWPropertyHook(AddCWPropertyHook):
 __regid__ = 'updatecwprop'
 events = ('after_update_entity',)
 return
 except ValueError as ex:
 raise validation_error(entity, {('value', 'subject'): str(ex)})
 if entity.for_user:
 for session in get_user_sessions(cnx.repo, entity.for_user[0].eid):
-_ChangeCWPropertyOp(cnx, cwpropdict=session.user.properties,
+_ChangeUserCWPropertyOp(cnx, session=session, key=key, value=value)
-key=key, value=value)
+else:
-else:
+_ChangeSiteWideCWPropertyOp(cnx, cwprop=self.entity)
-# site wide properties
-_ChangeCWPropertyOp(cnx, cwpropdict=cnx.vreg['propertyvalues'],
-key=key, value=value)
 class DeleteCWPropertyHook(AddCWPropertyHook):
 __regid__ = 'delcwprop'
 events = ('before_delete_entity',)
 for eidfrom, rtype, eidto in cnx.transaction_data.get('pendingrelations', ()):
 if rtype == 'for_user' and eidfrom == self.entity.eid:
 # if for_user was set, delete already handled by hook on for_user deletion
 break
 else:
-_DelCWPropertyOp(cnx, cwpropdict=cnx.vreg['propertyvalues'],
+_DelSiteWideCWPropertyOp(cnx, key=self.entity.pkey)
-key=self.entity.pkey)
 class AddForUserRelationHook(SyncSessionHook):
 __regid__ = 'addcwpropforuser'
 __select__ = SyncSessionHook.__select__ & hook.match_rtype('for_user')
 {'x': eidfrom})[0]
 if cnx.vreg.property_info(key)['sitewide']:
 msg = _("site-wide property can't be set for user")
 raise validation_error(eidfrom, {('for_user', 'subject'): msg})
 for session in get_user_sessions(cnx.repo, self.eidto):
-_ChangeCWPropertyOp(cnx, cwpropdict=session.user.properties,
+_ChangeUserCWPropertyOp(cnx, session=session, key=key, value=value)
-key=key, value=value)
 class DelForUserRelationHook(AddForUserRelationHook):
 __regid__ = 'delcwpropforuser'
 events = ('after_delete_relation',)
 cnx = self._cw
 key = cnx.execute('Any K WHERE P eid %(x)s, P pkey K', {'x': self.eidfrom})[0][0]
 cnx.transaction_data.setdefault('pendingrelations', []).append(
 (self.eidfrom, self.rtype, self.eidto))
 for session in get_user_sessions(cnx.repo, self.eidto):
-_DelCWPropertyOp(cnx, cwpropdict=session.user.properties, key=key)
+_DelUserCWPropertyOp(cnx, session=session, key=key)

changeset 11699	b48020a80dc3
parent 11348	70337ad23145
child 11700	41ddaf6802f0