cubicweb: comparison server/session.py

equal deleted inserted replaced

-:e08f9c55dab5
+:cb87e831c183
 methods.
 """
 def __init__(self, session, mode, *categories):
 assert mode in (HOOKS_ALLOW_ALL, HOOKS_DENY_ALL)
 self.session = session
-self.tx = session._tx
+self.cnx = session._cnx
 self.mode = mode
 self.categories = categories
 self.oldmode = None
 self.changes = ()
 def __enter__(self):
-self.oldmode = self.tx.hooks_mode
+self.oldmode = self.cnx.hooks_mode
-self.tx.hooks_mode = self.mode
+self.cnx.hooks_mode = self.mode
 if self.mode is HOOKS_DENY_ALL:
-self.changes = self.tx.enable_hook_categories(*self.categories)
+self.changes = self.cnx.enable_hook_categories(*self.categories)
 else:
-self.changes = self.tx.disable_hook_categories(*self.categories)
+self.changes = self.cnx.disable_hook_categories(*self.categories)
-self.tx.ctx_count += 1
+self.cnx.ctx_count += 1
 def __exit__(self, exctype, exc, traceback):
-self.tx.ctx_count -= 1
+self.cnx.ctx_count -= 1
-if self.tx.ctx_count == 0:
+if self.cnx.ctx_count == 0:
-self.session._clear_thread_storage(self.tx)
+self.session._clear_thread_storage(self.cnx)
 else:
 try:
 if self.categories:
 if self.mode is HOOKS_DENY_ALL:
-self.tx.disable_hook_categories(*self.categories)
+self.cnx.disable_hook_categories(*self.categories)
 else:
-self.tx.enable_hook_categories(*self.categories)
+self.cnx.enable_hook_categories(*self.categories)
 finally:
-self.tx.hooks_mode = self.oldmode
+self.cnx.hooks_mode = self.oldmode
 @deprecated('[3.17] use <object>.security_enabled instead')
 def security_enabled(obj, *args, **kwargs):
 return obj.security_enabled(*args, **kwargs)
 By default security is disabled on queries executed on the repository
 side.
 """
 def __init__(self, session, read=None, write=None):
 self.session = session
-self.tx = session._tx
+self.cnx = session._cnx
 self.read = read
 self.write = write
 self.oldread = None
 self.oldwrite = None
 def __enter__(self):
 if self.read is None:
 self.oldread = None
 else:
-self.oldread = self.tx.read_security
+self.oldread = self.cnx.read_security
-self.tx.read_security = self.read
+self.cnx.read_security = self.read
 if self.write is None:
 self.oldwrite = None
 else:
-self.oldwrite = self.tx.write_security
+self.oldwrite = self.cnx.write_security
-self.tx.write_security = self.write
+self.cnx.write_security = self.write
-self.tx.ctx_count += 1
+self.cnx.ctx_count += 1
 def __exit__(self, exctype, exc, traceback):
-self.tx.ctx_count -= 1
+self.cnx.ctx_count -= 1
-if self.tx.ctx_count == 0:
+if self.cnx.ctx_count == 0:
-self.session._clear_thread_storage(self.tx)
+self.session._clear_thread_storage(self.cnx)
 else:
 if self.oldread is not None:
-self.tx.read_security = self.oldread
+self.cnx.read_security = self.oldread
 if self.oldwrite is not None:
-self.tx.write_security = self.oldwrite
+self.cnx.write_security = self.oldwrite
 HOOKS_ALLOW_ALL = object()
 HOOKS_DENY_ALL = object()
 DEFAULT_SECURITY = object() # evaluated to true by design
 class SessionClosedError(RuntimeError):
 pass
 class CnxSetTracker(object):
-"""Keep track of which transaction use which cnxset.
+"""Keep track of which connection use which cnxset.
 There should be one of this object per session plus one another for
 internal session.
 Session object are responsible of creating their CnxSetTracker object.
-Transaction should use the :meth:`record` and :meth:`forget` to inform the
+Connection should use the :meth:`record` and :meth:`forget` to inform the
 tracker of cnxset they have acquired.
 .. automethod:: cubicweb.server.session.CnxSetTracker.record
 .. automethod:: cubicweb.server.session.CnxSetTracker.forget
 self._condition.__enter__()
 def __exit__(self, *args):
 self._condition.__exit__(*args)
-def record(self, txid, cnxset):
+def record(self, cnxid, cnxset):
-"""Inform the tracker that a txid have acquired a cnxset
+"""Inform the tracker that a cnxid have acquired a cnxset
-This methode is to be used by Transaction object.
+This methode is to be used by Connection object.
 This method fails when:
-- The txid already have a recorded cnxset.
+- The cnxid already have a recorded cnxset.
 - The tracker is not active anymore.
 Notes about the caller:
 (1) It is responsible for retrieving a cnxset.
 (2) It must be prepared to release the cnxset if the
 """
 # dubious since the caller is suppose to have acquired it anyway.
 with self._condition:
 if not self._active:
 raise SessionClosedError('Closed')
-old = self._record.get(txid)
+old = self._record.get(cnxid)
 if old is not None:
 raise ValueError('"%s" already have a cnx_set (%r)'
-% (txid, old))
+% (cnxid, old))
-self._record[txid] = cnxset
+self._record[cnxid] = cnxset
-def forget(self, txid, cnxset):
+def forget(self, cnxid, cnxset):
-"""Inform the tracker that a txid have release a cnxset
+"""Inform the tracker that a cnxid have release a cnxset
-This methode is to be used by Transaction object.
+This methode is to be used by Connection object.
 This method fails when:
-- The cnxset for the txid does not match the recorded one.
+- The cnxset for the cnxid does not match the recorded one.
 Notes about the caller:
 (1) It is responsible for releasing the cnxset.
 (2) It should acquire the tracker lock during the operation to ensure
 the internal tracker state is always accurate regarding its own state.
 cnxset_tracker.forget(caller.id, cnxset)
 finally:
 cnxset = repo._free_cnxset(cnxset) # (1)
 """
 with self._condition:
-old = self._record.get(txid, None)
+old = self._record.get(cnxid, None)
 if old is not cnxset:
 raise ValueError('recorded cnxset for "%s" mismatch: %r != %r'
-% (txid, old, cnxset))
+% (cnxid, old, cnxset))
-self._record.pop(txid)
+self._record.pop(cnxid)
 self._condition.notify_all()
 def close(self):
 """Marks the tracker as inactive.
 def wait(self, timeout=10):
 """Wait for all recorded cnxset to be released
 This methode is to be used by Session object.
-returns a tuple of transaction id that remains open.
+returns a tuple of connection id that remains open.
 """
 with self._condition:
 if  self._active:
 raise RuntimeError('Cannot wait on active tracker.'
 ' Call tracker.close() first')
 start = time()
 self._condition.wait(timeout)
 timeout -= time() - start
 return tuple(self._record)
-class Transaction(object):
+class Connection(object):
-"""Repository Transaction
+"""Repository Connection
-Holds all transaction related data
+Holds all connection related data
 Database connections resource:
 :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
 :attr:`cnxset`, the connections set to use to execute queries on sources.
 If the transaction is read only, the connection set may be freed between
-actual query. This allows multiple transaction with a reasonable low
+actual query. This allows multiple connection with a reasonable low
 connection set pool size. control mechanism is detailed below
-.. automethod:: cubicweb.server.session.Transaction.set_cnxset
+.. automethod:: cubicweb.server.session.Connection.set_cnxset
-.. automethod:: cubicweb.server.session.Transaction.free_cnxset
+.. automethod:: cubicweb.server.session.Connection.free_cnxset
 :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
 :attr:`read_security` and :attr:`write_security`, boolean flags telling if
 read/write security is currently activated.
 """
-def __init__(self, txid, session, rewriter):
+def __init__(self, cnxid, session, rewriter):
-#: transaction unique id
+#: connection unique id
-self.transactionid = txid
+self.connectionid = cnxid
 #: reentrance handling
 self.ctx_count = 0
 #: server.Repository object
 self.repo = session.repo
 self.mode = session.default_mode
 #: connection set used to execute queries on sources
 self._cnxset = None
 #: CnxSetTracker used to report cnxset usage
 self._cnxset_tracker = session._cnxset_tracker
-#: is this transaction from a client or internal to the repo
+#: is this connection from a client or internal to the repo
 self.running_dbapi_query = True
 #: dict containing arbitrary data cleared at the end of the transaction
 self.data = {}
 #: ordered list of operations to be processed on commit/rollback
 if new_cnxset is old_cnxset:
 return #nothing to do
 if old_cnxset is not None:
 self._cnxset = None
 self.ctx_count -= 1
-self._cnxset_tracker.forget(self.transactionid, old_cnxset)
+self._cnxset_tracker.forget(self.connectionid, old_cnxset)
 if new_cnxset is not None:
-self._cnxset_tracker.record(self.transactionid, new_cnxset)
+self._cnxset_tracker.record(self.connectionid, new_cnxset)
 self._cnxset = new_cnxset
 self.ctx_count += 1
 def set_cnxset(self):
-"""the transaction need a connections set to execute some queries"""
+"""the connection need a connections set to execute some queries"""
 if self.cnxset is None:
 cnxset = self.repo._get_cnxset()
 try:
 self.cnxset = cnxset
 try:
 self.repo._free_cnxset(cnxset)
 raise
 return self.cnxset
 def free_cnxset(self, ignoremode=False):
-"""the transaction is no longer using its connections set, at least for some time"""
+"""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
 if cnxset is not None and (ignoremode or self.mode == 'read'):
 try:
 self.repo._free_cnxset(cnxset)
 # Entity cache management #################################################
 #
-# The transaction entity cache as held in tx.data it is removed at end the
+# The connection entity cache as held in cnx.data it is removed at end the
-# end of the transaction (commit and rollback)
+# end of the connection (commit and rollback)
 #
-# XXX transaction level caching may be a pb with multiple repository
+# XXX connection level caching may be a pb with multiple repository
 # instances, but 1. this is probably not the only one :$ and 2. it may be
 # 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 transaction entity cache"""
+"""Add `entity` to the connection entity cache"""
 ecache = self.data.setdefault('ecache', {})
 ecache.setdefault(entity.eid, entity)
 def entity_cache(self, eid):
 """get cache entity for `eid`"""
 subjtype = self.repo.type_and_source_from_eid(eidfrom, self)[0]
 objtype = self.repo.type_and_source_from_eid(eidto, self)[0]
 return self.vreg.schema.rschema(rtype).rdefs[(subjtype, objtype)]
-def tx_attr(attr_name, writable=False):
+def cnx_attr(attr_name, writable=False):
-"""return a property to forward attribute access to transaction.
+"""return a property to forward attribute access to connection.
 This is to be used by session"""
 args = {}
-def attr_from_tx(session):
+def attr_from_cnx(session):
-return getattr(session._tx, attr_name)
+return getattr(session._cnx, attr_name)
-args['fget'] = attr_from_tx
+args['fget'] = attr_from_cnx
 if writable:
 def write_attr(session, value):
-return setattr(session._tx, attr_name, value)
+return setattr(session._cnx, attr_name, value)
 args['fset'] = write_attr
 return property(**args)
-def tx_meth(meth_name):
+def cnx_meth(meth_name):
-"""return a function forwarding calls to transaction.
+"""return a function forwarding calls to connection.
 This is to be used by session"""
-def meth_from_tx(session, *args, **kwargs):
+def meth_from_cnx(session, *args, **kwargs):
-return getattr(session._tx, meth_name)(*args, **kwargs)
+return getattr(session._cnx, meth_name)(*args, **kwargs)
-return meth_from_tx
+return meth_from_cnx
 class Session(RequestSessionBase):
 """Repository user session
 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:`_txs` is a dictionary of :class:`TransactionData` instance, one
+:attr:`_cnxs` is a dictionary of :class:`Connection` instance, one
-for each running transaction. The key is the transaction id. By default
+for each running connection. The key is the connection id. By default
-the transaction id is the thread name but it can be otherwise (per dbapi
+the connection 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 `tx` attribute
+:attr:`__threaddata` is a thread local storage whose `cnx` attribute
-refers to the proper instance of :class:`Transaction` according to the
+refers to the proper instance of :class:`Connection` according to the
-transaction.
+connection.
-You should not have to use neither :attr:`_tx` nor :attr:`__threaddata`,
+You should not have to use neither :attr:`_cnx` nor :attr:`__threaddata`,
-simply access transaction data transparently through the :attr:`_tx`
+simply access connection data transparently through the :attr:`_cnx`
 property. Also, you usually don't have to access it directly since current
-transaction's data may be accessed/modified through properties / methods:
+connection's data may be accessed/modified through properties / methods:
-:attr:`transaction_data`, similarly to :attr:`data`, is a dictionary
+:attr:`connection_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
+connection. 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.
 .. automethod:: cubicweb.server.session.Session.get_shared_data
 .. automethod:: cubicweb.server.session.Session.set_shared_data
 .. automethod:: cubicweb.server.session.Session.added_in_transaction
 .. automethod:: cubicweb.server.session.Session.deleted_in_transaction
-Transaction state information:
+Connection state information:
 :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
 :attr:`cnxset`, the connections set to use to execute queries on sources.
 # and the rql server
 self.data = {}
 # i18n initialization
 self.set_language(user.prefered_language())
 ### internals
-# Transaction of this section
+# Connection of this section
-self._txs = {}
+self._cnxs = {}
 # Data local to the thread
 self.__threaddata = threading.local()
 self._cnxset_tracker = CnxSetTracker()
 self._closed = False
 self._lock = threading.RLock()
 def __unicode__(self):
 return '<session %s (%s 0x%x)>' % (
 unicode(self.user.login), self.id, id(self))
-def get_tx(self, txid):
+def get_cnx(self, cnxid):
-"""return the <txid> transaction attached to this session
+"""return the <cnxid> connection attached to this session
-Transaction is created if necessary"""
+Connection is created if necessary"""
-with self._lock: # no transaction exist with the same id
+with self._lock: # no connection exist with the same id
 try:
 if self.closed:
 raise SessionClosedError('try to access connections set on a closed session %s' % self.id)
-tx = self._txs[txid]
+cnx = self._cnxs[cnxid]
 except KeyError:
 rewriter = RQLRewriter(self)
-tx = Transaction(txid, self, rewriter)
+cnx = Connection(cnxid, self, rewriter)
-self._txs[txid] = tx
+self._cnxs[cnxid] = cnx
-return tx
+return cnx
-def set_tx(self, txid=None):
+def set_cnx(self, cnxid=None):
-"""set the default transaction of the current thread to <txid>
+"""set the default connection of the current thread to <cnxid>
-Transaction is created if necessary"""
+Connection is created if necessary"""
-if txid is None:
+if cnxid is None:
-txid = threading.currentThread().getName()
+cnxid = threading.currentThread().getName()
-self.__threaddata.tx = self.get_tx(txid)
+self.__threaddata.cnx = self.get_cnx(cnxid)
 @property
-def _tx(self):
+def _cnx(self):
-"""default transaction for current session in current thread"""
+"""default connection for current session in current thread"""
 try:
-return self.__threaddata.tx
+return self.__threaddata.cnx
 except AttributeError:
-self.set_tx()
+self.set_cnx()
-return self.__threaddata.tx
+return self.__threaddata.cnx
 def get_option_value(self, option, foreid=None):
 return self.repo.get_option_value(option, foreid)
 def transaction(self, free_cnxset=True):
 entity._cw_related_cache['%s_%s' % (rtype, role)] = (
 rset, tuple(entities))
 # resource accessors ######################################################
-system_sql = tx_meth('system_sql')
+system_sql = cnx_meth('system_sql')
-deleted_in_transaction = tx_meth('deleted_in_transaction')
+deleted_in_transaction = cnx_meth('deleted_in_transaction')
-added_in_transaction = tx_meth('added_in_transaction')
+added_in_transaction = cnx_meth('added_in_transaction')
-rtype_eids_rdef = tx_meth('rtype_eids_rdef')
+rtype_eids_rdef = cnx_meth('rtype_eids_rdef')
 # security control #########################################################
 def security_enabled(self, read=None, write=None):
 return _security_enabled(self, read=read, write=write)
-read_security = tx_attr('read_security', writable=True)
+read_security = cnx_attr('read_security', writable=True)
-write_security = tx_attr('write_security', writable=True)
+write_security = cnx_attr('write_security', writable=True)
-running_dbapi_query = tx_attr('running_dbapi_query')
+running_dbapi_query = cnx_attr('running_dbapi_query')
 # hooks activation control #################################################
 # all hooks should be activated during normal execution
 def allow_all_hooks_but(self, *categories):
 return _hooks_control(self, HOOKS_ALLOW_ALL, *categories)
 def deny_all_hooks_but(self, *categories):
 return _hooks_control(self, HOOKS_DENY_ALL, *categories)
-hooks_mode = tx_attr('hooks_mode')
+hooks_mode = cnx_attr('hooks_mode')
-disabled_hook_categories = tx_attr('disabled_hook_cats')
+disabled_hook_categories = cnx_attr('disabled_hook_cats')
-enabled_hook_categories = tx_attr('enabled_hook_cats')
+enabled_hook_categories = cnx_attr('enabled_hook_cats')
-disable_hook_categories = tx_meth('disable_hook_categories')
+disable_hook_categories = cnx_meth('disable_hook_categories')
-enable_hook_categories = tx_meth('enable_hook_categories')
+enable_hook_categories = cnx_meth('enable_hook_categories')
-is_hook_category_activated = tx_meth('is_hook_category_activated')
+is_hook_category_activated = cnx_meth('is_hook_category_activated')
-is_hook_activated = tx_meth('is_hook_activated')
+is_hook_activated = cnx_meth('is_hook_activated')
 # connection management ###################################################
 def keep_cnxset_mode(self, mode):
 """set `mode`, e.g. how the session will keep its connections set:
 if mode == 'transaction':
 self.default_mode = 'transaction'
 else: # mode == 'write'
 self.default_mode = 'read'
-mode = tx_attr('mode', writable=True)
+mode = cnx_attr('mode', writable=True)
-commit_state = tx_attr('commit_state', writable=True)
+commit_state = cnx_attr('commit_state', writable=True)
 @property
 def cnxset(self):
 """connections set, set according to transaction mode for each query"""
 if self._closed:
 self.free_cnxset(True)
 raise SessionClosedError('try to access connections set on a closed session %s' % self.id)
-return self._tx.cnxset
+return self._cnx.cnxset
 def set_cnxset(self):
 """the session need a connections set to execute some queries"""
 with self._lock: # can probably be removed
 if self._closed:
 self.free_cnxset(True)
 raise SessionClosedError('try to set connections set on a closed session %s' % self.id)
-return self._tx.set_cnxset()
+return self._cnx.set_cnxset()
-free_cnxset = tx_meth('free_cnxset')
+free_cnxset = cnx_meth('free_cnxset')
 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 tx.data, no?
+self.local_perm_cache.clear() # XXX simply move in cnx.data, no?
 # shared data handling ###################################################
 def get_shared_data(self, key, default=None, pop=False, txdata=False):
 """return value associated to `key` in session data"""
 if txdata:
-data = self._tx.data
+data = self._cnx.data
 else:
 data = self.data
 if pop:
 return data.pop(key, default)
 else:
 return data.get(key, default)
 def set_shared_data(self, key, value, txdata=False):
 """set value associated to `key` in session data"""
 if txdata:
-self._tx.data[key] = value
+self._cnx.data[key] = value
 else:
 self.data[key] = value
 # server-side service call #################################################
 @property
 def cursor(self):
 """return a rql cursor"""
 return self
-set_entity_cache  = tx_meth('set_entity_cache')
+set_entity_cache  = cnx_meth('set_entity_cache')
-entity_cache      = tx_meth('entity_cache')
+entity_cache      = cnx_meth('entity_cache')
-cache_entities    = tx_meth('cached_entities')
+cache_entities    = cnx_meth('cached_entities')
-drop_entity_cache = tx_meth('drop_entity_cache')
+drop_entity_cache = cnx_meth('drop_entity_cache')
 def from_controller(self):
 """return the id (string) of the controller issuing the request (no
 sense here, always return 'view')
 """
 return 'view'
-source_defs = tx_meth('source_defs')
+source_defs = cnx_meth('source_defs')
-describe = tx_meth('describe')
+describe = cnx_meth('describe')
-source_from_eid = tx_meth('source_from_eid')
+source_from_eid = cnx_meth('source_from_eid')
 def execute(self, rql, kwargs=None, eid_key=None, build_descr=True):
 """db-api like method directly linked to the querier execute method.
 """remove everything from the thread local storage, except connections set
 which is explicitly removed by free_cnxset, and mode which is set anyway
 by _touch
 """
 try:
-tx = self.__threaddata.tx
+cnx = self.__threaddata.cnx
 except AttributeError:
 pass
 else:
 if free_cnxset:
 self.free_cnxset()
-if tx.ctx_count == 0:
+if cnx.ctx_count == 0:
-self._clear_thread_storage(tx)
+self._clear_thread_storage(cnx)
 else:
-self._clear_tx_storage(tx)
+self._clear_cnx_storage(cnx)
 else:
-self._clear_tx_storage(tx)
+self._clear_cnx_storage(cnx)
-def _clear_thread_storage(self, tx):
+def _clear_thread_storage(self, cnx):
-self._txs.pop(tx.transactionid, None)
+self._cnxs.pop(cnx.connectionid, None)
 try:
-del self.__threaddata.tx
+del self.__threaddata.cnx
 except AttributeError:
 pass
-def _clear_tx_storage(self, tx):
+def _clear_cnx_storage(self, cnx):
-tx.clear()
+cnx.clear()
-tx._rewriter = RQLRewriter(self)
+cnx._rewriter = RQLRewriter(self)
 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',
 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 = self._tx.cnxset
+cnxset = self._cnx.cnxset
 if cnxset is None:
 self._clear_thread_data()
 self._touch()
 self.debug('rollback session %s done (no db activity)', self.id)
 return
 tracker = self._cnxset_tracker
 with self._lock:
 self._closed = True
 tracker.close()
 self.rollback()
-self.info('waiting for open transaction of session: %s', self)
+self.info('waiting for open connection of session: %s', self)
 timeout = 10
 pendings = tracker.wait(timeout)
 if pendings:
-self.error('%i transaction still alive after 10 seconds, will close '
+self.error('%i connection still alive after 10 seconds, will close '
 'session anyway', len(pendings))
-for txid in pendings:
+for cnxid in pendings:
-tx = self._txs.get(txid)
+cnx = self._cnxs.get(cnxid)
-if tx is not None:
+if cnx is not None:
-# drop tx.cnxset
+# drop cnx.cnxset
 with tracker:
 try:
-cnxset = tx.cnxset
+cnxset = cnx.cnxset
 if cnxset is None:
 continue
-tx.cnxset = None
+cnx.cnxset = None
 except RuntimeError:
 msg = 'issue while force free of cnxset in %s'
-self.error(msg, tx)
+self.error(msg, cnx)
 # cnxset.reconnect() do an hard reset of the cnxset
 # it force it to be freed
 cnxset.reconnect()
 self.repo._free_cnxset(cnxset)
 del self.__threaddata
-del self._txs
+del self._cnxs
 @property
 def closed(self):
-return not hasattr(self, '_txs')
+return not hasattr(self, '_cnxs')
 # transaction data/operations management ##################################
-transaction_data = tx_attr('data')
+transaction_data = cnx_attr('data')
-pending_operations = tx_attr('pending_operations')
+pending_operations = cnx_attr('pending_operations')
-pruned_hooks_cache = tx_attr('pruned_hooks_cache')
+pruned_hooks_cache = cnx_attr('pruned_hooks_cache')
-add_operation      = tx_meth('add_operation')
+add_operation      = cnx_meth('add_operation')
 # undo support ############################################################
-ertype_supports_undo = tx_meth('ertype_supports_undo')
+ertype_supports_undo = cnx_meth('ertype_supports_undo')
-transaction_inc_action_counter = tx_meth('transaction_inc_action_counter')
+transaction_inc_action_counter = cnx_meth('transaction_inc_action_counter')
 def transaction_uuid(self, set=True):
 try:
-return self._tx.transaction_uuid(set=set)
+return self._cnx.transaction_uuid(set=set)
 except KeyError:
-self._tx.data['tx_uuid'] = uuid = uuid4().hex
+self._cnx.data['tx_uuid'] = uuid = uuid4().hex
 self.repo.system_source.start_undoable_transaction(self, uuid)
 return uuid
 # querier helpers #########################################################
-rql_rewriter = tx_attr('_rewriter')
+rql_rewriter = cnx_attr('_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 self._tx.cnxset
+return self._cnx.cnxset
 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 9020	cb87e831c183
parent 9016	0368b94921ed
child 9021	d8806996ac01