neo4j-ruby-driver 1.7.4 → 4.4.0

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

@@ -0,0 +1,95 @@
+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)
+          @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 = 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)
+        end
+
+        def on_write_failure(address)
+          @routing_table.forget_writer(address)
+        end
+
+        def ensure_routing_table(context)
+          @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
+          rescue => error
+            cluster_composition_lookup_failed(error)
+          end
+        end
+
+        def update_routing_table(composition_lookup_result)
+          @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
+          end
+        end
+
+        private
+
+        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&.then do |addresses|
+            addresses_to_retain << addresses
+          end
+
+          @connection_pool.retain_all(addresses_to_retain)
+
+          @log.debug("Updated routing table for database '#{@database_name.description}'. #{routing_table}")
+          @routing_table
+        rescue => error
+          cluster_composition_lookup_failed(error)
+        end
+
+        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
+
+        public
+
+        # This method cannot be synchronized as it will be visited by all routing table handler's threads concurrently
+        def routing_table_aged?
+          @mutex.with_read_lock { @routing_table.has_been_stale_for?(@routing_table_purge_delay) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+module Neo4j::Driver
+  module Internal
+    module Cluster
+      class RoutingTableRegistryImpl
+        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)
+          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 = context.database_name
+
+          return ConnectionContextAndHandler.new(context, nil) if context_database_name
+          @mutex.synchronize do
+            return ConnectionContextAndHandler.new(context, nil) if context_database_name
+
+            impersonated_user = context.impersonated_user
+            principal = Principal.new(impersonated_user)
+            database_name = @principal_to_database_name[principal]
+            handler_ref = Concurrent::AtomicReference.new
+
+            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
+
+            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.
+          @routing_table_handlers.values.map(&:servers).reduce(&:+)
+        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 routing_table_handler(database_name)
+          database_name = DatabaseNameUtil.database(database_name) unless database_name.is_a?(InternalDatabaseName)
+          @routing_table_handlers[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
+            # 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
+        end
+
+        private
+
+        class RoutingTableHandlerFactory
+          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 = 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)
+          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,73 @@
+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)
+          begin
+            result = run_procedure(delegate, procedure, bookmark_holder)
+            RoutingProcedureResponse.new(procedure, **result.error ? { error: result.error } : { records: result.result! })
+          rescue => error
+            handle_error(procedure, error)
+          ensure
+            release_connection(delegate)
+          end
+        end
+
+        private
+
+        def connection(connection)
+          Async::Connection::DirectConnection.new(connection, DatabaseNameUtil.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, ROUTING_CONTEXT => @context.to_h)
+        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.list_async
+        end
+
+        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
+        end
+
+        def handle_error(procedure, error)
+          if error.is_a? Exceptions::ClientException
+            RoutingProcedureResponse.new(procedure, error: error)
+          else
+            raise error
+          end
+        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,55 @@
+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
+          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
+        end
+
+        def list_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.error.then { |error| run_error ? nil : error }
+        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
+
+        def map_successful_run_completion_async
+          run_error&.then(&Util::ResultHolder.method(:failed)) || Util::ResultHolder.successful(self)
+        end
+
+        def run_error
+          @run_handler.error
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Neo4j::Driver
+  module Internal
+    module Cursor
+      # Used by Bolt V1, V2, V3
+      class AsyncResultCursorOnlyFactory
+        def initialize(connection, run_message, run_handler, 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)
+
+          @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
+
+          DisposableAsyncResultCursor.new(AsyncResultCursorImpl.new(@run_handler, @pull_all_handler))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Neo4j::Driver
+  module Internal
+    module Cursor
+      class DisposableAsyncResultCursor
+        include Enumerable
+        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
+          @delegate.next_async
+        end
+
+        def peek_async
+          assert_not_disposed
+          @delegate.peek_async
+        end
+
+        def single_async
+          assert_not_disposed
+          @delegate.single_async
+        end
+
+        def each(&action)
+          assert_not_disposed
+          @delegate.each(&action)
+        end
+
+        def list_async(&block)
+          assert_not_disposed
+          @delegate.list_async(&block)
+        end
+
+        def discard_all_failure_async
+          @disposed = true
+          @delegate.discard_all_failure_async
+        end
+
+        private def assert_not_disposed
+          raise Util::ErrorUtil.new_result_consumed_error if @disposed
+        end
+
+        def disposed?
+          @disposed
+        end
+
+        def map_successful_run_completion_async
+          @delegate.map_successful_run_completion_async.then { self }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+module Neo4j::Driver
+  module Internal
+    module Cursor
+      class RxResultCursorImpl
+        DISCARD_RECORD_CONSUMER = -> (record, throwable) {}
+
+        delegate :cancel, to: :@pull_handler
+        delegate :done?, to: :@summary_future
+
+        def initialize(run_error, run_handler, pull_handler)
+          java.util.Objects.require_non_null(run_handler)
+          java.util.Objects.require_non_null(pull_handler)
+
+          @run_response_error = run_error
+          @run_handler = @run_handler
+          @pull_handler = @pull_handler
+          @summary_future = java.util.concurrent.CompletableFuture.new
+          @consumer_status = RecordConsumerStatus::NOT_INSTALLED
+          install_summary_consumer
+        end
+
+        def keys
+          @run_handler.query_keys.keys
+        end
+
+        def install_record_consumer(record_consumer)
+          raise Util::ErrorUtil.new_result_consumed_error if result_consumed
+
+          return if @consumer_status.installed?
+
+          @consumer_status = record_consumer == DISCARD_RECORD_CONSUMER ? RecordConsumerStatus::DISCARD_INSTALLED : RecordConsumerStatus::INSTALLED
+          @pull_handler.install_record_consumer(record_consumer)
+          assert_run_completed_successfully
+        end
+
+        def request(n)
+          n = -1 if n == java.lang.Long::MAX_VALUE
+
+          @pull_handler.request(n)
+        end
+
+        def discard_all_failure_async
+          # calling this method will enforce discarding record stream and finish running cypher query
+          summary_stage.then_apply(-> (_summary) { nil }).exceptionally do |throwable|
+            @summary_future_exposed ? null : throwable
+          end
+        end
+
+        def pull_all_failure_async
+          if @consumer_status.installed? && !done?
+            return java.util.concurrent.CompletableFuture.completed_future(Exceptions::TransactionNestingException.new("You cannot run another query or begin a new transaction in the same session before you've fully consumed the previous run result."))
+          end
+
+          # It is safe to discard records as either the streaming has not started at all, or the streaming is fully finished.
+          discard_all_failure_async
+        end
+
+        def summary_async
+          @summary_future_exposed = true
+          summary_stage
+        end
+
+        def summary_stage
+          unless done? && @result_consumed # the summary is called before record streaming
+            install_record_consumer(DISCARD_RECORD_CONSUMER)
+            cancel
+            @result_consumed = true
+          end
+
+          @summary_future
+        end
+
+        private
+
+        def assert_run_completed_successfully
+          unless @run_response_error.nil?
+            @pull_handler.on_failure(@run_response_error)
+          end
+        end
+
+        def install_summary_consumer
+          @pull_handler.install_summary_consumer do |summary, error|
+            if !error.nil? && @consumer_status.discard_consumer?
+              # We will only report the error to summary if there is no user record consumer installed
+              # When a user record consumer is installed, the error will be reported to record consumer instead.
+              @summary_future.complete_exceptionally(error)
+            elsif !summary.nil?
+              @summary_future.complete(summary)
+            end
+
+            # else (nil, nil) to indicate a has_more success
+          end
+        end
+
+        class RecordConsumerStatus
+          attr_reader :installed, :discard_consumer
+
+          def initialize(installed, discard_consumer)
+            @installed = installed
+            @discard_consumer = discard_consumer
+          end
+
+          NOT_INSTALLED = new(false, false)
+          INSTALLED = new(true, false)
+          DISCARD_INSTALLED = new(true, true)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Neo4j::Driver
+  module Internal
+    class DatabaseNameUtil
+      DEFAULT_DATABASE_NAME = nil
+      SYSTEM_DATABASE_NAME = 'system'
+
+      private
+
+      DEFAULT_DATABASE = InternalDatabaseName.new(description: '<default database>')
+      SYSTEM_DATABASE = InternalDatabaseName.new(database_name: SYSTEM_DATABASE_NAME)
+
+      public
+
+      class << self
+        def default_database
+          DEFAULT_DATABASE
+        end
+
+        def system_database
+          SYSTEM_DATABASE
+        end
+
+        def database(name)
+          case name
+          when DEFAULT_DATABASE_NAME
+            default_database
+          when SYSTEM_DATABASE_NAME
+            system_database
+          else
+            InternalDatabaseName.new(database_name: name)
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,9 @@
+module Neo4j::Driver
+  module Internal
+    class DefaultBookmarkHolder < ReadOnlyBookmarkHolder
+      def bookmark=(bookmark)
+        @bookmark = bookmark if bookmark.present?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Neo4j::Driver
+  module Internal
+    class DefaultDomainNameResolver
+      INSTANCE = new
+
+      def resolve(name)
+        java.net.InetAddress.get_all_by_name(name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Neo4j::Driver
+  module Internal
+    class DirectConnectionProvider
+      attr_reader :address
+
+      def initialize(address, connection_pool)
+        @address = address
+        @connection_pool = connection_pool
+      end
+
+      delegate :close, to: :@connection_pool
+
+      def acquire_connection(context)
+        database_name = context.database_name || DatabaseNameUtil::DEFAULT_DATABASE
+        Async::Connection::DirectConnection.new(private_acquire_connection, database_name, context.mode,
+                                                context.impersonated_user)
+      end
+
+      def verify_connectivity
+        private_acquire_connection&.release
+      end
+
+      def supports_multi_db?
+        private_acquire_connection.then do |conn|
+          Messaging::Request::MultiDatabaseUtil.supports_multi_database?(conn)
+        ensure
+          conn.release
+        end
+      end
+
+      private
+
+      # Used only for grabbing a connection with the server after hello message.
+      # This connection cannot be directly used for running any queries as it is missing necessary connection context
+      def private_acquire_connection
+        @connection_pool.acquire(@address)
+      end
+    end
+  end
+end