Routing refactoring and fixes

Author: technige

neo4j/__init__.py

@@ -20,12 +20,3 @@
 
 
 from .meta import version as __version__
-
-# Export current (v1) API. This should be updated to export the latest
-# version of the API when a new one is added. This gives the option to
-# `import neo4j.vX` for a specific version or `import neo4j` for the
-# latest.
-from .v1.constants import *
-from .v1.exceptions import *
-from .v1.session import *
-from .v1.types import *

neo4j/util.py

@@ -94,61 +94,3 @@ def watch(logger_name, level=logging.INFO, out=stdout):
     watcher = Watcher(logger_name)
     watcher.watch(level, out)
     return watcher
-
-
-class RoundRobinSet(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 __next__(self):
-        current = None
-        if self._elements:
-            if self._current is None:
-                self._current = 0
-            else:
-                self._current = (self._current + 1) % len(self._elements)
-            current = list(self._elements.keys())[self._current]
-        return current
-
-    def __iter__(self):
-        return iter(self._elements)
-
-    def __len__(self):
-        return len(self._elements)
-
-    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 next(self):
-        return self.__next__()
-
-    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))

neo4j/v1/bolt.py

@@ -37,7 +37,7 @@
 from select import select
 from socket import create_connection, SHUT_RDWR, error as SocketError
 from struct import pack as struct_pack, unpack as struct_unpack, unpack_from as struct_unpack_from
-from threading import Lock
+from threading import RLock
 
 from .constants import DEFAULT_USER_AGENT, KNOWN_HOSTS, MAGIC_PREAMBLE, TRUST_DEFAULT, TRUST_ON_FIRST_USE
 from .exceptions import ProtocolError, Unauthorized, ServiceUnavailable
@@ -378,15 +378,26 @@ class ConnectionPool(object):
     """ A collection of connections to one or more server addresses.
     """
 
+    closed = False
+
     def __init__(self, connector):
         self.connector = connector
         self.connections = {}
-        self.lock = Lock()
+        self.lock = RLock()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
 
     def acquire(self, address):
         """ Acquire a connection to a given address from the pool.
         This method is thread safe.
         """
+        if self.closed:
+            raise ServiceUnavailable("This connection pool is closed so no new "
+                                     "connections may be acquired")
         with self.lock:
             try:
                 connections = self.connections[address]
@@ -411,18 +422,25 @@ def release(self, connection):
         with self.lock:
             connection.in_use = False
 
+    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.
         """
         with self.lock:
-            for _, connections in self.connections.items():
-                for connection in connections:
-                    try:
-                        connection.close()
-                    except IOError:
-                        pass
-            self.connections.clear()
+            self.closed = True
+            for address in list(self.connections):
+                self.remove(address)
 
 
 class CertificateStore(object):

neo4j/v1/compat.py renamed to neo4j/v1/compat/__init__.py

@@ -25,8 +25,6 @@
 excluded from test coverage.
 """
 
-__all__ = ["integer", "perf_counter", "secure_socket", "string", "urlparse"]
-
 
 # Workaround for Python 2/3 type differences
 try:

neo4j/v1/compat/collections.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+
+# Copyright (c) 2002-2016 "Neo Technology,"
+# Network Engine for Objects in Lund AB [http://neotechnology.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 absolute_import
+
+try:
+    from collections.abc import MutableSet
+except ImportError:
+    from collections import MutableSet, OrderedDict
+else:
+    from collections import OrderedDict