async def a_main(prog):
parser = ArgumentParser(prog=prog)
parser.add_argument("cypher", help="Cypher query to execute")
parser.add_argument("-a",
"--auth",
metavar="USER:PASSWORD",
default="",
help="user name and password")
parser.add_argument("-s",
"--server-addr",
metavar="HOST:PORT",
default=":7687",
help="address of server")
parser.add_argument("-v",
"--verbose",
action="store_true",
help="increase output verbosity")
parsed = parser.parse_args()
if parsed.verbose:
watch("neo4j")
addr = Address.parse(parsed.server_addr)
user, _, password = parsed.auth.partition(":")
if not password:
password = getpass()
auth = (user or "neo4j", password)
bolt = await Bolt.open(addr, auth=auth)
try:
result = await bolt.run(parsed.cypher)
print("\t".join(await result.fields()))
async for record in result:
print("\t".join(map(repr, record)))
finally:
await bolt.close()
def __new__(cls, uri, **config):
cls._check_uri(uri)
instance = object.__new__(cls)
parsed = urlparse(uri)
instance.initial_address = initial_address = \
Address.parse(parsed.netloc, default_port=DEFAULT_PORT)
if config.get("encrypted") is None:
config["encrypted"] = False
instance._ssl_context = make_ssl_context(**config)
instance.encrypted = instance._ssl_context is not None
routing_context = cls.parse_routing_context(uri)
def connector(address, **kwargs):
return Connection.open(address, **dict(config, **kwargs))
pool = RoutingConnectionPool(connector, initial_address,
routing_context, initial_address,
**config)
try:
pool.update_routing_table()
except Exception:
pool.close()
raise
else:
instance._pool = pool
instance._max_retry_time = \
config.get("max_retry_time", default_config["max_retry_time"])
return instance
def __new__(cls, uri, **config):
cls._check_uri(uri)
instance = object.__new__(cls)
# We keep the address containing the host name or IP address exactly
# as-is from the original URI. This means that every new connection
# will carry out DNS resolution, leading to the possibility that
# the connection pool may contain multiple IP address keys, one for
# an old address and one for a new address.
parsed = urlparse(uri)
instance.address = Address.parse(parsed.netloc,
default_port=DEFAULT_PORT)
if config.get("encrypted") is None:
config["encrypted"] = False
instance._ssl_context = make_ssl_context(**config)
instance.encrypted = instance._ssl_context is not None
def connector(address, **kwargs):
return Connection.open(address, **dict(config, **kwargs))
pool = ConnectionPool(connector, instance.address, **config)
pool.release(pool.acquire())
instance._pool = pool
instance._max_retry_time = config.get("max_retry_time",
default_config["max_retry_time"])
return instance
def parse_routing_info(cls, records):
""" Parse the records returned from a getServers call and
return a new RoutingTable instance.
"""
if len(records) != 1:
raise RoutingProtocolError("Expected exactly one record")
record = records[0]
routers = []
readers = []
writers = []
try:
servers = record["servers"]
for server in servers:
role = server["role"]
addresses = []
for address in server["addresses"]:
addresses.append(Address.parse(address, default_port=DEFAULT_PORT))
if role == "ROUTE":
routers.extend(addresses)
elif role == "READ":
readers.extend(addresses)
elif role == "WRITE":
writers.extend(addresses)
ttl = record["ttl"]
except (KeyError, TypeError):
raise RoutingProtocolError("Cannot parse routing info")
else:
return cls(routers, readers, writers, ttl)
def parse_routing_info(cls, *, database, servers, ttl):
""" Parse the records returned from the procedure call and
return a new RoutingTable instance.
"""
routers = []
readers = []
writers = []
try:
for server in servers:
role = server["role"]
addresses = []
for address in server["addresses"]:
addresses.append(Address.parse(address, default_port=7687))
if role == "ROUTE":
routers.extend(addresses)
elif role == "READ":
readers.extend(addresses)
elif role == "WRITE":
writers.extend(addresses)
except (KeyError, TypeError):
raise ValueError("Cannot parse routing info")
else:
return cls(database=database,
routers=routers,
readers=readers,
writers=writers,
ttl=ttl)
def parse_target(cls, target):
""" Parse a target string to produce an address.
"""
if not target:
target = cls.default_target
address = Address.parse(target, default_host=cls.default_host,
default_port=cls.default_port)
return address
def test_address_parse_with_invalid_input(test_input, expected):
# python -m pytest tests/unit/test_addressing.py -s -k test_address_parse_with_invalid_input
with pytest.raises(expected):
parsed = Address.parse(test_input)
def test_address_should_parse_ipv6(test_input, expected):
# python -m pytest tests/unit/test_addressing.py -s -k test_address_should_parse_ipv6
parsed = Address.parse(test_input)
assert parsed == expected
def test_address_parse_with_ipv4(test_input, expected):
# python -m pytest tests/unit/test_addressing.py -s -k test_address_parse_with_ipv4
parsed = Address.parse(test_input)
assert parsed == expected
def test_should_parse_host_name_and_port(self):
parsed = Address.parse("localhost:7687")
self.assertEqual(parsed, ("localhost", 7687))
def test_should_parse_ipv6_address_and_port(self):
parsed = Address.parse("[::1]:7687")
self.assertEqual(parsed, ("::1", 7687, 0, 0))
def test_should_parse_ipv4_address_and_port(self):
parsed = Address.parse("127.0.0.1:7687")
self.assertEqual(parsed, ("127.0.0.1", 7687))
