def __new__(cls, uri, **config):
from neobolt.addressing import SocketAddress
from neobolt.direct import ConnectionPool, DEFAULT_PORT, connect
from neobolt.security import ENCRYPTION_OFF, ENCRYPTION_ON, SSL_AVAILABLE, SecurityPlan
cls._check_uri(uri)
if SocketAddress.parse_routing_context(uri):
raise ValueError("Parameters are not supported with scheme 'bolt'. Given URI: '%s'." % 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.
instance.address = SocketAddress.from_uri(uri, DEFAULT_PORT)
if config.get("encrypted") is None:
config["encrypted"] = ENCRYPTION_ON if SSL_AVAILABLE else ENCRYPTION_OFF
instance.security_plan = security_plan = SecurityPlan.build(**config)
instance.encrypted = security_plan.encrypted
def connector(address, **kwargs):
return connect(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 __new__(cls, uri, **config):
from neobolt.addressing import SocketAddress
from neobolt.direct import DEFAULT_PORT, connect
from neobolt.routing import RoutingConnectionPool
from neobolt.security import ENCRYPTION_OFF, ENCRYPTION_ON, SSL_AVAILABLE, SecurityPlan
cls._check_uri(uri)
instance = object.__new__(cls)
instance.initial_address = initial_address = SocketAddress.from_uri(uri, DEFAULT_PORT)
if config.get("encrypted") is None:
config["encrypted"] = ENCRYPTION_ON if SSL_AVAILABLE else ENCRYPTION_OFF
instance.security_plan = security_plan = SecurityPlan.build(**config)
instance.encrypted = security_plan.encrypted
routing_context = SocketAddress.parse_routing_context(uri)
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(address, **kwargs):
return connect(address, **dict(config, **kwargs))
pool = RoutingConnectionPool(connector, initial_address, routing_context, initial_address, **config)
try:
pool.update_routing_table()
except:
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):
from neobolt.addressing import SocketAddress
from neobolt.direct import DEFAULT_PORT, connect
from neobolt.routing import RoutingConnectionPool
from neobolt.security import make_ssl_context
cls._check_uri(uri)
instance = object.__new__(cls)
instance.initial_address = initial_address = SocketAddress.from_uri(
uri, 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 = SocketAddress.parse_routing_context(uri)
def connector(address, **kwargs):
return connect(address, **dict(config, **kwargs))
pool = RoutingConnectionPool(connector, initial_address,
routing_context, initial_address,
**config)
try:
pool.update_routing_table()
except:
pool.close()
raise
else:
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(SocketAddress.parse(
address, 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 __init__(self, protocol_version, address, sock, **config):
self.protocol_version = protocol_version
self.address = address
self.socket = sock
self.error_handler = config.get("error_handler", ConnectionErrorHandler())
self.server = ServerInfo(SocketAddress.from_socket(sock), protocol_version)
self.input_buffer = ChunkedInputBuffer()
self.output_buffer = ChunkedOutputBuffer()
self.packer = Packer(self.output_buffer)
self.unpacker = Unpacker()
self.responses = deque()
self._max_connection_lifetime = config.get("max_connection_lifetime", DEFAULT_MAX_CONNECTION_LIFETIME)
self._creation_timestamp = perf_counter()
# Determine the user agent and ensure it is a Unicode value
user_agent = config.get("user_agent", DEFAULT_USER_AGENT)
if isinstance(user_agent, bytes):
user_agent = user_agent.decode("UTF-8")
self.user_agent = user_agent
# Determine auth details
auth = config.get("auth")
if not auth:
self.auth_dict = {}
elif isinstance(auth, tuple) and 2 <= len(auth) <= 3:
self.auth_dict = vars(AuthToken("basic", *auth))
else:
try:
self.auth_dict = vars(auth)
except (KeyError, TypeError):
raise TypeError("Cannot determine auth details from %r" % auth)
# Pick up the server certificate, if any
self.der_encoded_server_certificate = config.get("der_encoded_server_certificate")
def main():
parser = ArgumentParser(description="Execute one or more Cypher statements using Bolt.")
parser.add_argument("statement", nargs="+")
parser.add_argument("-a", "--address", default="localhost:7687", metavar="ADDRESS")
parser.add_argument("-k", "--keys", action="store_true")
parser.add_argument("-P", "--password")
parser.add_argument("-p", "--parameter", action="append", metavar="NAME=VALUE")
parser.add_argument("-q", "--quiet", action="store_true")
parser.add_argument("-s", "--secure", action="store_true")
parser.add_argument("-U", "--user", default="neo4j")
parser.add_argument("-v", "--verbose", action="count")
parser.add_argument("-x", "--times", type=int, default=1)
parser.add_argument("-z", "--summary", action="store_true")
args = parser.parse_args()
if args.verbose:
Watcher("neobolt").watch(logging.DEBUG, stderr)
parameters = {}
for parameter in args.parameter or []:
name, _, value = parameter.partition("=")
if value == "" and name in parameters:
del parameters[name]
else:
try:
parameters[name] = json_loads(value)
except ValueError:
parameters[name] = value
cx = connect(SocketAddress.parse(args.address, DEFAULT_PORT), auth=(args.user, args.password), encrypted=args.secure)
try:
for _ in range(args.times):
for statement in args.statement:
metadata = {}
records = []
try:
cx.run(statement, parameters, on_success=metadata.update)
cx.pull_all(on_records=records.extend, on_success=metadata.update)
cx.sync()
except CypherError as error:
stderr.write("%s: %s\r\n" % (error.code, error.message))
else:
if not args.quiet:
if args.keys:
stdout.write("%s\r\n" % "\t".join(metadata.get("fields", ())))
for i, record in enumerate(records):
stdout.write("%s\r\n" % "\t".join(map(repr, record)))
if args.summary:
for key, value in sorted(metadata):
stdout.write("{}: {}\r\n".format(key, value))
stdout.write("\r\n")
finally:
cx.close()
def __init__(self, protocol_version, unresolved_address, sock, **config):
self.protocol_version = protocol_version
self.unresolved_address = unresolved_address
self.socket = sock
self.server = ServerInfo(SocketAddress.from_socket(sock),
protocol_version)
self.outbox = Outbox()
self.inbox = Inbox(BufferedSocket(self.socket, 32768),
on_error=self._set_defunct)
self.packer = Packer(self.outbox)
self.unpacker = Unpacker(self.inbox)
self.responses = deque()
self._max_connection_lifetime = config.get(
"max_connection_lifetime", DEFAULT_MAX_CONNECTION_LIFETIME)
self._creation_timestamp = perf_counter()
# Determine the user agent and ensure it is a Unicode value
user_agent = config.get("user_agent", get_user_agent())
if isinstance(user_agent, bytes):
user_agent = user_agent.decode("UTF-8")
self.user_agent = user_agent
# Determine auth details
auth = config.get("auth")
if not auth:
self.auth_dict = {}
elif isinstance(auth, tuple) and 2 <= len(auth) <= 3:
self.auth_dict = vars(AuthToken("basic", *auth))
else:
try:
self.auth_dict = vars(auth)
except (KeyError, TypeError):
raise AuthError("Cannot determine auth details from %r" % auth)
# Check for missing password
try:
credentials = self.auth_dict["credentials"]
except KeyError:
pass
else:
if credentials is None:
raise AuthError("Password cannot be None")
# Pick up the server certificate, if any
self.der_encoded_server_certificate = config.get(
"der_encoded_server_certificate")
def test_should_error_when_key_duplicate(self):
with self.assertRaises(ValueError):
SocketAddress.parse_routing_context("bolt+routing://127.0.0.1/?name=molly&name=white")
def test_should_error_when_value_missing(self):
with self.assertRaises(ValueError):
SocketAddress.parse_routing_context("bolt+routing://127.0.0.1/?name=&color=white")
def verify_routing_context(self, expected, uri):
context = SocketAddress.parse_routing_context(uri)
self.assertEqual(context, expected)
def test_should_fail_on_non_numeric_port(self):
with self.assertRaises(ValueError):
_ = SocketAddress.parse("127.0.0.1:X")
def test_should_parse_host_name_and_port(self):
parsed = SocketAddress.parse("localhost:7687")
self.assertEqual(parsed, ("localhost", 7687))
def test_should_parse_ipv6_address_and_port(self):
parsed = SocketAddress.parse("[::1]:7687")
self.assertEqual(parsed, ("::1", 7687, 0, 0))
def test_should_parse_ipv4_address_and_port(self):
parsed = SocketAddress.parse("127.0.0.1:7687")
self.assertEqual(parsed, ("127.0.0.1", 7687))
