cubicweb: comparison server/session.py

equal deleted inserted replaced

-:5d10ee381e67
+:21edcb0a5ed7
 :attr:`_threads_in_transaction` is a set of (thread, connections set)
 referencing threads that currently hold a connections set for the session.
 .. automethod:: cubicweb.server.session.transaction
 You should not have to use neither :attr:`_tx` nor :attr:`__threaddata`,
-simply access transaction data transparently through the :attr:`_threaddata`
+simply access transaction data transparently through the :attr:`_tx`
 property. Also, you usually don't have to access it directly since current
 transaction's data may be accessed/modified through properties / methods:
 :attr:`transaction_data`, similarly to :attr:`data`, is a dictionary
 containing some shared data that should be cleared at the end of the
 rewriter = RQLRewriter(self)
 tx = Transaction(txid, self.default_mode, rewriter)
 self.__threaddata.tx = self._txs[txid] = tx
 @property
-def _threaddata(self):
+def _tx(self):
 try:
 return self.__threaddata.tx
 except AttributeError:
 self.set_tx()
 return self.__threaddata.tx
 def hijack_user(self, user):
 """return a fake request/session using specified user"""
 session = Session(user, self.repo)
-threaddata = session._threaddata
+tx = session._tx
-threaddata.cnxset = self.cnxset
+tx.cnxset = self.cnxset
 # we attributed a connections set, need to update ctx_count else it will be freed
 # while undesired
-threaddata.ctx_count = 1
+tx.ctx_count = 1
 # share pending_operations, else operation added in the hi-jacked
 # session such as SendMailOp won't ever be processed
-threaddata.pending_operations = self.pending_operations
+tx.pending_operations = self.pending_operations
 # everything in transaction_data should be copied back but the entity
 # type cache we don't want to avoid security pb
-threaddata.transaction_data = self.transaction_data.copy()
+tx.transaction_data = self.transaction_data.copy()
-threaddata.transaction_data.pop('ecache', None)
+tx.transaction_data.pop('ecache', None)
 return session
 def add_relation(self, fromeid, rtype, toeid):
 """provide direct access to the repository method to add a relation.
 oldread = self.set_read_security(read)
 if write is None:
 oldwrite = None
 else:
 oldwrite = self.set_write_security(write)
-self._threaddata.ctx_count += 1
+self._tx.ctx_count += 1
 return oldread, oldwrite
 def reset_security(self, read, write):
-txstore = self._threaddata
+txstore = self._tx
 txstore.ctx_count -= 1
 if txstore.ctx_count == 0:
 self._clear_thread_storage(txstore)
 else:
 if read is not None:
 self.set_write_security(write)
 @property
 def read_security(self):
 """return a boolean telling if read security is activated or not"""
-txstore = self._threaddata
+txstore = self._tx
 if txstore is None:
 return DEFAULT_SECURITY
 return txstore.read_security
 def set_read_security(self, activated):
 later restoration.
 you should usually use the `security_enabled` context manager instead
 of this to change security settings.
 """
-txstore = self._threaddata
+txstore = self._tx
 if txstore is None:
 return DEFAULT_SECURITY
 oldmode = txstore.read_security
 txstore.read_security = activated
 # dbapi_query used to detect hooks triggered by a 'dbapi' query (eg not
 return oldmode
 @property
 def write_security(self):
 """return a boolean telling if write security is activated or not"""
-txstore = self._threaddata
+txstore = self._tx
 if txstore is None:
 return DEFAULT_SECURITY
 return txstore.write_security
 def set_write_security(self, activated):
 later restoration.
 you should usually use the `security_enabled` context manager instead
 of this to change security settings.
 """
-txstore = self._threaddata
+txstore = self._tx
 if txstore is None:
 return DEFAULT_SECURITY
 oldmode = txstore.write_security
 txstore.write_security = activated
 return oldmode
 """return a boolean telling if it's triggered by a db-api query or by
 a session query.
 To be used in hooks, else may have a wrong value.
 """
-return getattr(self._threaddata, 'dbapi_query', True)
+return getattr(self._tx, 'dbapi_query', True)
 # hooks activation control #################################################
 # all hooks should be activated during normal execution
 def allow_all_hooks_but(self, *categories):
 def deny_all_hooks_but(self, *categories):
 return hooks_control(self, HOOKS_DENY_ALL, *categories)
 @property
 def hooks_mode(self):
-return self._threaddata.hooks_mode
+return self._tx.hooks_mode
 def set_hooks_mode(self, mode):
 assert mode is HOOKS_ALLOW_ALL or mode is HOOKS_DENY_ALL
-oldmode = self._threaddata.hooks_mode
+oldmode = self._tx.hooks_mode
-self._threaddata.hooks_mode = mode
+self._tx.hooks_mode = mode
 return oldmode
 def init_hooks_mode_categories(self, mode, categories):
 oldmode = self.set_hooks_mode(mode)
 if mode is self.HOOKS_DENY_ALL:
 changes = self.enable_hook_categories(*categories)
 else:
 changes = self.disable_hook_categories(*categories)
-self._threaddata.ctx_count += 1
+self._tx.ctx_count += 1
 return oldmode, changes
 def reset_hooks_mode_categories(self, oldmode, mode, categories):
-txstore = self._threaddata
+txstore = self._tx
 txstore.ctx_count -= 1
 if txstore.ctx_count == 0:
 self._clear_thread_storage(txstore)
 else:
 try:
 finally:
 self.set_hooks_mode(oldmode)
 @property
 def disabled_hook_categories(self):
-return self._threaddata.disabled_hook_cats
+return self._tx.disabled_hook_cats
 @property
 def enabled_hook_categories(self):
-return self._threaddata.enabled_hook_cats
+return self._tx.enabled_hook_cats
 def disable_hook_categories(self, *categories):
 """disable the given hook categories:
 - on HOOKS_DENY_ALL mode, ensure those categories are not enabled
 self.default_mode = 'transaction'
 else: # mode == 'write'
 self.default_mode = 'read'
 def get_mode(self):
-return self._threaddata.mode
+return self._tx.mode
 def set_mode(self, value):
-self._threaddata.mode = value
+self._tx.mode = value
 mode = property(get_mode, set_mode,
 doc='transaction mode (read/write/transaction), resetted to'
 ' default_mode on commit / rollback')
 def get_commit_state(self):
-return self._threaddata.commit_state
+return self._tx.commit_state
 def set_commit_state(self, value):
-self._threaddata.commit_state = value
+self._tx.commit_state = value
 commit_state = property(get_commit_state, set_commit_state)
 @property
 def cnxset(self):
 """connections set, set according to transaction mode for each query"""
 if self._closed:
 self.free_cnxset(True)
 raise Exception('try to access connections set on a closed session %s' % self.id)
-return getattr(self._threaddata, 'cnxset', None)
+return getattr(self._tx, 'cnxset', None)
 def set_cnxset(self):
 """the session need a connections set to execute some queries"""
 with self._closed_lock:
 if self._closed:
 self.free_cnxset(True)
 raise Exception('try to set connections set on a closed session %s' % self.id)
 if self.cnxset is None:
 # get connections set first to avoid race-condition
-self._threaddata.cnxset = cnxset = self.repo._get_cnxset()
+self._tx.cnxset = cnxset = self.repo._get_cnxset()
-self._threaddata.ctx_count += 1
+self._tx.ctx_count += 1
 try:
 cnxset.cnxset_set()
 except Exception:
-self._threaddata.cnxset = None
+self._tx.cnxset = None
 self.repo._free_cnxset(cnxset)
 raise
 self._threads_in_transaction.add(
 (threading.currentThread(), cnxset) )
-return self._threaddata.cnxset
+return self._tx.cnxset
 def _free_thread_cnxset(self, thread, cnxset, force_close=False):
 try:
 self._threads_in_transaction.remove( (thread, cnxset) )
 except KeyError:
 def free_cnxset(self, ignoremode=False):
 """the session 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 = getattr(self._threaddata, 'cnxset', None)
+cnxset = getattr(self._tx, 'cnxset', None)
 if cnxset is not None and (ignoremode or self.mode == 'read'):
 # even in read mode, we must release the current transaction
 self._free_thread_cnxset(threading.currentThread(), cnxset)
-del self._threaddata.cnxset
+del self._tx.cnxset
-self._threaddata.ctx_count -= 1
+self._tx.ctx_count -= 1
 def _touch(self):
 """update latest session usage timestamp and reset mode to read"""
 self.timestamp = time()
 self.local_perm_cache.clear() # XXX simply move in transaction_data, no?
 if reset_pool is not None:
 warn('[3.13] use free_cnxset argument instead for reset_pool',
 DeprecationWarning, stacklevel=2)
 free_cnxset = reset_pool
 # don't use self.cnxset, rollback may be called with _closed == True
-cnxset = getattr(self._threaddata, 'cnxset', None)
+cnxset = getattr(self._tx, 'cnxset', None)
 if cnxset is None:
 self._clear_thread_data()
 self._touch()
 self.debug('rollback session %s done (no db activity)', self.id)
 return
 # transaction data/operations management ##################################
 @property
 def transaction_data(self):
-return self._threaddata.transaction_data
+return self._tx.transaction_data
 @property
 def pending_operations(self):
-return self._threaddata.pending_operations
+return self._tx.pending_operations
 @property
 def pruned_hooks_cache(self):
-return self._threaddata.pruned_hooks_cache
+return self._tx.pruned_hooks_cache
 def add_operation(self, operation, index=None):
 """add an operation"""
 if index is None:
 self.pending_operations.append(operation)
 # querier helpers #########################################################
 @property
 def rql_rewriter(self):
 # in thread local storage since the rewriter isn't thread safe
-return self._threaddata._rewriter
+return self._tx._rewriter
 # deprecated ###############################################################
 @deprecated('[3.13] use getattr(session.rtype_eids_rdef(rtype, eidfrom, eidto), prop)')
 def schema_rproperty(self, rtype, eidfrom, eidto, rprop):
 def cnxset(self):
 """connections set, set according to transaction mode for each query"""
 if self.repo.shutting_down:
 self.free_cnxset(True)
 raise ShuttingDown('repository is shutting down')
-return getattr(self._threaddata, 'cnxset', None)
+return getattr(self._tx, 'cnxset', None)
 class InternalManager(object):
 """a manager user with all access rights used internally for task such as
 bootstrapping the repository or creating regular users according to

changeset 8773	21edcb0a5ed7
parent 8772	5d10ee381e67
child 8774	608fdcab6fa1