cubicweb: comparison dbapi.py

equal deleted inserted replaced

-:ff6114c2c416
+:f84ba1a66abb
 from logging import getLogger
 from time import time, clock
 from itertools import count
 from logilab.common.logging_ext import set_log_methods
+from logilab.common.decorators import monkeypatch
+from logilab.common.deprecation import deprecated
 from cubicweb import ETYPE_NAME_MAP, ConnectionError, RequestSessionMixIn
-from cubicweb.cwvreg import CubicWebRegistry, MulCnxCubicWebRegistry
+from cubicweb import cwvreg, cwconfig
-from cubicweb.cwconfig import CubicWebNoAppConfiguration
 _MARKER = object()
 def _fake_property_value(self, name):
 try:
 return super(dbapi.DBAPIRequest, self).property_value(name)
 except KeyError:
 return ''
+def _fix_cls_attrs(reg, appobject):
+appobject.vreg = reg.vreg
+appobject.schema = reg.schema
+appobject.config = reg.config
+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
+registries.
+"""
+defaultcls = cwvreg.VRegistry.REGISTRY_FACTORY[None]
+orig_select_best = defaultcls.orig_select_best = defaultcls.select_best
+@monkeypatch(defaultcls)
+def select_best(self, appobjects, *args, **kwargs):
+"""return an instance of the most specific object according
+to parameters
+raise NoSelectableObject if no object apply
+"""
+for appobjectcls in appobjects:
+_fix_cls_attrs(self, appobjectcls)
+selected = orig_select_best(self, appobjects, *args, **kwargs)
+# redo the same thing on the instance so it won't use equivalent class
+# attributes (which may change)
+_fix_cls_attrs(self, selected)
+return selected
+etypescls = cwvreg.VRegistry.REGISTRY_FACTORY['etypes']
+orig_etype_class = etypescls.orig_etype_class = etypescls.etype_class
+@monkeypatch(defaultcls)
+def etype_class(self, etype):
+"""return an entity class for the given entity type.
+Try to find out a specific class for this kind of entity or
+default to a dump of the class registered for 'Any'
+"""
+usercls = orig_etype_class(self, etype)
+if etype == 'Any':
+return usercls
+usercls.e_schema = self.schema.eschema(etype)
+return usercls
+def multiple_connections_unfix():
+defaultcls = cwvreg.VRegistry.REGISTRY_FACTORY[None]
+defaultcls.select_best = defaultcls.orig_select_best
+etypescls = cwvreg.VRegistry.REGISTRY_FACTORY['etypes']
+etypescls.etype_class = etypescls.orig_etype_class
 class ConnectionProperties(object):
 def __init__(self, cnxtype=None, lang=None, close=True, log=False):
 self.cnxtype = cnxtype or 'pyro'
 self.lang = lang
 if method == 'inmemory':
 # get local access to the repository
 from cubicweb.server.repository import Repository
 return Repository(config, vreg=vreg)
 else: # method == 'pyro'
-from Pyro import core, naming
-from Pyro.errors import NamingError, ProtocolError
-core.initClient(banner=0)
-nsid = ':%s.%s' % (config['pyro-ns-group'], database)
-locator = naming.NameServerLocator()
 # resolve the Pyro object
+from logilab.common.pyro_ext import ns_get_proxy
 try:
-nshost, nsport = config['pyro-ns-host'], config['pyro-ns-port']
+return ns_get_proxy(database,
-uri = locator.getNS(nshost, nsport).resolve(nsid)
+defaultnsgroup=config['pyro-ns-group'],
-except ProtocolError:
+nshost=config['pyro-ns-host'])
-raise ConnectionError('Could not connect to the Pyro name server '
+except Exception, ex:
-'(host: %s:%i)' % (nshost, nsport))
+raise ConnectionError(str(ex))
-except NamingError:
-raise ConnectionError('Could not get repository for %s '
-'(not registered in Pyro), '
-'you may have to restart your server-side '
-'instance' % nsid)
-return core.getProxyForURI(uri)
 def repo_connect(repo, login, password, cnxprops=None):
 """Constructor to create a new connection to the CubicWeb repository.
 Returns a Connection instance.
 cnx = Connection(repo, cnxid, cnxprops)
 if cnxprops.cnxtype == 'inmemory':
 cnx.vreg = repo.vreg
 return cnx
-def connect(database=None, login=None, password=None, host=None,
+def connect(database=None, login=None, password=None, host=None, group=None,
-group=None, cnxprops=None, port=None, setvreg=True, mulcnx=True,
+cnxprops=None, setvreg=True, mulcnx=True, initlog=True):
-initlog=True):
 """Constructor for creating a connection to the CubicWeb repository.
 Returns a Connection object.
-When method is 'pyro' and setvreg is True, use a special registry class
+When method is 'pyro', setvreg is True, try to deal with connections to
-(MulCnxCubicWebRegistry) made to deal with connections to differents instances
+differents instances in the same process unless specified otherwise by
-in the same process unless specified otherwise by setting the mulcnx to
+setting the mulcnx to False.
-False.
 """
-config = CubicWebNoAppConfiguration()
+config = cwconfig.CubicWebNoAppConfiguration()
 if host:
 config.global_set_option('pyro-ns-host', host)
-if port:
-config.global_set_option('pyro-ns-port', port)
 if group:
 config.global_set_option('pyro-ns-group', group)
 cnxprops = cnxprops or ConnectionProperties()
 method = cnxprops.cnxtype
 repo = get_repository(method, database, config=config)
 if method == 'inmemory':
 vreg = repo.vreg
 elif setvreg:
 if mulcnx:
-vreg = MulCnxCubicWebRegistry(config, initlog=initlog)
+multiple_connections_fix()
-else:
+vreg = cwvreg.CubicWebVRegistry(config, initlog=initlog)
-vreg = CubicWebRegistry(config, initlog=initlog)
 schema = repo.get_schema()
 for oldetype, newetype in ETYPE_NAME_MAP.items():
 if oldetype in schema:
 print 'aliasing', newetype, 'to', oldetype
 schema._entities[newetype] = schema._entities[oldetype]
 def in_memory_cnx(config, login, password):
 """usefull method for testing and scripting to get a dbapi.Connection
 object connected to an in-memory repository instance
 """
-if isinstance(config, CubicWebRegistry):
+if isinstance(config, cwvreg.CubicWebVRegistry):
 vreg = config
 config = None
 else:
 vreg = None
 # get local access to the repository
 """
 if self._closed is not None:
 raise ProgrammingError('Closed connection')
 return self._repo.get_schema()
-def load_vobjects(self, cubes=_MARKER, subpath=None, expand=True,
+def load_appobjects(self, cubes=_MARKER, subpath=None, expand=True,
 force_reload=None):
 config = self.vreg.config
 if cubes is _MARKER:
 cubes = self._repo.get_cubes()
 elif cubes is None:
 hm.register_system_hooks(config)
 # instance specific hooks
 if self._repo.config.instance_hooks:
 hm.register_hooks(config.load_hooks(self.vreg))
+load_vobjects = deprecated()(load_appobjects)
 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_vobjects` at some point to register those views.
+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.list_form_param = cwrb.list_form_param.im_func
 DBAPIRequest.property_value = _fake_property_value
 eid, login, groups, properties = self._repo.user_info(self.sessionid,
 props)
 if req is None:
 req = self.request()
 rset = req.eid_rset(eid, 'CWUser')
-user = self.vreg.etype_class('CWUser')(req, rset, row=0, groups=groups,
+user = self.vreg['etypes'].etype_class('CWUser')(req, rset, row=0,
-properties=properties)
+groups=groups,
+properties=properties)
 user['login'] = login # cache login
 return user
 def __del__(self):
 """close the remote connection if necessary"""

changeset 2675	f84ba1a66abb
parent 2665	0c6281487f90
child 2770	356e9d7c356d
child 3110	757d36162235