neo4j-ruby-driver 4.4.0.alpha.4 → 4.4.0.alpha.7

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
+          records = run_procedure(delegate, procedure, bookmark_holder)
+          release_connection(delegate)
+          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)
@@ -45,16 +43,16 @@ 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.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)

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)
@@ -25,7 +26,7 @@ module Neo4j::Driver
           first_record
         end
 
-        def each_async(&action)
+        def each(&action)
           internal_for_each_async(&action)
           consume_async
         end

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 Neo4j::Driver::Internal::Util.new_result_consumed_error if @disposed
         end
 
         def disposed?

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/channel_releasing_reset_response_handler.rb

@@ -2,26 +2,27 @@ module Neo4j::Driver
   module Internal
     module Handlers
       class ChannelReleasingResetResponseHandler < ResetResponseHandler
-        def initialize(channel, pool, message_dispatcher, clock, release_future)
+        def initialize(channel, pool, message_dispatcher, log, release_future)
           super(message_dispatcher, release_future)
           @channel = channel
           @pool = pool
-          @clock = clock
+          @log = log
         end
 
-        def reset_completed(completion_future, success)
+        def reset_completed(success)
           if success
             # update the last-used timestamp before returning the channel back to the pool
-            Async::Connection::ChannelAttributes.set_last_used_timestamp(@channel, @clock.millis)
-            closure_stage = Util::Futures.completed_with_null
+            # Async::Connection::ChannelAttributes.set_last_used_timestamp(@channel, @clock.millis)
+            # closure_stage = Util::Futures.completed_with_null
           else
             # close the channel before returning it back to the pool if RESET failed
-            closure_stage = Util::Futures.as_completion_stage(@channel.close)
-          end
-
-          closure_stage.exceptionally(-> (_throwable) { nil }).then_compose(-> (_ignored) { @pool.release(@channel) }).when_complete do |_, _error|
-            completion_future.complete(nil)
+            @channel.close
           end
+        rescue
+          nil
+        ensure
+          @pool.release(@channel)
+          @log.debug { "Channel #{@channel.object_id} released." }
         end
       end
     end