Adopted py2neo-style error hydration

Author: technige

neo4j/bolt/connection.py

@@ -274,7 +274,6 @@ def fetch(self):
         elif summary_signature == FAILURE:
             log_info("S: FAILURE (%r)", summary_metadata)
             response.on_failure(summary_metadata or {})
-            self.reset()
         else:
             raise ProtocolError("Unexpected response message with signature %02X" % summary_signature)
 

neo4j/exceptions.py

@@ -19,26 +19,140 @@
 # limitations under the License.
 
 
+"""
+This module contains the core driver exceptions.
+"""
+
+
 class AddressError(Exception):
     """ Raised when a network address is invalid.
     """
 
 
+class ProtocolError(Exception):
+    """ Raised when an unexpected or unsupported protocol event occurs.
+    """
+
+
+class ServiceUnavailable(Exception):
+    """ Raised when no database service is available.
+    """
+
+
 class SecurityError(Exception):
     """ Raised when an action is denied due to security settings.
     """
 
 
-class AuthError(SecurityError):
-    """ Raised when authentication failure occurs.
+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
 
-class ProtocolError(Exception):
-    """ Raised when an unexpected or unsupported protocol event occurs.
+    @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"
+        if classification == "ClientError":
+            try:
+                error_class = client_errors[code]
+            except KeyError:
+                error_class = ClientError
+        elif classification == "DatabaseError":
+            error_class = DatabaseError
+        elif classification == "TransientError":
+            error_class = TransientError
+        else:
+            error_class = cls
+        inst = error_class(message)
+        inst.message = message
+        inst.code = code
+        inst.classification = classification
+        inst.category = category
+        inst.title = title
+        inst.metadata = metadata
+        return inst
+
+
+class ClientError(CypherError):
+    """ The Client sent a bad request - changing the request might yield a successful outcome.
     """
 
 
-class ServiceUnavailable(Exception):
-    """ Raised when no database service is available.
+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 ConstraintError(ClientError):
     """
+    """
+
+
+class CypherSyntaxError(ClientError):
+    """
+    """
+
+
+class CypherTypeError(ClientError):
+    """
+    """
+
+
+class Forbidden(ClientError, SecurityError):
+    """
+    """
+
+
+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": Forbidden,
+    "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,
+
+}

neo4j/v1/__init__.py

@@ -19,6 +19,8 @@
 # limitations under the License.
 
 
+from neo4j.exceptions import *
+
 from .api import *
 from .direct import *
 from .exceptions import *

neo4j/v1/api.py

@@ -27,8 +27,9 @@
 
 from neo4j.bolt import ProtocolError, ServiceUnavailable
 from neo4j.compat import urlparse
+from neo4j.exceptions import CypherError
 
-from .exceptions import DriverError, SessionError, SessionExpired, TransactionError, CypherError
+from .exceptions import DriverError, SessionError, SessionExpired, TransactionError
 
 
 _warned_about_transaction_bookmarks = False
@@ -558,6 +559,7 @@ def close(self):
         """ Close this transaction, triggering either a COMMIT or a ROLLBACK.
         """
         if not self.closed():
+            self.sync()
             try:
                 self.sync()
             except CypherError:

neo4j/v1/exceptions.py

@@ -19,9 +19,6 @@
 # limitations under the License.
 
 
-from neo4j.exceptions import *
-
-
 class DriverError(Exception):
     """ Raised when an error occurs while using a driver.
     """
@@ -42,7 +39,7 @@ def __init__(self, session, *args, **kwargs):
 
 class SessionExpired(SessionError):
     """ Raised when no a session is no longer able to fulfil
-    its purpose, as defined by its original session parameters.
+    the purpose described by its original parameters.
     """
 
     def __init__(self, session, *args, **kwargs):
@@ -56,17 +53,3 @@ class TransactionError(Exception):
     def __init__(self, transaction, *args, **kwargs):
         super(TransactionError, self).__init__(*args, **kwargs)
         self.transaction = transaction
-
-
-class CypherError(Exception):
-    """ Raised when the Cypher engine returns an error to the client.
-    """
-
-    code = None
-    message = None
-
-    def __init__(self, data):
-        super(CypherError, self).__init__(data.get("message"))
-        for key, value in data.items():
-            if not key.startswith("_"):
-                setattr(self, key, value)

neo4j/v1/result.py

@@ -21,8 +21,8 @@
 
 from collections import namedtuple
 
+from neo4j.exceptions import CypherError
 from neo4j.v1.api import GraphDatabase, StatementResult
-from neo4j.v1.exceptions import CypherError
 from neo4j.v1.types import Record
 
 
@@ -36,8 +36,6 @@ class BoltStatementResult(StatementResult):
     """ A handler for the result of Cypher statement execution.
     """
 
-    error_class = CypherError
-
     value_system = GraphDatabase.value_systems["packstream"]
 
     zipper = Record
@@ -68,7 +66,7 @@ def on_failure(metadata):
             # Called on execution failure.
             self._session._connection.acknowledge_failure()
             on_footer(metadata)
-            raise self.error_class(metadata)
+            raise CypherError.hydrate(**metadata)
 
         run_response.on_success = on_header
         run_response.on_failure = on_failure

neo4j/v1/routing.py

@@ -25,8 +25,9 @@
 from neo4j.addressing import SocketAddress, resolve
 from neo4j.bolt import ConnectionPool, ServiceUnavailable, ProtocolError, DEFAULT_PORT, connect
 from neo4j.compat.collections import MutableSet, OrderedDict
+from neo4j.exceptions import CypherError
 from neo4j.v1.api import Driver, READ_ACCESS, WRITE_ACCESS
-from neo4j.v1.exceptions import SessionExpired, CypherError
+from neo4j.v1.exceptions import SessionExpired
 from neo4j.v1.security import SecurityPlan
 from neo4j.v1.session import BoltSession
 

test/stub/scripts/broken_router.script

@@ -3,7 +3,7 @@
 
 C: RUN "CALL dbms.cluster.routing.getServers" {}
    PULL_ALL
-S: FAILURE {"code": "Neo.X", "message": "X"}
+S: FAILURE {"code": "Neo.DatabaseError.General.UnknownError", "message": "An unknown error occurred."}
    IGNORED
 C: ACK_FAILURE
 S: SUCCESS {}