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

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

@@ -24,59 +24,38 @@ module Neo4j::Driver
         # @param routingTable   current routing table of the given database.
         # @param connectionPool connection pool.
         # @return new cluster composition and an optional set of resolved initial router addresses.
-        def lookup_cluster_composition(routing_table, connection_pool, bookmark, impersonated_user, failures = nil, previous_delay = nil, result = nil, base_error = nil)
-          result = java.util.concurrent.CompletableFuture.new
-
-          # if we failed discovery, we will chain all errors into this one.
-          base_error = Exceptions::ServiceUnavailableException.new(NO_ROUTERS_AVAILABLE % routing_table.database.description)
-
-          lookup(routing_table, connection_pool, bookmark, impersonated_user, base_error).when_complete do |composition_lookup_result, completion_error|
-            error = Util::Futures.completion_exception_cause(completion_error)
-
-            if !error.nil?
-              result.complete_exceptionally(error)
-            elsif !composition_lookup_result.nil?
-              result.complete(composition_lookup_result)
+        def lookup_cluster_composition(
+          routing_table, connection_pool, bookmark, impersonated_user,
+          failures = 0,
+          previous_delay = 0,
+          base_error = Exceptions::ServiceUnavailableException.new(NO_ROUTERS_AVAILABLE % routing_table.database.description))
+
+          lookup(routing_table, connection_pool, bookmark, impersonated_user, base_error) ||
+            if failures > @settings.max_routing_failures
+              # now we throw our saved error out
+              raise base_error
             else
-              new_failures = failures + 1
-
-              if new_failures >= @settings.max_routing_failures
-                # now we throw our saved error out
-                result.complete_exceptionally(base_error)
-              else
-                next_delay = java.lang.Math.max(@settings.retry_timeout_delay, previous_delay * 2)
-                @log.info("Unable to fetch new routing table, will try again in #{next_delay} ms")
-
-                @event_executor_group.next.schedule(next_delay, java.util.concurrent.TimeUnit::MILLISECONDS) do
-                  lookup_cluster_composition(routing_table, connection_pool, bookmark, impersonated_user, new_failures, next_delay, result, base_error)
-                end
-              end
+              next_delay = [@settings.retry_timeout_delay, previous_delay * 2].max
+              @log.info("Unable to fetch new routing table, will try again in #{next_delay} ms")
+              sleep next_delay
+              lookup_cluster_composition(routing_table, connection_pool, bookmark, impersonated_user, failures + 1, next_delay, base_error)
             end
-          end
-
-          result
         end
 
         def resolve
-          resolved_addresses = java.util.LinkedList.new
           exception = nil
 
-          @resolver.resolve(initial_router).each do |server_address|
-            begin
-              resolve_all_by_domain_name(server_address).unicast_stream.for_each(resolved_addresses::add)
-            rescue java.net.UnknownHostException => e
-              if exception.nil?
-                exception = e
-              else
-                exception.add_suppressed(e)
-              end
-            end
+          resolved_addresses = @resolver.call(@initial_router).flat_map do |server_address|
+            resolve_all_by_domain_name(server_address).unicast_stream
+            # rescue java.net.UnknownHostException => e
+          rescue => e
+            exception&.add_suppressed(e)
+            exception ||= e
+            []
           end
 
           # give up only if there are no addresses to work with at all
-          if resolved_addresses.empty? && !exception.nil?
-            raise exception
-          end
+          raise exception if resolved_addresses.empty? && exception
 
           resolved_addresses
         end
@@ -84,153 +63,84 @@ module Neo4j::Driver
         private
 
         def lookup(routing_table, connection_pool, bookmark, impersonated_user, base_error)
-          composition_stage =  if routing_table.prefer_initial_router
-                                lookup_on_initial_router_then_on_known_routers(routing_table, connection_pool, bookmark, impersonated_user, base_error)
-                              else
-                                lookup_on_known_routers_then_on_initial_router(routing_table, connection_pool, bookmark, impersonated_user, base_error)
-                              end
+          if routing_table.prefer_initial_router
+            lookup_on_initial_router_then_on_known_routers(routing_table, connection_pool, bookmark, impersonated_user, base_error)
+          else
+            lookup_on_known_routers_then_on_initial_router(routing_table, connection_pool, bookmark, impersonated_user, base_error)
+          end
         end
 
         def lookup_on_known_routers_then_on_initial_router(routing_table, connection_pool, bookmark, impersonated_user, base_error)
-          seen_servers = {}
-
-          lookup_on_known_routers(routing_table, connection_pool, seen_servers, bookmark, impersonated_user, base_error).then_compose do |composition_lookup_result|
-            if composition_lookup_result.nil?
-              java.util.concurrent.CompletableFuture.completed_future(composition_lookup_result)
-            end
-
+          seen_servers = Set.new
+          lookup_on_known_routers(routing_table, connection_pool, seen_servers, bookmark, impersonated_user, base_error) ||
             lookup_on_initial_router(routing_table, connection_pool, seen_servers, bookmark, impersonated_user, base_error)
-          end
         end
 
         def lookup_on_initial_router_then_on_known_routers(routing_table, connection_pool, bookmark, impersonated_user, base_error)
-          seen_servers = [].freeze
-
-          lookup_on_initial_router(routing_table, connection_pool, seen_servers, bookmark, impersonated_user, base_error).then_compose do |composition_lookup_result|
-            if composition_lookup_result.nil?
-              java.util.concurrent.CompletableFuture.completed_future(composition_lookup_result)
-            end
-
-            lookup_on_known_routers(routing_table, connection_pool, {}, bookmark, impersonated_user, base_error)
-          end
+          lookup_on_initial_router(routing_table, connection_pool, Set.new, bookmark, impersonated_user, base_error) ||
+            lookup_on_known_routers(routing_table, connection_pool, Set.new, bookmark, impersonated_user, base_error)
         end
 
         def lookup_on_known_routers(routing_table, connection_pool, seen_servers, bookmark, impersonated_user, base_error)
-          result = Util::Futures.completed_with_null
-
-          routing_table.routers.each do |address|
-            result = result.then_compose do |composition|
-                       if !composition.nil?
-                         java.util.concurrent.CompletableFuture.completed_future(composition)
-                       else
-                         lookup_on_router(address, true, routing_table, connection_pool, seen_servers, bookmark, impersonated_user, base_error)
-                       end
-                     end
-          end
-
-          result.then_apply do |composition|
-            composition.nil? ? nil : ClusterCompositionLookupResult.new(composition)
-          end
+          routing_table.routers.lazy.map do |address|
+            lookup_on_router(address, true, routing_table, connection_pool, seen_servers, bookmark, impersonated_user, base_error)
+          end.first&.then(&ClusterCompositionLookupResult.method(:new))
         end
 
         def lookup_on_initial_router(routing_table, connection_pool, seen_servers, bookmark, impersonated_user, base_error)
-          begin
-            resolved_routers = resolve
-          rescue StandardError => error
-            Util::Futures.failed_future(error)
-          end
-
-          resolved_router_set = [resolved_routers]
-          resolved_routers - seen_servers
-
-          result = Util::Futures.completed_with_null
-
-          resolved_routers.each do |address|
-            result = result.then_compose do |composition|
-                       if !composition.nil?
-                         java.util.concurrent.CompletableFuture.completed_future(composition)
-                       else
-                         lookup_on_router(address, false, routing_table, connection_pool, nil, bookmark, impersonated_user, base_error)
-                       end
-                     end
-          end
-
-          result.then_apply do |composition|
-            composition.nil? ? nil : ClusterCompositionLookupResult.new(composition, resolved_router_set)
-          end
+          resolved_routers = resolve
+          (resolved_routers - seen_servers.to_a).lazy.filter_map do |address|
+            lookup_on_router(address, false, routing_table, connection_pool, nil, bookmark,
+                             impersonated_user, base_error)
+          end.first&.then { |composition| ClusterCompositionLookupResult.new(composition, Set.new(resolved_routers)) }
         end
 
         def lookup_on_router(router_address, resolve_address, routing_table, connection_pool, seen_servers, bookmark, impersonated_user, base_error)
-          address_future = java.util.concurrent.CompletableFuture.completed_future(router_address)
-
-          address_future.then_apply do |address|
-            resolve_address ? resolve_by_domain_name_or_throw_completion_exception(address, routing_table) : address
-          end.then_apply do |address|
-                add_and_return(seen_servers, address)
-              end.then_compose do
-                    connection_pool::acquire
-                  end.then_apply do |connection|
-                        ImpersonationUtil.ensure_impersonation_support(connection, impersonated_user)
-                      end.then_compose do |connection|
-                            @provider.get_cluster_composition(connection, routing_table.database, bookmark, impersonated_user)
-                          end.handle do |response, error|
-                                cause = Util::Futures.completion_exception_cause(error)
-
-                                if !cause.nil?
-                                  handle_routing_procedure_error(cause, routing_table, router_address, base_error)
-                                else
-                                  response
-                                end
-                              end
+          address = resolve_address ? resolve_by_domain_name_or_throw_completion_exception(router_address, routing_table) : router_address
+          seen_servers&.send(:<<, address)
+          connection = connection_pool.acquire(address)
+          ImpersonationUtil.ensure_impersonation_support(connection, impersonated_user)
+          @provider.get_cluster_composition(connection, routing_table.database, bookmark, impersonated_user)
+        rescue => error
+          handle_routing_procedure_error(error, routing_table, router_address, base_error)
         end
 
         def handle_routing_procedure_error(error, routing_table, router_address, base_error)
-          raise java.util.concurrent.CompletionException, error if must_abort_discovery(error)
+          raise error if must_abort_discovery(error)
 
           # Retriable error happened during discovery.
-          discovery_error = Exceptions::DiscoveryException.new(RECOVERABLE_ROUTING_ERROR % router_address, error)
+          discovery_error = Exceptions::DiscoveryException.new(nil, RECOVERABLE_ROUTING_ERROR % router_address, error)
           Util::Futures.combine_errors(base_error, discovery_error) # we record each failure here
           warning_message = RECOVERABLE_DISCOVERY_ERROR_WITH_SERVER % router_address
           @log.warn(warning_message)
-          @log.debug(warning_message, discovery_error)
+          @log.debug(discovery_error)
           routing_table.forget(router_address)
           nil
         end
 
-        def must_abort_discovery(throwable)
-          abort = if !(throwable.is_a? Exceptions::AuthorizationExpiredException) && (throwable.is_a? Exceptions::SecurityException)
-                    true
-                  elsif throwable.is_a? Exceptions::FatalDiscoveryException
-                    true
-                  elsif throwable.is_a? Exceptions::IllegalStateException && Spi::ConnectionPool::CONNECTION_POOL_CLOSED_ERROR_MESSAGE == throwable.message
-                    true
-                  elsif throwable.is_a? Exceptions::ClientException
-                    code = throwable.code
-                    INVALID_BOOKMARK_CODE.eql?(code) || INVALID_BOOKMARK_MIXTURE_CODE.eql?(code)
-                  end
-        end
-
-        def add_and_return(collection, element)
-          collection << element unless collection.nil?
-
-          element
+        def must_abort_discovery(error)
+          !error.is_a?(Exceptions::AuthorizationExpiredException) && error.is_a?(Exceptions::SecurityException) ||
+            error.is_a?(Exceptions::FatalDiscoveryException) ||
+            error.is_a?(Exceptions::IllegalStateException) &&
+              Spi::ConnectionPool::CONNECTION_POOL_CLOSED_ERROR_MESSAGE == error.message ||
+            error.is_a?(Exceptions::ClientException) &&
+              [INVALID_BOOKMARK_CODE, INVALID_BOOKMARK_MIXTURE_CODE].include?(error.code) ||
+          # Not sure why this is not im java
+            !error.is_a?(Exceptions::Neo4jException) ||
+            Util::ErrorUtil.fatal?(error)
         end
 
         def resolve_by_domain_name_or_throw_completion_exception(address, routing_table)
-          begin
-            resolved_address = resolve_all_by_domain_name(address)
-            routing_table.replace_router_if_present(address, resolved_address)
+          resolved_address = resolve_all_by_domain_name(address)
+          routing_table.replace_router_if_present(address, resolved_address)
 
-            resolved_address.unicast_stream.find_first.or_else_throw do
-              Exceptions::IllegalStateException.new('Unexpected condition, the ResolvedBoltServerAddress must always have at least one unicast address')
-            end
-          rescue StandardError => e
-            raise java.util.concurrent.CompletionException, e
-          end
+          resolved_address.unicast_stream.first or
+            raise Exceptions::IllegalStateException,
+                  'Unexpected condition, the ResolvedBoltServerAddress must always have at least one unicast address'
         end
 
         def resolve_all_by_domain_name(address)
-          ResolvedBoltServerAddress.new(address.host, address.port, domain_name_resolver.resolve(address.host))
+          ResolvedBoltServerAddress.new(address.host, address.port, *@domain_name_resolver.call(address.host))
         end
       end
     end

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

@@ -16,9 +16,9 @@ module Neo4j::Driver
             Messaging::Request::RouteMessage.new(@routing_context, bookmark, database_name.database_name,
                                                  impersonated_user),
             Handlers::RouteMessageResponseHandler.new(self))
-          RoutingProcedureResponse.new(query(database_name), to_record(routing_table))
+          RoutingProcedureResponse.new(query(database_name), records: [to_record(@routing_table)])
         rescue => e
-          RoutingProcedureResponse.new(query(database_name), e)
+          RoutingProcedureResponse.new(query(database_name), error: e)
         ensure
           direct_connection.release
         end

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

@@ -4,34 +4,30 @@ module Neo4j::Driver
       class RoutingProcedureClusterCompositionProvider
         PROTOCOL_ERROR_MESSAGE = "Failed to parse '%s' result received from server due to "
 
-        def initialize(clock, routing_context)
-          @clock = clock
+        def initialize(_clock, routing_context)
           @single_database_routing_procedure_runner = SingleDatabaseRoutingProcedureRunner.new(routing_context)
           @multi_database_routing_procedure_runner = MultiDatabasesRoutingProcedureRunner.new(routing_context)
           @route_message_routing_procedure_runner = RouteMessageRoutingProcedureRunner.new(routing_context)
         end
 
         def get_cluster_composition(connection, database_name, bookmark, impersonated_user)
-          runner = if Messaging::Request::MultiDatabaseUtil.supports_route_message(connection)
+          runner = if Messaging::Request::MultiDatabaseUtil.supports_route_message?(connection)
                     @route_message_routing_procedure_runner
-                  elsif Messaging::Request::MultiDatabaseUtil.supports_multi_database(connection)
+                  elsif Messaging::Request::MultiDatabaseUtil.supports_multi_database?(connection)
                     @multi_database_routing_procedure_runner
                   else
                     @single_database_routing_procedure_runner
                   end
 
-          runner.run(connection, database_name, bookmark, impersonated_user).then_apply do
-            self::process_routing_response
-          end
+          process_routing_response(runner.run(connection, database_name, bookmark, impersonated_user))
         end
 
         def process_routing_response(response)
-          if !response.success?
-            raise java.util.concurrent.CompletionException, "Failed to run '#{invoked_procedure_string(response)}' on server. Please make sure that there is a Neo4j server or cluster up running.", response.error
+          unless response.success?
+            raise response.error.class, "Failed to run '#{invoked_procedure_string(response)}' on server. Please make sure that there is a Neo4j server or cluster up running."
           end
 
           records = response.records
-          now = clock.millis
 
           # the record size is wrong
           if records.size != 1
@@ -40,7 +36,7 @@ module Neo4j::Driver
 
           # failed to parse the record
           begin
-            cluster = ClusterComposition.parse( records[0], now)
+            cluster = ClusterComposition.parse( records[0], Time.now)
           rescue Exceptions::Value::ValueException => e
             raise Exceptions::ProtocolException, "#{PROTOCOL_ERROR_MESSAGE % invoked_procedure_string(response)} unparsable record received. #{e}"
           end
@@ -56,7 +52,7 @@ module Neo4j::Driver
 
         def invoked_procedure_string(response)
           query = response.procedure
-          query.text + '' + query.parameters
+          "#{query.text} #{query.parameters}"
         end
       end
     end

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

@@ -2,16 +2,32 @@ module Neo4j::Driver
   module Internal
     module Cluster
       class RoutingProcedureResponse
-        attr_reader :procedure, :records, :error
+        attr_reader :procedure
 
-        def initialize(procedure, records = nil, error = nil)
+        def initialize(procedure, records: nil, error: nil)
           @procedure = procedure
           @records = records
           @error = error
         end
 
         def success?
-          !records.nil?
+          !@records.nil?
+        end
+
+        def records
+          if success?
+            @records
+          else
+            raise Exceptions::IllegalStateException, "Can't access records of a failed result #{@error}"
+          end
+        end
+
+        def error
+          if success?
+            raise Exceptions::IllegalStateException, "Can't access error of a succeeded result #{@records}"
+          else
+            @error
+          end
         end
       end
     end

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