Driver NotificationFilter config

boltstub/bolt_protocol.py

@@ -463,7 +463,7 @@ class Bolt4x4Protocol(Bolt4x3Protocol):
 class Bolt5x0Protocol(Bolt4x4Protocol):
 
     protocol_version = (5, 0)
-    version_aliases = set()
+    version_aliases = {(5,)}
     # allow the server to negotiate other bolt versions
     equivalent_versions = set()
 
@@ -479,8 +479,6 @@ class Bolt5x1Protocol(Bolt5x0Protocol):
     # allow the server to negotiate other bolt versions
     equivalent_versions = set()
 
-    server_agent = "Neo4j/5.4.0"  # TODO: finalize!
-
     messages = {
         "C": {
             **Bolt5x0Protocol.messages["C"],
@@ -489,3 +487,14 @@ class Bolt5x1Protocol(Bolt5x0Protocol):
         },
         "S": Bolt5x0Protocol.messages["S"],
     }
+
+    server_agent = "Neo4j/5.1.0"
+
+
+class Bolt5x2Protocol(Bolt5x1Protocol):
+    protocol_version = (5, 2)
+    version_aliases = set()
+    # allow the server to negotiate other bolt versions
+    equivalent_versions = set()
+
+    server_agent = "Neo4j/5.2.0"

nutkit/frontend/driver.py

@@ -10,7 +10,9 @@ def __init__(self, backend, uri, auth_token, user_agent=None,
                  max_tx_retry_time_ms=None, encrypted=None,
                  trusted_certificates=None, liveness_check_timeout_ms=None,
                  max_connection_pool_size=None,
-                 connection_acquisition_timeout_ms=None):
+                 connection_acquisition_timeout_ms=None,
+                 notifications_min_severity=None,
+                 notifications_disabled_categories=None):
         self._backend = backend
         self._resolver_fn = resolver_fn
         self._domain_name_resolver_fn = domain_name_resolver_fn
@@ -25,6 +27,8 @@ def __init__(self, backend, uri, auth_token, user_agent=None,
             liveness_check_timeout_ms=liveness_check_timeout_ms,
             max_connection_pool_size=max_connection_pool_size,
             connection_acquisition_timeout_ms=connection_acquisition_timeout_ms,  # noqa: E501
+            notifications_min_severity=notifications_min_severity,
+            notifications_disabled_categories=notifications_disabled_categories
         )
         res = backend.send_and_receive(req)
         if not isinstance(res, protocol.Driver):
@@ -84,54 +88,58 @@ def execute_query(self, cypher, params=None,
         req = protocol.ExecuteQuery(self._driver.id, cypher, params, config)
         res = self.send_and_receive(req, allow_resolution=True)
         if not isinstance(res, protocol.EagerResult):
-            raise Exception("Should be EagerResult but was: %s" % res)
+            raise Exception(f"Should be EagerResult but was: {res}")
         return res
 
     def verify_connectivity(self):
         req = protocol.VerifyConnectivity(self._driver.id)
         res = self.send_and_receive(req, allow_resolution=True)
         if not isinstance(res, protocol.Driver):
-            raise Exception("Should be Driver but was: %s" % res)
+            raise Exception(f"Should be Driver but was: {res}")
 
     def get_server_info(self):
         req = protocol.GetServerInfo(self._driver.id)
         res = self.send_and_receive(req, allow_resolution=True)
         if not isinstance(res, protocol.ServerInfo):
-            raise Exception("Should be ServerInfo but was: %s" % res)
+            raise Exception(f"Should be ServerInfo but was: {res}")
         return res
 
     def supports_multi_db(self):
         req = protocol.CheckMultiDBSupport(self._driver.id)
         res = self.send_and_receive(req, allow_resolution=False)
         if not isinstance(res, protocol.MultiDBSupport):
-            raise Exception("Should be MultiDBSupport")
+            raise Exception(f"Should be MultiDBSupport but was: {res}")
         return res.available
 
     def is_encrypted(self):
         req = protocol.CheckDriverIsEncrypted(self._driver.id)
         res = self.send_and_receive(req, allow_resolution=False)
         if not isinstance(res, protocol.DriverIsEncrypted):
-            raise Exception("Should be DriverIsEncrypted")
+            raise Exception(f"Should be DriverIsEncrypted but was {res}")
         return res.encrypted
 
     def close(self):
         req = protocol.DriverClose(self._driver.id)
         res = self.send_and_receive(req, allow_resolution=False)
         if not isinstance(res, protocol.Driver):
-            raise Exception("Should be driver")
+            raise Exception(f"Should be Driver but was {res}")
 
     def session(self, access_mode, bookmarks=None, database=None,
                 fetch_size=None, impersonated_user=None,
-                bookmark_manager=None):
+                bookmark_manager=None,
+                notifications_min_severity=None,
+                notifications_disabled_categories=None):
         req = protocol.NewSession(
             self._driver.id, access_mode, bookmarks=bookmarks,
             database=database, fetchSize=fetch_size,
             impersonatedUser=impersonated_user,
-            bookmark_manager=bookmark_manager
+            bookmark_manager=bookmark_manager,
+            notifications_min_severity=notifications_min_severity,
+            notifications_disabled_categories=notifications_disabled_categories
         )
         res = self.send_and_receive(req, allow_resolution=False)
         if not isinstance(res, protocol.Session):
-            raise Exception("Should be session")
+            raise Exception(f"Should be Session but was {res}")
 
         return Session(self, res)
 
@@ -153,12 +161,12 @@ def get_routing_table(self, database=None):
         req = protocol.GetRoutingTable(self._driver.id, database=database)
         res = self.send_and_receive(req, allow_resolution=False)
         if not isinstance(res, protocol.RoutingTable):
-            raise Exception("Should be RoutingTable")
+            raise Exception(f"Should be RoutingTable but was {res}")
         return res
 
     def get_connection_pool_metrics(self, address):
         req = protocol.GetConnectionPoolMetrics(self._driver.id, address)
         res = self.send_and_receive(req, allow_resolution=False)
         if not isinstance(res, protocol.ConnectionPoolMetrics):
-            raise Exception("Should be ConnectionPoolMetrics")
+            raise Exception(f"Should be ConnectionPoolMetrics but was {res}")
         return res

nutkit/protocol/feature.py

@@ -23,6 +23,8 @@ class Feature(Enum):
     # The driver offers a method for driver objects to report if they were
     # configured with a or without encryption.
     API_DRIVER_IS_ENCRYPTED = "Feature:API:Driver.IsEncrypted"
+    # The driver supports notification filters configuration.
+    API_DRIVER_NOTIFICATIONS_CONFIG = "Feature:API:Driver:NotificationsConfig"
     # The driver offers a method for checking if a connection to the remote
     # server of cluster can be established.
     API_DRIVER_VERIFY_CONNECTIVITY = "Feature:API:Driver.VerifyConnectivity"
@@ -45,6 +47,9 @@ class Feature(Enum):
     # If there are more than records, the driver emits a warning.
     # This method is supposed to always exhaust the result stream.
     API_RESULT_SINGLE_OPTIONAL = "Feature:API:Result.SingleOptional"
+    # The session supports notification filters configuration.
+    API_SESSION_NOTIFICATIONS_CONFIG = \
+        "Feature:API:Session:NotificationsConfig"
     # The driver implements explicit configuration options for SSL.
     #  - enable / disable SSL
     #  - verify signature against system store / custom cert / not at all
@@ -81,6 +86,8 @@ class Feature(Enum):
     BOLT_5_0 = "Feature:Bolt:5.0"
     # The driver supports Bolt protocol version 5.1
     BOLT_5_1 = "Feature:Bolt:5.1"
+    # The driver supports Bolt protocol version 5.2
+    BOLT_5_2 = "Feature:Bolt:5.2"
     # The driver supports patching DateTimes to use UTC for Bolt 4.3 and 4.4
     BOLT_PATCH_UTC = "Feature:Bolt:Patch:UTC"
     # The driver supports impersonation

nutkit/protocol/requests.py

@@ -70,8 +70,9 @@ def __init__(
         domainNameResolverRegistered=False, connectionTimeoutMs=None,
         fetchSize=None, maxTxRetryTimeMs=None, encrypted=None,
         trustedCertificates=None, liveness_check_timeout_ms=None,
-        max_connection_pool_size=None,
-        connection_acquisition_timeout_ms=None
+        max_connection_pool_size=None, connection_acquisition_timeout_ms=None,
+        notifications_min_severity=None,
+        notifications_disabled_categories=None
     ):
         # Neo4j URI to connect to
         self.uri = uri
@@ -87,6 +88,10 @@ def __init__(
         self.livenessCheckTimeoutMs = liveness_check_timeout_ms
         self.maxConnectionPoolSize = max_connection_pool_size
         self.connectionAcquisitionTimeoutMs = connection_acquisition_timeout_ms
+        if notifications_min_severity is not None:
+            self.notificationsMinSeverity = notifications_min_severity
+        if notifications_disabled_categories is not None:
+            self.notificationsDisabledCategories = notifications_disabled_categories  # noqa: E501
         # (bool) whether to enable or disable encryption
         # field missing in message: use driver default (should be False)
         if encrypted is not None:
@@ -282,7 +287,8 @@ class NewSession:
 
     def __init__(self, driverId, accessMode, bookmarks=None,
                  database=None, fetchSize=None, impersonatedUser=None,
-                 bookmark_manager=None):
+                 bookmark_manager=None, notifications_min_severity=None,
+                 notifications_disabled_categories=None):
         # Id of driver on backend that session should be created on
         self.driverId = driverId
         # Session accessmode: 'r' for read access and 'w' for write access.
@@ -292,6 +298,11 @@ def __init__(self, driverId, accessMode, bookmarks=None,
         self.database = database
         self.fetchSize = fetchSize
         self.impersonatedUser = impersonatedUser
+        if notifications_min_severity is not None:
+            self.notificationsMinSeverity = notifications_min_severity
+        if notifications_disabled_categories is not None:
+            self.notificationsDisabledCategories = notifications_disabled_categories  # noqa: E501
+
         if bookmark_manager is not None:
             self.bookmarkManagerId = bookmark_manager.id
 

tests/stub/notifications_config/notifications_base.py

@@ -0,0 +1,135 @@
+from nutkit.frontend import Driver
+import nutkit.protocol as types
+from tests.shared import TestkitTestCase
+from tests.stub.shared import StubServer
+
+
+class NotificationsBase(TestkitTestCase):
+    _auth = types.AuthorizationToken("basic", principal="neo4j",
+                                     credentials="pass")
+
+    def setUp(self):
+        super().setUp()
+        self._server = StubServer(9010)
+        self._uri = "bolt://%s" % self._server.address
+        self._driver = None
+
+    def tearDown(self):
+        self._server.reset()
+        if self._driver:
+            self._driver.close()
+        return super().tearDown()
+
+    def _new_driver(self, min_sev=None, disabled_cats=None):
+        return Driver(self._backend, self._uri, self._auth,
+                      notifications_min_severity=min_sev,
+                      notifications_disabled_categories=disabled_cats)
+
+    def _run_test_get_summary(self, parameters, script_params,
+                              script="notifications_config_driver.script"):
+        self._server.start(self.script_path(script),
+                           vars_=script_params)
+        self._driver = self._new_driver(parameters["min_sev"],
+                                        parameters["dis_cats"])
+        session = self._driver.session("w", database="neo4j")
+        cursor = session.run("CREATE (:node)")
+        result = cursor.consume()
+        self._server.done()
+        return result
+
+    @staticmethod
+    def configs():
+        return [
+            {
+                "protocol": {"min_sev": "OFF", "dis_cats": None},
+                "script": {
+                    "#NOTIS#": '"notifications_minimum_severity": "OFF", '
+                }
+            },
+            {
+                "protocol": {"min_sev": "INFORMATION", "dis_cats": None},
+                "script": {
+                    "#NOTIS#": '"notifications_minimum_severity": '
+                               '"INFORMATION", '
+                }
+            },
+            {
+                "protocol": {"min_sev": "WARNING", "dis_cats": None},
+                "script": {
+                    "#NOTIS#": '"notifications_minimum_severity": "WARNING", '
+                }
+            },
+            {
+                "protocol": {"min_sev": None, "dis_cats": []},
+                "script": {
+                    "#NOTIS#": '"notifications_disabled_categories": [], '
+                }
+            },
+            {
+                "protocol": {
+                    "min_sev": "INFORMATION",
+                    "dis_cats": ["UNRECOGNIZED"]
+                },
+                "script": {
+                    "#NOTIS#": '"notifications_minimum_severity": '
+                               '"INFORMATION", '
+                               '"notifications_disabled_categories": '
+                               '["UNRECOGNIZED"], '
+                }
+            },
+            {
+                "protocol": {
+                    "min_sev": "WARNING",
+                    "dis_cats": ["UNRECOGNIZED", "UNSUPPORTED"]
+                },
+                "script": {
+                    "#NOTIS#": '"notifications_minimum_severity": "WARNING", '
+                               '"notifications_disabled_categories{}": '
+                               '["UNRECOGNIZED", "UNSUPPORTED"], '
+                }
+            },
+            {
+                "protocol": {
+                    "min_sev": "WARNING",
+                    "dis_cats": ["PERFORMANCE"]
+                },
+                "script": {
+                    "#NOTIS#": '"notifications_minimum_severity": "WARNING", '
+                               '"notifications_disabled_categories": '
+                               '["PERFORMANCE"], '
+                }
+            },
+            {
+                "protocol": {
+                    "min_sev": "WARNING",
+                    "dis_cats": ["DEPRECATION"]
+                },
+                "script": {
+                    "#NOTIS#": '"notifications_minimum_severity": "WARNING", '
+                               '"notifications_disabled_categories": '
+                               '["DEPRECATION"], '
+                }
+            },
+            {
+                "protocol": {
+                    "min_sev": "WARNING",
+                    "dis_cats": ["GENERIC"]
+                },
+                "script": {
+                    "#NOTIS#": '"notifications_minimum_severity": "WARNING", '
+                               '"notifications_disabled_categories": '
+                               '["GENERIC"], '
+                }
+            },
+            {
+                "protocol": {
+                    "min_sev": "WARNING",
+                    "dis_cats": ["HINT"]
+                },
+                "script": {
+                    "#NOTIS#": '"notifications_minimum_severity": "WARNING", '
+                               '"notifications_disabled_categories": '
+                               '["HINT"], '
+                }
+            }
+        ]

tests/stub/notifications_config/scripts/notifications_config_driver.script

@@ -0,0 +1,15 @@
+!: BOLT 5.2
+
+A: HELLO {#NOTIS#"[user_agent]": "*", "[routing]": "*"}
+A: LOGON {"{}": "*"}
+*: RESET
+C: RUN "*" "*" {"[db]": "*"}
+S: SUCCESS {"fields": ["t"]}
+{{
+    C: PULL "*"
+----
+    C: DISCARD "*"
+}}
+S: SUCCESS {"type": "w"}
+*: RESET
+?: GOODBYE

tests/stub/notifications_config/scripts/notifications_config_override_session_begin.script

@@ -0,0 +1,19 @@
+!: BOLT 5.2
+
+A: HELLO {"[user_agent]": "*", "[routing]": "*", "notifications_minimum_severity": "WARNING", "notifications_disabled_categories{}":["UNSUPPORTED", "UNRECOGNIZED", "DEPRECATION", "HINT"]}
+A: LOGON {"{}": "*"}
+*: RESET
+C: BEGIN {#NOTIS#"[mode]": "*", "[db]": "*"}
+S: SUCCESS {}
+C: RUN "RETURN 1 as n" {} {}
+S: SUCCESS {"fields": ["n"]}
+{{
+    C: PULL "*"
+----
+    C: DISCARD "*"
+}}
+S: SUCCESS {"type": "r"}
+C: COMMIT
+S: SUCCESS {}
+*: RESET
+?: GOODBYE

tests/stub/notifications_config/scripts/notifications_config_override_session_run.script

@@ -0,0 +1,16 @@
+!: BOLT 5.2
+
+A: HELLO {"[user_agent]": "*", "[routing]": "*", "notifications_minimum_severity": "WARNING", "notifications_disabled_categories{}":["UNSUPPORTED", "UNRECOGNIZED", "DEPRECATION", "HINT"]}
+A: LOGON {"{}": "*"}
+*: RESET
+C: RUN "RETURN 1 as n" {} {#NOTIS#"[mode]": "*", "[db]": "*"}
+S: SUCCESS {"fields": ["n"]}
+{{
+    C: PULL "*"
+    S: RECORD [1]
+----
+    C: DISCARD "*"
+}}
+S: SUCCESS {"type": "r"}
+*: RESET
+?: GOODBYE