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))