cubicweb: comparison dbapi.py

equal deleted inserted replaced

-:48f468f33704
+:e4580e5f0703
 def _fake_property_value(self, name):
 try:
 return super(DBAPIRequest, self).property_value(name)
 except KeyError:
 return ''
+def fake(*args, **kwargs):
+return None
 def multiple_connections_fix():
 """some monkey patching necessary when an application has to deal with
 several connections to different repositories. It tries to hide buggy class
 attributes since classes are not designed to be shared among multiple
 flag telling if logging should be initialized. You usually don't want
 logging initialization when establishing the connection from a process
 where it's already initialized.
 :kwargs:
-there goes authentication tokens. You usually have to specify for
+there goes authentication tokens. You usually have to specify a password
-instance a password for the given user, using a named 'password' argument.
+for the given user, using a named 'password' argument.
 """
-config = cwconfig.CubicWebNoAppConfiguration()
-if host:
-config.global_set_option('pyro-ns-host', host)
-if group:
-config.global_set_option('pyro-ns-group', group)
 cnxprops = cnxprops or ConnectionProperties()
 method = cnxprops.cnxtype
+if method == 'pyro':
+config = cwconfig.CubicWebNoAppConfiguration()
+if host:
+config.global_set_option('pyro-ns-host', host)
+if group:
+config.global_set_option('pyro-ns-group', group)
+else:
+assert database
+config = cwconfig.instance_configuration(database)
 repo = get_repository(method, database, config=config)
 if method == 'inmemory':
 vreg = repo.vreg
 elif setvreg:
 if mulcnx:
 vreg = None
 cnx = repo_connect(repo, login, cnxprops=cnxprops, **kwargs)
 cnx.vreg = vreg
 return cnx
-def in_memory_cnx(config, login, **kwargs):
+def in_memory_repo(config):
-"""usefull method for testing and scripting to get a dbapi.Connection
+"""Return and in_memory Repository object from a config (or vreg)"""
-object connected to an in-memory repository instance
-"""
 if isinstance(config, cwvreg.CubicWebVRegistry):
 vreg = config
 config = None
 else:
 vreg = None
 # get local access to the repository
-repo = get_repository('inmemory', config=config, vreg=vreg)
+return get_repository('inmemory', config=config, vreg=vreg)
+def in_memory_cnx(repo, login, **kwargs):
+"""Establish a In memory connection to a <repo> for the user with <login>
+additionel credential might be required"""
+cnxprops = ConnectionProperties('inmemory')
+return repo_connect(repo, login, cnxprops=cnxprops, **kwargs)
+def in_memory_repo_cnx(config, login, **kwargs):
+"""usefull method for testing and scripting to get a dbapi.Connection
+object connected to an in-memory repository instance
+"""
 # connection to the CubicWeb repository
-cnxprops = ConnectionProperties('inmemory')
+repo = in_memory_repo(config)
-cnx = repo_connect(repo, login, cnxprops=cnxprops, **kwargs)
+return repo, in_memory_cnx(repo, login, **kwargs)
-return repo, cnx
 class _NeedAuthAccessMock(object):
 def __getattribute__(self, attr):
 raise AuthenticationError()
 def __nonzero__(self):
 else:
 del self._eid_cache[eid]
 # low level session data management #######################################
-def get_shared_data(self, key, default=None, pop=False):
+def get_shared_data(self, key, default=None, pop=False, txdata=False):
-"""return value associated to `key` in shared data"""
+"""see :meth:`Connection.get_shared_data`"""
-return self.cnx.get_shared_data(key, default, pop)
+return self.cnx.get_shared_data(key, default, pop, txdata)
-def set_shared_data(self, key, value, querydata=False):
+def set_shared_data(self, key, value, txdata=False, querydata=None):
-"""set value associated to `key` in shared data
+"""see :meth:`Connection.set_shared_data`"""
+if querydata is not None:
-if `querydata` is true, the value will be added to the repository
+txdata = querydata
-session's query data which are cleared on commit/rollback of the current
+warn('[3.10] querydata argument has been renamed to txdata',
-transaction, and won't be available through the connexion, only on the
+DeprecationWarning, stacklevel=2)
-repository side.
+return self.cnx.set_shared_data(key, value, txdata)
-"""
-return self.cnx.set_shared_data(key, value, querydata)
 # server session compat layer #############################################
 def describe(self, eid):
 """return a tuple (type, sourceuri, extid) for the entity with id <eid>"""
 def __init__(self, repo, cnxid, cnxprops=None):
 self._repo = repo
 self.sessionid = cnxid
 self._close_on_del = getattr(cnxprops, 'close_on_del', True)
 self._cnxtype = getattr(cnxprops, 'cnxtype', 'pyro')
+self._web_request = False
 if cnxprops and cnxprops.log_queries:
 self.executed_queries = []
 self.cursor_class = LogCursor
 if self._cnxtype == 'pyro':
 # check client/server compat
 esubpath = subpath
 if 'views' in subpath:
 esubpath = list(subpath)
 esubpath.remove('views')
 esubpath.append(join('web', 'views'))
-cubespath = [config.cube_dir(p) for p in cubes]
+config.init_cubes(cubes)
-config.load_site_cubicweb(cubespath)
+vpath = config.build_vregistry_path(reversed(config.cubes_path()),
-vpath = config.build_vregistry_path(reversed(cubespath),
 evobjpath=esubpath,
 tvobjpath=subpath)
 self.vreg.register_objects(vpath)
 def use_web_compatible_requests(self, baseurl, sitetitle=None):
 """monkey patch DBAPIRequest to fake a cw.web.request, so you should
 able to call html views using rset from a simple dbapi connection.
 You should call `load_appobjects` at some point to register those views.
 """
-from cubicweb.web.request import CubicWebRequestBase as cwrb
-DBAPIRequest.build_ajax_replace_url = cwrb.build_ajax_replace_url.im_func
-DBAPIRequest.ajax_replace_url = cwrb.ajax_replace_url.im_func
-DBAPIRequest.list_form_param = cwrb.list_form_param.im_func
 DBAPIRequest.property_value = _fake_property_value
 DBAPIRequest.next_tabindex = count().next
-DBAPIRequest.form = {}
-DBAPIRequest.data = {}
-fake = lambda *args, **kwargs: None
 DBAPIRequest.relative_path = fake
 DBAPIRequest.url = fake
-DBAPIRequest.next_tabindex = fake
 DBAPIRequest.get_page_data = fake
 DBAPIRequest.set_page_data = fake
-DBAPIRequest.add_js = fake #cwrb.add_js.im_func
-DBAPIRequest.add_css = fake #cwrb.add_css.im_func
 # XXX could ask the repo for it's base-url configuration
 self.vreg.config.set_option('base-url', baseurl)
+self.vreg.config.uiprops = {}
+self.vreg.config.datadir_url = baseurl + '/data'
 # XXX why is this needed? if really needed, could be fetched by a query
 if sitetitle is not None:
 self.vreg['propertydefs']['ui.site-title'] = {'default': sitetitle}
+self._web_request = True
-@check_not_closed
-def source_defs(self):
+def request(self):
-"""Return the definition of sources used by the repository.
+if self._web_request:
+from cubicweb.web.request import CubicWebRequestBase
-This is NOT part of the DB-API.
+req = CubicWebRequestBase(self.vreg, False)
-"""
+req.get_header = lambda x, default=None: default
-return self._repo.source_defs()
+req.set_session = lambda session, user=None: DBAPIRequest.set_session(
+req, session, user)
+req.relative_path = lambda includeparams=True: ''
+else:
+req = DBAPIRequest(self.vreg)
+req.set_session(DBAPISession(self))
+return req
 @check_not_closed
 def user(self, req=None, props=None):
 """return the User object associated to this connection"""
 # cnx validity is checked by the call to .user_info
 groups=groups,
 properties=properties)
 else:
 from cubicweb.entity import Entity
 user = Entity(req, rset, row=0)
-user['login'] = login # cache login
+user.cw_attr_cache['login'] = login # cache login
 return user
 @check_not_closed
 def check(self):
-"""raise `BadConnectionId` if the connection is no more valid"""
+"""raise `BadConnectionId` if the connection is no more valid, else
-self._repo.check_session(self.sessionid)
+return its latest activity timestamp.
+"""
+return self._repo.check_session(self.sessionid)
 def _txid(self, cursor=None): # XXX could now handle various isolation level!
 # return a dict as bw compat trick
 return {'txid': currentThread().getName()}
-def request(self):
-return DBAPIRequest(self.vreg, DBAPISession(self))
 # session data methods #####################################################
 @check_not_closed
 def set_session_props(self, **props):
 """raise `BadConnectionId` if the connection is no more valid"""
 self._repo.set_session_props(self.sessionid, props)
 @check_not_closed
-def get_shared_data(self, key, default=None, pop=False):
+def get_shared_data(self, key, default=None, pop=False, txdata=False):
-"""return value associated to `key` in shared data"""
+"""return value associated to key in the session's data dictionary or
-return self._repo.get_shared_data(self.sessionid, key, default, pop)
+session's transaction's data if `txdata` is true.
-@check_not_closed
+If pop is True, value will be removed from the dictionnary.
-def set_shared_data(self, key, value, querydata=False):
+If key isn't defined in the dictionnary, value specified by the
+`default` argument will be returned.
+"""
+return self._repo.get_shared_data(self.sessionid, key, default, pop, txdata)
+@check_not_closed
+def set_shared_data(self, key, value, txdata=False):
 """set value associated to `key` in shared data
-if `querydata` is true, the value will be added to the repository
+if `txdata` is true, the value will be added to the repository
 session's query data which are cleared on commit/rollback of the current
-transaction, and won't be available through the connexion, only on the
+transaction.
-repository side.
+"""
-"""
+return self._repo.set_shared_data(self.sessionid, key, value, txdata)
-return self._repo.set_shared_data(self.sessionid, key, value, querydata)
 # meta-data accessors ######################################################
+@check_not_closed
+def source_defs(self):
+"""Return the definition of sources used by the repository."""
+return self._repo.source_defs()
 @check_not_closed
 def get_schema(self):
 """Return the schema currently used by the repository."""
 return self._repo.get_schema()

branch	oldstable
changeset 7074	e4580e5f0703
parent 7056	51f88f13d6f3
child 7061	bb2080547722
child 7083	b8e35cde46e9