cubicweb: comparison server/session.py

equal deleted inserted replaced

-:6a9e66d788b3
+:26695dd703d8
 self.transactionid = txid
 self.ctx_count = 0
 class Session(RequestSessionBase):
-"""tie session id, user, connections pool and other session data all
+"""Repository usersession, tie a session id, user, connections set and
-together
+other session data all together.
+About session storage / transactions
+------------------------------------
+Here is a description of internal session attributes. Besides :attr:`data`
+and :attr:`transaction_data`, you should not have to use attributes
+described here but higher level APIs.
+:attr:`data` is a dictionary containing shared data, used to communicate
+extra information between the client and the repository
+:attr:`_tx_data` is a dictionary of :class:`TransactionData` instance, one
+for each running transaction. The key is the transaction id. By default
+the transaction id is the thread name but it can be otherwise (per dbapi
+cursor for instance, or per thread name *from another process*).
+:attr:`__threaddata` is a thread local storage whose `txdata` attribute
+refers to the proper instance of :class:`TransactionData` according to the
+transaction.
+:attr:`_threads_in_transaction` is a set of (thread, connections set)
+referencing threads that currently hold a connections set for the session.
+You should not have to use neither :attr:`_txdata` nor :attr:`__threaddata`,
+simply access transaction data transparently through the :attr:`_threaddata`
+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
+transaction. Hooks and operations may put arbitrary data in there, and
+this may also be used as a communication channel between the client and
+the repository.
+:attr:`cnxset`, the connections set to use to execute queries on sources.
+During a transaction, the connection set may be freed so that is may be
+used by another session as long as no writing is done. This means we can
+have multiple sessions with a reasonably low connections set pool size.
+:attr:`mode`, string telling the connections set handling mode, may be one
+of 'read' (connections set may be freed), 'write' (some write was done in
+the connections set, it can't be freed before end of the transaction),
+'transaction' (we want to keep the connections set during all the
+transaction, with or without writing)
+:attr:`pending_operations`, ordered list of operations to be processed on
+commit/rollback
+:attr:`commit_state`, describing the transaction commit state, may be one
+of None (not yet committing), 'precommit' (calling precommit event on
+operations), 'postcommit' (calling postcommit event on operations),
+'uncommitable' (some :exc:`ValidationError` or :exc:`Unauthorized` error
+has been raised during the transaction and so it must be rollbacked).
+:attr:`read_security` and :attr:`write_security`, boolean flags telling if
+read/write security is currently activated.
+:attr:`hooks_mode`, may be either `HOOKS_ALLOW_ALL` or `HOOKS_DENY_ALL`.
+:attr:`enabled_hook_categories`, when :attr:`hooks_mode` is
+`HOOKS_DENY_ALL`, this set contains hooks categories that are enabled.
+:attr:`disabled_hook_categories`, when :attr:`hooks_mode` is
+`HOOKS_ALLOW_ALL`, this set contains hooks categories that are disabled.
+:attr:`running_dbapi_query`, boolean flag telling if the executing query
+is coming from a dbapi connection or is a query from within the repository
 """
 is_internal_session = False
 def __init__(self, user, repo, cnxprops=None, _id=None):
 super(Session, self).__init__(repo.vreg)
 def hijack_user(self, user):
 """return a fake request/session using specified user"""
 session = Session(user, self.repo)
 threaddata = session._threaddata
-threaddata.pool = self.pool
+threaddata.cnxset = self.cnxset
-# we attributed a pool, need to update ctx_count else it will be freed
+# we attributed a connections set, need to update ctx_count else it will be freed
 # while undesired
 threaddata.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
 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.pool.source('system')
+source = self.cnxset.source('system')
 try:
 return source.doexec(self, sql, args, rollback=rollback_on_failure)
 except (source.OperationalError, source.InterfaceError):
 if not rollback_on_failure:
 raise
 source.warning("trying to reconnect")
-self.pool.reconnect(source)
+self.cnxset.reconnect(source)
 return source.doexec(self, sql, args, rollback=rollback_on_failure)
 def set_language(self, language):
 """i18n configuration for translation"""
 language = language or self.user.property_value('ui.language')
 """
 return self.is_hook_category_activated(hook.category)
 # connection management ###################################################
-def keep_pool_mode(self, mode):
+def keep_cnxset_mode(self, mode):
-"""set pool_mode, e.g. how the session will keep its pool:
+"""set `mode`, e.g. how the session will keep its connections set:
-* if mode == 'write', the pool is freed after each ready query, but kept
+* if mode == 'write', the connections set is freed after each ready
-until the transaction's end (eg commit or rollback) when a write query
+query, but kept until the transaction's end (eg commit or rollback)
-is detected (eg INSERT/SET/DELETE queries)
+when a write query is detected (eg INSERT/SET/DELETE queries)
-* if mode == 'transaction', the pool is only freed after the
+* if mode == 'transaction', the connections set is only freed after the
 transaction's end
-notice that a repository has a limited set of pools, and a session has to
+notice that a repository has a limited set of connections sets, and a
-wait for a free pool to run any rql query (unless it already has a pool
+session has to wait for a free connections set to run any rql query
-set).
+(unless it already has one set).
 """
 assert mode in ('transaction', 'write')
 if mode == 'transaction':
 self.default_mode = 'transaction'
 else: # mode == 'write'
 def set_commit_state(self, value):
 self._threaddata.commit_state = value
 commit_state = property(get_commit_state, set_commit_state)
 @property
-def pool(self):
+def cnxset(self):
-"""connections pool, set according to transaction mode for each query"""
+"""connections set, set according to transaction mode for each query"""
 if self._closed:
-self.reset_pool(True)
+self.free_cnxset(True)
-raise Exception('try to access pool on a closed session')
+raise Exception('try to access connections set on a closed session')
-return getattr(self._threaddata, 'pool', None)
+return getattr(self._threaddata, 'cnxset', None)
-def set_pool(self):
+def set_cnxset(self):
-"""the session need a pool to execute some queries"""
+"""the session need a connections set to execute some queries"""
 with self._closed_lock:
 if self._closed:
-self.reset_pool(True)
+self.free_cnxset(True)
-raise Exception('try to set pool on a closed session')
+raise Exception('try to set connections set on a closed session')
-if self.pool is None:
+if self.cnxset is None:
-# get pool first to avoid race-condition
+# get connections set first to avoid race-condition
-self._threaddata.pool = pool = self.repo._get_pool()
+self._threaddata.cnxset = cnxset = self.repo._get_cnxset()
 self._threaddata.ctx_count += 1
 try:
-pool.pool_set()
+cnxset.cnxset_set()
 except:
-self._threaddata.pool = None
+self._threaddata.cnxset = None
-self.repo._free_pool(pool)
+self.repo._free_cnxset(cnxset)
 raise
 self._threads_in_transaction.add(
-(threading.currentThread(), pool) )
+(threading.currentThread(), cnxset) )
-return self._threaddata.pool
+return self._threaddata.cnxset
-def _free_thread_pool(self, thread, pool, force_close=False):
+def _free_thread_cnxset(self, thread, cnxset, force_close=False):
 try:
-self._threads_in_transaction.remove( (thread, pool) )
+self._threads_in_transaction.remove( (thread, cnxset) )
 except KeyError:
-# race condition on pool freeing (freed by commit or rollback vs
+# race condition on cnxset freeing (freed by commit or rollback vs
 # close)
 pass
 else:
 if force_close:
-pool.reconnect()
+cnxset.reconnect()
 else:
-pool.pool_reset()
+cnxset.cnxset_freed()
-# free pool once everything is done to avoid race-condition
+# free cnxset once everything is done to avoid race-condition
-self.repo._free_pool(pool)
+self.repo._free_cnxset(cnxset)
-def reset_pool(self, ignoremode=False):
+def free_cnxset(self, ignoremode=False):
-"""the session is no longer using its pool, at least for some time"""
+"""the session is no longer using its connections set, at least for some time"""
-# pool may be none if no operation has been done since last commit
+# cnxset may be none if no operation has been done since last commit
 # or rollback
-pool = getattr(self._threaddata, 'pool', None)
+cnxset = getattr(self._threaddata, 'cnxset', None)
-if pool is not None and (ignoremode or self.mode == 'read'):
+if cnxset is not None and (ignoremode or self.mode == 'read'):
 # even in read mode, we must release the current transaction
-self._free_thread_pool(threading.currentThread(), pool)
+self._free_thread_cnxset(threading.currentThread(), cnxset)
-del self._threaddata.pool
+del self._threaddata.cnxset
 self._threaddata.ctx_count -= 1
 def _touch(self):
 """update latest session usage timestamp and reset mode to read"""
 self.timestamp = time()
 self.timestamp = time() # update timestamp
 rset = self._execute(self, rql, kwargs, build_descr)
 rset.req = self
 return rset
-def _clear_thread_data(self, reset_pool=True):
+def _clear_thread_data(self, free_cnxset=True):
-"""remove everything from the thread local storage, except pool
+"""remove everything from the thread local storage, except connections set
-which is explicitly removed by reset_pool, and mode which is set anyway
+which is explicitly removed by free_cnxset, and mode which is set anyway
 by _touch
 """
 try:
 txstore = self.__threaddata.txdata
 except AttributeError:
 pass
 else:
-if reset_pool:
+if free_cnxset:
-self.reset_pool()
+self.free_cnxset()
 if txstore.ctx_count == 0:
 self._clear_thread_storage(txstore)
 else:
 self._clear_tx_storage(txstore)
 else:
 try:
 delattr(txstore, name)
 except AttributeError:
 continue
-def commit(self, reset_pool=True):
+def commit(self, free_cnxset=True, reset_pool=None):
 """commit the current session's transaction"""
-if self.pool is None:
+if reset_pool is not None:
+warn('[3.13] use free_cnxset argument instead for reset_pool',
+DeprecationWarning, stacklevel=2)
+free_cnxset = reset_pool
+if self.cnxset is None:
 assert not self.pending_operations
 self._clear_thread_data()
 self._touch()
 self.debug('commit session %s done (no db activity)', self.id)
 return
 self.critical('error while reverting precommit',
 exc_info=True)
 # XXX use slice notation since self.pending_operations is a
 # read-only property.
 self.pending_operations[:] = processed + self.pending_operations
-self.rollback(reset_pool)
+self.rollback(free_cnxset)
 raise
-self.pool.commit()
+self.cnxset.commit()
 self.commit_state = 'postcommit'
 while self.pending_operations:
 operation = self.pending_operations.pop(0)
 operation.processed = 'postcommit'
 try:
 exc_info=sys.exc_info())
 self.debug('postcommit session %s done', self.id)
 return self.transaction_uuid(set=False)
 finally:
 self._touch()
-if reset_pool:
+if free_cnxset:
-self.reset_pool(ignoremode=True)
+self.free_cnxset(ignoremode=True)
-self._clear_thread_data(reset_pool)
+self._clear_thread_data(free_cnxset)
-def rollback(self, reset_pool=True):
+def rollback(self, free_cnxset=True, reset_pool=None):
 """rollback the current session's transaction"""
-# don't use self.pool, rollback may be called with _closed == True
+if reset_pool is not None:
-pool = getattr(self._threaddata, 'pool', None)
+warn('[3.13] use free_cnxset argument instead for reset_pool',
-if pool is None:
+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)
+if cnxset is None:
 self._clear_thread_data()
 self._touch()
 self.debug('rollback session %s done (no db activity)', self.id)
 return
 try:
 operation = self.pending_operations.pop(0)
 operation.handle_event('rollback_event')
 except:
 self.critical('rollback error', exc_info=sys.exc_info())
 continue
-pool.rollback()
+cnxset.rollback()
 self.debug('rollback for session %s done', self.id)
 finally:
 self._touch()
-if reset_pool:
+if free_cnxset:
-self.reset_pool(ignoremode=True)
+self.free_cnxset(ignoremode=True)
-self._clear_thread_data(reset_pool)
+self._clear_thread_data(free_cnxset)
 def close(self):
-"""do not close pool on session close, since they are shared now"""
+"""do not close connections set on session close, since they are shared now"""
 with self._closed_lock:
 self._closed = True
 # copy since _threads_in_transaction maybe modified while waiting
-for thread, pool in self._threads_in_transaction.copy():
+for thread, cnxset in self._threads_in_transaction.copy():
 if thread is threading.currentThread():
 continue
 self.info('waiting for thread %s', thread)
 # do this loop/break instead of a simple join(10) in case thread is
 # the main thread (in which case it will be removed from
 # self._threads_in_transaction but still be alive...)
 for i in xrange(10):
 thread.join(1)
 if not (thread.isAlive() and
-(thread, pool) in self._threads_in_transaction):
+(thread, cnxset) in self._threads_in_transaction):
 break
 else:
 self.error('thread %s still alive after 10 seconds, will close '
 'session anyway', thread)
-self._free_thread_pool(thread, pool, force_close=True)
+self._free_thread_cnxset(thread, cnxset, force_close=True)
 self.rollback()
 del self.__threaddata
 del self._tx_data
 @property
 except AttributeError:
 self._threaddata.pruned_hooks_cache = {}
 return self._threaddata.pruned_hooks_cache
 def add_operation(self, operation, index=None):
-"""add an observer"""
+"""add an operation"""
-assert self.commit_state != 'commit'
 if index is None:
 self.pending_operations.append(operation)
 else:
 self.pending_operations.insert(index, operation)
 description.append(tuple(row_descr))
 return description
 # deprecated ###############################################################
+@property
+@deprecated("[3.13] use .cnxset attribute instead of .pool")
+def pool(self):
+return self.cnxset
+@deprecated("[3.13] use .set_cnxset() method instead of .set_pool()")
+def set_pool(self):
+return self.set_cnxset()
+@deprecated("[3.13] use .free_cnxset() method instead of .reset_pool()")
+def reset_pool(self):
+return self.free_cnxset()
 @deprecated("[3.7] execute is now unsafe by default in hooks/operation. You"
 " can also control security with the security_enabled context "
 "manager")
 def unsafe_execute(self, rql, kwargs=None, eid_key=None, build_descr=True,
 propagate=False):
 self.user._cw = self # XXX remove when "vreg = user._cw.vreg" hack in entity.py is gone
 self.cnxtype = 'inmemory'
 self.disable_hook_categories('integrity')
 @property
-def pool(self):
+def cnxset(self):
-"""connections pool, set according to transaction mode for each query"""
+"""connections set, set according to transaction mode for each query"""
 if self.repo.shutting_down:
-self.reset_pool(True)
+self.free_cnxset(True)
 raise Exception('repository is shutting down')
-return getattr(self._threaddata, 'pool', None)
+return getattr(self._threaddata, '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 7398	26695dd703d8
parent 7387	d240cff2d8ba
child 7406	e772a2c57b00