Merge pull request #330 from martin-neotech/4.0-ConnectionExpired-removal

Removed ConnectionExpired

Author: martin-neotech

neo4j/exceptions.py

@@ -200,3 +200,21 @@ class AuthError(ClientError, SecurityError):
     # DatabaseUnavailableError
     "Neo.TransientError.General.DatabaseUnavailable": DatabaseUnavailableError
 }
+
+
+class SessionExpired(Exception):
+    """ Raised when no a session is no longer able to fulfil
+    the purpose described by its original parameters.
+    """
+
+    def __init__(self, session, *args, **kwargs):
+        super(SessionExpired, self).__init__(session, *args, **kwargs)
+
+
+class TransactionError(Exception):
+    """ Raised when an error occurs while using a transaction.
+    """
+
+    def __init__(self, transaction, *args, **kwargs):
+        super(TransactionError, self).__init__(*args, **kwargs)
+        self.transaction = transaction

neo4j/io/__init__.py

@@ -49,15 +49,24 @@
 from neo4j.conf import Config, PoolConfig
 from neo4j.io._bolt3 import Outbox, BufferedSocket, Inbox, Response, InitResponse, CommitResponse
 from neo4j.errors import BoltRoutingError, Neo4jAvailabilityError
-from neo4j.exceptions import ProtocolError, SecurityError, \
-    ServiceUnavailable, AuthError, IncompleteCommitError, \
-    ConnectionExpired, DatabaseUnavailableError, NotALeaderError, \
-    ForbiddenOnReadOnlyDatabaseError, ClientError
+from neo4j.exceptions import (
+    ProtocolError,
+    SecurityError,
+    ServiceUnavailable,
+    AuthError,
+    IncompleteCommitError,
+    ConnectionExpired,
+    DatabaseUnavailableError,
+    NotALeaderError,
+    ForbiddenOnReadOnlyDatabaseError,
+    ClientError,
+    SessionExpired,
+    TransactionError,
+)
 from neo4j.meta import get_user_agent
 from neo4j.packstream import Packer, Unpacker
 from neo4j.routing import RoutingTable
 
-
 # Set up logger
 log = getLogger("neo4j")
 
@@ -89,10 +98,6 @@ class Bolt:
     #: 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
-
     @classmethod
     def ping(cls, address, *, timeout=None, **config):
         """ Attempt to establish a Bolt connection, returning the
@@ -305,13 +310,13 @@ 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))
+            raise ServiceUnavailable("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))
+            raise ServiceUnavailable("Failed to write to defunct connection {!r} ({!r})".format(
+                self.unresolved_address, self.server.address))
+
         try:
             self._send_all()
         except (IOError, OSError) as error:
@@ -331,13 +336,13 @@ def fetch_message(self):
                  messages fetched
         """
         if self._closed:
-            raise self.Error("Failed to read from closed connection "
-                             "{!r} ({!r})".format(self.unresolved_address,
-                                                  self.server.address))
+            raise ServiceUnavailable("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))
+            raise ServiceUnavailable("Failed to read from defunct connection {!r} ({!r})".format(
+                self.unresolved_address, self.server.address))
+
         if not self.responses:
             return 0, 0
 
@@ -388,9 +393,11 @@ def fetch_message(self):
         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))
+        direct_driver = isinstance(self.pool, BoltPool)
+
+        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
@@ -406,7 +413,11 @@ def _set_defunct(self, error=None):
         for response in self.responses:
             if isinstance(response, CommitResponse):
                 raise IncompleteCommitError(message)
-        raise self.Error(message)
+
+        if direct_driver:
+            raise ServiceUnavailable(message)
+        else:
+            raise SessionExpired(message)
 
     def timedout(self):
         return 0 <= self._max_connection_lifetime <= perf_counter() - self._creation_timestamp
@@ -846,11 +857,9 @@ def acquire(self, access_mode=None, timeout=None):
             try:
                 address = self._select_address(access_mode)
             except Neo4jAvailabilityError as err:
-                raise ConnectionExpired("Failed to obtain connection "
-                                        "towards '%s' server." % access_mode) from err
+                raise SessionExpired("Failed to obtain connection towards '%s' server." % access_mode) from err
             try:
                 connection = self._acquire(address, timeout=timeout)  # should always be a resolved address
-                connection.Error = ConnectionExpired
             except ServiceUnavailable:
                 self.deactivate(address)
             else:

neo4j/work/simple.py

@@ -34,6 +34,8 @@
     IncompleteCommitError,
     ServiceUnavailable,
     TransientError,
+    SessionExpired,
+    TransactionError,
 )
 from neo4j.work import Workspace, WorkspaceConfig
 from neo4j.work.summary import BoltStatementResultSummary
@@ -727,24 +729,6 @@ def data(self, *items):
         return [record.data(*items) for record in self.records()]
 
 
-class SessionExpired(Exception):
-    """ Raised when no a session is no longer able to fulfil
-    the purpose described by its original parameters.
-    """
-
-    def __init__(self, session, *args, **kwargs):
-        super(SessionExpired, self).__init__(session, *args, **kwargs)
-
-
-class TransactionError(Exception):
-    """ Raised when an error occurs while using a transaction.
-    """
-
-    def __init__(self, transaction, *args, **kwargs):
-        super(TransactionError, self).__init__(*args, **kwargs)
-        self.transaction = transaction
-
-
 def unit_of_work(metadata=None, timeout=None):
     """ This function is a decorator for transaction functions that allows
     extra control over how the transaction is carried out.