neo4j-ruby-driver 4.4.0.alpha.5 → 4.4.0.alpha.8

data/ruby/neo4j/driver/internal/cluster/routing_table_handler_impl.rb

@@ -6,109 +6,88 @@ module Neo4j::Driver
 
         delegate :servers, to: :routing_table
 
-        def initialize(routing_table, rediscovery, connection_pool, routing_table_registry, logger, routing_table_purge_delay_ms)
+        def initialize(routing_table, rediscovery, connection_pool, routing_table_registry, logger, routing_table_purge_delay)
           @routing_table = routing_table
           @database_name = routing_table.database
           @rediscovery = rediscovery
           @connection_pool = connection_pool
           @routing_table_registry = routing_table_registry
           @log = logger
-          @routing_table_purge_delay_ms = routing_table_purge_delay_ms
-          @resolved_initial_routers = []
-          @refresh_routing_table_future = nil
+          @routing_table_purge_delay = routing_table_purge_delay
+          @mutex = Concurrent::ReentrantReadWriteLock.new
         end
 
         def on_connection_failure(address)
           # remove server from the routing table, to prevent concurrent threads from making connections to this address
-          routing_table.forget(address)
+          @routing_table.forget(address)
         end
 
         def on_write_failure(address)
-          routing_table.forget_writer(address)
+          @routing_table.forget_writer(address)
         end
 
         def ensure_routing_table(context)
-          # refresh is already happening concurrently, just use it's result
-          return @refresh_routing_table_future unless @refresh_routing_table_future.nil?
-
-          if routing_table.stale_for?(context.mode)
-            # existing routing table is not fresh and should be updated
-            @log.debug( "Routing table for database '#{@database_name.description}' is stale. #{routing_table}")
-
-            result_future = java.util.concurrent.CompletableFuture.new
-            @refresh_routing_table_future = result_future
-
-            @rediscovery.lookup_cluster_composition(routing_table, @connection_pool, context.rediscovery_bookmark, nil).when_complete do |composition, completion_error|
-              error = Util::Futures.completion_exception_cause(completion_error)
-
-              if error.nil?
-                fresh_cluster_composition_fetched(composition)
-              else
-                cluster_composition_lookup_failed(error)
-              end
+          @mutex.with_write_lock do
+            if @routing_table.stale_for?(context.mode)
+              # existing routing table is not fresh and should be updated
+              @log.debug("Routing table for database '#{@database_name.description}' is stale. #{@routing_table}")
+
+              fresh_cluster_composition_fetched(
+                @rediscovery.lookup_cluster_composition(@routing_table, @connection_pool, context.rediscovery_bookmark,
+                                                        nil))
+            else
+              # existing routing table is fresh, use it
+              @routing_table
             end
-
-            result_future
-          else
-            # existing routing table is fresh, use it
-            java.util.concurrent.CompletableFuture.completed_future(routing_table)
+          rescue => error
+            cluster_composition_lookup_failed(error)
           end
         end
 
         def update_routing_table(composition_lookup_result)
-          if !@refresh_routing_table_future.nil?
-            # refresh is already happening concurrently, just use its result
-            @refresh_routing_table_future
-          else
-            if composition_lookup_result.get_cluster_composition.expiration_timestamp < routing_table.expiration_timestamp
-              return java.util.concurrent.CompletableFuture.completed_future(routing_table)
+          @mutex.with_write_lock do
+            if composition_lookup_result.cluster_composition.expiration_timestamp < @routing_table.expiration_timestamp
+              @routing_table
+            else
+              fresh_cluster_composition_fetched(composition_lookup_result)
             end
-
-            result_future = java.util.concurrent.CompletableFuture.new
-            @refresh_routing_table_future = result_future
-            fresh_cluster_composition_fetched(composition_lookup_result)
-            result_future
           end
         end
 
-        private def fresh_cluster_composition_fetched(composition_lookup_result)
-          begin
-            @log.debug("Fetched cluster composition for database '#{@database_name.description}'. #{composition_lookup_result.cluster_composition}")
-            routing_table.update(composition_lookup_result.cluster_composition)
-            @routing_table_registry.remove_aged
+        private
 
-            addresses_to_retain = []
-            @routing_table_registry.all_servers.stream.flat_map(BoltServerAddress::unicast_stream).for_each(addresses_to_retain::add)
+        def fresh_cluster_composition_fetched(composition_lookup_result)
+          @log.debug("Fetched cluster composition for database '#{@database_name.description}'. #{composition_lookup_result.cluster_composition}")
+          @routing_table.update(composition_lookup_result.cluster_composition)
+          @routing_table_registry.remove_aged
+          addresses_to_retain = @routing_table_registry.all_servers.map(&:unicast_stream).reduce(&:+)
 
-            composition_lookup_result.resolved_initial_routers.if_present do |addresses|
-              @resolved_initial_routers.clear
-              @resolved_initial_routers << addresses
-            end
+          composition_lookup_result.resolved_initial_routers&.then do |addresses|
+            addresses_to_retain << addresses
+          end
 
-            addresses_to_retain << @resolved_initial_routers
-            @connection_pool.retain_all(addresses_to_retain)
+          @connection_pool.retain_all(addresses_to_retain)
 
-            @log.debug("Updated routing table for database '#{@database_name.description}'. #{routing_table}")
+          @log.debug("Updated routing table for database '#{@database_name.description}'. #{routing_table}")
+          @routing_table
+        rescue => error
+          cluster_composition_lookup_failed(error)
+        end
 
-            routing_table_future = @refresh_routing_table_future
-            @refresh_routing_table_future = nil
-            routing_table_future.complete( routing_table)
-          rescue StandardError => error
-            cluster_composition_lookup_failed(error)
+        def cluster_composition_lookup_failed(error)
+          @log.error do
+            "Failed to update routing table for database '#{@database_name.description}'. Current routing table: #{@routing_table}."
           end
+          @log.error(error)
+          @routing_table_registry.remove(@database_name)
+          raise error
         end
 
-        private def cluster_composition_lookup_failed(error)
-          @log.error("Failed to update routing table for database '#{database_name.description}'. Current routing table: #{routing_table}.", error)
-          @routing_table_registry.remove(database_name)
-          routing_table_future = @refresh_routing_table_future
-          @refresh_routing_table_future = nil
-          routing_table_future.complete_exceptionally(error)
-        end
+        public
 
         # This method cannot be synchronized as it will be visited by all routing table handler's threads concurrently
         def routing_table_aged?
-          @refresh_routing_table_future.nil? && routing_table.has_been_stale_for?(@routing_table_purge_delay_ms)
+          @mutex.with_read_lock { @routing_table.has_been_stale_for?(@routing_table_purge_delay) }
         end
       end
     end

data/ruby/neo4j/driver/internal/cluster/routing_table_registry_impl.rb

@@ -2,78 +2,57 @@ module Neo4j::Driver
   module Internal
     module Cluster
       class RoutingTableRegistryImpl
-        def initialize(connection_pool, rediscovery, clock, logger, routing_table_purge_delay_ms)
-          @factory = RoutingTableHandlerFactory.new(connection_pool, rediscovery, clock, logger, routing_table_purge_delay_ms)
-          @routing_table_handlers = Concurrent::Hash.new
-          @principal_to_database_name_stage = {}
+        def initialize(connection_pool, rediscovery, clock, logger, routing_table_purge_delay)
+          @factory = RoutingTableHandlerFactory.new(connection_pool, rediscovery, clock, logger, routing_table_purge_delay)
+          @routing_table_handlers = Concurrent::Map.new
+          @principal_to_database_name = {}
           @clock = clock
           @connection_pool = connection_pool
           @rediscovery = rediscovery
           @log = logger
+          @mutex = Mutex.new
         end
 
         def ensure_routing_table(context)
-          ensure_database_name_is_completed(context).then_compose do |ctx_and_handler|
-            completed_context = ctx_and_handler.context
-            handler = ctx_and_handler.handler.nil? ? get_or_create(Util::Futures.join_now_or_else_throw(completed_context.database_name_future, Async::ConnectionContext::PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER)) : ctx_and_handler.handler
-            handler.ensure_routing_table(completed_context).then_apply(-> (_ignored) { handler })
-          end
+          ctx_and_handler = ensure_database_name_is_completed(context)
+          (ctx_and_handler.handler || get_or_create(context.database_name))
+            .tap { |handler| handler.ensure_routing_table(ctx_and_handler.context) }
         end
 
         private def ensure_database_name_is_completed(context)
-          context_database_name_future = context.database_name_future
+          context_database_name = context.database_name
+
+          return ConnectionContextAndHandler.new(context, nil) if context_database_name
+          @mutex.synchronize do
+            return ConnectionContextAndHandler.new(context, nil) if context_database_name
 
-          if context_database_name_future.done?
-            context_and_handler_stage = java.util.concurrent.CompletableFuture.completed_future(ConnectionContextAndHandler.new(context, nil))
-          else
             impersonated_user = context.impersonated_user
             principal = Principal.new(impersonated_user)
-            database_name_stage = @principal_to_database_name_stage[principal]
-            handler_ref = java.util.concurrent.atomic.AtomicReference.new
-
-            if database_name_stage.nil?
-              database_name_future = java.util.concurrent.CompletableFuture.new
-              @principal_to_database_name_stage[principal] = database_name_future
-              database_name_stage = database_name_future
-
-              routing_table = ClusterRoutingTable.new(DatabaseNameUtil::DEFAULT_DATABASE, @clock)
-
-              @rediscovery.lookup_cluster_composition(routing_table, @connection_pool, context.rediscovery_bookmark, impersonated_user).then_compose do |composition_lookup_result|
-                database_name = DatabaseNameUtil.database(composition_lookup_result.cluster_composition.database_name)
-                handler = get_or_create(database_name)
-                handler_ref.set(handler)
-                handler.update_routing_table(composition_lookup_result).then_apply(-> (_ignored) { database_name })
-              end.when_complete do |database_name, _throwable|
-                    @principal_to_database_name_stage.delete(principal)
-                  end.when_complete do |database_name, throwable|
-                        if throwable.nil?
-                          database_name_future.complete(database_name)
-                        else
-                          database_name_future.complete_exceptionally(throwable)
-                        end
-                      end
-            end
+            database_name = @principal_to_database_name[principal]
+            handler_ref = Concurrent::AtomicReference.new
 
-            context_and_handler_stage =
-            database_name_stage.then_apply do |database_name|
-              context_database_name_future.complete(database_name)
-              ConnectionContextAndHandler.new(context, handler_ref)
+            if database_name.nil?
+              @principal_to_database_name[principal] = database_name
+
+              routing_table = ClusterRoutingTable.new(DatabaseNameUtil.default_database, @clock)
+
+              composition_lookup_result = @rediscovery.lookup_cluster_composition(routing_table, @connection_pool, context.rediscovery_bookmark, impersonated_user)
+              database_name = DatabaseNameUtil.database(composition_lookup_result.cluster_composition.database_name)
+              handler = get_or_create(database_name)
+              handler_ref.set(handler)
+              handler.update_routing_table(composition_lookup_result)
+              @principal_to_database_name.delete(principal)
             end
-          end
 
-          context_and_handler_stage
+            context.database_name = database_name
+            ConnectionContextAndHandler.new(context, handler_ref.get)
+          end
         end
 
         def all_servers
           # obviously we just had a snapshot of all servers in all routing tables
           # after we read it, the set could already be changed.
-          servers = []
-
-          @routing_table_handlers.values.each do |table_handler|
-            servers << table_handler.servers
-          end
-
-          servers
+          @routing_table_handlers.values.map(&:servers).reduce(&:+)
         end
 
         def remove(database_name)
@@ -90,17 +69,19 @@ module Neo4j::Driver
           end
         end
 
-        def get_routing_table_handler(database_name)
-          java.util.Optional.of_nullable(@routing_table_handlers[database_name])
+        def routing_table_handler(database_name)
+          database_name = DatabaseNameUtil.database(database_name) unless database_name.is_a?(InternalDatabaseName)
+          @routing_table_handlers[database_name]
         end
 
-        def contains(database_name)
-          @routing_table_handlers.keys.include?(database_name)
-        end
+        # For tests
+        delegate :key?, to: :@routing_table_handlers
 
         def get_or_create(database_name)
-          @routing_table_handlers.compute_if_absent(database_name) do |name|
-            handler = @factory.new_instance(name, self)
+          @routing_table_handlers.compute_if_absent(database_name) do
+            # TODO: Verify if applies
+            # Note: Atomic methods taking a block do not allow the self instance to be used within the block. Doing so will cause a deadlock.
+            handler = @factory.new_instance(database_name, self)
             @log.debug("Routing table handler for database '#{database_name.description}' is added.")
             handler
           end
@@ -109,17 +90,17 @@ module Neo4j::Driver
         private
 
         class RoutingTableHandlerFactory
-          def initialize(connection_pool, rediscovery, clock, logger, routing_table_purge_delay_ms)
+          def initialize(connection_pool, rediscovery, clock, logger, routing_table_purge_delay)
             @connection_pool = connection_pool
             @rediscovery = rediscovery
             @clock = clock
             @logger = logger
-            @routing_table_purge_delay_ms = routing_table_purge_delay_ms
+            @routing_table_purge_delay = routing_table_purge_delay
           end
 
           def new_instance(database_name, all_tables)
             routing_table = ClusterRoutingTable.new(database_name, @clock)
-            RoutingTableHandlerImpl.new(routing_table, @rediscovery, @connection_pool, all_tables, @logger, @routing_table_purge_delay_ms)
+            RoutingTableHandlerImpl.new(routing_table, @rediscovery, @connection_pool, all_tables, @logger, @routing_table_purge_delay)
           end
         end
 

data/ruby/neo4j/driver/internal/cluster/single_database_routing_procedure_runner.rb

@@ -5,7 +5,7 @@ module Neo4j::Driver
       # This implementation of the {@link RoutingProcedureRunner} works with single database versions of Neo4j calling
       # the procedure `dbms.cluster.routing.getRoutingTable`
       class SingleDatabaseRoutingProcedureRunner
-        ROUTING_CONTEXT = 'context'
+        ROUTING_CONTEXT = :context
         GET_ROUTING_TABLE = "CALL dbms.cluster.routing.getRoutingTable($#{ROUTING_CONTEXT})"
 
         def initialize(context)
@@ -16,17 +16,15 @@ module Neo4j::Driver
           delegate = connection(connection)
           procedure = procedure_query(connection.server_version, database_name)
           bookmark_holder = bookmark_holder(bookmark)
-          run_procedure(delegate, procedure, bookmark_holder).then_compose do |records|
-            release_connection(delegate, records).handle do |records, error|
-              process_procedure_response(procedure, records, error)
-            end
-          end
+          run_procedure(delegate, procedure, bookmark_holder)
+            .side { release_connection(delegate) }
+            .chain { |records, error| process_procedure_response(procedure, records, error) }
         end
 
         private
 
         def connection(connection)
-          Async::Connection::DirectConnection.new(connection, default_database, AccessMode::WRITE, nil)
+          Async::Connection::DirectConnection.new(connection, DatabaseNameUtil.default_database, AccessMode::WRITE, nil)
         end
 
         def procedure_query(server_version, database_name)
@@ -34,7 +32,7 @@ module Neo4j::Driver
             raise Exceptions::FatalDiscoveryException, "Refreshing routing table for multi-databases is not supported in server version lower than 4.0. Current server version: #{server_version}. Database name: '#{database_name.description}'"
           end
 
-          Query.new(GET_ROUTING_TABLE, Values.parameters(ROUTING_CONTEXT, @context.to_map))
+          Query.new(GET_ROUTING_TABLE, ROUTING_CONTEXT => @context.to_h)
         end
 
         def bookmark_holder(_ignored)
@@ -45,30 +43,28 @@ module Neo4j::Driver
           connection.protocol
                     .run_in_auto_commit_transaction(connection, procedure, bookmark_holder, TransactionConfig.empty,
                                                     Handlers::Pulln::FetchSizeUtil::UNLIMITED_FETCH_SIZE)
-                    .async_result.then_compose(Async::ResultCursor::list_async)
+                    .async_result.then(&:to_a)
         end
 
-        def release_connection(connection, records)
+        def release_connection(connection)
           # It is not strictly required to release connection after routing procedure invocation because it'll
           # be released by the PULL_ALL response handler after result is fully fetched. Such release will happen
           # in background. However, releasing it early as part of whole chain makes it easier to reason about
           # rediscovery in stub server tests. Some of them assume connections to instances not present in new
           # routing table will be closed immediately.
-          connection.release.then_apply(->(_ignore) { records } )
+          connection.release
         end
 
         def process_procedure_response(procedure, records, error)
-          cause = Util::Futures.completion_exception_cause(error)
-
-          return RoutingProcedureResponse.new(procedure, records) if cause.nil?
-
-          handle_error(procedure, cause)
+          error ? handle_error(procedure, error) : RoutingProcedureResponse.new(procedure, records: records)
         end
 
         def handle_error(procedure, error)
-          return RoutingProcedureResponse.new(procedure, records) if error.is_a? Exceptions::ClientException
-
-          raise java.util.concurrent.CompletionException, error
+          if error.is_a? Exceptions::ClientException
+            RoutingProcedureResponse.new(procedure, error: error)
+          else
+            raise error
+          end
         end
       end
     end

data/ruby/neo4j/driver/internal/cursor/async_result_cursor_impl.rb

@@ -2,6 +2,7 @@ module Neo4j::Driver
   module Internal
     module Cursor
       class AsyncResultCursorImpl
+        include Enumerable
         delegate :consume_async, :next_async, :peek_async, to: :@pull_all_handler
 
         def initialize(run_handler, pull_all_handler)
@@ -14,20 +15,24 @@ module Neo4j::Driver
         end
 
         def single_async
-          first_record = next_async
-          unless first_record
-            raise Exceptions::NoSuchRecordException, 'Cannot retrieve a single record, because this result is empty.'
-          end
-          if next_async
-            raise Exceptions::NoSuchRecordException,
-                  'Expected a result with a single record, but this result contains at least one more. Ensure your query returns only one record.'
+          next_async.compose do |first_record|
+            unless first_record
+              raise Exceptions::NoSuchRecordException, 'Cannot retrieve a single record, because this result is empty.'
+            end
+            next_async.then do |second_record|
+              if second_record
+                raise Exceptions::NoSuchRecordException,
+                      'Expected a result with a single record, but this result contains at least one more. Ensure your query returns only one record.'
+              end
+              first_record
+            end
           end
-          first_record
         end
 
-        def each_async(&action)
-          internal_for_each_async(&action)
-          consume_async
+        def each(&action)
+          result_holder = Util::ResultHolder.new
+          internal_for_each_async(result_holder, &action)
+          result_holder.then { consume_async }
         end
 
         def to_async(&map_function)
@@ -36,7 +41,7 @@ module Neo4j::Driver
 
         def discard_all_failure_async
           # runError has priority over other errors and is expected to have been reported to user by now
-          consume_async #.chain { |_fulfilled, _summary, error| @run_error ? nil : error }
+          consume_async.chain { |_summary, error| run_error ? nil : error }
           nil
         end
 
@@ -45,18 +50,25 @@ module Neo4j::Driver
           @pull_all_handler.pull_all_failure_async.then { |error| run_error ? nil : error }
         end
 
-        private def internal_for_each_async
-          while record = next_async
-            begin
-              yield record
-            rescue
-              nil
+        private def internal_for_each_async(result_holder, &action)
+          next_async.chain do |record, error|
+            if error
+              result_holder.fail(error)
+            elsif record
+              begin
+                yield record
+              rescue => action_error
+                result_holder.fail(action_error)
+              end
+              internal_for_each_async(result_holder, &action)
+            else
+              result_holder.succeed(nil)
             end
           end
         end
 
         def map_successful_run_completion_async
-          run_error || self
+          run_error&.then(&Util::ResultHolder.method(:failed)) || Util::ResultHolder.successful(self)
         end
 
         def run_error

data/ruby/neo4j/driver/internal/cursor/disposable_async_result_cursor.rb

@@ -2,6 +2,7 @@ module Neo4j::Driver
   module Internal
     module Cursor
       class DisposableAsyncResultCursor
+        include Enumerable
         delegate :keys, :pull_all_failure_async, to: :@delegate
 
         def initialize(delegate)
@@ -14,25 +15,23 @@ module Neo4j::Driver
         end
 
         def next_async
-          assert_not_disposed.then_compose(-> (_ignored) { @delegate.next_async })
+          assert_not_disposed
+          @delegate.next_async
         end
 
         def peek_async
-          assert_not_disposed.then_compose(-> (_ignored) { @delegate.peek_async })
+          assert_not_disposed
+          @delegate.peek_async
         end
 
         def single_async
-          assert_not_disposed.then_compose(-> (_ignored) { @delegate.single_async })
+          assert_not_disposed
+          @delegate.single_async
         end
 
-        def for_each_async(action)
-          assert_not_disposed.then_compose(-> (_ignored) { @delegate.for_each_async(action) })
-        end
-
-        def list_async(map_function = nil)
-          return assert_not_disposed.then_compose(-> (_ignored) { @delegate.list_async(map_function) }) if map_function.present?
-
-          assert_not_disposed.then_compose(-> (_ignored) { @delegate.list_async })
+        def each(&action)
+          assert_not_disposed
+          @delegate.each(&action)
         end
 
         def discard_all_failure_async
@@ -41,9 +40,7 @@ module Neo4j::Driver
         end
 
         private def assert_not_disposed
-          return Util::Futures.failed_future(new_result_consumed_error) if @disposed
-
-          Util::Futures.completed_with_null
+          raise Util::ErrorUtil.new_result_consumed_error if @disposed
         end
 
         def disposed?
@@ -51,7 +48,7 @@ module Neo4j::Driver
         end
 
         def map_successful_run_completion_async
-          @delegate.map_successful_run_completion_async
+          @delegate.map_successful_run_completion_async.then { self }
         end
       end
     end

data/ruby/neo4j/driver/internal/database_name_util.rb

@@ -6,8 +6,8 @@ module Neo4j::Driver
 
       private
 
-      DEFAULT_DATABASE = Struct.new(:database_name, :description).new(nil, '<default database>')
-      SYSTEM_DATABASE = InternalDatabaseName.new(SYSTEM_DATABASE_NAME)
+      DEFAULT_DATABASE = InternalDatabaseName.new(description: '<default database>')
+      SYSTEM_DATABASE = InternalDatabaseName.new(database_name: SYSTEM_DATABASE_NAME)
 
       public
 
@@ -27,7 +27,7 @@ module Neo4j::Driver
           when SYSTEM_DATABASE_NAME
             system_database
           else
-            InternalDatabaseName.new(name)
+            InternalDatabaseName.new(database_name: name)
           end
         end
       end

data/ruby/neo4j/driver/internal/default_bookmark_holder.rb

@@ -1,12 +1,6 @@
 module Neo4j::Driver
   module Internal
-    class DefaultBookmarkHolder
-      attr_reader :bookmark
-
-      def initialize(bookmark = InternalBookmark.empty)
-        @bookmark = bookmark
-      end
-
+    class DefaultBookmarkHolder < ReadOnlyBookmarkHolder
       def bookmark=(bookmark)
         @bookmark = bookmark if bookmark.present?
       end

data/ruby/neo4j/driver/internal/direct_connection_provider.rb

@@ -22,7 +22,7 @@ module Neo4j::Driver
 
       def supports_multi_db?
         private_acquire_connection.then do |conn|
-          supports_multi_database?(conn)
+          Messaging::Request::MultiDatabaseUtil.supports_multi_database?(conn)
         ensure
           conn.release
         end

data/ruby/neo4j/driver/internal/driver_factory.rb

@@ -83,8 +83,8 @@ module Neo4j::Driver::Internal
       driver(:Direct, securityPlan, address, connection_provider, retryLogic, metricsProvider, config)
     end
 
-    def create_routing_driver(securityPlan, address, connection_pool, eventExecutorGroup, routingSettings, retryLogic, metricsProvider, config)
-      connection_provider = create_load_balancer(address, connection_pool, eventExecutorGroup, config, routingSettings)
+    def create_routing_driver(securityPlan, address, connection_pool, eventExecutorGroup, routing_settings, retryLogic, metricsProvider, config)
+      connection_provider = create_load_balancer(address, connection_pool, eventExecutorGroup, config, routing_settings)
       driver(:Routing, securityPlan, address, connection_provider, retryLogic, metricsProvider, config)
     end
 
@@ -95,11 +95,11 @@ module Neo4j::Driver::Internal
       end
     end
 
-    def create_load_balancer(address, connection_pool, eventExecutorGroup, config, routingSettings)
+    def create_load_balancer(address, connection_pool, eventExecutorGroup, config, routing_settings)
       load_balancing_strategy = Cluster::Loadbalancing::LeastConnectedLoadBalancingStrategy.new(connection_pool, config[:logger])
       resolver = create_resolver(config)
       Cluster::Loadbalancing::LoadBalancer.new(
-        address, routingSettings, connection_pool, eventExecutorGroup,
+        address, routing_settings, connection_pool, eventExecutorGroup,
         config[:logger], load_balancing_strategy, resolver, &method(:domain_name_resolver))
     end
 

data/ruby/neo4j/driver/internal/handlers/commit_tx_response_handler.rb

@@ -4,16 +4,16 @@ module Neo4j::Driver
       class CommitTxResponseHandler
         include Spi::ResponseHandler
 
-        def initialize(completion_listener)
-          @completion_listener = completion_listener
+        def initialize(result_holder)
+          @result_holder = result_holder
         end
 
         def on_success(metadata)
-          @completion_listener.bookmark = metadata[:bookmark]&.then(&InternalBookmark.method(:parse))
+          @result_holder.succeed(metadata[:bookmark]&.then(&InternalBookmark.method(:parse)))
         end
 
         def on_failure(error)
-          raise error
+          @result_holder.fail(error)
         end
 
         def on_record(fields)