cubicweb: comparison server/repository.py

equal deleted inserted replaced

-:7df3494ae657
+:04034421b072
 from cubicweb.server.utils import RepoThread, LoopTask
 from cubicweb.server.pool import ConnectionsPool, LateOperation, SingleLastOperation
 from cubicweb.server.session import Session, InternalSession
 from cubicweb.server.querier import QuerierHelper
 from cubicweb.server.sources import get_source
-from cubicweb.server.hooksmanager import HooksManager
 from cubicweb.server.hookhelper import rproperty
 class CleanupEidTypeCacheOp(SingleLastOperation):
 """on rollback of a insert query or commit of delete query, we have to
 self.sources.insert(0, self.system_source)
 # cache eid -> type / source
 self._type_source_cache = {}
 # cache (extid, source uri) -> eid
 self._extid_cache = {}
-# create the hooks manager
-self.hm = HooksManager(self.schema)
 # open some connections pools
 self._available_pools = Queue.Queue()
 self._available_pools.put_nowait(ConnectionsPool(self.sources))
 if config.read_instance_schema:
 # normal start: load the instance schema from the database
 self.fill_schema()
 elif config.bootstrap_schema:
 # usually during repository creation
 self.warning("set fs instance'schema as bootstrap schema")
 config.bootstrap_cubes()
-self.set_bootstrap_schema(self.config.load_schema())
+self.set_schema(self.config.load_schema(), resetvreg=False)
 # need to load the Any and CWUser entity types
 self.vreg.schema = self.schema
 etdirectory = join(CW_SOFTWARE_ROOT, 'entities')
 self.vreg.init_registration([etdirectory])
 self.vreg.load_file(join(etdirectory, '__init__.py'),
 self.pools = []
 for i in xrange(config['connections-pool-size']):
 self.pools.append(ConnectionsPool(self.sources))
 self._available_pools.put_nowait(self.pools[-1])
 self._shutting_down = False
+self.hm = vreg['hooks']
 if not (config.creating or config.repairing):
 # call instance level initialisation hooks
 self.hm.call_hooks('server_startup', repo=self)
 # register a task to cleanup expired session
 self.looping_task(self.config['session-time']/3.,
 self.clean_sessions)
-CW_EVENT_MANAGER.bind('after-registry-load', self.reset_hooks)
 # internals ###############################################################
 def get_source(self, uri, source_config):
 source_config['uri'] = uri
 self.schema = schema
 if resetvreg:
 # full reload of all appobjects
 self.vreg.reset()
 self.vreg.set_schema(schema)
-self.reset_hooks()
-def reset_hooks(self):
-self.hm.set_schema(self.schema)
-self.hm.register_system_hooks(self.config)
-# instance specific hooks
-if self.config.instance_hooks:
-self.info('loading instance hooks')
-self.hm.register_hooks(self.config.load_hooks(self.vreg))
 def fill_schema(self):
 """lod schema from the repository"""
 from cubicweb.server.schemaserial import deserialize_schema
 self.info('loading schema from the repository')
 appschema = CubicWebSchema(self.config.appid)
-self.set_bootstrap_schema(self.config.load_bootstrap_schema())
+self.set_schema(self.config.load_bootstrap_schema(), resetvreg=False)
 self.debug('deserializing db schema into %s %#x', appschema.name, id(appschema))
 session = self.internal_session()
 try:
 try:
 deserialize_schema(appschema, session)
 import traceback
 traceback.print_exc()
 raise Exception('Is the database initialised ? (cause: %s)' %
 (ex.args and ex.args[0].strip() or 'unknown')), \
 None, sys.exc_info()[-1]
-self.info('set the actual schema')
-# XXX have to do this since CWProperty isn't in the bootstrap schema
-#     it'll be redone in set_schema
-self.set_bootstrap_schema(appschema)
-# 2.49 migration
-if exists(join(self.config.apphome, 'vc.conf')):
-session.set_pool()
-if not 'template' in file(join(self.config.apphome, 'vc.conf')).read():
-# remaning from cubicweb < 2.38...
-session.execute('DELETE CWProperty X WHERE X pkey "system.version.template"')
-session.commit()
 finally:
 session.close()
+self.set_schema(appschema)
 self.config.init_cubes(self.get_cubes())
-self.set_schema(appschema)
-def set_bootstrap_schema(self, schema):
-"""disable hooks when setting a bootstrap schema, but restore
-the configuration for the next time
-"""
-config = self.config
-# XXX refactor
-config.core_hooks = False
-config.usergroup_hooks = False
-config.schema_hooks = False
-config.notification_hooks = False
-config.instance_hooks = False
-self.set_schema(schema, resetvreg=False)
-config.core_hooks = True
-config.usergroup_hooks = True
-config.schema_hooks = True
-config.notification_hooks = True
-config.instance_hooks = True
 def start_looping_tasks(self):
 assert isinstance(self._looping_tasks, list), 'already started'
 for i, (interval, func, args) in enumerate(self._looping_tasks):
 self._looping_tasks[i] = task = LoopTask(interval, func, args)
 session = Session(user, self, cnxprops)
 user.cw_req = user.rset.req = session
 user.clear_related_cache()
 self._sessions[session.id] = session
 self.info('opened %s', session)
-self.hm.call_hooks('session_open', session=session)
+self.hm.call_hooks('session_open', session)
 # commit session at this point in case write operation has been done
 # during `session_open` hooks
 session.commit()
 return session.id
 """close the session with the given id"""
 session = self._get_session(sessionid, setpool=True,
 checkshuttingdown=checkshuttingdown)
 # operation uncommited before close are rollbacked before hook is called
 session.rollback()
-self.hm.call_hooks('session_close', session=session)
+self.hm.call_hooks('session_close', session)
 # commit session at this point in case write operation has been done
 # during `session_close` hooks
 session.commit()
 session.close()
 del self._sessions[sessionid]
 self._type_source_cache[eid] = (etype, source.uri, extid)
 if recreate:
 entity = source.before_entity_insertion(session, extid, etype, eid)
 entity._cw_recreating = True
 if source.should_call_hooks:
-self.hm.call_hooks('before_add_entity', etype, session, entity)
+self.hm.call_hooks('before_add_entity', session, entity=entity)
 # XXX add fti op ?
 source.after_entity_insertion(session, extid, entity)
 if source.should_call_hooks:
-self.hm.call_hooks('after_add_entity', etype, session, entity)
+self.hm.call_hooks('after_add_entity', session, entity=entity)
 if reset_pool:
 session.reset_pool()
 return eid
 if not insert:
 return
 eid = self.system_source.create_eid(session)
 self._extid_cache[cachekey] = eid
 self._type_source_cache[eid] = (etype, source.uri, extid)
 entity = source.before_entity_insertion(session, extid, etype, eid)
 if source.should_call_hooks:
-self.hm.call_hooks('before_add_entity', etype, session, entity)
+self.hm.call_hooks('before_add_entity', session, entity=entity)
 # XXX call add_info with complete=False ?
 self.add_info(session, entity, source, extid)
 source.after_entity_insertion(session, extid, entity)
 if source.should_call_hooks:
-self.hm.call_hooks('after_add_entity', etype, session, entity)
+self.hm.call_hooks('after_add_entity', session, entity=entity)
 else:
 # minimal meta-data
 session.execute('SET X is E WHERE X eid %(x)s, E name %(name)s',
 {'x': entity.eid, 'name': entity.id}, 'x')
 session.commit(reset_pool)
 print 'ADD entity', etype, entity.eid, dict(entity)
 entity._is_saved = False # entity has an eid but is not yet saved
 relations = []
 # if inlined relations are specified, fill entity's related cache to
 # avoid unnecessary queries
-for attr in entity.keys():
+entity.edited_attributes = set(entity)
+for attr in entity.edited_attributes:
 rschema = eschema.subject_relation(attr)
 if not rschema.is_final(): # inlined relation
 relations.append((attr, entity[attr]))
 if source.should_call_hooks:
-self.hm.call_hooks('before_add_entity', etype, session, entity)
+self.hm.call_hooks('before_add_entity', session, entity=entity)
-entity.edited_attributes = entity.keys()
 entity.set_defaults()
 entity.check(creation=True)
 source.add_entity(session, entity)
 if source.uri != 'system':
 extid = source.get_extid(entity)
 # set inline relation cache before call to after_add_entity
 for attr, value in relations:
 session.update_rel_cache_add(entity.eid, attr, value)
 # trigger after_add_entity after after_add_relation
 if source.should_call_hooks:
-self.hm.call_hooks('after_add_entity', etype, session, entity)
+self.hm.call_hooks('after_add_entity', session, entity=entity)
 # call hooks for inlined relations
 for attr, value in relations:
-self.hm.call_hooks('before_add_relation', attr, session,
+self.hm.call_hooks('before_add_relation', session,
-entity.eid, attr, value)
+eidfrom=entity.eid, rtype=attr, eidto=value)
-self.hm.call_hooks('after_add_relation', attr, session,
+self.hm.call_hooks('after_add_relation', session,
-entity.eid, attr, value)
+eidfrom=entity.eid, rtype=attr, eidto=value)
 return entity.eid
 def glob_update_entity(self, session, entity, edited_attributes):
 """replace an entity in the repository
 the type and the eid of an entity must not be changed
 if previous_value:
 previous_value = previous_value[0][0] # got a result set
 if previous_value == entity[attr]:
 previous_value = None
 else:
-self.hm.call_hooks('before_delete_relation', attr,
+self.hm.call_hooks('before_delete_relation', session,
-session, entity.eid, attr,
+eidfrom=entity.eid, rtype=attr,
-previous_value)
+eidto=previous_value)
 relations.append((attr, entity[attr], previous_value))
 source = self.source_from_eid(entity.eid, session)
 if source.should_call_hooks:
 # call hooks for inlined relations
 for attr, value, _ in relations:
-self.hm.call_hooks('before_add_relation', attr, session,
+self.hm.call_hooks('before_add_relation', session,
-entity.eid, attr, value)
+eidfrom=entity.eid, rtype=attr, eidto=value)
 if not only_inline_rels:
-self.hm.call_hooks('before_update_entity', etype, session,
+self.hm.call_hooks('before_update_entity', session, entity=entity)
-entity)
 source.update_entity(session, entity)
 if not only_inline_rels:
 if need_fti_update and self.do_fti:
 # reindex the entity only if this query is updating at least
 # one indexable attribute
 FTIndexEntityOp(session, entity=entity)
 if source.should_call_hooks:
-self.hm.call_hooks('after_update_entity', etype, session,
+self.hm.call_hooks('after_update_entity', session, entity=entity)
-entity)
 if source.should_call_hooks:
 for attr, value, prevvalue in relations:
 # if the relation is already cached, update existant cache
 relcache = entity.relation_cached(attr, 'subject')
 if prevvalue:
-self.hm.call_hooks('after_delete_relation', attr, session,
+self.hm.call_hooks('after_delete_relation', session,
-entity.eid, attr, prevvalue)
+eidfrom=entity.eid, rtype=attr, eidto=prevvalue)
 if relcache is not None:
 session.update_rel_cache_del(entity.eid, attr, prevvalue)
 del_existing_rel_if_needed(session, entity.eid, attr, value)
 if relcache is not None:
 session.update_rel_cache_add(entity.eid, attr, value)
 else:
 entity.set_related_cache(attr, 'subject',
 session.eid_rset(value))
-self.hm.call_hooks('after_add_relation', attr, session,
+self.hm.call_hooks('after_add_relation', session,
-entity.eid, attr, value)
+eidfrom=entity.eid, rtype=attr, eidto=value)
 def glob_delete_entity(self, session, eid):
 """delete an entity and all related entities from the repository"""
 # call delete_info before hooks
 self._prepare_delete_info(session, eid)
 print 'DELETE entity', etype, eid
 if eid == 937:
 server.DEBUG |= (server.DBG_SQL | server.DBG_RQL | server.DBG_MORE)
 source = self.sources_by_uri[uri]
 if source.should_call_hooks:
-self.hm.call_hooks('before_delete_entity', etype, session, eid)
+entity = session.entity_from_eid(eid)
+self.hm.call_hooks('before_delete_entity', session, entity=entity)
 self._delete_info(session, eid)
 source.delete_entity(session, etype, eid)
 if source.should_call_hooks:
-self.hm.call_hooks('after_delete_entity', etype, session, eid)
+self.hm.call_hooks('after_delete_entity', session, entity=entity)
 # don't clear cache here this is done in a hook on commit
 def glob_add_relation(self, session, subject, rtype, object):
 """add a relation to the repository"""
 if server.DEBUG & server.DBG_REPO:
 print 'ADD relation', subject, rtype, object
 source = self.locate_relation_source(session, subject, rtype, object)
 if source.should_call_hooks:
 del_existing_rel_if_needed(session, subject, rtype, object)
-self.hm.call_hooks('before_add_relation', rtype, session,
+self.hm.call_hooks('before_add_relation', session,
-subject, rtype, object)
+eidfrom=subject, rtype=rtype, eidto=object)
 source.add_relation(session, subject, rtype, object)
 rschema = self.schema.rschema(rtype)
 session.update_rel_cache_add(subject, rtype, object, rschema.symetric)
 if source.should_call_hooks:
-self.hm.call_hooks('after_add_relation', rtype, session,
+self.hm.call_hooks('after_add_relation', session,
-subject, rtype, object)
+eidfrom=subject, rtype=rtype, eidto=object)
 def glob_delete_relation(self, session, subject, rtype, object):
 """delete a relation from the repository"""
 if server.DEBUG & server.DBG_REPO:
 print 'DELETE relation', subject, rtype, object
 source = self.locate_relation_source(session, subject, rtype, object)
 if source.should_call_hooks:
-self.hm.call_hooks('before_delete_relation', rtype, session,
+self.hm.call_hooks('before_delete_relation', session,
-subject, rtype, object)
+eidfrom=subject, rtype=rtype, eidto=object)
 source.delete_relation(session, subject, rtype, object)
 rschema = self.schema.rschema(rtype)
 session.update_rel_cache_del(subject, rtype, object, rschema.symetric)
 if rschema.symetric:
 # on symetric relation, we can't now in which sense it's
 # stored so try to delete both
 source.delete_relation(session, object, rtype, subject)
 if source.should_call_hooks:
-self.hm.call_hooks('after_delete_relation', rtype, session,
+self.hm.call_hooks('after_delete_relation', session,
-subject, rtype, object)
+eidfrom=subject, rtype=rtype, eidto=object)
 # pyro handling ###########################################################
 def pyro_register(self, host=''):

changeset 2835	04034421b072
parent 2822	f26578339214
child 2839	6419af16faa0