cubicweb: comparison cubicweb/server/session.py

equal deleted inserted replaced

-:b4dcfd734686
+:70337ad23145
-# copyright 2003-2015 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2016 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #
 # This file is part of CubicWeb.
 #
 # CubicWeb is free software: you can redistribute it and/or modify it under the
 """Repository users' and internal' sessions."""
 from __future__ import print_function
 __docformat__ = "restructuredtext en"
+import functools
 import sys
 from time import time
 from uuid import uuid4
 from warnings import warn
-import functools
 from contextlib import contextmanager
+from logging import getLogger
 from six import text_type
 from logilab.common.deprecation import deprecated
 from logilab.common.textutils import unormalize
 from logilab.common.registry import objectify_predicate
-from cubicweb import QueryError, schema, server, ProgrammingError
+from cubicweb import QueryError, ProgrammingError, schema, server
+from cubicweb import set_log_methods
 from cubicweb.req import RequestSessionBase
 from cubicweb.utils import make_uid
 from cubicweb.rqlrewrite import RQLRewriter
 from cubicweb.server.edition import EditedEntity
 NO_UNDO_TYPES.add('is')
 NO_UNDO_TYPES.add('is_instance_of')
 NO_UNDO_TYPES.add('cw_source')
 # XXX rememberme,forgotpwd,apycot,vcsfile
 @objectify_predicate
 def is_user_session(cls, req, **kwargs):
 """return 1 when session is not internal.
 This predicate can only be used repository side only. """
 return not req.is_internal_session
 @objectify_predicate
 def is_internal_session(cls, req, **kwargs):
 """return 1 when session is not internal.
 This predicate can only be used repository side only. """
 return req.is_internal_session
 @objectify_predicate
 def repairing(cls, req, **kwargs):
 """return 1 when repository is running in repair mode"""
 return req.vreg.config.repairing
 @deprecated('[3.17] use <object>.allow/deny_all_hooks_but instead')
 def hooks_control(obj, mode, *categories):
-assert mode in  (HOOKS_ALLOW_ALL, HOOKS_DENY_ALL)
+assert mode in (HOOKS_ALLOW_ALL, HOOKS_DENY_ALL)
 if mode == HOOKS_ALLOW_ALL:
 return obj.allow_all_hooks_but(*categories)
 elif mode == HOOKS_DENY_ALL:
 return obj.deny_all_hooks_but(*categories)
 @deprecated('[3.17] use <object>.security_enabled instead')
 def security_enabled(obj, *args, **kwargs):
 return obj.security_enabled(*args, **kwargs)
 class _security_enabled(object):
 """context manager to control security w/ session.execute,
 By default security is disabled on queries executed on the repository
 side.
 if self.oldwrite is not None:
 self.cnx.write_security = self.oldwrite
 HOOKS_ALLOW_ALL = object()
 HOOKS_DENY_ALL = object()
-DEFAULT_SECURITY = object() # evaluated to true by design
+DEFAULT_SECURITY = object()  # evaluated to true by design
 class SessionClosedError(RuntimeError):
 pass
 """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):
 #: ordered list of operations to be processed on commit/rollback
 self.pending_operations = []
 #: (None, 'precommit', 'postcommit', 'uncommitable')
 self.commit_state = None
-### hook control attribute
+# hook control attribute
 self.hooks_mode = HOOKS_ALLOW_ALL
 self.disabled_hook_cats = set()
 self.enabled_hook_cats = set()
 self.pruned_hooks_cache = {}
+# security control attributes
-### security control attributes
+self._read_security = DEFAULT_SECURITY  # handled by a property
-self._read_security = DEFAULT_SECURITY # handled by a property
 self.write_security = DEFAULT_SECURITY
 # undo control
 config = session.repo.config
 if config.creating or config.repairing or self.is_internal_session:
 self.set_language(self.user.prefered_language())
 else:
 self._set_user(session.user)
 @_open_only
-def source_defs(self):
-"""Return the definition of sources used by the repository."""
-return self.session.repo.source_defs()
-@_open_only
 def get_schema(self):
 """Return the schema currently used by the repository."""
 return self.session.repo.source_defs()
 @_open_only
 return self.repo.system_source.undo_transaction(self, txuuid)
 # life cycle handling ####################################################
 def __enter__(self):
-assert self._open is None # first opening
+assert self._open is None  # first opening
 self._open = True
 self.cnxset = self.repo._get_cnxset()
 return self
 def __exit__(self, exctype=None, excvalue=None, tb=None):
-assert self._open # actually already open
+assert self._open  # actually already open
 self.rollback()
 self._open = False
 self.cnxset.cnxset_freed()
 self.repo._free_cnxset(self.cnxset)
 self.cnxset = None
 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'
+raise ProgrammingError('Closed Connection: %s' % self.connectionid)
-% self.connectionid)
 ecache = self.transaction_data.setdefault('ecache', {})
 ecache.setdefault(entity.eid, entity)
 @_open_only
 def entity_cache(self, eid):
 without read security check but also all the burden of rql execution.
 You may use this in hooks when you know both eids of the relation you
 want to add.
 """
-self.add_relations([(rtype, [(fromeid,  toeid)])])
+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_dict[rtype] = eids
 self.repo.glob_add_relations(self, relations_dict)
 for edited in edited_entities.values():
 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:
 if rcache is not None:
 rset, entities = rcache
 rset = rset.copy()
 entities = list(entities)
 rset.rows.append([targeteid])
-if not isinstance(rset.description, list): # else description not set
+if not isinstance(rset.description, list):  # else description not set
 rset.description = list(rset.description)
 rset.description.append([self.entity_metas(targeteid)['type']])
 targetentity = self.entity_from_eid(targeteid)
 if targetentity.cw_rset is None:
 targetentity.cw_rset = rset
 role, targeteid)
 return
 rset = rset.copy()
 entities = list(entities)
 del rset.rows[idx]
-if isinstance(rset.description, list): # else description not set
+if isinstance(rset.description, list):  # else description not set
 del rset.description[idx]
 del entities[idx]
 rset.rowcount -= 1
 entity._cw_related_cache['%s_%s' % (rtype, role)] = (
 rset, tuple(entities))
 self.pruned_hooks_cache.clear()
 categories = set(categories)
 if self.hooks_mode is HOOKS_DENY_ALL:
 enabledcats = self.enabled_hook_cats
 changes = enabledcats & categories
-enabledcats -= changes # changes is small hence faster
+enabledcats -= changes  # changes is small hence faster
 else:
 disabledcats = self.disabled_hook_cats
 changes = categories - disabledcats
-disabledcats |= changes # changes is small hence faster
+disabledcats |= changes  # changes is small hence faster
 return tuple(changes)
 @_open_only
 def enable_hook_categories(self, *categories):
 """enable the given hook categories:
 self.pruned_hooks_cache.clear()
 categories = set(categories)
 if self.hooks_mode is HOOKS_DENY_ALL:
 enabledcats = self.enabled_hook_cats
 changes = categories - enabledcats
-enabledcats |= changes # changes is small hence faster
+enabledcats |= changes  # changes is small hence faster
 else:
 disabledcats = self.disabled_hook_cats
 changes = disabledcats & categories
-disabledcats -= changes # changes is small hence faster
+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
 def describe(self, eid, asdict=False):
 """return a tuple (type, sourceuri, extid) for the entity with id <eid>"""
 etype, extid, source = self.repo.type_and_source_from_eid(eid, self)
 metas = {'type': etype, 'source': source, 'extid': extid}
 if asdict:
-metas['asource'] = metas['source'] # XXX pre 3.19 client compat
+metas['asource'] = metas['source']  # XXX pre 3.19 client compat
 return metas
 return etype, source, extid
 @_open_only
 def entity_metas(self, eid):
 def cnx_attr(attr_name, writable=False):
 """return a property to forward attribute access to connection.
 This is to be used by session"""
 args = {}
 @deprecated('[3.19] use a Connection object instead')
 def attr_from_cnx(session):
 return getattr(session._cnx, attr_name)
 args['fget'] = attr_from_cnx
 if writable:
 @deprecated('[3.19] use a Connection object instead')
 def write_attr(session, value):
 return setattr(session._cnx, attr_name, value)
 * other session data.
 """
 def __init__(self, user, repo, _id=None):
 self.sessionid = _id or make_uid(unormalize(user.login))
-self.user = user # XXX repoapi: deprecated and store only a login.
+self.user = user  # XXX repoapi: deprecated and store only a login.
 self.repo = repo
 self._timestamp = Timestamp()
 self.data = {}
 self.closed = False
 def _touch(self):
 """update latest session usage timestamp and reset mode to read"""
 self._timestamp.touch()
 local_perm_cache = cnx_attr('local_perm_cache')
 @local_perm_cache.setter
 def local_perm_cache(self, value):
-#base class assign an empty dict:-(
+# base class assign an empty dict:-(
 assert value == {}
 pass
 # deprecated ###############################################################
 def schema_rproperty(self, rtype, eidfrom, eidto, rprop):
 return getattr(self.rtype_eids_rdef(rtype, eidfrom, eidto), rprop)
 # these are overridden by set_log_methods below
 # only defining here to prevent pylint from complaining
-info = warning = error = critical = exception = debug = lambda msg,*a,**kw: None
+info = warning = error = critical = exception = debug = lambda msg, *a, **kw: 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
 def cw_adapt_to(self, iface):
 if iface == 'IEmailable':
 return self._IEmailable
 return None
-from logging import getLogger
-from cubicweb import set_log_methods
 set_log_methods(Session, getLogger('cubicweb.session'))
 set_log_methods(Connection, getLogger('cubicweb.session'))

changeset 11348	70337ad23145
parent 11206	6454ee8f2137
child 11374	0e50215016f3