def __init__(self, uri, **config):
parsed = urlparse(uri)
self.address = (parsed.hostname, parsed.port or DEFAULT_PORT)
self.security_plan = security_plan = SecurityPlan.build(**config)
self.encrypted = security_plan.encrypted
pool = ConnectionPool(lambda a: connect(a, security_plan.ssl_context, **config))
Driver.__init__(self, pool)
def from_uri(cls, uri, default_port=0):
parsed = urlparse(uri)
if parsed.netloc.startswith("["):
return IPv6SocketAddress(parsed.hostname, parsed.port
or default_port, 0, 0)
else:
return IPv4SocketAddress(parsed.hostname, parsed.port
or default_port)
def _check_uri(cls, uri):
""" Check whether a URI is compatible with a :class:`.Driver`
subclass. When called from a subclass, execution simply passes
through if the URI scheme is valid for that class. If invalid,
a `ValueError` is raised.
:param uri: URI to check for compatibility
:raise: `ValueError` if URI scheme is incompatible
"""
parsed = urlparse(uri)
if parsed.scheme != cls.uri_scheme:
raise ValueError("%s objects require the %r URI scheme" % (cls.__name__, cls.uri_scheme))
def parse_routing_context(cls, uri):
query = urlparse(uri).query
if not query:
return {}
context = {}
parameters = parse_qs(query, True)
for key in parameters:
value_list = parameters[key]
if len(value_list) != 1:
raise ValueError("Duplicated query parameters with key '%s', value '%s' found in URL '%s'" % (key, value_list, uri))
value = value_list[0]
if not value:
raise ValueError("Invalid parameters:'%s=%s' in URI '%s'." % (key, value, uri))
context[key] = value
return context
def driver(cls, uri, **config):
""" Acquire a :class:`.Driver` instance for the given URI and
configuration. The URI scheme determines the Driver implementation
that will be returned. Options are:
``bolt``
Returns a :class:`.DirectDriver`.
``bolt+routing``
Returns a :class:`.RoutingDriver`.
:param uri: URI for a graph database service
:param config: configuration and authentication details (valid keys are listed below)
`auth`
An authentication token for the server, for example
``("neo4j", "password")``.
`der_encoded_server_certificate`
The server certificate in DER format, if required.
`encrypted`
A boolean flag to determine whether encryption should be used.
Defaults to :const:`True`.
`trust`
Trust level: one of :attr:`.TRUST_ALL_CERTIFICATES` (default) or
:attr:`.TRUST_SYSTEM_CA_SIGNED_CERTIFICATES`.
`user_agent`
A custom user agent string, if required.
for more config options see neo4j.config.default_config
"""
parsed = urlparse(uri)
try:
driver_class = cls.uri_schemes[parsed.scheme]
except KeyError:
raise ProtocolError("URI scheme %r not supported" % parsed.scheme)
else:
return driver_class(uri, **config)
def on_refresh(self, data):
if data is None:
self.invalidate.fire()
return
self.mode = data.system.dbms.mode
if self.mode in (u"CORE", u"READ_REPLICA"):
overview = data.cluster_overview
widths = [0]
for role in self.servers:
self.servers[role] = [
urlparse(server[u"addresses"][0]).netloc
for server in overview.data if server[u"role"] == role
]
widths.extend(map(len, self.servers[role]))
self.max_width = max(widths)
else:
self.servers[u"LEADER"] = [self.address]
self.max_width = len(self.address)
self.padding = 6 if self.max_width % 2 == 0 else 5
self.max_width += self.padding
self.invalidate.fire()
def __init__(self, uri, **config):
parsed = urlparse(uri)
initial_address = (parsed.hostname, parsed.port or DEFAULT_PORT)
self.security_plan = security_plan = SecurityPlan.build(**config)
self.encrypted = security_plan.encrypted
if not security_plan.routing_compatible:
# this error message is case-specific as there is only one incompatible
# scenario right now
raise ValueError("TRUST_ON_FIRST_USE is not compatible with routing")
def connector(a):
return connect(a, security_plan.ssl_context, **config)
pool = RoutingConnectionPool(connector, initial_address)
try:
pool.update_routing_table()
except:
pool.close()
raise
else:
Driver.__init__(self, pool)
def first_address(server):
return urlparse(server[u"addresses"][0]).netloc
def connector(address, error_handler):
return connect(address, security_plan.ssl_context,
urlparse(uri).hostname, error_handler, **config)
def __new__(cls, uri, **config):
parsed = urlparse(uri)
for subclass in Driver.__subclasses__():
if parsed.scheme == subclass.uri_scheme:
return subclass(uri, **config)
raise ValueError("URI scheme %r not supported" % parsed.scheme)
