neo4j-ruby-driver 1.7.6 → 4.4.0.alpha.1

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

@@ -0,0 +1,64 @@
+module Neo4j::Driver
+  module Internal
+    module Cluster
+      class RoutingProcedureClusterCompositionProvider
+        PROTOCOL_ERROR_MESSAGE = "Failed to parse '%s' result received from server due to "
+
+        def initialize(clock, routing_context)
+          @clock = clock
+          @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)
+                    @route_message_routing_procedure_runner
+                  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
+        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
+          end
+
+          records = response.records
+          now = clock.millis
+
+          # the record size is wrong
+          if records.size != 1
+            raise Exceptions::ProtocolException, "#{PROTOCOL_ERROR_MESSAGE % invoked_procedure_string(response)} records received '#{records.size}' is too few or too many."
+          end
+
+          # failed to parse the record
+          begin
+            cluster = ClusterComposition.parse( records[0], now)
+          rescue Exceptions::Value::ValueException => e
+            raise Exceptions::ProtocolException, "#{PROTOCOL_ERROR_MESSAGE % invoked_procedure_string(response)} unparsable record received. #{e}"
+          end
+
+          # the cluster result is not a legal reply
+          if !cluster.has_routers_and_readers?
+            raise Exceptions::ProtocolException, "#{PROTOCOL_ERROR_MESSAGE % invoked_procedure_string(response)} no router or reader found in response."
+          end
+
+          # all good
+          cluster
+        end
+
+        def invoked_procedure_string(response)
+          query = response.procedure
+          query.text + '' + query.parameters
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Neo4j::Driver
+  module Internal
+    module Cluster
+      class RoutingProcedureResponse
+        attr_reader :procedure, :records, :error
+
+        def initialize(procedure, records = nil, error = nil)
+          @procedure = procedure
+          @records = records
+          @error = error
+        end
+
+        def success?
+          !records.nil?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Neo4j::Driver
+  module Internal
+    module Cluster
+      class RoutingSettings
+        attr_reader :max_routing_failures, :retry_timeout_delay, :routing_context, :routing_table_purge_delay
+
+        def initialize(max_routing_failures, retry_timeout_delay, routing_table_purge_delay,
+                       routing_context = RoutingContext::EMPTY)
+          @max_routing_failures = max_routing_failures
+          @retry_timeout_delay = retry_timeout_delay
+          @routing_context = routing_context
+          @routing_table_purge_delay = routing_table_purge_delay
+        end
+
+        STALE_ROUTING_TABLE_PURGE_DELAY = 30.seconds
+        DEFAULT = new(1, 5.seconds, STALE_ROUTING_TABLE_PURGE_DELAY)
+
+        def with_routing_context(new_routing_context)
+          self.class.new(@max_routing_failures, @retry_timeout_delay, @routing_table_purge_delay, new_routing_context)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+module Neo4j::Driver
+  module Internal
+    module Cluster
+      class RoutingTableHandlerImpl
+        attr_reader :routing_table
+
+        delegate :servers, to: :routing_table
+
+        def initialize(routing_table, rediscovery, connection_pool, routing_table_registry, logger, routing_table_purge_delay_ms)
+          @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
+        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)
+        end
+
+        def on_write_failure(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
+            end
+
+            result_future
+          else
+            # existing routing table is fresh, use it
+            java.util.concurrent.CompletableFuture.completed_future(routing_table)
+          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)
+            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
+
+            addresses_to_retain = []
+            @routing_table_registry.all_servers.stream.flat_map(BoltServerAddress::unicast_stream).for_each(addresses_to_retain::add)
+
+            composition_lookup_result.resolved_initial_routers.if_present do |addresses|
+              @resolved_initial_routers.clear
+              @resolved_initial_routers << addresses
+            end
+
+            addresses_to_retain << @resolved_initial_routers
+            @connection_pool.retain_all(addresses_to_retain)
+
+            @log.debug("Updated routing table for database '#{@database_name.description}'. #{routing_table}")
+
+            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)
+          end
+        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
+
+        # 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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+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 = {}
+          @principal_to_database_name_stage = {}
+          @clock = clock
+          @connection_pool = connection_pool
+          @rediscovery = rediscovery
+          @log = logger
+        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
+        end
+
+        private def ensure_database_name_is_completed(context)
+          context_database_name_future = context.database_name_future
+
+          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
+
+            context_and_handler_stage =
+            database_name_stage.then_apply do |database_name|
+              context_database_name_future.complete(database_name)
+              ConnectionContextAndHandler.new(context, handler_ref)
+            end
+          end
+
+          context_and_handler_stage
+        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
+        end
+
+        def remove(database_name)
+          @routing_table_handlers.delete(database_name)
+          @log.debug("Routing table handler for database '#{database_name.description}' is removed.")
+        end
+
+        def remove_aged
+          @routing_table_handlers.each do |database_name, handler|
+            if handler.routing_table_aged?
+              @log.info("Routing table handler for database '#{database_name.description}' is removed because it has not been used for a long time. Routing table: #{handler.routing_table}")
+              @routing_table_handlers.delete(database_name)
+            end
+          end
+        end
+
+        def get_routing_table_handler(database_name)
+          java.util.Optional.of_nullable(@routing_table_handlers[database_name])
+        end
+
+        def contains(database_name)
+          @routing_table_handlers.keys.include?(database_name)
+        end
+
+        def get_or_create(database_name)
+          @routing_table_handlers.compute_if_absent(database_name) do |name|
+            handler = @factory.new_instance(name, self)
+            @log.debug("Routing table handler for database '#{database_name.description}' is added.")
+            handler
+          end
+        end
+
+        private
+
+        class RoutingTableHandlerFactory
+          def initialize(connection_pool, rediscovery, clock, logger, routing_table_purge_delay_ms)
+            @connection_pool = connection_pool
+            @rediscovery = rediscovery
+            @clock = clock
+            @logger = logger
+            @routing_table_purge_delay_ms = routing_table_purge_delay_ms
+          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)
+          end
+        end
+
+        class Principal < Struct.new(:id)
+        end
+
+        class ConnectionContextAndHandler
+          attr_reader :context, :handler
+
+          def initialize(context, handler)
+            @context = context
+            @handler = handler
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Neo4j::Driver
+  module Internal
+    module Cluster
+
+      # 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'
+        GET_ROUTING_TABLE = "CALL dbms.cluster.routing.getRoutingTable($#{ROUTING_CONTEXT})"
+
+        def initialize(context)
+          @context = context
+        end
+
+        def run(connection, database_name, bookmark, impersonated_user)
+          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
+        end
+
+        private
+
+        def connection(connection)
+          Async::Connection::DirectConnection.new(connection, default_database, AccessMode::WRITE, nil)
+        end
+
+        def procedure_query(server_version, database_name)
+          if database_name.database_name.present?
+            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))
+        end
+
+        def bookmark_holder(_ignored)
+          BookmarkHolder::NO_OP
+        end
+
+        def run_procedure(connection, procedure, bookmark_holder)
+          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)
+        end
+
+        def release_connection(connection, records)
+          # 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 } )
+        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)
+        end
+
+        def handle_error(procedure, error)
+          return RoutingProcedureResponse.new(procedure, records) if error.is_a? Exceptions::ClientException
+
+          raise java.util.concurrent.CompletionException, error
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Neo4j::Driver
+  module Internal
+
+    # The connection settings are used whenever a new connection is
+    # established to a server, specifically as part of the INIT request.
+    class ConnectionSettings
+      attr_reader :auth_token, :user_agent, :connect_timeout_millis
+
+      def initialize(auth_token, user_agent, connect_timeout_millis)
+        @auth_token = auth_token
+        @user_agent = user_agent
+        @connect_timeout_millis = connect_timeout_millis
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Neo4j::Driver
+  module Internal
+    module Cursor
+      class AsyncResultCursorImpl
+        delegate :consume_async, :next_async, :peek_async, to: :@pull_all_handler
+
+        def initialize(run_handler, pull_all_handler)
+          @run_handler = run_handler
+          @pull_all_handler = pull_all_handler
+        end
+
+        def keys
+          @run_handler.query_keys
+        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.'
+          end
+          first_record
+        end
+
+        def each_async(&action)
+          internal_for_each_async(result_future, &action)
+          consume_async
+        end
+
+        def to_async(&map_function)
+          @pull_all_handler.list_async(&block_given? ? map_function : :itself)
+        end
+
+        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 }
+          nil
+        end
+
+        def pull_all_failure_async
+          # runError has priority over other errors and is expected to have been reported to user by now
+          @pull_all_handler.pull_all_failure_async.then { |error| @run_error ? nil : error }
+        end
+
+        private def internal_for_each_async(result_future, &action)
+          record_future = next_async
+
+          # use async completion listener because of recursion, otherwise it is possible for
+          # the caller thread to get StackOverflowError when result is large and buffered
+          record_future.on_complete do |_fulfilled, record, error|
+            if error
+              result_future.reject(error)
+            elsif record
+              begin
+                yield record
+              rescue => action_error
+                result_future.reject(action_error)
+                return
+              end
+              internal_for_each_async(result_future, &action)
+            else
+              result_future.fulfill(nil)
+            end
+          end
+        end
+
+        def map_successful_run_completion_async
+          @run_error || self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Neo4j::Driver
+  module Internal
+    module Cursor
+      # Used by Bolt V1, V2, V3
+      class AsyncResultCursorOnlyFactory
+        def initialize(connection, run_message, run_handler, run_future, pull_handler)
+          @connection = Internal::Validator.require_non_nil!(connection)
+          @run_message = Internal::Validator.require_non_nil!(run_message)
+          @run_handler = Internal::Validator.require_non_nil!(run_handler)
+          @run_future = Internal::Validator.require_non_nil!(run_future)
+
+          @pull_all_handler = Internal::Validator.require_non_nil!(pull_handler)
+        end
+
+        def async_result
+          # only write and flush messages when async result is wanted.
+          @connection.write(@run_message, @run_handler) # queues the run message, will be flushed with pull message together
+          @pull_all_handler.pre_populate_records
+
+          @run_future.handle { |_ignored, error| DisposableAsyncResultCursor.new(AsyncResultCursorImpl.new(error, @run_handler, @pull_all_handler)) }
+        end
+
+        def rx_result
+          Util::Futures.failed_future(Exceptions::ClientException.new('Driver is connected to the database that does not support driver reactive API. In order to use the driver reactive API, please upgrade to neo4j 4.0.0 or later.'))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Neo4j::Driver
+  module Internal
+    module Cursor
+      class DisposableAsyncResultCursor
+        delegate :keys, :pull_all_failure_async, to: :@delegate
+
+        def initialize(delegate)
+          @delegate = delegate
+        end
+
+        def consume_async
+          @disposed = true
+          @delegate.consume_async
+        end
+
+        def next_async
+          assert_not_disposed.then_compose(-> (_ignored) { @delegate.next_async })
+        end
+
+        def peek_async
+          assert_not_disposed.then_compose(-> (_ignored) { @delegate.peek_async })
+        end
+
+        def single_async
+          assert_not_disposed.then_compose(-> (_ignored) { @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 })
+        end
+
+        def discard_all_failure_async
+          @disposed = true
+          @delegate.discard_all_failure_async
+        end
+
+        private def assert_not_disposed
+          return Util::Futures.failed_future(new_result_consumed_error) if @disposed
+
+          Util::Futures.completed_with_null
+        end
+
+        def disposed?
+          @disposed
+        end
+
+        def map_successful_run_completion_async
+          @delegate.map_successful_run_completion_async
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Neo4j::Driver
+  module Internal
+    module Cursor
+      # Bolt V4
+      class ResultCursorFactoryImpl
+        def initialize(connection, run_message, run_handler, pull_handler, pull_all_handler)
+          @connection = Internal::Validator.require_non_nil!(connection)
+          @run_message = Internal::Validator.require_non_nil!(run_message)
+          @run_handler = Internal::Validator.require_non_nil!(run_handler)
+          @pull_handler = Internal::Validator.require_non_nil!(pull_handler)
+          @pull_all_handler = Internal::Validator.require_non_nil!(pull_all_handler)
+        end
+
+        def async_result
+          # only write and flush messages when async result is wanted.
+          @connection.write(@run_message, @run_handler) # queues the run message, will be flushed with pull message together
+          @pull_all_handler.pre_populate_records
+
+          DisposableAsyncResultCursor.new(AsyncResultCursorImpl.new(@run_handler, @pull_all_handler))
+        end
+
+        def rx_result
+          @connection.write_and_flush(@run_message, @run_handler)
+          @run_future.handle { |_ignored, error| RxResultCursorImpl.new(error, @run_handler, @pull_handler) }
+        end
+      end
+    end
+  end
+end