cubicweb: comparison server/session.py

equal deleted inserted replaced

-:9c867d852067
+:c859c7cef346
 from logilab.common.deprecation import deprecated
 from logilab.common.textutils import unormalize
 from logilab.common.registry import objectify_predicate
-from cubicweb import UnknownEid, QueryError, schema, server
+from cubicweb import UnknownEid, QueryError, schema, server, ProgrammingError
 from cubicweb.req import RequestSessionBase
 from cubicweb.utils import make_uid
 from cubicweb.rqlrewrite import RQLRewriter
 from cubicweb.server import ShuttingDown
 from cubicweb.server.edition import EditedEntity
 def wrapper(cnx, *args, **kwargs):
 with cnx.ensure_cnx_set:
 return func(cnx, *args, **kwargs)
 return wrapper
+def _open_only(func):
+"""decorator for Connection method that check it is open"""
+@functools.wraps(func)
+def check_open(cnx, *args, **kwargs):
+if not cnx._open:
+raise ProgrammingError('Closed Connection: %s'
+% cnx.connectionid)
+return func(cnx, *args, **kwargs)
+return check_open
 class Connection(RequestSessionBase):
 """Repository Connection
 Holds all connection related data
 @property
 def rql_rewriter(self):
 return self._rewriter
+@_open_only
 def get_shared_data(self, key, default=None, pop=False, txdata=False):
 """return value associated to `key` in session data"""
 if txdata:
 data = self.transaction_data
 else:
 if pop:
 return data.pop(key, default)
 else:
 return data.get(key, default)
+@_open_only
 def set_shared_data(self, key, value, txdata=False):
 """set value associated to `key` in session data"""
 if txdata:
 self.transaction_data[key] = value
 else:
 self.local_perm_cache.clear()
 self.rewriter = RQLRewriter(self)
 # Connection Set Management ###############################################
 @property
+@_open_only
 def cnxset(self):
 return self._cnxset
 @cnxset.setter
+@_open_only
 def cnxset(self, new_cnxset):
 with self._cnxset_tracker:
 old_cnxset = self._cnxset
 if new_cnxset is old_cnxset:
 return #nothing to do
 if new_cnxset is not None:
 self._cnxset_tracker.record(self.connectionid, new_cnxset)
 self._cnxset = new_cnxset
 self.ctx_count += 1
+@_open_only
 def _set_cnxset(self):
 """the connection need a connections set to execute some queries"""
 if self.cnxset is None:
 cnxset = self.repo._get_cnxset()
 try:
 except:
 self.repo._free_cnxset(cnxset)
 raise
 return self.cnxset
+@_open_only
 def _free_cnxset(self, ignoremode=False):
 """the connection is no longer using its connections set, at least for some time"""
 # cnxset may be none if no operation has been done since last commit
 # or rollback
 cnxset = self.cnxset
 return self._free_cnxset(ignoremode=ignoremode)
 @property
 @contextmanager
+@_open_only
 def ensure_cnx_set(self):
 assert self._cnxset_count >= 0
 if self._cnxset_count == 0:
 self._set_cnxset()
 try:
 # an acceptable risk. Anyway we could activate it or not according to a
 # configuration option
 def set_entity_cache(self, entity):
 """Add `entity` to the connection entity cache"""
+#XXX not using _open_only because before at creation time. _set_user
+# call this function to cache the Connection user.
+if entity.cw_etype != 'CWUser' and not self._open:
+raise ProgrammingError('Closed Connection: %s'
+% self.connectionid)
 ecache = self.transaction_data.setdefault('ecache', {})
 ecache.setdefault(entity.eid, entity)
+@_open_only
 def entity_cache(self, eid):
 """get cache entity for `eid`"""
 return self.transaction_data['ecache'][eid]
+@_open_only
 def cached_entities(self):
 """return the whole entity cache"""
 return self.transaction_data.get('ecache', {}).values()
+@_open_only
 def drop_entity_cache(self, eid=None):
 """drop entity from the cache
 If eid is None, the whole cache is dropped"""
 if eid is None:
 else:
 del self.transaction_data['ecache'][eid]
 # relations handling #######################################################
+@_open_only
 def add_relation(self, fromeid, rtype, toeid):
 """provide direct access to the repository method to add a relation.
 This is equivalent to the following rql query:
 You may use this in hooks when you know both eids of the relation you
 want to add.
 """
 self.add_relations([(rtype, [(fromeid,  toeid)])])
+@_open_only
 def add_relations(self, relations):
 '''set many relation using a shortcut similar to the one in add_relation
 relations is a list of 2-uples, the first element of each
 2-uple is the rtype, and the second is a list of (fromeid,
 self.repo.glob_add_relations(self, relations_dict)
 for edited in edited_entities.itervalues():
 self.repo.glob_update_entity(self, edited)
+@_open_only
 def delete_relation(self, fromeid, rtype, toeid):
 """provide direct access to the repository method to delete a relation.
 This is equivalent to the following rql query:
 else:
 self.repo.glob_delete_relation(self, fromeid, rtype, toeid)
 # relations cache handling #################################################
+@_open_only
 def update_rel_cache_add(self, subject, rtype, object, symmetric=False):
 self._update_entity_rel_cache_add(subject, rtype, 'subject', object)
 if symmetric:
 self._update_entity_rel_cache_add(object, rtype, 'subject', subject)
 else:
 self._update_entity_rel_cache_add(object, rtype, 'object', subject)
+@_open_only
 def update_rel_cache_del(self, subject, rtype, object, symmetric=False):
 self._update_entity_rel_cache_del(subject, rtype, 'subject', object)
 if symmetric:
 self._update_entity_rel_cache_del(object, rtype, 'object', object)
 else:
 self._update_entity_rel_cache_del(object, rtype, 'object', subject)
+@_open_only
 def _update_entity_rel_cache_add(self, eid, rtype, role, targeteid):
 try:
 entity = self.entity_cache(eid)
 except KeyError:
 return
 rset.rowcount += 1
 entities.append(targetentity)
 entity._cw_related_cache['%s_%s' % (rtype, role)] = (
 rset, tuple(entities))
+@_open_only
 def _update_entity_rel_cache_del(self, eid, rtype, role, targeteid):
 try:
 entity = self.entity_cache(eid)
 except KeyError:
 return
 # Tracking of entity added of removed in the transaction ##################
 #
 # Those are function to  allows cheap call from client in other process.
+@_open_only
 def deleted_in_transaction(self, eid):
 """return True if the entity of the given eid is being deleted in the
 current transaction
 """
 return eid in self.transaction_data.get('pendingeids', ())
+@_open_only
 def added_in_transaction(self, eid):
 """return True if the entity of the given eid is being created in the
 current transaction
 """
 return eid in self.transaction_data.get('neweids', ())
 # Operation management ####################################################
+@_open_only
 def add_operation(self, operation, index=None):
 """add an operation to be executed at the end of the transaction"""
 if index is None:
 self.pending_operations.append(operation)
 else:
 self.pending_operations.insert(index, operation)
 # Hooks control ###########################################################
+@_open_only
 def allow_all_hooks_but(self, *categories):
 return _hooks_control(self, HOOKS_ALLOW_ALL, *categories)
+@_open_only
 def deny_all_hooks_but(self, *categories):
 return _hooks_control(self, HOOKS_DENY_ALL, *categories)
+@_open_only
 def disable_hook_categories(self, *categories):
 """disable the given hook categories:
 - on HOOKS_DENY_ALL mode, ensure those categories are not enabled
 - on HOOKS_ALLOW_ALL mode, ensure those categories are disabled
 disabledcats = self.disabled_hook_cats
 changes = categories - disabledcats
 disabledcats |= changes # changes is small hence faster
 return tuple(changes)
+@_open_only
 def enable_hook_categories(self, *categories):
 """enable the given hook categories:
 - on HOOKS_DENY_ALL mode, ensure those categories are enabled
 - on HOOKS_ALLOW_ALL mode, ensure those categories are not disabled
 disabledcats = self.disabled_hook_cats
 changes = disabledcats & categories
 disabledcats -= changes # changes is small hence faster
 return tuple(changes)
+@_open_only
 def is_hook_category_activated(self, category):
 """return a boolean telling if the given category is currently activated
 or not
 """
 if self.hooks_mode is HOOKS_DENY_ALL:
 return category in self.enabled_hook_cats
 return category not in self.disabled_hook_cats
+@_open_only
 def is_hook_activated(self, hook):
 """return a boolean telling if the given hook class is currently
 activated or not
 """
 return self.is_hook_category_activated(hook.category)
 # Security management #####################################################
+@_open_only
 def security_enabled(self, read=None, write=None):
 return _security_enabled(self, read=read, write=write)
 @property
+@_open_only
 def read_security(self):
 return self._read_security
 @read_security.setter
+@_open_only
 def read_security(self, activated):
 oldmode = self._read_security
 self._read_security = activated
 # running_dbapi_query used to detect hooks triggered by a 'dbapi' query
 # (eg not issued on the session). This is tricky since we the execution
 self.running_dbapi_query = (oldmode is DEFAULT_SECURITY
 or activated is DEFAULT_SECURITY)
 # undo support ############################################################
+@_open_only
 def ertype_supports_undo(self, ertype):
 return self.undo_actions and ertype not in NO_UNDO_TYPES
+@_open_only
 def transaction_uuid(self, set=True):
 uuid = self.transaction_data.get('tx_uuid')
 if set and uuid is None:
 self.transaction_data['tx_uuid'] = uuid = uuid4().hex
 self.repo.system_source.start_undoable_transaction(self, uuid)
 return uuid
+@_open_only
 def transaction_inc_action_counter(self):
 num = self.transaction_data.setdefault('tx_action_count', 0) + 1
 self.transaction_data['tx_action_count'] = num
 return num
 # db-api like interface ###################################################
+@_open_only
 def source_defs(self):
 return self.repo.source_defs()
 @_with_cnx_set
+@_open_only
 def describe(self, eid, asdict=False):
 """return a tuple (type, sourceuri, extid) for the entity with id <eid>"""
 metas = self.repo.type_and_source_from_eid(eid, self)
 if asdict:
 return dict(zip(('type', 'source', 'extid', 'asource'), metas))
 # XXX :-1 for cw compat, use asdict=True for full information
 return metas[:-1]
 @_with_cnx_set
+@_open_only
 def source_from_eid(self, eid):
 """return the source where the entity with id <eid> is located"""
 return self.repo.source_from_eid(eid, self)
 # core method #############################################################
 @_with_cnx_set
+@_open_only
 def execute(self, rql, kwargs=None, eid_key=None, build_descr=True):
 """db-api like method directly linked to the querier execute method.
 See :meth:`cubicweb.dbapi.Cursor.execute` documentation.
 """
 rset = self._execute(self, rql, kwargs, build_descr)
 rset.req = self
 self._session_timestamp.touch()
 return rset
+@_open_only
 def rollback(self, free_cnxset=True, reset_pool=None):
 """rollback the current transaction"""
 if reset_pool is not None:
 warn('[3.13] use free_cnxset argument instead for reset_pool',
 DeprecationWarning, stacklevel=2)
 self._session_timestamp.touch()
 if free_cnxset:
 self.free_cnxset(ignoremode=True)
 self.clear()
+@_open_only
 def commit(self, free_cnxset=True, reset_pool=None):
 """commit the current session's transaction"""
 if reset_pool is not None:
 warn('[3.13] use free_cnxset argument instead for reset_pool',
 DeprecationWarning, stacklevel=2)
 self.clear()
 # resource accessors ######################################################
 @_with_cnx_set
+@_open_only
 def call_service(self, regid, **kwargs):
 json.dumps(kwargs) # This line ensure that people use serialisable
 # argument for call service. this is very important
 # to enforce that from start to make sure RPC
 # version is available.
 # from start to make sure RPC version is
 # available.
 return result
 @_with_cnx_set
+@_open_only
 def system_sql(self, sql, args=None, rollback_on_failure=True):
 """return a sql cursor on the system database"""
 if sql.split(None, 1)[0].upper() != 'SELECT':
 self.mode = 'write'
 source = self.cnxset.source('system')
 raise
 source.warning("trying to reconnect")
 self.cnxset.reconnect(source)
 return source.doexec(self, sql, args, rollback=rollback_on_failure)
+@_open_only
 def rtype_eids_rdef(self, rtype, eidfrom, eidto):
 # use type_and_source_from_eid instead of type_from_eid for optimization
 # (avoid two extra methods call)
 subjtype = self.repo.type_and_source_from_eid(eidfrom, self)[0]
 objtype = self.repo.type_and_source_from_eid(eidto, self)[0]

changeset 9112	c859c7cef346
parent 9110	ed8b383d94fd
child 9113	af6efc15fc90