cubicweb: comparison server/repository.py

equal deleted inserted replaced

-:04034421b072
+:6419af16faa0
 from cubicweb import (CW_SOFTWARE_ROOT, CW_MIGRATION_MAP, CW_EVENT_MANAGER,
 UnknownEid, AuthenticationError, ExecutionError,
 ETypeNotSupportedBySources, RTypeNotSupportedBySources,
 BadConnectionId, Unauthorized, ValidationError,
 typed_eid)
-from cubicweb.cwvreg import CubicWebVRegistry
+from cubicweb import cwvreg, schema, server
-from cubicweb.schema import VIRTUAL_RTYPES, CubicWebSchema
+from cubicweb.server import utils, hook, pool, querier, sources
-from cubicweb import server
-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.hookhelper import rproperty
+class CleanupEidTypeCacheOp(hook.SingleLastOperation):
-class CleanupEidTypeCacheOp(SingleLastOperation):
 """on rollback of a insert query or commit of delete query, we have to
 clear repository's cache from no more valid entries
 NOTE: querier's rqlst/solutions cache may have been polluted too with
 queries such as Any X WHERE X eid 32 if 32 has been rollbacked however
 self.repo.clear_caches(self.session.transaction_data['neweids'])
 except KeyError:
 pass
-class FTIndexEntityOp(LateOperation):
+class FTIndexEntityOp(hook.LateOperation):
 """operation to delay entity full text indexation to commit
 since fti indexing may trigger discovery of other entities, it should be
 triggered on precommit, not commit, and this should be done after other
 precommit operation which may add relations to the entity
 """
 # skip delete queries (only?) if session is an internal session. This is
 # hooks responsability to ensure they do not violate relation's cardinality
 if session.is_super_session:
 return
-card = rproperty(session, rtype, eidfrom, eidto, 'cardinality')
+card = session.schema_rproperty(rtype, eidfrom, eidto, 'cardinality')
 # one may be tented to check for neweids but this may cause more than one
 # relation even with '1?'  cardinality if thoses relations are added in the
 # same transaction where the entity is being created. This never occurs from
 # the web interface but may occurs during test or dbapi connection (though
 # not expected for this).  So: don't do it, we pretend to ensure repository
 """
 def __init__(self, config, vreg=None, debug=False):
 self.config = config
 if vreg is None:
-vreg = CubicWebVRegistry(config, debug)
+vreg = cwvreg.CubicWebVRegistry(config, debug)
 self.vreg = vreg
 self.pyro_registered = False
 self.info('starting repository from %s', self.config.apphome)
 # dictionary of opened sessions
 self._sessions = {}
 # list of functions to be called at regular interval
 self._looping_tasks = []
 # list of running threads
 self._running_threads = []
 # initial schema, should be build or replaced latter
-self.schema = CubicWebSchema(config.appid)
+self.schema = schema.CubicWebSchema(config.appid)
 # querier helper, need to be created after sources initialization
-self.querier = QuerierHelper(self, self.schema)
+self.querier = querier.QuerierHelper(self, self.schema)
 # should we reindex in changes?
 self.do_fti = not config['delay-full-text-indexation']
 # sources
 self.sources = []
 self.sources_by_uri = {}
 self._type_source_cache = {}
 # cache (extid, source uri) -> eid
 self._extid_cache = {}
 # open some connections pools
 self._available_pools = Queue.Queue()
-self._available_pools.put_nowait(ConnectionsPool(self.sources))
+self._available_pools.put_nowait(pool.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
 # initialization now that we know cubes
 self._get_pool().close(True)
 # list of available pools (we can't iterated on Queue instance)
 self.pools = []
 for i in xrange(config['connections-pool-size']):
-self.pools.append(ConnectionsPool(self.sources))
+self.pools.append(pool.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
 # internals ###############################################################
 def get_source(self, uri, source_config):
 source_config['uri'] = uri
-return get_source(source_config, self.schema, self)
+return sources.get_source(source_config, self.schema, self)
 def set_schema(self, schema, resetvreg=True):
 schema.rebuild_infered_relations()
 self.info('set schema %s %#x', schema.name, id(schema))
 self.debug(', '.join(sorted(str(e) for e in schema.entities())))
 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)
+appschema = schema.CubicWebSchema(self.config.appid)
 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:
 self.config.init_cubes(self.get_cubes())
 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)
+self._looping_tasks[i] = task = utils.LoopTask(interval, func, args)
 self.info('starting task %s with interval %.2fs', task.name,
 interval)
 task.start()
 # ensure no tasks will be further added
 self._looping_tasks = tuple(self._looping_tasks)
 except AttributeError:
 raise RuntimeError("can't add looping task once the repository is started")
 def threaded_task(self, func):
 """start function in a separated thread"""
-t = RepoThread(func, self._running_threads)
+t = utils.RepoThread(func, self._running_threads)
 t.start()
 #@locked
 def _get_pool(self):
 try:
 rql = []
 eschema = self.schema.eschema(etype)
 pendingrtypes = session.transaction_data.get('pendingrtypes', ())
 for rschema, targetschemas, x in eschema.relation_definitions():
 rtype = rschema.type
-if rtype in VIRTUAL_RTYPES or rtype in pendingrtypes:
+if rtype in schema.VIRTUAL_RTYPES or rtype in pendingrtypes:
 continue
 var = '%s%s' % (rtype.upper(), x.upper())
 if x == 'subject':
 # don't skip inlined relation so they are regularly
 # deleted and so hooks are correctly called
 entity._is_saved = True # entity has an eid and is saved
 # prefill entity relation caches
 session.set_entity_cache(entity)
 for rschema in eschema.subject_relations():
 rtype = str(rschema)
-if rtype in VIRTUAL_RTYPES:
+if rtype in schema.VIRTUAL_RTYPES:
 continue
 if rschema.is_final():
 entity.setdefault(rtype, None)
 else:
 entity.set_related_cache(rtype, 'subject', session.empty_rset())
 for rschema in eschema.object_relations():
 rtype = str(rschema)
-if rtype in VIRTUAL_RTYPES:
+if rtype in schema.VIRTUAL_RTYPES:
 continue
 entity.set_related_cache(rtype, 'object', session.empty_rset())
 # set inline relation cache before call to after_add_entity
 for attr, value in relations:
 session.update_rel_cache_add(entity.eid, attr, value)

changeset 2839	6419af16faa0
parent 2835	04034421b072
child 2847	c2ee28f4d4b1