def route(self, graph_name=None, context=None):
try:
if self._neo4j_version >= Version("4.0"):
routers, readers, writers, ttl = self._route4(graph_name, context)
else:
routers, readers, writers, ttl = self._route1(graph_name, context)
profiles, scheme = self._get_http_profiles() # Convert Bolt addresses to HTTP
return ([ConnectionProfile(_, scheme=scheme, address=profiles[_.address]) for _ in routers],
[ConnectionProfile(_, scheme=scheme, address=profiles[_.address]) for _ in readers],
[ConnectionProfile(_, scheme=scheme, address=profiles[_.address]) for _ in writers],
ttl)
finally:
self.release()
def test_to_dict():
p = ConnectionProfile()
d = p.to_dict()
assert d == {
'address': IPv4Address(('localhost', 7687)),
'host': 'localhost',
'port': 7687,
'port_number': 7687,
'protocol': 'bolt',
'scheme': 'bolt',
'secure': False,
'verify': True,
'uri': 'bolt://neo4j@localhost:7687',
'user': '******',
}
def open(cls,
profile=None,
user_agent=None,
on_release=None,
on_broken=None):
""" Open and authenticate a Bolt connection.
:param profile: :class:`.ConnectionProfile` detailing how and
where to connect
:param user_agent:
:param on_release:
:param on_broken:
:returns: :class:`.Bolt` connection object
:raises: :class:`.ConnectionUnavailable` if a connection cannot
be opened, or a protocol version cannot be agreed
"""
if profile is None:
profile = ConnectionProfile(scheme="bolt")
try:
wire = cls._connect(profile, on_broken=on_broken)
protocol_version = cls._handshake(wire)
subclass = cls._get_subclass(protocol_version)
if subclass is None:
raise TypeError("Unable to agree supported protocol version")
bolt = subclass(wire, profile, on_release=on_release)
bolt._hello(user_agent or bolt_user_agent())
return bolt
except (TypeError, WireError) as error:
raise_from(
ConnectionUnavailable("Cannot open connection to %r" %
profile), error)
def _get_http_profiles(self):
scheme = "https" if self.profile.secure else "http"
profiles = {}
try:
result = self.auto_run("CALL dbms.cluster.overview")
self.pull(result)
while True:
record = result.take()
if record is None:
break
key = None
value = None
for address in record[1]:
profile = ConnectionProfile(address)
if profile.scheme == "bolt":
key = profile.address
elif profile.scheme == scheme:
value = profile.address
else:
pass # unusable value (should never happen)
if key and value:
profiles[key] = value
except Neo4jError as error:
if error.title == "ProcedureNotFound":
raise_from(TypeError("Neo4j service does not expose a cluster overview"), error)
else:
raise
else:
return profiles, scheme
def test_to_dict_with_password():
p = ConnectionProfile()
d = p.to_dict(include_password=True)
assert d == {
'address': IPv4Address(('localhost', 7687)),
'auth': ('neo4j', 'password'),
'host': 'localhost',
'password': '******',
'port': 7687,
'port_number': 7687,
'protocol': 'bolt',
'scheme': 'bolt',
'secure': False,
'verify': True,
'uri': 'bolt://localhost:7687',
'user': '******',
}
def test_profile_from_profile():
prof1 = ConnectionProfile(password="******")
prof2 = ConnectionProfile(prof1)
data = dict(prof2)
assert data == {
'address': IPv4Address(('localhost', 7687)),
'auth': ('neo4j', 'secret'),
'host': 'localhost',
'password': '******',
'port': 7687,
'port_number': 7687,
'protocol': 'bolt',
'scheme': 'bolt',
'secure': False,
'verify': True,
'uri': 'bolt://neo4j@localhost:7687',
'user': '******',
}
def accept(cls, wire, min_protocol_version=None):
data = wire.read(20)
if data[0:4] != BOLT_SIGNATURE:
raise ProtocolError("Incoming connection did not provide Bolt signature")
for major, minor in cls._proposed_versions(data, offset=4):
if min_protocol_version and (major, minor) < min_protocol_version:
continue
try:
subclass = Bolt._get_subclass((major, minor))
except TypeError:
continue
else:
wire.write(bytearray([0, 0, minor, major]))
wire.send()
return subclass(wire, ConnectionProfile(address=wire.remote_address))
raise TypeError("Unable to agree supported protocol version")
def test_bolt_default_port():
data = dict(ConnectionProfile("bolt://host"))
assert data == {
'address': IPv4Address(('host', 7687)),
'auth': ('neo4j', 'password'),
'host': 'host',
'password': '******',
'port': 7687,
'port_number': 7687,
'protocol': 'bolt',
'scheme': 'bolt',
'secure': False,
'verify': True,
'uri': 'bolt://host:7687',
'user': '******',
}
def test_bolt_uri_only():
data = dict(ConnectionProfile("bolt://*****:*****@host:9999',
'user': '******',
}
def test_explicit_auth_tuple():
data = dict(ConnectionProfile(auth=("bob", "secret")))
assert data == {
'address': IPv4Address(('localhost', 7687)),
'auth': ('bob', 'secret'),
'host': 'localhost',
'password': '******',
'port': 7687,
'port_number': 7687,
'protocol': 'bolt',
'scheme': 'bolt',
'secure': False,
'verify': True,
'uri': 'bolt://bob@localhost:7687',
'user': '******',
}
def test_secure_and_verify():
data = dict(ConnectionProfile(secure=True, verify=True))
assert data == {
'address': IPv4Address(('localhost', 7687)),
'auth': ('neo4j', 'password'),
'host': 'localhost',
'password': '******',
'port': 7687,
'port_number': 7687,
'protocol': 'bolt',
'scheme': 'bolt+s',
'secure': True,
'verify': True,
'uri': 'bolt+s://neo4j@localhost:7687',
'user': '******',
}
def test_bolt_uri_with_user_and_password():
data = dict(ConnectionProfile("bolt://*****:*****@host:9999"))
assert data == {
'address': IPv4Address(('host', 9999)),
'auth': ('bob', 'secret'),
'host': 'host',
'password': '******',
'port': 9999,
'port_number': 9999,
'protocol': 'bolt',
'scheme': 'bolt',
'secure': False,
'verify': True,
'uri': 'bolt://bob@host:9999',
'user': '******',
}
def test_uri_and_port():
data = dict(ConnectionProfile("bolt://*****:*****@host:8888',
'user': '******',
}
def test_https_uri_without_secure():
data = dict(ConnectionProfile("https://*****:*****@host:9999',
'user': '******',
}
def test_https_default_port():
data = dict(ConnectionProfile("https://host"))
assert data == {
'address': IPv4Address(('host', 7473)),
'auth': ('neo4j', 'password'),
'host': 'host',
'password': '******',
'port': 7473,
'port_number': 7473,
'protocol': 'http',
'scheme': 'https',
'secure': True,
'verify': True,
'uri': 'https://neo4j@host:7473',
'user': '******',
}
def test_http_uri_wth_secure_and_no_verify():
data = dict(
ConnectionProfile("http://host:9999", secure=True, verify=False))
assert data == {
'address': IPv4Address(('host', 9999)),
'auth': ('neo4j', 'password'),
'host': 'host',
'password': '******',
'port': 9999,
'port_number': 9999,
'protocol': 'http',
'scheme': 'http+ssc',
'secure': True,
'verify': False,
'uri': 'http+ssc://host:9999',
'user': '******',
}
def test_profile_from_dict():
dict1 = {
'address': IPv4Address(('localhost', 7687)),
'auth': ('neo4j', 'dictionary'),
'host': 'localhost',
'password': '******',
'port': 7687,
'port_number': 7687,
'protocol': 'bolt',
'scheme': 'bolt',
'secure': False,
'verify': True,
'uri': 'bolt://localhost:7687',
'user': '******',
}
prof1 = ConnectionProfile(dict1)
data = dict(prof1)
assert data == dict1
def test_loading_profile_from_file():
filename = path.join(path.dirname(__file__),
"..", "resources", "example.ini")
prof = ConnectionProfile.from_file(filename, "Neo4j")
data = dict(prof)
assert data == {
'secure': False,
'verify': True,
'scheme': 'bolt',
'user': '******',
'password': '******',
'address': IPv4Address(('graph.mystery.inc', 7777)),
'auth': ('shaggy', 'velma'),
'host': 'graph.mystery.inc',
'port': 7777,
'port_number': 7777,
'protocol': 'bolt',
'uri': 'bolt://[email protected]:7777',
}
def open(cls, profile=None, user_agent=None, on_release=None, on_broken=None):
""" Open an HTTP connection to a server.
:param profile: :class:`.ConnectionProfile` detailing how and
where to connect
:param user_agent:
:param on_release:
:param on_broken:
:returns: :class:`.HTTP` connection object
:raises: :class:`.ConnectionUnavailable` if a connection cannot
be opened
"""
if profile is None:
profile = ConnectionProfile(scheme="http")
try:
http = cls(profile, on_release=on_release)
http._hello(user_agent or http_user_agent())
return http
except HTTPError as error:
raise_from(ConnectionUnavailable("Cannot open connection to %r", profile), error)
def _get_routing_info(self, graph_name, query, parameters):
try:
result = self.auto_run(query, parameters, graph_name)
self.pull(result)
while True:
record = result.take()
if record is None:
break
addresses = {}
for a in record[1]:
addresses[a["role"]] = [
ConnectionProfile(self.profile, address=address)
for address in a["addresses"]
]
return (addresses.get("ROUTE", []), addresses.get("READ", []),
addresses.get("WRITE", []), record[0])
except Neo4jError as error:
if error.title == "ProcedureNotFound":
raise_from(TypeError("Neo4j service does not support routing"),
error)
else:
raise
def test_get_non_existent_key():
prof = ConnectionProfile()
with raises(KeyError):
_ = prof["routing"]
def test_profile_from_invalid_argument():
with raises(TypeError):
_ = ConnectionProfile(object())
def test_verify_env_var(monkeypatch):
import py2neo
monkeypatch.setattr(py2neo, "NEO4J_VERIFY", "1")
prof = ConnectionProfile()
assert prof.verify
def test_secure_env_var(monkeypatch):
import py2neo
monkeypatch.setattr(py2neo, "NEO4J_SECURE", "1")
prof = ConnectionProfile()
assert prof.secure
def test_auth_env_var(monkeypatch):
import py2neo
monkeypatch.setattr(py2neo, "NEO4J_AUTH", "alice:python")
prof = ConnectionProfile()
assert prof.auth == ("alice", "python")
def test_uri_env_var(monkeypatch):
import py2neo
monkeypatch.setattr(py2neo, "NEO4J_URI", "http://alice@somewhere:8899")
prof = ConnectionProfile()
assert prof.uri == "http://alice@somewhere:8899"
def test_length():
prof1 = ConnectionProfile()
assert len(prof1) == 12
def test_profile_repr():
prof = ConnectionProfile()
assert repr(prof).startswith("ConnectionProfile")
def test_profile_str():
prof = ConnectionProfile()
s = str(prof)
assert s.startswith("«")
assert s.endswith("»")
def test_explicit_address_string():
profile = ConnectionProfile(address="victor:4291")
assert profile.host == "victor"
assert profile.port == 4291
