././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1617665406.4000027 neobolt-4.0.dev0/0002755000174500001730000000000000000000000013373 5ustar00janitorsbuild././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/MANIFEST.in0000644000174500001730000000020300000000000015122 0ustar00janitorsbuildglobal-exclude *.class *.pyc *.pyo *.so *.dll __pycache__ recursive-include neobolt *.c recursive-include neobolt *.pyx prune test ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1617665406.3960028 neobolt-4.0.dev0/PKG-INFO0000644000174500001730000000212500000000000014466 0ustar00janitorsbuildMetadata-Version: 1.1 Name: neobolt Version: 4.0.dev0 Summary: Neo4j Bolt connector for Python Home-page: https://github.com/neo4j-drivers/neobolt Author: Neo4j Sweden AB Author-email: drivers@neo4j.com License: Apache License, Version 2.0 Description: ======================================== Neobolt: Neo4j Bolt connector for Python ======================================== Neobolt is a Bolt connector library for Python. It is generally intended for use by a higher level `driver `_. Keywords: neo4j graph database Platform: UNKNOWN Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: Apache Software License Classifier: Operating System :: OS Independent Classifier: Topic :: Database Classifier: Topic :: Software Development Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.8 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/README.rst0000644000174500001730000000043200000000000015057 0ustar00janitorsbuild======================================== Neobolt: Neo4j Bolt connector for Python ======================================== Neobolt is a Bolt connector library for Python. It is generally intended for use by a higher level `driver `_. ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1617665406.3960028 neobolt-4.0.dev0/neobolt/0002755000174500001730000000000000000000000015035 5ustar00janitorsbuild././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/neobolt/__init__.py0000644000174500001730000000127300000000000017147 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/neobolt/__main__.py0000644000174500001730000000677700000000000017146 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from __future__ import unicode_literals import logging from argparse import ArgumentParser from json import loads as json_loads from sys import stdout, stderr from neobolt.addressing import SocketAddress from neobolt.diagnostics import Watcher from neobolt.direct import connect, DEFAULT_PORT from neobolt.exceptions import CypherError 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.send_all() cx.fetch_all() 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() if __name__ == "__main__": main() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/neobolt/addressing.py0000644000174500001730000001156500000000000017540 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from collections import namedtuple from socket import getaddrinfo, gaierror, SOCK_STREAM, IPPROTO_TCP from urllib.parse import urlparse, parse_qs VALID_IPv4_SEGMENTS = [str(i).encode("latin1") for i in range(0x100)] VALID_IPv6_SEGMENT_CHARS = b"0123456789abcdef" def is_ipv4_address(string): if not isinstance(string, bytes): string = str(string).encode("latin1") segments = string.split(b".") return len(segments) == 4 and all(segment in VALID_IPv4_SEGMENTS for segment in segments) def is_ipv6_address(string): if not isinstance(string, bytes): string = str(string).encode("latin1") segments = string.lower().split(b":") return 3 <= len(segments) <= 8 and all(all(c in VALID_IPv6_SEGMENT_CHARS for c in segment) for segment in segments) def is_ip_address(string): return is_ipv4_address(string) or is_ipv6_address(string) IPv4SocketAddress = namedtuple("Address", ["host", "port"]) IPv6SocketAddress = namedtuple("Address", ["host", "port", "flow_info", "scope_id"]) class SocketAddress(object): @classmethod def from_socket(cls, socket): address = socket.getpeername() if len(address) == 2: return IPv4SocketAddress(*address) elif len(address) == 4: return IPv6SocketAddress(*address) else: raise ValueError("Unsupported address {!r}".format(address)) @classmethod 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) @classmethod def parse(cls, string, default_port=0): """ Parse a string address, such as 'localhost:1234' or '[::1]:7687'. """ return cls.from_uri("//{}".format(string), default_port) @classmethod 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 class Resolver(object): """ A Resolver instance stores a list of addresses, each in a tuple, and provides methods to perform resolution on these, thereby replacing them with the resolved values. """ def __init__(self, custom_resolver=None): self.addresses = [] self.custom_resolver = custom_resolver def custom_resolve(self): """ If a custom resolver is defined, perform custom resolution on the contained addresses. :return: """ if not callable(self.custom_resolver): return new_addresses = [] for address in self.addresses: for new_address in self.custom_resolver(address): new_addresses.append(new_address) self.addresses = new_addresses def dns_resolve(self): """ Perform DNS resolution on the contained addresses. :return: """ new_addresses = [] for address in self.addresses: try: info = getaddrinfo(address[0], address[1], 0, SOCK_STREAM, IPPROTO_TCP) except gaierror: raise AddressError("Cannot resolve address {!r}".format(address)) else: for _, _, _, _, address in info: if len(address) == 4 and address[3] != 0: # skip any IPv6 addresses with a non-zero scope id # as these appear to cause problems on some platforms continue new_addresses.append(address) self.addresses = new_addresses class AddressError(Exception): """ Raised when a network address is invalid. """ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/neobolt/diagnostics.py0000644000174500001730000000536200000000000017722 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from logging import CRITICAL, ERROR, WARNING, INFO, DEBUG, Formatter, StreamHandler, getLogger from sys import stdout class ColourFormatter(Formatter): """ Colour formatter for pretty log output. """ def format(self, record): s = super(ColourFormatter, self).format(record) if record.levelno == CRITICAL: return "\x1b[31;1m%s\x1b[0m" % s # bright red elif record.levelno == ERROR: return "\x1b[33;1m%s\x1b[0m" % s # bright yellow elif record.levelno == WARNING: return "\x1b[33m%s\x1b[0m" % s # yellow elif record.levelno == INFO: return "\x1b[37m%s\x1b[0m" % s # white elif record.levelno == DEBUG: return "\x1b[36m%s\x1b[0m" % s # cyan else: return s class Watcher(object): """ Log watcher for monitoring driver and protocol activity. """ handlers = {} def __init__(self, logger_name): super(Watcher, self).__init__() self.logger_name = logger_name self.logger = getLogger(self.logger_name) self.formatter = ColourFormatter("%(asctime)s %(message)s") def __enter__(self): self.watch() return self def __exit__(self, exc_type, exc_val, exc_tb): self.stop() def watch(self, level=DEBUG, out=stdout): self.stop() handler = StreamHandler(out) handler.setFormatter(self.formatter) self.handlers[self.logger_name] = handler self.logger.addHandler(handler) self.logger.setLevel(level) def stop(self): try: self.logger.removeHandler(self.handlers[self.logger_name]) except KeyError: pass def watch(logger_name, level=DEBUG, out=stdout): """ Quick wrapper for using the Watcher. :param logger_name: name of logger to watch :param level: minimum log level to show (default INFO) :param out: where to send output (default stdout) :return: Watcher instance """ watcher = Watcher(logger_name) watcher.watch(level, out) return watcher ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/neobolt/direct.py0000644000174500001730000011454400000000000016670 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ This module contains the low-level functionality required for speaking Bolt. It is not intended to be used directly by driver users. Instead, the `session` module provides the main user-facing abstractions. """ from __future__ import division __all__ = [ "DEFAULT_PORT", "AbstractConnectionPool", "Connection", "ConnectionPool", "ServerInfo", "connect", ] from collections import deque from logging import getLogger from select import select from socket import socket, SOL_SOCKET, SO_KEEPALIVE, SHUT_RDWR, \ timeout as SocketTimeout, AF_INET, AF_INET6 from ssl import HAS_SNI, SSLSocket, SSLError from struct import pack as struct_pack, unpack as struct_unpack from threading import RLock, Condition from time import perf_counter from neobolt.addressing import SocketAddress, Resolver from neobolt.exceptions import ClientError, ProtocolError, SecurityError, \ ServiceUnavailable, AuthError, CypherError, IncompleteCommitError, \ ConnectionExpired, DatabaseUnavailableError, NotALeaderError, \ ForbiddenOnReadOnlyDatabaseError from neobolt.meta import get_user_agent from neobolt.packstream import Packer, Unpacker, UnpackableBuffer from neobolt.security import make_ssl_context DEFAULT_PORT = 7687 MAGIC_PREAMBLE = 0x6060B017 # Connection Pool Management DEFAULT_MAX_CONNECTION_LIFETIME = 3600 # 1h DEFAULT_MAX_CONNECTION_POOL_SIZE = 100 DEFAULT_CONNECTION_TIMEOUT = 5.0 # 5s DEFAULT_KEEP_ALIVE = True # Connection Settings DEFAULT_CONNECTION_ACQUISITION_TIMEOUT = 60 # 1m # Set up logger log = getLogger("neobolt") class AuthToken(object): """ Container for auth information """ #: By default we should not send any realm realm = None def __init__(self, scheme, principal, credentials, realm=None, **parameters): self.scheme = scheme self.principal = principal self.credentials = credentials if realm: self.realm = realm if parameters: self.parameters = parameters class ServerInfo(object): address = None def __init__(self, address, protocol_version): self.address = address self.protocol_version = protocol_version self.metadata = {} @property def agent(self): return self.metadata.get("server") def version_info(self): if not self.agent: return None _, _, value = self.agent.partition("/") value = value.replace("-", ".").split(".") for i, v in enumerate(value): try: value[i] = int(v) except ValueError: pass return tuple(value) class Outbox(object): def __init__(self, capacity=8192, max_chunk_size=16384): self._max_chunk_size = max_chunk_size self._header = 0 self._start = 2 self._end = 2 self._data = bytearray(capacity) def max_chunk_size(self): return self._max_chunk_size def clear(self): self._header = 0 self._start = 2 self._end = 2 self._data[0:2] = b"\x00\x00" def write(self, b): to_write = len(b) max_chunk_size = self._max_chunk_size pos = 0 while to_write > 0: chunk_size = self._end - self._start remaining = max_chunk_size - chunk_size if remaining == 0 or remaining < to_write <= max_chunk_size: self.chunk() else: wrote = min(to_write, remaining) new_end = self._end + wrote self._data[self._end:new_end] = b[pos:pos+wrote] self._end = new_end pos += wrote new_chunk_size = self._end - self._start self._data[self._header:(self._header + 2)] = struct_pack(">H", new_chunk_size) to_write -= wrote def chunk(self): self._header = self._end self._start = self._header + 2 self._end = self._start self._data[self._header:self._start] = b"\x00\x00" def view(self): end = self._end chunk_size = end - self._start if chunk_size == 0: return memoryview(self._data[:self._header]) else: return memoryview(self._data[:end]) class BufferedSocket(object): """ Wrapper for a regular socket, with an added a dynamically-resizing receive buffer to reduce the number of calls to recv. NOTE: not all socket methods are implemented yet """ def __init__(self, socket_, initial_capacity=0): self.socket = socket_ self.buffer = bytearray(initial_capacity) self.r_pos = 0 self.w_pos = 0 def _fill_buffer(self, min_bytes): """ Fill the buffer with at least `min_bytes` bytes, requesting more if the buffer has space. Internally, this method attempts to do as little allocation as possible and make as few calls to socket.recv as possible. """ # First, we need to calculate how much spare space exists between the # write cursor and the end of the buffer. space_at_end = len(self.buffer) - self.w_pos if min_bytes <= space_at_end: # If there's at least enough here for the minimum number of bytes # we need, then do nothing # pass elif min_bytes <= space_at_end + self.r_pos: # If the buffer contains enough space, but it's split between the # end of the buffer and recyclable space at the start of the # buffer, then recycle that space by pushing the remaining data # towards the front. # # print("Recycling {} bytes".format(self.r_pos)) size = self.w_pos - self.r_pos view = memoryview(self.buffer) self.buffer[0:size] = view[self.r_pos:self.w_pos] self.r_pos = 0 self.w_pos = size else: # Otherwise, there's just not enough space whichever way you shake # it. So, rebuild the buffer from scratch, taking the unread data # and appending empty space big enough to hold the minimum number # of bytes we're looking for. # # print("Rebuilding buffer from {} bytes ({} used) to " # "{} bytes".format(len(self.buffer), # self.w_pos - self.r_pos, # self.w_pos - self.r_pos + min_bytes)) self.buffer = (self.buffer[self.r_pos:self.w_pos] + bytearray(min_bytes)) self.w_pos -= self.r_pos self.r_pos = 0 min_end = self.w_pos + min_bytes end = len(self.buffer) view = memoryview(self.buffer) self.socket.setblocking(0) while self.w_pos < min_end: ready_to_read, _, _ = select([self.socket], [], []) subview = view[self.w_pos:end] n = self.socket.recv_into(subview, end - self.w_pos) if n == 0: raise OSError("No data") self.w_pos += n def recv_into(self, buffer, n_bytes=0, flags=0): """ Intercepts a regular socket.recv_into call, taking data from the internal buffer, if available. If not enough data exists in the buffer, more will be retrieved first. Unlike the lower-level call, this method will never return 0, instead raising an OSError if no data is returned on the underlying socket. :param buffer: :param n_bytes: :param flags: :raises OSError: :return: """ available = self.w_pos - self.r_pos required = n_bytes - available if required > 0: self._fill_buffer(required) view = memoryview(self.buffer) end = self.r_pos + n_bytes buffer[:] = view[self.r_pos:end] self.r_pos = end return n_bytes class Inbox(object): def __init__(self, s, on_error): super(Inbox, self).__init__() self.on_error = on_error self._messages = self._yield_messages(s) def __iter__(self): return self def __next__(self): return next(self._messages) @classmethod def _load_chunks(cls, sock, buffer): chunk_size = 0 while True: if chunk_size == 0: buffer.receive(sock, 2) chunk_size = buffer.pop_u16() if chunk_size > 0: buffer.receive(sock, chunk_size + 2) yield chunk_size def _yield_messages(self, sock): try: buffer = UnpackableBuffer() chunk_loader = self._load_chunks(sock, buffer) unpacker = Unpacker(buffer) details = [] while True: unpacker.reset() details[:] = () chunk_size = -1 while chunk_size != 0: chunk_size = next(chunk_loader) summary_signature = None summary_metadata = None size, signature = unpacker.unpack_structure_header() if size > 1: raise ProtocolError("Expected one field") if signature == b"\x71": data = unpacker.unpack() details.append(data) else: summary_signature = signature summary_metadata = unpacker.unpack_map() yield details, summary_signature, summary_metadata except OSError as error: self.on_error(error) class Connection(object): """ Server connection for Bolt protocol v1. A :class:`.Connection` should be constructed following a successful Bolt handshake and takes the socket over which the handshake was carried out. .. note:: logs at INFO level """ #: The protocol version in use on this connection protocol_version = 0 #: Server details for this connection server = None in_use = False _closed = False _defunct = False #: The pool of which this connection is a member pool = None #: Error class used for raising connection errors # TODO: separate errors for connector API Error = ServiceUnavailable 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") @property def secure(self): return isinstance(self.socket, SSLSocket) @property def local_port(self): try: return self.socket.getsockname()[1] except IOError: return 0 def hello(self): headers = {"user_agent": self.user_agent} headers.update(self.auth_dict) logged_headers = dict(headers) if "credentials" in logged_headers: logged_headers["credentials"] = "*******" log.debug("[#%04X] C: HELLO %r", self.local_port, logged_headers) self._append(b"\x01", (headers,), response=InitResponse(self, on_success=self.server.metadata.update)) self.send_all() self.fetch_all() def __del__(self): try: self.close() except: pass def __enter__(self): return self def __exit__(self, exc_type, exc_value, traceback): self.close() def run(self, statement, parameters=None, mode=None, bookmarks=None, metadata=None, timeout=None, **handlers): if not parameters: parameters = {} extra = {} if mode: extra["mode"] = mode if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided within an iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout: try: extra["tx_timeout"] = int(1000 * timeout) except TypeError: raise TypeError("Timeout must be specified as a number of seconds") fields = (statement, parameters, extra) log.debug("[#%04X] C: RUN %s", self.local_port, " ".join(map(repr, fields))) if statement.upper() == u"COMMIT": self._append(b"\x10", fields, CommitResponse(self, **handlers)) else: self._append(b"\x10", fields, Response(self, **handlers)) def discard_all(self, **handlers): log.debug("[#%04X] C: DISCARD_ALL", self.local_port) self._append(b"\x2F", (), Response(self, **handlers)) def pull_all(self, **handlers): log.debug("[#%04X] C: PULL_ALL", self.local_port) self._append(b"\x3F", (), Response(self, **handlers)) def begin(self, mode=None, bookmarks=None, metadata=None, timeout=None, **handlers): extra = {} if mode: extra["mode"] = mode if bookmarks: try: extra["bookmarks"] = list(bookmarks) except TypeError: raise TypeError("Bookmarks must be provided within an iterable") if metadata: try: extra["tx_metadata"] = dict(metadata) except TypeError: raise TypeError("Metadata must be coercible to a dict") if timeout: try: extra["tx_timeout"] = int(1000 * timeout) except TypeError: raise TypeError("Timeout must be specified as a number of seconds") log.debug("[#%04X] C: BEGIN %r", self.local_port, extra) self._append(b"\x11", (extra,), Response(self, **handlers)) def commit(self, **handlers): log.debug("[#%04X] C: COMMIT", self.local_port) self._append(b"\x12", (), CommitResponse(self, **handlers)) def rollback(self, **handlers): log.debug("[#%04X] C: ROLLBACK", self.local_port) self._append(b"\x13", (), Response(self, **handlers)) def _append(self, signature, fields=(), response=None): """ Add a message to the outgoing queue. :arg signature: the signature of the message :arg fields: the fields of the message as a tuple :arg response: a response object to handle callbacks """ self.packer.pack_struct(signature, fields) self.outbox.chunk() self.outbox.chunk() self.responses.append(response) def reset(self): """ Add a RESET message to the outgoing queue, send it and consume all remaining messages. """ def fail(metadata): raise ProtocolError("RESET failed %r" % metadata) log.debug("[#%04X] C: RESET", self.local_port) self._append(b"\x0F", response=Response(self, on_failure=fail)) self.send_all() self.fetch_all() def _send_all(self): data = self.outbox.view() if data: self.socket.sendall(data) self.outbox.clear() def send_all(self): """ Send all queued messages to the server. """ if self.closed(): raise self.Error("Failed to write to closed connection " "{!r} ({!r})".format(self.unresolved_address, self.server.address)) if self.defunct(): raise self.Error("Failed to write to defunct connection " "{!r} ({!r})".format(self.unresolved_address, self.server.address)) try: self._send_all() except (IOError, OSError) as error: log.error("Failed to write data to connection " "{!r} ({!r}); ({!r})". format(self.unresolved_address, self.server.address, "; ".join(map(repr, error.args)))) if self.pool: self.pool.deactivate(self.unresolved_address) raise def fetch_message(self): """ Receive at least one message from the server, if available. :return: 2-tuple of number of detail messages and number of summary messages fetched """ if self._closed: raise self.Error("Failed to read from closed connection " "{!r} ({!r})".format(self.unresolved_address, self.server.address)) if self._defunct: raise self.Error("Failed to read from defunct connection " "{!r} ({!r})".format(self.unresolved_address, self.server.address)) if not self.responses: return 0, 0 # Receive exactly one message try: details, summary_signature, summary_metadata = next(self.inbox) except (IOError, OSError) as error: log.error("Failed to read data from connection " "{!r} ({!r}); ({!r})". format(self.unresolved_address, self.server.address, "; ".join(map(repr, error.args)))) if self.pool: self.pool.deactivate(self.unresolved_address) raise if details: log.debug("[#%04X] S: RECORD * %d", self.local_port, len(details)) # TODO self.responses[0].on_records(details) if summary_signature is None: return len(details), 0 response = self.responses.popleft() response.complete = True if summary_signature == b"\x70": log.debug("[#%04X] S: SUCCESS %r", self.local_port, summary_metadata) response.on_success(summary_metadata or {}) elif summary_signature == b"\x7E": log.debug("[#%04X] S: IGNORED", self.local_port) response.on_ignored(summary_metadata or {}) elif summary_signature == b"\x7F": log.debug("[#%04X] S: FAILURE %r", self.local_port, summary_metadata) try: response.on_failure(summary_metadata or {}) except (ConnectionExpired, ServiceUnavailable, DatabaseUnavailableError): if self.pool: self.pool.deactivate(self.unresolved_address), raise except (NotALeaderError, ForbiddenOnReadOnlyDatabaseError): if self.pool: self.pool.remove_writer(self.unresolved_address), raise else: raise ProtocolError("Unexpected response message with " "signature %02X" % summary_signature) return len(details), 1 def _set_defunct(self, error=None): message = ("Failed to read from defunct connection " "{!r} ({!r})".format(self.unresolved_address, self.server.address)) log.error(message) # We were attempting to receive data but the connection # has unexpectedly terminated. So, we need to close the # connection from the client side, and remove the address # from the connection pool. self._defunct = True self.close() if self.pool: self.pool.deactivate(self.unresolved_address) # Iterate through the outstanding responses, and if any correspond # to COMMIT requests then raise an error to signal that we are # unable to confirm that the COMMIT completed successfully. for response in self.responses: if isinstance(response, CommitResponse): raise IncompleteCommitError(message) raise self.Error(message) def timedout(self): return 0 <= self._max_connection_lifetime <= perf_counter() - self._creation_timestamp def fetch_all(self): """ Fetch all outstanding messages. :return: 2-tuple of number of detail messages and number of summary messages fetched """ detail_count = summary_count = 0 while self.responses: response = self.responses[0] while not response.complete: detail_delta, summary_delta = self.fetch_message() detail_count += detail_delta summary_count += summary_delta return detail_count, summary_count def close(self): """ Close the connection. """ if not self._closed: if not self._defunct: log.debug("[#%04X] C: GOODBYE", self.local_port) self._append(b"\x02", ()) try: self._send_all() except: pass log.debug("[#%04X] C: ", self.local_port) try: self.socket.close() except IOError: pass finally: self._closed = True def closed(self): return self._closed def defunct(self): return self._defunct class AbstractConnectionPool(object): """ A collection of connections to one or more server addresses. """ _closed = False def __init__(self, connector, **config): self.connector = connector self.connections = {} self.lock = RLock() self.cond = Condition(self.lock) self._max_connection_pool_size = config.get("max_connection_pool_size", DEFAULT_MAX_CONNECTION_POOL_SIZE) self._connection_acquisition_timeout = config.get("connection_acquisition_timeout", DEFAULT_CONNECTION_ACQUISITION_TIMEOUT) def __enter__(self): return self def __exit__(self, exc_type, exc_value, traceback): self.close() def acquire_direct(self, address): """ Acquire a connection to a given address from the pool. The address supplied should always be an IP address, not a host name. This method is thread safe. """ if self.closed(): raise ServiceUnavailable("Connection pool closed") with self.lock: try: connections = self.connections[address] except KeyError: connections = self.connections[address] = deque() connection_acquisition_start_timestamp = perf_counter() while True: # try to find a free connection in pool for connection in list(connections): if connection.closed() or connection.defunct() or connection.timedout(): connections.remove(connection) continue if not connection.in_use: connection.in_use = True return connection # all connections in pool are in-use infinite_connection_pool = (self._max_connection_pool_size < 0 or self._max_connection_pool_size == float("inf")) can_create_new_connection = infinite_connection_pool or len(connections) < self._max_connection_pool_size if can_create_new_connection: try: connection = self.connector(address) except ServiceUnavailable: self.remove(address) raise else: connection.pool = self connection.in_use = True connections.append(connection) return connection # failed to obtain a connection from pool because the pool is full and no free connection in the pool span_timeout = self._connection_acquisition_timeout - (perf_counter() - connection_acquisition_start_timestamp) if span_timeout > 0: self.cond.wait(span_timeout) # if timed out, then we throw error. This time computation is needed, as with python 2.7, we cannot # tell if the condition is notified or timed out when we come to this line if self._connection_acquisition_timeout <= (perf_counter() - connection_acquisition_start_timestamp): raise ClientError("Failed to obtain a connection from pool within {!r}s".format( self._connection_acquisition_timeout)) else: raise ClientError("Failed to obtain a connection from pool within {!r}s".format(self._connection_acquisition_timeout)) def acquire(self, access_mode=None): """ Acquire a connection to a server that can satisfy a set of parameters. :param access_mode: """ def release(self, connection): """ Release a connection back into the pool. This method is thread safe. """ with self.lock: connection.in_use = False self.cond.notify_all() def in_use_connection_count(self, address): """ Count the number of connections currently in use to a given address. """ try: connections = self.connections[address] except KeyError: return 0 else: return sum(1 if connection.in_use else 0 for connection in connections) def deactivate(self, address): """ Deactivate an address from the connection pool, if present, closing all idle connection to that address """ with self.lock: try: connections = self.connections[address] except KeyError: # already removed from the connection pool return for conn in list(connections): if not conn.in_use: connections.remove(conn) try: conn.close() except IOError: pass if not connections: self.remove(address) def remove(self, address): """ Remove an address from the connection pool, if present, closing all connections to that address. """ with self.lock: for connection in self.connections.pop(address, ()): try: connection.close() except IOError: pass def close(self): """ Close all connections and empty the pool. This method is thread safe. """ if self._closed: return try: with self.lock: if not self._closed: self._closed = True for address in list(self.connections): self.remove(address) except TypeError as e: pass def closed(self): """ Return :const:`True` if this pool is closed, :const:`False` otherwise. """ with self.lock: return self._closed class ConnectionPool(AbstractConnectionPool): def __init__(self, connector, address, **config): super(ConnectionPool, self).__init__(connector, **config) self.address = address def acquire(self, access_mode=None): return self.acquire_direct(self.address) class Response(object): """ Subscriber object for a full response (zero or more detail messages followed by one summary message). """ def __init__(self, connection, **handlers): self.connection = connection self.handlers = handlers self.complete = False def on_records(self, records): """ Called when one or more RECORD messages have been received. """ handler = self.handlers.get("on_records") if callable(handler): handler(records) def on_success(self, metadata): """ Called when a SUCCESS message has been received. """ handler = self.handlers.get("on_success") if callable(handler): handler(metadata) handler = self.handlers.get("on_summary") if callable(handler): handler() def on_failure(self, metadata): """ Called when a FAILURE message has been received. """ self.connection.reset() handler = self.handlers.get("on_failure") if callable(handler): handler(metadata) handler = self.handlers.get("on_summary") if callable(handler): handler() raise CypherError.hydrate(**metadata) def on_ignored(self, metadata=None): """ Called when an IGNORED message has been received. """ handler = self.handlers.get("on_ignored") if callable(handler): handler(metadata) handler = self.handlers.get("on_summary") if callable(handler): handler() class InitResponse(Response): def on_failure(self, metadata): code = metadata.get("code") message = metadata.get("message", "Connection initialisation failed") if code == "Neo.ClientError.Security.Unauthorized": raise AuthError(message) else: raise ServiceUnavailable(message) class CommitResponse(Response): pass # TODO: remove in 2.0 def _last_bookmark(b0, b1): """ Return the latest of two bookmarks by looking for the maximum integer value following the last colon in the bookmark string. """ n = [None, None] _, _, n[0] = b0.rpartition(":") _, _, n[1] = b1.rpartition(":") for i in range(2): try: n[i] = int(n[i]) except ValueError: raise ValueError("Invalid bookmark: {}".format(b0)) return b0 if n[0] > n[1] else b1 # TODO: remove in 2.0 def last_bookmark(bookmarks): """ The bookmark returned by the last :class:`.Transaction`. """ last = None for bookmark in bookmarks: if last is None: last = bookmark else: last = _last_bookmark(last, bookmark) return last def _connect(resolved_address, **config): """ :param resolved_address: :param config: :return: socket object """ s = None try: if len(resolved_address) == 2: s = socket(AF_INET) elif len(resolved_address) == 4: s = socket(AF_INET6) else: raise ValueError("Unsupported address " "{!r}".format(resolved_address)) t = s.gettimeout() s.settimeout(config.get("connection_timeout", DEFAULT_CONNECTION_TIMEOUT)) log.debug("[#0000] C: %s", resolved_address) s.connect(resolved_address) s.settimeout(t) keep_alive = 1 if config.get("keep_alive", DEFAULT_KEEP_ALIVE) else 0 s.setsockopt(SOL_SOCKET, SO_KEEPALIVE, keep_alive) except SocketTimeout: log.debug("[#0000] C: %s", resolved_address) log.debug("[#0000] C: %s", resolved_address) s.close() raise ServiceUnavailable("Timed out trying to establish connection " "to {!r}".format(resolved_address)) except OSError as error: log.debug("[#0000] C: %s %s", type(error).__name__, " ".join(map(repr, error.args))) log.debug("[#0000] C: %s", resolved_address) s.close() raise ServiceUnavailable("Failed to establish connection to {!r} " "(reason {})".format(resolved_address, error)) else: return s def _secure(s, host, ssl_context): local_port = s.getsockname()[1] # Secure the connection if an SSL context has been provided if ssl_context: log.debug("[#%04X] C: %s", local_port, host) try: sni_host = host if HAS_SNI and host else None s = ssl_context.wrap_socket(s, server_hostname=sni_host) except SSLError as cause: s.close() error = SecurityError("Failed to establish secure connection " "to {!r}".format(cause.args[1])) error.__cause__ = cause raise error else: # Check that the server provides a certificate der_encoded_server_certificate = s.getpeercert(binary_form=True) if der_encoded_server_certificate is None: s.close() raise ProtocolError("When using a secure socket, the server " "should always provide a certificate") else: der_encoded_server_certificate = None return s, der_encoded_server_certificate def _handshake(s, resolved_address, der_encoded_server_certificate, **config): """ :param s: :return: """ local_port = s.getsockname()[1] # Send details of the protocol versions supported supported_versions = [3, 0, 0, 0] handshake = [MAGIC_PREAMBLE] + supported_versions log.debug("[#%04X] C: 0x%08X", local_port, MAGIC_PREAMBLE) log.debug("[#%04X] C: 0x%08X 0x%08X 0x%08X 0x%08X", local_port, *supported_versions) data = b"".join(struct_pack(">I", num) for num in handshake) s.sendall(data) # Handle the handshake response ready_to_read = False while not ready_to_read: ready_to_read, _, _ = select((s,), (), (), 1) try: data = s.recv(4) except OSError: raise ServiceUnavailable("Failed to read any data from server {!r} " "after connected".format(resolved_address)) data_size = len(data) if data_size == 0: # If no data is returned after a successful select # response, the server has closed the connection log.debug("[#%04X] S: ", local_port) s.close() raise ServiceUnavailable("Connection to %r closed without handshake " "response" % (resolved_address,)) if data_size != 4: # Some garbled data has been received log.debug("[#%04X] S: @*#!", local_port) s.close() raise ProtocolError("Expected four byte Bolt handshake response " "from %r, received %r instead; check for " "incorrect port number" % (resolved_address, data)) agreed_version, = struct_unpack(">I", data) log.debug("[#%04X] S: 0x%08X", local_port, agreed_version) if agreed_version == 0: log.debug("[#%04X] C: ", local_port) s.shutdown(SHUT_RDWR) s.close() elif agreed_version in (3,): connection = Connection( agreed_version, resolved_address, s, der_encoded_server_certificate=der_encoded_server_certificate, **config) connection.hello() return connection elif agreed_version == 0x48545450: log.debug("[#%04X] S: ", local_port) s.close() raise ServiceUnavailable("Cannot to connect to Bolt service on {!r} " "(looks like HTTP)".format(resolved_address)) else: log.debug("[#%04X] S: ", local_port) s.close() raise ProtocolError("Unknown Bolt protocol version: " "{}".format(agreed_version)) def connect(address, **config): """ Connect and perform a handshake and return a valid Connection object, assuming a protocol version can be agreed. """ ssl_context = make_ssl_context(**config) last_error = None # Establish a connection to the host and port specified # Catches refused connections see: # https://docs.python.org/2/library/errno.html log.debug("[#0000] C: %s", address) resolver = Resolver(custom_resolver=config.get("resolver")) resolver.addresses.append(address) resolver.custom_resolve() resolver.dns_resolve() for resolved_address in resolver.addresses: s = None try: host = address[0] s = _connect(resolved_address, **config) s, der_encoded_server_certificate = _secure(s, host, ssl_context) connection = _handshake(s, address, der_encoded_server_certificate, **config) except Exception as error: if s: s.close() last_error = error else: return connection if last_error is None: raise ServiceUnavailable("Failed to resolve addresses for %s" % address) else: raise last_error ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/neobolt/exceptions.py0000644000174500001730000001245200000000000017572 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ This module contains the core driver exceptions. """ class ProtocolError(Exception): """ Raised when an unexpected or unsupported protocol event occurs. """ class ServiceUnavailable(Exception): """ Raised when no database service is available. """ class IncompleteCommitError(Exception): """ Raised when a disconnection occurs while still waiting for a commit response. For non-idempotent write transactions, this leaves the data in an unknown state with regard to whether the transaction completed successfully or not. """ class ConnectionExpired(Exception): """ Raised when a connection is no longer available for the purpose it was originally acquired. """ class SecurityError(Exception): """ Raised when an action is denied due to security settings. """ class CypherError(Exception): """ Raised when the Cypher engine returns an error to the client. """ message = None code = None classification = None category = None title = None metadata = None @classmethod def hydrate(cls, message=None, code=None, **metadata): message = message or "An unknown error occurred." code = code or "Neo.DatabaseError.General.UnknownError" try: _, classification, category, title = code.split(".") except ValueError: classification = "DatabaseError" category = "General" title = "UnknownError" error_class = cls._extract_error_class(classification, code) inst = error_class(message) inst.message = message inst.code = code inst.classification = classification inst.category = category inst.title = title inst.metadata = metadata return inst @classmethod def _extract_error_class(cls, classification, code): if classification == "ClientError": try: return client_errors[code] except KeyError: return ClientError elif classification == "TransientError": try: return transient_errors[code] except KeyError: return TransientError elif classification == "DatabaseError": return DatabaseError else: return cls class ClientError(CypherError): """ The Client sent a bad request - changing the request might yield a successful outcome. """ class DatabaseError(CypherError): """ The database failed to service the request. """ class TransientError(CypherError): """ The database cannot service the request right now, retrying later might yield a successful outcome. """ class DatabaseUnavailableError(TransientError): """ """ class ConstraintError(ClientError): """ """ class CypherSyntaxError(ClientError): """ """ class CypherTypeError(ClientError): """ """ class NotALeaderError(ClientError): """ """ class Forbidden(ClientError, SecurityError): """ """ class ForbiddenOnReadOnlyDatabaseError(Forbidden): """ """ class AuthError(ClientError, SecurityError): """ Raised when authentication failure occurs. """ client_errors = { # ConstraintError "Neo.ClientError.Schema.ConstraintValidationFailed": ConstraintError, "Neo.ClientError.Schema.ConstraintViolation": ConstraintError, "Neo.ClientError.Statement.ConstraintVerificationFailed": ConstraintError, "Neo.ClientError.Statement.ConstraintViolation": ConstraintError, # CypherSyntaxError "Neo.ClientError.Statement.InvalidSyntax": CypherSyntaxError, "Neo.ClientError.Statement.SyntaxError": CypherSyntaxError, # CypherTypeError "Neo.ClientError.Procedure.TypeError": CypherTypeError, "Neo.ClientError.Statement.InvalidType": CypherTypeError, "Neo.ClientError.Statement.TypeError": CypherTypeError, # Forbidden "Neo.ClientError.General.ForbiddenOnReadOnlyDatabase": ForbiddenOnReadOnlyDatabaseError, "Neo.ClientError.General.ReadOnly": Forbidden, "Neo.ClientError.Schema.ForbiddenOnConstraintIndex": Forbidden, "Neo.ClientError.Schema.IndexBelongsToConstraint": Forbidden, "Neo.ClientError.Security.Forbidden": Forbidden, "Neo.ClientError.Transaction.ForbiddenDueToTransactionType": Forbidden, # AuthError "Neo.ClientError.Security.AuthorizationFailed": AuthError, "Neo.ClientError.Security.Unauthorized": AuthError, # NotALeaderError "Neo.ClientError.Cluster.NotALeader": NotALeaderError } transient_errors = { # DatabaseUnavailableError "Neo.TransientError.General.DatabaseUnavailable": DatabaseUnavailableError } ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/neobolt/meta.py0000644000174500001730000000310300000000000016330 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. package = "neobolt" version = "4.0.dev0" def get_user_agent(): """ Obtain the default user agent string sent to the server after a successful handshake. """ from sys import platform, version_info template = "neobolt/{} Python/{}.{}.{}-{}-{} ({})" fields = (version,) + tuple(version_info) + (platform,) return template.format(*fields) def deprecated(message): """ Decorator for deprecating functions and methods. :: @deprecated("'foo' has been deprecated in favour of 'bar'") def foo(x): pass """ def f__(f): def f_(*args, **kwargs): from warnings import warn warn(message, category=DeprecationWarning, stacklevel=2) return f(*args, **kwargs) f_.__name__ = f.__name__ f_.__doc__ = f.__doc__ f_.__dict__.update(f.__dict__) return f_ return f__ ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1617665406.3960028 neobolt-4.0.dev0/neobolt/packstream/0002755000174500001730000000000000000000000017167 5ustar00janitorsbuild././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/neobolt/packstream/__init__.py0000644000174500001730000000156300000000000021303 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. __all__ = [ "Packer", "Unpacker", "UnpackableBuffer", ] from neobolt.packstream.packer import Packer from neobolt.packstream.unpacker import Unpacker, UnpackableBuffer ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/neobolt/packstream/packer.py0000644000174500001730000002351100000000000021006 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from struct import pack as struct_pack from neobolt.types import Structure NULL_ = b"\xC0" FALSE = b"\xC2" TRUE = b"\xC3" PACKED_UINT_8 = [struct_pack(">B", value) for value in range(0x100)] PACKED_UINT_16 = [struct_pack(">H", value) for value in range(0x10000)] UNPACKED_UINT_8 = {bytes(bytearray([x])): x for x in range(0x100)} UNPACKED_UINT_16 = {struct_pack(">H", x): x for x in range(0x10000)} UNPACKED_MARKERS = {NULL_: None, TRUE: True, FALSE: False} UNPACKED_MARKERS.update({bytes(bytearray([z])): z for z in range(0x00, 0x80)}) UNPACKED_MARKERS.update({bytes(bytearray([z + 256])): z for z in range(-0x10, 0x00)}) INT64_HI = 2 ** 63 INT64_LO = -(2 ** 63) class Packer(object): def __init__(self, stream): self.stream = stream self._write = self.stream.write def pack_raw(self, data): self._write(data) def pack(self, value): return self._pack(value) def _pack(self, value): write = self._write # None if value is None: write(b"\xC0") # NULL # Boolean elif value is True: write(b"\xC3") elif value is False: write(b"\xC2") # Float (only double precision is supported) elif isinstance(value, float): write(b"\xC1") write(struct_pack(">d", value)) # Integer elif isinstance(value, int): if -0x10 <= value < 0x80: write(PACKED_UINT_8[value % 0x100]) elif -0x80 <= value < -0x10: write(b"\xC8") write(PACKED_UINT_8[value % 0x100]) elif -0x8000 <= value < 0x8000: write(b"\xC9") write(PACKED_UINT_16[value % 0x10000]) elif -0x80000000 <= value < 0x80000000: write(b"\xCA") write(struct_pack(">i", value)) elif INT64_LO <= value < INT64_HI: write(b"\xCB") write(struct_pack(">q", value)) else: raise OverflowError("Integer %s out of range" % value) # String elif isinstance(value, str): if isinstance(value, bytes): value_bytes = value else: value_bytes = value.encode("utf-8") self.pack_string_header(len(value_bytes)) self.pack_raw(value_bytes) # Bytes (deliberately listed after String since in # Python 2, bytes should be treated as a String) elif isinstance(value, bytes): self.pack_bytes_header(len(value)) self.pack_raw(value) elif isinstance(value, bytearray): self.pack_bytes_header(len(value)) self.pack_raw(bytes(value)) # List elif isinstance(value, list): self.pack_list_header(len(value)) for item in value: self._pack(item) # Map elif isinstance(value, dict): self.pack_map_header(len(value)) for key, item in value.items(): self._pack(key) self._pack(item) # Structure elif isinstance(value, Structure): self.pack_struct(value.tag, value.fields) # Other else: raise ValueError("Values of type %s are not supported" % type(value)) def pack_bytes_header(self, size): write = self._write if size < 0x100: write(b"\xCC") write(PACKED_UINT_8[size]) elif size < 0x10000: write(b"\xCD") write(PACKED_UINT_16[size]) elif size < 0x100000000: write(b"\xCE") write(struct_pack(">I", size)) else: raise OverflowError("Bytes header size out of range") def pack_string_header(self, size): write = self._write if size == 0x00: write(b"\x80") elif size == 0x01: write(b"\x81") elif size == 0x02: write(b"\x82") elif size == 0x03: write(b"\x83") elif size == 0x04: write(b"\x84") elif size == 0x05: write(b"\x85") elif size == 0x06: write(b"\x86") elif size == 0x07: write(b"\x87") elif size == 0x08: write(b"\x88") elif size == 0x09: write(b"\x89") elif size == 0x0A: write(b"\x8A") elif size == 0x0B: write(b"\x8B") elif size == 0x0C: write(b"\x8C") elif size == 0x0D: write(b"\x8D") elif size == 0x0E: write(b"\x8E") elif size == 0x0F: write(b"\x8F") elif size < 0x100: write(b"\xD0") write(PACKED_UINT_8[size]) elif size < 0x10000: write(b"\xD1") write(PACKED_UINT_16[size]) elif size < 0x100000000: write(b"\xD2") write(struct_pack(">I", size)) else: raise OverflowError("String header size out of range") def pack_list_header(self, size): write = self._write if size == 0x00: write(b"\x90") elif size == 0x01: write(b"\x91") elif size == 0x02: write(b"\x92") elif size == 0x03: write(b"\x93") elif size == 0x04: write(b"\x94") elif size == 0x05: write(b"\x95") elif size == 0x06: write(b"\x96") elif size == 0x07: write(b"\x97") elif size == 0x08: write(b"\x98") elif size == 0x09: write(b"\x99") elif size == 0x0A: write(b"\x9A") elif size == 0x0B: write(b"\x9B") elif size == 0x0C: write(b"\x9C") elif size == 0x0D: write(b"\x9D") elif size == 0x0E: write(b"\x9E") elif size == 0x0F: write(b"\x9F") elif size < 0x100: write(b"\xD4") write(PACKED_UINT_8[size]) elif size < 0x10000: write(b"\xD5") write(PACKED_UINT_16[size]) elif size < 0x100000000: write(b"\xD6") write(struct_pack(">I", size)) else: raise OverflowError("List header size out of range") def pack_list_stream_header(self): self._write(b"\xD7") def pack_map_header(self, size): write = self._write if size == 0x00: write(b"\xA0") elif size == 0x01: write(b"\xA1") elif size == 0x02: write(b"\xA2") elif size == 0x03: write(b"\xA3") elif size == 0x04: write(b"\xA4") elif size == 0x05: write(b"\xA5") elif size == 0x06: write(b"\xA6") elif size == 0x07: write(b"\xA7") elif size == 0x08: write(b"\xA8") elif size == 0x09: write(b"\xA9") elif size == 0x0A: write(b"\xAA") elif size == 0x0B: write(b"\xAB") elif size == 0x0C: write(b"\xAC") elif size == 0x0D: write(b"\xAD") elif size == 0x0E: write(b"\xAE") elif size == 0x0F: write(b"\xAF") elif size < 0x100: write(b"\xD8") write(PACKED_UINT_8[size]) elif size < 0x10000: write(b"\xD9") write(PACKED_UINT_16[size]) elif size < 0x100000000: write(b"\xDA") write(struct_pack(">I", size)) else: raise OverflowError("Map header size out of range") def pack_map_stream_header(self): self._write(b"\xDB") def pack_struct(self, signature, fields): if len(signature) != 1 or not isinstance(signature, bytes): raise ValueError("Structure signature must be a single byte value") write = self._write size = len(fields) if size == 0x00: write(b"\xB0") elif size == 0x01: write(b"\xB1") elif size == 0x02: write(b"\xB2") elif size == 0x03: write(b"\xB3") elif size == 0x04: write(b"\xB4") elif size == 0x05: write(b"\xB5") elif size == 0x06: write(b"\xB6") elif size == 0x07: write(b"\xB7") elif size == 0x08: write(b"\xB8") elif size == 0x09: write(b"\xB9") elif size == 0x0A: write(b"\xBA") elif size == 0x0B: write(b"\xBB") elif size == 0x0C: write(b"\xBC") elif size == 0x0D: write(b"\xBD") elif size == 0x0E: write(b"\xBE") elif size == 0x0F: write(b"\xBF") elif size < 0x100: write(b"\xDC") write(PACKED_UINT_8[size]) elif size < 0x10000: write(b"\xDD") write(PACKED_UINT_16[size]) else: raise OverflowError("Structure size out of range") write(signature) for field in fields: self._pack(field) def pack_end_of_stream(self): self._write(b"\xDF") ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/neobolt/packstream/unpacker.py0000644000174500001730000002156000000000000021353 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from codecs import decode from struct import unpack as struct_unpack from neobolt.types import Structure EndOfStream = object() class UnpackableBuffer(object): initial_capacity = 8192 def __init__(self, data=None): if data is None: self.data = bytearray(self.initial_capacity) self.used = 0 else: self.data = bytearray(data) self.used = len(self.data) self.p = 0 def reset(self): self.used = 0 self.p = 0 def ensure_capacity(self, size): if size > len(self.data): self.data += bytearray(size - len(self.data)) def read(self, n=1): view = memoryview(self.data) q = self.p + n subview = view[self.p:q] self.p = q return subview def read_u8(self): if self.used - self.p >= 1: value = self.data[self.p] self.p += 1 return value else: return -1 def pop_u16(self): """ Remove the last two bytes of data, returning them as a big-endian 16-bit unsigned integer. """ if self.used >= 2: value = 0x100 * self.data[self.used - 2] + self.data[self.used - 1] self.used -= 2 return value else: return -1 def receive(self, sock, n_bytes): end = self.used + n_bytes if end > len(self.data): self.data += bytearray(end - len(self.data)) view = memoryview(self.data) while self.used < end: n = sock.recv_into(view[self.used:end], end - self.used) if n == 0: raise OSError("No data") self.used += n class Unpacker(object): def __init__(self, unpackable): self.unpackable = unpackable def reset(self): self.unpackable.reset() def read(self, n=1): return self.unpackable.read(n) def read_u8(self): return self.unpackable.read_u8() def unpack(self): return self._unpack() def _unpack(self): marker = self.read_u8() if marker == -1: raise ValueError("Nothing to unpack") # Tiny Integer if 0x00 <= marker <= 0x7F: return marker elif 0xF0 <= marker <= 0xFF: return marker - 0x100 # Null elif marker == 0xC0: return None # Float elif marker == 0xC1: value, = struct_unpack(">d", self.read(8)) return value # Boolean elif marker == 0xC2: return False elif marker == 0xC3: return True # Integer elif marker == 0xC8: return struct_unpack(">b", self.read(1))[0] elif marker == 0xC9: return struct_unpack(">h", self.read(2))[0] elif marker == 0xCA: return struct_unpack(">i", self.read(4))[0] elif marker == 0xCB: return struct_unpack(">q", self.read(8))[0] # Bytes elif marker == 0xCC: size, = struct_unpack(">B", self.read(1)) return self.read(size).tobytes() elif marker == 0xCD: size, = struct_unpack(">H", self.read(2)) return self.read(size).tobytes() elif marker == 0xCE: size, = struct_unpack(">I", self.read(4)) return self.read(size).tobytes() else: marker_high = marker & 0xF0 # String if marker_high == 0x80: # TINY_STRING return decode(self.read(marker & 0x0F), "utf-8") elif marker == 0xD0: # STRING_8: size, = struct_unpack(">B", self.read(1)) return decode(self.read(size), "utf-8") elif marker == 0xD1: # STRING_16: size, = struct_unpack(">H", self.read(2)) return decode(self.read(size), "utf-8") elif marker == 0xD2: # STRING_32: size, = struct_unpack(">I", self.read(4)) return decode(self.read(size), "utf-8") # List elif 0x90 <= marker <= 0x9F or 0xD4 <= marker <= 0xD7: return list(self._unpack_list_items(marker)) # Map elif 0xA0 <= marker <= 0xAF or 0xD8 <= marker <= 0xDB: return self._unpack_map(marker) # Structure elif 0xB0 <= marker <= 0xBF or 0xDC <= marker <= 0xDD: size, tag = self._unpack_structure_header(marker) value = Structure(tag, *([None] * size)) for i in range(len(value)): value[i] = self._unpack() return value elif marker == 0xDF: # END_OF_STREAM: return EndOfStream else: raise ValueError("Unknown PackStream marker %02X" % marker) def _unpack_list_items(self, marker): marker_high = marker & 0xF0 if marker_high == 0x90: size = marker & 0x0F if size == 0: return elif size == 1: yield self._unpack() else: for _ in range(size): yield self._unpack() elif marker == 0xD4: # LIST_8: size, = struct_unpack(">B", self.read(1)) for _ in range(size): yield self._unpack() elif marker == 0xD5: # LIST_16: size, = struct_unpack(">H", self.read(2)) for _ in range(size): yield self._unpack() elif marker == 0xD6: # LIST_32: size, = struct_unpack(">I", self.read(4)) for _ in range(size): yield self._unpack() elif marker == 0xD7: # LIST_STREAM: item = None while item is not EndOfStream: item = self._unpack() if item is not EndOfStream: yield item else: return def unpack_map(self): marker = self.read_u8() return self._unpack_map(marker) def _unpack_map(self, marker): marker_high = marker & 0xF0 if marker_high == 0xA0: size = marker & 0x0F value = {} for _ in range(size): key = self._unpack() value[key] = self._unpack() return value elif marker == 0xD8: # MAP_8: size, = struct_unpack(">B", self.read(1)) value = {} for _ in range(size): key = self._unpack() value[key] = self._unpack() return value elif marker == 0xD9: # MAP_16: size, = struct_unpack(">H", self.read(2)) value = {} for _ in range(size): key = self._unpack() value[key] = self._unpack() return value elif marker == 0xDA: # MAP_32: size, = struct_unpack(">I", self.read(4)) value = {} for _ in range(size): key = self._unpack() value[key] = self._unpack() return value elif marker == 0xDB: # MAP_STREAM: value = {} key = None while key is not EndOfStream: key = self._unpack() if key is not EndOfStream: value[key] = self._unpack() return value else: return None def unpack_structure_header(self): marker = self.read_u8() if marker == -1: return None, None else: return self._unpack_structure_header(marker) def _unpack_structure_header(self, marker): marker_high = marker & 0xF0 if marker_high == 0xB0: # TINY_STRUCT signature = self.read(1).tobytes() return marker & 0x0F, signature elif marker == 0xDC: # STRUCT_8: size, = struct_unpack(">B", self.read(1)) signature = self.read(1).tobytes() return size, signature elif marker == 0xDD: # STRUCT_16: size, = struct_unpack(">H", self.read(2)) signature = self.read(1).tobytes() return size, signature else: raise ValueError("Expected structure, found marker %02X" % marker) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/neobolt/routing.py0000644000174500001730000004013200000000000017074 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from collections import OrderedDict from collections.abc import MutableSet from logging import getLogger from sys import maxsize from threading import Lock from time import perf_counter from neobolt.addressing import SocketAddress from neobolt.direct import AbstractConnectionPool, DEFAULT_PORT from neobolt.exceptions import ConnectionExpired, ServiceUnavailable from neobolt.versioning import Version READ_ACCESS = "READ" WRITE_ACCESS = "WRITE" INITIAL_RETRY_DELAY = 1.0 RETRY_DELAY_MULTIPLIER = 2.0 RETRY_DELAY_JITTER_FACTOR = 0.2 DEFAULT_MAX_RETRY_TIME = 30.0 # 30s LOAD_BALANCING_STRATEGY_LEAST_CONNECTED = 0 LOAD_BALANCING_STRATEGY_ROUND_ROBIN = 1 DEFAULT_LOAD_BALANCING_STRATEGY = LOAD_BALANCING_STRATEGY_LEAST_CONNECTED log = getLogger("neobolt") class OrderedSet(MutableSet): def __init__(self, elements=()): self._elements = OrderedDict.fromkeys(elements) self._current = None def __repr__(self): return "{%s}" % ", ".join(map(repr, self._elements)) def __contains__(self, element): return element in self._elements def __iter__(self): return iter(self._elements) def __len__(self): return len(self._elements) def __getitem__(self, index): return list(self._elements.keys())[index] def add(self, element): self._elements[element] = None def clear(self): self._elements.clear() def discard(self, element): try: del self._elements[element] except KeyError: pass def remove(self, element): try: del self._elements[element] except KeyError: raise ValueError(element) def update(self, elements=()): self._elements.update(OrderedDict.fromkeys(elements)) def replace(self, elements=()): e = self._elements e.clear() e.update(OrderedDict.fromkeys(elements)) class RoutingTable(object): timer = perf_counter @classmethod 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, routers=(), readers=(), writers=(), ttl=0): self.routers = OrderedSet(routers) self.readers = OrderedSet(readers) self.writers = OrderedSet(writers) self.last_updated_time = self.timer() self.ttl = ttl def __repr__(self): return "RoutingTable(routers=%r, readers=%r, writers=%r, last_updated_time=%r, ttl=%r)" % ( self.routers, self.readers, self.writers, self.last_updated_time, self.ttl, ) def is_fresh(self, access_mode): """ Indicator for whether routing information is still usable. """ log.debug("[#0000] C: Checking table freshness for %r", access_mode) expired = self.last_updated_time + self.ttl <= self.timer() has_server_for_mode = bool(access_mode == READ_ACCESS and self.readers) or bool(access_mode == WRITE_ACCESS and self.writers) log.debug("[#0000] C: Table expired=%r", expired) log.debug("[#0000] C: Table routers=%r", self.routers) log.debug("[#0000] C: Table has_server_for_mode=%r", has_server_for_mode) return not expired and self.routers and has_server_for_mode def update(self, new_routing_table): """ Update the current routing table with new routing information from a replacement table. """ self.routers.replace(new_routing_table.routers) self.readers.replace(new_routing_table.readers) self.writers.replace(new_routing_table.writers) self.last_updated_time = self.timer() self.ttl = new_routing_table.ttl log.debug("[#0000] S: table=%r", self) def servers(self): return set(self.routers) | set(self.writers) | set(self.readers) class LeastConnectedLoadBalancingStrategy(object): def __init__(self, connection_pool): self._readers_offset = 0 self._writers_offset = 0 self._connection_pool = connection_pool def select_reader(self, known_readers): address = self._select(self._readers_offset, known_readers) self._readers_offset += 1 return address def select_writer(self, known_writers): address = self._select(self._writers_offset, known_writers) self._writers_offset += 1 return address def _select(self, offset, addresses): if not addresses: return None num_addresses = len(addresses) start_index = offset % num_addresses index = start_index least_connected_address = None least_in_use_connections = maxsize while True: address = addresses[index] index = (index + 1) % num_addresses in_use_connections = self._connection_pool.in_use_connection_count(address) if in_use_connections < least_in_use_connections: least_connected_address = address least_in_use_connections = in_use_connections if index == start_index: return least_connected_address class RoutingConnectionPool(AbstractConnectionPool): """ Connection pool with routing table. """ def __init__(self, connector, initial_address, routing_context, *routers, **config): super(RoutingConnectionPool, self).__init__(connector, **config) self.initial_address = initial_address self.routing_context = routing_context self.routing_table = RoutingTable(routers) self.missing_writer = False self.refresh_lock = Lock() self.load_balancing_strategy = LeastConnectedLoadBalancingStrategy(connection_pool=self) def fetch_routing_info(self, address): """ Fetch raw routing info from a given router address. :param address: router address :return: list of routing records or None if no connection could be established :raise ServiceUnavailable: if the server does not support routing or if routing support is broken """ metadata = {} records = [] def fail(md): if md.get("code") == "Neo.ClientError.Procedure.ProcedureNotFound": raise RoutingProtocolError("Server {!r} does not support routing".format(address)) else: raise RoutingProtocolError("Routing support broken on server {!r}".format(address)) try: with self.acquire_direct(address) as cx: _, _, server_version = (cx.server.agent or "").partition("/") # TODO 2.0: remove old routing procedure if server_version and Version.parse(server_version) >= Version((3, 2)): log.debug("[#%04X] C: query=%r", cx.local_port, self.routing_context or {}) cx.run("CALL dbms.cluster.routing.getRoutingTable({context})", {"context": self.routing_context}, on_success=metadata.update, on_failure=fail) else: log.debug("[#%04X] C: query={}", cx.local_port) cx.run("CALL dbms.cluster.routing.getServers", {}, on_success=metadata.update, on_failure=fail) cx.pull_all(on_success=metadata.update, on_records=records.extend) cx.send_all() cx.fetch_all() routing_info = [dict(zip(metadata.get("fields", ()), values)) for values in records] log.debug("[#%04X] S: info=%r", cx.local_port, routing_info) return routing_info except RoutingProtocolError as error: raise ServiceUnavailable(*error.args) except ServiceUnavailable: self.deactivate(address) return None def fetch_routing_table(self, address): """ Fetch a routing table from a given router address. :param address: router address :return: a new RoutingTable instance or None if the given router is currently unable to provide routing information :raise ServiceUnavailable: if no writers are available :raise ProtocolError: if the routing information received is unusable """ new_routing_info = self.fetch_routing_info(address) if new_routing_info is None: return None # Parse routing info and count the number of each type of server new_routing_table = RoutingTable.parse_routing_info(new_routing_info) num_routers = len(new_routing_table.routers) num_readers = len(new_routing_table.readers) num_writers = len(new_routing_table.writers) # No writers are available. This likely indicates a temporary state, # such as leader switching, so we should not signal an error. # When no writers available, then we flag we are reading in absence of writer self.missing_writer = (num_writers == 0) # No routers if num_routers == 0: raise RoutingProtocolError("No routing servers returned from server %r" % (address,)) # No readers if num_readers == 0: raise RoutingProtocolError("No read servers returned from server %r" % (address,)) # At least one of each is fine, so return this table return new_routing_table def update_routing_table_from(self, *routers): """ Try to update routing tables with the given routers. :return: True if the routing table is successfully updated, otherwise False """ log.debug("Attempting to update routing table from " "{}".format(", ".join(map(repr, routers)))) for router in routers: new_routing_table = self.fetch_routing_table(router) if new_routing_table is not None: self.routing_table.update(new_routing_table) log.debug("Successfully updated routing table from " "{!r} ({!r})".format(router, self.routing_table)) return True return False def update_routing_table(self): """ Update the routing table from the first router able to provide valid routing information. """ # copied because it can be modified existing_routers = list(self.routing_table.routers) has_tried_initial_routers = False if self.missing_writer: has_tried_initial_routers = True if self.update_routing_table_from(self.initial_address): return if self.update_routing_table_from(*existing_routers): return if not has_tried_initial_routers and self.initial_address not in existing_routers: if self.update_routing_table_from(self.initial_address): return # None of the routers have been successful, so just fail log.error("Unable to retrieve routing information") raise ServiceUnavailable("Unable to retrieve routing information") def update_connection_pool(self): servers = self.routing_table.servers() for address in list(self.connections): if address not in servers: super(RoutingConnectionPool, self).deactivate(address) def ensure_routing_table_is_fresh(self, access_mode): """ Update the routing table if stale. This method performs two freshness checks, before and after acquiring the refresh lock. If the routing table is already fresh on entry, the method exits immediately; otherwise, the refresh lock is acquired and the second freshness check that follows determines whether an update is still required. This method is thread-safe. :return: `True` if an update was required, `False` otherwise. """ if self.routing_table.is_fresh(access_mode): return False with self.refresh_lock: if self.routing_table.is_fresh(access_mode): if access_mode == READ_ACCESS: # if reader is fresh but writers is not fresh, then we are reading in absence of writer self.missing_writer = not self.routing_table.is_fresh(WRITE_ACCESS) return False self.update_routing_table() self.update_connection_pool() return True def acquire(self, access_mode=None): if access_mode is None: access_mode = WRITE_ACCESS if access_mode == READ_ACCESS: server_list = self.routing_table.readers server_selector = self.load_balancing_strategy.select_reader elif access_mode == WRITE_ACCESS: server_list = self.routing_table.writers server_selector = self.load_balancing_strategy.select_writer else: raise ValueError("Unsupported access mode {}".format(access_mode)) self.ensure_routing_table_is_fresh(access_mode) while True: address = server_selector(server_list) if address is None: break try: connection = self.acquire_direct(address) # should always be a resolved address connection.Error = ConnectionExpired except ServiceUnavailable: self.deactivate(address) else: return connection raise ConnectionExpired("Failed to obtain connection towards '%s' server." % access_mode) def deactivate(self, address): """ Deactivate an address from the connection pool, if present, remove from the routing table and also closing all idle connections to that address. """ log.debug("[#0000] C: Deactivating address %r", address) # We use `discard` instead of `remove` here since the former # will not fail if the address has already been removed. self.routing_table.routers.discard(address) self.routing_table.readers.discard(address) self.routing_table.writers.discard(address) log.debug("[#0000] C: table=%r", self.routing_table) super(RoutingConnectionPool, self).deactivate(address) def remove_writer(self, address): """ Remove a writer address from the routing table, if present. """ log.debug("[#0000] C: Removing writer %r", address) self.routing_table.writers.discard(address) log.debug("[#0000] C: table=%r", self.routing_table) class RoutingProtocolError(Exception): """ Raised when a fault occurs with the routing protocol. """ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/neobolt/security.py0000644000174500001730000000317300000000000017260 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from ssl import SSLContext, PROTOCOL_SSLv23, OP_NO_SSLv2, CERT_REQUIRED # TODO 2.0: tidy these up TRUST_ALL_CERTIFICATES = 2 TRUST_CUSTOM_CA_SIGNED_CERTIFICATES = 3 TRUST_SYSTEM_CA_SIGNED_CERTIFICATES = 4 TRUST_DEFAULT = TRUST_ALL_CERTIFICATES def make_ssl_context(**config): if config.get("encrypted") or config.get("secure"): ssl_context = SSLContext(PROTOCOL_SSLv23) ssl_context.options |= OP_NO_SSLv2 trust = config.get("trust", TRUST_DEFAULT) if trust == TRUST_ALL_CERTIFICATES: pass elif trust == TRUST_CUSTOM_CA_SIGNED_CERTIFICATES: raise NotImplementedError("Custom CA support is not implemented") elif trust == TRUST_SYSTEM_CA_SIGNED_CERTIFICATES: ssl_context.verify_mode = CERT_REQUIRED else: raise ValueError("Unknown trust mode") ssl_context.set_default_verify_paths() return ssl_context else: return None ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1617665406.3960028 neobolt-4.0.dev0/neobolt/types/0002755000174500001730000000000000000000000016201 5ustar00janitorsbuild././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/neobolt/types/__init__.py0000644000174500001730000003103400000000000020311 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ This package contains classes for modelling the standard set of data types available within a Neo4j graph database. Most non-primitive types are represented by PackStream structures on the wire before being converted into concrete values through the PackStreamHydrant. """ from collections.abc import Mapping, Sequence from functools import reduce from operator import xor as xor_operator INT64_MIN = -(2 ** 63) INT64_MAX = (2 ** 63) - 1 map_type = type(map(str, range(0))) class Structure(object): def __init__(self, tag, *fields): self.tag = tag self.fields = list(fields) def __repr__(self): return "Structure<%s>(%s)" % (self.tag, ", ".join(map(repr, self.fields))) def __eq__(self, other): try: return self.tag == other.tag and self.fields == other.fields except AttributeError: return False def __ne__(self, other): return not self.__eq__(other) def __len__(self): return len(self.fields) def __getitem__(self, key): return self.fields[key] def __setitem__(self, key, value): self.fields[key] = value class PackStreamHydrator(object): def __init__(self, protocol_version): super(PackStreamHydrator, self).__init__() from .graph import Graph self.graph = Graph() self.graph_hydrator = Graph.Hydrator(self.graph) self.hydration_functions = { b"N": self.graph_hydrator.hydrate_node, b"R": self.graph_hydrator.hydrate_relationship, b"r": self.graph_hydrator.hydrate_unbound_relationship, b"P": self.graph_hydrator.hydrate_path, } if protocol_version >= 2: from .spatial import hydrate_point from .temporal import hydrate_date, hydrate_time, hydrate_datetime, hydrate_duration self.hydration_functions.update({ b"X": hydrate_point, b"Y": hydrate_point, b"D": hydrate_date, b"T": hydrate_time, # time zone offset b"t": hydrate_time, # no time zone b"F": hydrate_datetime, # time zone offset b"f": hydrate_datetime, # time zone name b"d": hydrate_datetime, # no time zone b"E": hydrate_duration, }) def hydrate(self, values): """ Convert PackStream values into native values. """ def hydrate_(obj): if isinstance(obj, Structure): try: f = self.hydration_functions[obj.tag] except KeyError: # If we don't recognise the structure type, just return it as-is return obj else: return f(*map(hydrate_, obj.fields)) elif isinstance(obj, list): return list(map(hydrate_, obj)) elif isinstance(obj, dict): return {key: hydrate_(value) for key, value in obj.items()} else: return obj return tuple(map(hydrate_, values)) def hydrate_records(self, keys, record_values): for values in record_values: yield Record(zip(keys, self.hydrate(values))) class PackStreamDehydrator(object): def __init__(self, protocol_version): self.dehydration_functions = {} from datetime import date, time, datetime, timedelta from .spatial import Point, dehydrate_point from .temporal import ( Date, dehydrate_date, Time, dehydrate_time, DateTime, dehydrate_datetime, Duration, dehydrate_duration, dehydrate_timedelta, ) self.dehydration_functions.update({ Point: dehydrate_point, Date: dehydrate_date, date: dehydrate_date, Time: dehydrate_time, time: dehydrate_time, DateTime: dehydrate_datetime, datetime: dehydrate_datetime, Duration: dehydrate_duration, timedelta: dehydrate_timedelta, }) # Allow dehydration from any direct Point subclass self.dehydration_functions.update({cls: dehydrate_point for cls in Point.__subclasses__()}) def dehydrate(self, values): """ Convert native values into PackStream values. """ def dehydrate_(obj): try: f = self.dehydration_functions[type(obj)] except KeyError: pass else: return f(obj) if obj is None: return None elif isinstance(obj, bool): return obj elif isinstance(obj, int): if INT64_MIN <= obj <= INT64_MAX: return obj raise ValueError("Integer out of bounds (64-bit signed integer values only)") elif isinstance(obj, float): return obj elif isinstance(obj, str): return obj elif isinstance(obj, (bytes, bytearray)): # order is important here - bytes must be checked after string return obj elif isinstance(obj, (list, map_type)): return list(map(dehydrate_, obj)) elif isinstance(obj, dict): if any(not isinstance(key, str) for key in obj.keys()): raise TypeError("Non-string dictionary keys are not supported") return {key: dehydrate_(value) for key, value in obj.items()} else: raise TypeError(obj) return tuple(map(dehydrate_, values)) class Record(tuple, Mapping): """ A :class:`.Record` is an immutable ordered collection of key-value pairs. It is generally closer to a :py:class:`namedtuple` than to a :py:class:`OrderedDict` inasmuch as iteration of the collection will yield values rather than keys. """ __keys = None def __new__(cls, iterable=()): keys = [] values = [] for key, value in iter_items(iterable): keys.append(key) values.append(value) inst = tuple.__new__(cls, values) inst.__keys = tuple(keys) return inst def __repr__(self): return "<%s %s>" % (self.__class__.__name__, " ".join("%s=%r" % (field, self[i]) for i, field in enumerate(self.__keys))) def __eq__(self, other): """ In order to be flexible regarding comparison, the equality rules for a record permit comparison with any other Sequence or Mapping. :param other: :return: """ compare_as_sequence = isinstance(other, Sequence) compare_as_mapping = isinstance(other, Mapping) if compare_as_sequence and compare_as_mapping: return list(self) == list(other) and dict(self) == dict(other) elif compare_as_sequence: return list(self) == list(other) elif compare_as_mapping: return dict(self) == dict(other) else: return False def __ne__(self, other): return not self.__eq__(other) def __hash__(self): return reduce(xor_operator, map(hash, self.items())) def __getitem__(self, key): if isinstance(key, slice): keys = self.__keys[key] values = super(Record, self).__getitem__(key) return self.__class__(zip(keys, values)) try: index = self.index(key) except IndexError: return None else: return super(Record, self).__getitem__(index) def __getslice__(self, start, stop): key = slice(start, stop) keys = self.__keys[key] values = tuple(self)[key] return self.__class__(zip(keys, values)) def get(self, key, default=None): """ Obtain a value from the record by key, returning a default value if the key does not exist. :param key: :param default: :return: """ try: index = self.__keys.index(str(key)) except ValueError: return default if 0 <= index < len(self): return super(Record, self).__getitem__(index) else: return default def index(self, key): """ Return the index of the given item. :param key: :return: """ if isinstance(key, int): if 0 <= key < len(self.__keys): return key raise IndexError(key) elif isinstance(key, str): try: return self.__keys.index(key) except ValueError: raise KeyError(key) else: raise TypeError(key) def value(self, key=0, default=None): """ Obtain a single value from the record by index or key. If no index or key is specified, the first value is returned. If the specified item does not exist, the default value is returned. :param key: :param default: :return: """ try: index = self.index(key) except (IndexError, KeyError): return default else: return self[index] def keys(self): """ Return the keys of the record. :return: list of key names """ return list(self.__keys) def values(self, *keys): """ Return the values of the record, optionally filtering to include only certain values by index or key. :param keys: indexes or keys of the items to include; if none are provided, all values will be included :return: list of values """ if keys: d = [] for key in keys: try: i = self.index(key) except KeyError: d.append(None) else: d.append(self[i]) return d return list(self) def items(self, *keys): """ Return the fields of the record as a list of key and value tuples :return: """ if keys: d = [] for key in keys: try: i = self.index(key) except KeyError: d.append((key, None)) else: d.append((self.__keys[i], self[i])) return d return list((self.__keys[i], super(Record, self).__getitem__(i)) for i in range(len(self))) def data(self, *keys): """ Return the keys and values of this record as a dictionary, optionally including only certain values by index or key. Keys provided in the items that are not in the record will be inserted with a value of :const:`None`; indexes provided that are out of bounds will trigger an :exc:`IndexError`. :param keys: indexes or keys of the items to include; if none are provided, all values will be included :return: dictionary of values, keyed by field name :raises: :exc:`IndexError` if an out-of-bounds index is specified """ if keys: d = {} for key in keys: try: i = self.index(key) except KeyError: d[key] = None else: d[self.__keys[i]] = self[i] return d return dict(self) def iter_items(iterable): """ Iterate through all items (key-value pairs) within an iterable dictionary-like object. If the object has a `keys` method, this is used along with `__getitem__` to yield each pair in turn. If no `keys` method exists, each iterable element is assumed to be a 2-tuple of key and value. """ if hasattr(iterable, "keys"): for key in iterable.keys(): yield key, iterable[key] else: for key, value in iterable: yield key, value ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/neobolt/types/graph.py0000644000174500001730000002316600000000000017662 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Graph data types """ from collections.abc import Mapping __all__ = [ "Graph", "Node", "Relationship", "Path", ] class Graph(object): """ Local, self-contained graph object that acts as a container for :class:`.Node` and :class:`.Relationship` instances. """ def __init__(self): self._nodes = {} self._relationships = {} self._relationship_types = {} self._node_set_view = EntitySetView(self._nodes) self._relationship_set_view = EntitySetView(self._relationships) @property def nodes(self): """ Access a set view of the nodes in this graph. """ return self._node_set_view @property def relationships(self): """ Access a set view of the relationships in this graph. """ return self._relationship_set_view def relationship_type(self, name): """ Obtain a :class:`.Relationship` subclass for a given relationship type name. """ try: cls = self._relationship_types[name] except KeyError: cls = self._relationship_types[name] = type(str(name), (Relationship,), {}) return cls class Hydrator(object): def __init__(self, graph): self.graph = graph def hydrate_node(self, n_id, n_labels=None, properties=None): assert isinstance(self.graph, Graph) try: inst = self.graph._nodes[n_id] except KeyError: inst = self.graph._nodes[n_id] = Node(self.graph, n_id, n_labels, properties) return inst def hydrate_relationship(self, r_id, n0_id, n1_id, r_type, properties=None): inst = self.hydrate_unbound_relationship(r_id, r_type, properties) inst._start_node = self.hydrate_node(n0_id) inst._end_node = self.hydrate_node(n1_id) return inst def hydrate_unbound_relationship(self, r_id, r_type, properties=None): assert isinstance(self.graph, Graph) try: inst = self.graph._relationships[r_id] except KeyError: r = self.graph.relationship_type(r_type) inst = self.graph._relationships[r_id] = r(self.graph, r_id, properties) return inst def hydrate_path(self, nodes, relationships, sequence): assert isinstance(self.graph, Graph) assert len(nodes) >= 1 assert len(sequence) % 2 == 0 last_node = nodes[0] entities = [last_node] for i, rel_index in enumerate(sequence[::2]): assert rel_index != 0 next_node = nodes[sequence[2 * i + 1]] if rel_index > 0: r = relationships[rel_index - 1] r._start_node = last_node r._end_node = next_node entities.append(r) else: r = relationships[-rel_index - 1] r._start_node = next_node r._end_node = last_node entities.append(r) last_node = next_node return Path(*entities) class Entity(Mapping): """ Base class for :class:`.Node` and :class:`.Relationship` that provides :class:`.Graph` membership and property containment functionality. """ def __init__(self, graph, id, properties): self._graph = graph self._id = id self._properties = dict((k, v) for k, v in (properties or {}).items() if v is not None) def __eq__(self, other): try: return type(self) == type(other) and self.graph == other.graph and self.id == other.id except AttributeError: return False def __ne__(self, other): return not self.__eq__(other) def __hash__(self): return hash(self.id) def __len__(self): return len(self._properties) def __getitem__(self, name): return self._properties.get(name) def __contains__(self, name): return name in self._properties def __iter__(self): return iter(self._properties) @property def graph(self): """ The :class:`.Graph` to which this entity belongs. """ return self._graph @property def id(self): """ The identity of this entity in its container :class:`.Graph`. """ return self._id def get(self, name, default=None): """ Get a property value by name, optionally with a default. """ return self._properties.get(name, default) def keys(self): """ Return an iterable of all property names. """ return self._properties.keys() def values(self): """ Return an iterable of all property values. """ return self._properties.values() def items(self): """ Return an iterable of all property name-value pairs. """ return self._properties.items() class EntitySetView(Mapping): """ View of a set of :class:`.Entity` instances within a :class:`.Graph`. """ def __init__(self, entity_dict): self._entity_dict = entity_dict def __getitem__(self, e_id): return self._entity_dict[e_id] def __len__(self): return len(self._entity_dict) def __iter__(self): return iter(self._entity_dict.values()) class Node(Entity): """ Self-contained graph node. """ def __init__(self, graph, n_id, n_labels=None, properties=None): Entity.__init__(self, graph, n_id, properties) self._labels = frozenset(n_labels or ()) def __repr__(self): return "" % (self._id, self._labels, self._properties) @property def labels(self): """ The set of labels attached to this node. """ return self._labels class Relationship(Entity): """ Self-contained graph relationship. """ def __init__(self, graph, r_id, properties): Entity.__init__(self, graph, r_id, properties) self._start_node = None self._end_node = None def __repr__(self): return "" % ( self._id, self._start_node, self._end_node, self.type, self._properties) @property def nodes(self): """ The pair of nodes which this relationship connects. """ return self._start_node, self._end_node @property def start_node(self): """ The start node of this relationship. """ return self._start_node @property def end_node(self): """ The end node of this relationship. """ return self._end_node @property def type(self): """ The type name of this relationship. This is functionally equivalent to ``type(relationship).__name__``. """ return type(self).__name__ class Path(object): """ Self-contained graph path. """ def __init__(self, start_node, *relationships): assert isinstance(start_node, Node) nodes = [start_node] for i, relationship in enumerate(relationships, start=1): assert isinstance(relationship, Relationship) if relationship.start_node == nodes[-1]: nodes.append(relationship.end_node) elif relationship.end_node == nodes[-1]: nodes.append(relationship.start_node) else: raise ValueError("Relationship %d does not connect to the last node" % i) self._nodes = tuple(nodes) self._relationships = relationships def __repr__(self): return "" % \ (self.start_node, self.end_node, len(self)) def __eq__(self, other): try: return self.start_node == other.start_node and self.relationships == other.relationships except AttributeError: return False def __ne__(self, other): return not self.__eq__(other) def __hash__(self): value = hash(self._nodes[0]) for relationship in self._relationships: value ^= hash(relationship) return value def __len__(self): return len(self._relationships) def __iter__(self): return iter(self._relationships) @property def graph(self): """ The :class:`.Graph` to which this path belongs. """ return self._nodes[0].graph @property def nodes(self): """ The sequence of :class:`.Node` objects in this path. """ return self._nodes @property def start_node(self): """ The first :class:`.Node` in this path. """ return self._nodes[0] @property def end_node(self): """ The last :class:`.Node` in this path. """ return self._nodes[-1] @property def relationships(self): """ The sequence of :class:`.Relationship` objects in this path. """ return self._relationships ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/neobolt/types/spatial.py0000644000174500001730000000662200000000000020214 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ This module defines spatial data types. """ from threading import Lock from neobolt.types import Structure __all__ = [ "Point", "point_type", "hydrate_point", "dehydrate_point", ] # SRID to subclass mappings __srid_table = {} __srid_table_lock = Lock() class Point(tuple): """ A point within a geometric space. This type is generally used via its subclasses and should not be instantiated directly unless there is no subclass defined for the required SRID. """ srid = None def __new__(cls, iterable): return tuple.__new__(cls, iterable) def __repr__(self): return "POINT(%s)" % " ".join(map(str, self)) def __eq__(self, other): try: return type(self) is type(other) and tuple(self) == tuple(other) except (AttributeError, TypeError): return False def __ne__(self, other): return not self.__eq__(other) def __hash__(self): return hash(type(self)) ^ hash(tuple(self)) def point_type(name, fields, srid_map): """ Dynamically create a Point subclass. """ def srid(self): try: return srid_map[len(self)] except KeyError: return None attributes = {"srid": property(srid)} for index, subclass_field in enumerate(fields): def accessor(self, i=index, f=subclass_field): try: return self[i] except IndexError: raise AttributeError(f) for field_alias in {subclass_field, "xyz"[index]}: attributes[field_alias] = property(accessor) cls = type(name, (Point,), attributes) with __srid_table_lock: for dim, srid in srid_map.items(): __srid_table[srid] = (cls, dim) return cls def hydrate_point(srid, *coordinates): """ Create a new instance of a Point subclass from a raw set of fields. The subclass chosen is determined by the given SRID; a ValueError will be raised if no such subclass can be found. """ try: point_class, dim = __srid_table[srid] except KeyError: point = Point(coordinates) point.srid = srid return point else: if len(coordinates) != dim: raise ValueError("SRID %d requires %d coordinates (%d provided)" % (srid, dim, len(coordinates))) return point_class(coordinates) def dehydrate_point(value): """ Dehydrator for Point data. :param value: :type value: Point :return: """ dim = len(value) if dim == 2: return Structure(b"X", value.srid, *value) elif dim == 3: return Structure(b"Y", value.srid, *value) else: raise ValueError("Cannot dehydrate Point with %d dimensions" % dim) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/neobolt/types/temporal.py0000644000174500001730000001241700000000000020401 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from __future__ import division """ This module defines temporal data types. """ from datetime import time, datetime, timedelta from neotime import Duration, Date, Time, DateTime from pytz import FixedOffset, timezone, utc from neobolt.types import Structure UNIX_EPOCH_DATE = Date(1970, 1, 1) UNIX_EPOCH_DATE_ORDINAL = UNIX_EPOCH_DATE.to_ordinal() UNIX_EPOCH_DATETIME_UTC = DateTime(1970, 1, 1, 0, 0, 0, utc) def hydrate_date(days): """ Hydrator for `Date` values. :param days: :return: Date """ return Date.from_ordinal(UNIX_EPOCH_DATE_ORDINAL + days) def dehydrate_date(value): """ Dehydrator for `date` values. :param value: :type value: Date :return: """ return Structure(b"D", value.toordinal() - UNIX_EPOCH_DATE.toordinal()) def hydrate_time(nanoseconds, tz=None): """ Hydrator for `Time` and `LocalTime` values. :param nanoseconds: :param tz: :return: Time """ seconds, nanoseconds = map(int, divmod(nanoseconds, 1000000000)) minutes, seconds = map(int, divmod(seconds, 60)) hours, minutes = map(int, divmod(minutes, 60)) seconds = (1000000000 * seconds + nanoseconds) / 1000000000 t = Time(hours, minutes, seconds) if tz is None: return t tz_offset_minutes, tz_offset_seconds = divmod(tz, 60) zone = FixedOffset(tz_offset_minutes) return zone.localize(t) def dehydrate_time(value): """ Dehydrator for `time` values. :param value: :type value: Time :return: """ if isinstance(value, Time): nanoseconds = int(value.ticks * 1000000000) elif isinstance(value, time): nanoseconds = (3600000000000 * value.hour + 60000000000 * value.minute + 1000000000 * value.second + 1000 * value.microsecond) else: raise TypeError("Value must be a neotime.Time or a datetime.time") if value.tzinfo: return Structure(b"T", nanoseconds, value.tzinfo.utcoffset(value).seconds) else: return Structure(b"t", nanoseconds) def hydrate_datetime(seconds, nanoseconds, tz=None): """ Hydrator for `DateTime` and `LocalDateTime` values. :param seconds: :param nanoseconds: :param tz: :return: datetime """ minutes, seconds = map(int, divmod(seconds, 60)) hours, minutes = map(int, divmod(minutes, 60)) days, hours = map(int, divmod(hours, 24)) seconds = (1000000000 * seconds + nanoseconds) / 1000000000 t = DateTime.combine(Date.from_ordinal(UNIX_EPOCH_DATE_ORDINAL + days), Time(hours, minutes, seconds)) if tz is None: return t if isinstance(tz, int): tz_offset_minutes, tz_offset_seconds = divmod(tz, 60) zone = FixedOffset(tz_offset_minutes) else: zone = timezone(tz) return zone.localize(t) def dehydrate_datetime(value): """ Dehydrator for `datetime` values. :param value: :type value: datetime :return: """ def seconds_and_nanoseconds(dt): if isinstance(dt, datetime): dt = DateTime.from_native(dt) zone_epoch = DateTime(1970, 1, 1, tzinfo=dt.tzinfo) t = dt.to_clock_time() - zone_epoch.to_clock_time() return t.seconds, t.nanoseconds tz = value.tzinfo if tz is None: # without time zone value = utc.localize(value) seconds, nanoseconds = seconds_and_nanoseconds(value) return Structure(b"d", seconds, nanoseconds) elif hasattr(tz, "zone") and tz.zone: # with named time zone seconds, nanoseconds = seconds_and_nanoseconds(value) return Structure(b"f", seconds, nanoseconds, tz.zone) else: # with time offset seconds, nanoseconds = seconds_and_nanoseconds(value) return Structure(b"F", seconds, nanoseconds, tz.utcoffset(value).seconds) def hydrate_duration(months, days, seconds, nanoseconds): """ Hydrator for `Duration` values. :param months: :param days: :param seconds: :param nanoseconds: :return: `duration` namedtuple """ return Duration(months=months, days=days, seconds=seconds, nanoseconds=nanoseconds) def dehydrate_duration(value): """ Dehydrator for `duration` values. :param value: :type value: Duration :return: """ return Structure(b"E", value.months, value.days, value.seconds, int(1000000000 * value.subseconds)) def dehydrate_timedelta(value): """ Dehydrator for `timedelta` values. :param value: :type value: timedelta :return: """ months = 0 days = value.days seconds = value.seconds nanoseconds = 1000 * value.microseconds return Structure(b"E", months, days, seconds, nanoseconds) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/neobolt/versioning.py0000644000174500001730000000406100000000000017571 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. class Version(tuple): @classmethod def parse(cls, string): from unicodedata import category parts = [] last_ch = None for ch in string: if last_ch is None: parts.append([ch]) elif ch == ".": if last_ch in ".-": parts[-1][-1] += "0" parts[-1].append("") elif ch == "-": if last_ch in ".-": parts[-1][-1] += "0" parts.append([""]) else: if last_ch not in ".-" and category(ch)[0] != category(last_ch)[0]: parts.append([ch]) else: parts[-1][-1] += ch last_ch = ch for part in parts: for i, x in enumerate(part): try: part[i] = int(x) except (ValueError, TypeError): pass while len(part) > 1 and not part[-1]: part[:] = part[:-1] return cls(*map(tuple, parts)) def __new__(cls, *parts): parts = list(parts) for i, part in enumerate(parts): if not isinstance(part, tuple): parts[i] = (part,) return super(Version, cls).__new__(cls, parts) def __repr__(self): return "%s%r" % (type(self).__name__, tuple(self)) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1617665406.3960028 neobolt-4.0.dev0/neobolt.egg-info/0002755000174500001730000000000000000000000016527 5ustar00janitorsbuild././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665406.0 neobolt-4.0.dev0/neobolt.egg-info/PKG-INFO0000644000174500001730000000212500000000000017622 0ustar00janitorsbuildMetadata-Version: 1.1 Name: neobolt Version: 4.0.dev0 Summary: Neo4j Bolt connector for Python Home-page: https://github.com/neo4j-drivers/neobolt Author: Neo4j Sweden AB Author-email: drivers@neo4j.com License: Apache License, Version 2.0 Description: ======================================== Neobolt: Neo4j Bolt connector for Python ======================================== Neobolt is a Bolt connector library for Python. It is generally intended for use by a higher level `driver `_. Keywords: neo4j graph database Platform: UNKNOWN Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: Apache Software License Classifier: Operating System :: OS Independent Classifier: Topic :: Database Classifier: Topic :: Software Development Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.8 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665406.0 neobolt-4.0.dev0/neobolt.egg-info/SOURCES.txt0000644000174500001730000000110200000000000020403 0ustar00janitorsbuildMANIFEST.in README.rst setup.py neobolt/__init__.py neobolt/__main__.py neobolt/addressing.py neobolt/diagnostics.py neobolt/direct.py neobolt/exceptions.py neobolt/meta.py neobolt/routing.py neobolt/security.py neobolt/versioning.py neobolt.egg-info/PKG-INFO neobolt.egg-info/SOURCES.txt neobolt.egg-info/dependency_links.txt neobolt.egg-info/requires.txt neobolt.egg-info/top_level.txt neobolt/packstream/__init__.py neobolt/packstream/packer.py neobolt/packstream/unpacker.py neobolt/types/__init__.py neobolt/types/graph.py neobolt/types/spatial.py neobolt/types/temporal.py././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665406.0 neobolt-4.0.dev0/neobolt.egg-info/dependency_links.txt0000644000174500001730000000000100000000000022573 0ustar00janitorsbuild ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665406.0 neobolt-4.0.dev0/neobolt.egg-info/requires.txt0000644000174500001730000000001500000000000021121 0ustar00janitorsbuildneotime pytz ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665406.0 neobolt-4.0.dev0/neobolt.egg-info/top_level.txt0000644000174500001730000000001000000000000021246 0ustar00janitorsbuildneobolt ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1617665406.4000027 neobolt-4.0.dev0/setup.cfg0000644000174500001730000000004600000000000015212 0ustar00janitorsbuild[egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617665403.0 neobolt-4.0.dev0/setup.py0000644000174500001730000000400500000000000015102 0ustar00janitorsbuild#!/usr/bin/env python # -*- encoding: utf-8 -*- # Copyright (c) 2002-2019 "Neo4j," # Neo4j Sweden AB [http://neo4j.com] # # This file is part of Neo4j. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from __future__ import print_function from os.path import dirname, join as path_join try: from setuptools import setup, Extension except ImportError: from distutils.core import setup, Extension from neobolt.meta import package, version install_requires = [ "neotime", "pytz", ] classifiers = [ "Intended Audience :: Developers", "License :: OSI Approved :: Apache Software License", "Operating System :: OS Independent", "Topic :: Database", "Topic :: Software Development", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.8", ] packages = [ "neobolt", "neobolt.packstream", "neobolt.types", ] setup_args = { "name": package, "version": version, "description": "Neo4j Bolt connector for Python", "license": "Apache License, Version 2.0", "long_description": open(path_join(dirname(__file__), "README.rst")).read(), "author": "Neo4j Sweden AB", "author_email": "drivers@neo4j.com", "keywords": "neo4j graph database", "url": "https://github.com/neo4j-drivers/neobolt", "install_requires": install_requires, "classifiers": classifiers, "packages": packages, } setup(**setup_args)