neo4j-ruby-driver 5.7.0.alpha.4 → 6.0.3.alpha.0-java

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

@@ -1,147 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Cluster
-      class RediscoveryImpl
-        NO_ROUTERS_AVAILABLE = "Could not perform discovery for database '%s'. No routing server available."
-        RECOVERABLE_ROUTING_ERROR = "Failed to update routing table with server '%s'."
-        RECOVERABLE_DISCOVERY_ERROR_WITH_SERVER = "Received a recoverable discovery error with server '%s', will continue discovery with other routing servers if available. Complete failure is reported separately from this entry."
-        INVALID_BOOKMARK_CODE = 'Neo.ClientError.Transaction.InvalidBookmark'
-        INVALID_BOOKMARK_MIXTURE_CODE = 'Neo.ClientError.Transaction.InvalidBookmarkMixture'
-
-        def initialize(initial_router, settings, provider, event_executor_group, resolver, logger, domain_name_resolver)
-          @initial_router = initial_router
-          @settings = settings
-          @log = logger
-          @provider = provider
-          @resolver = resolver
-          @event_executor_group = event_executor_group
-          @domain_name_resolver = Internal::Validator.require_non_nil!(domain_name_resolver)
-        end
-
-        # Given a database and its current routing table, and the global connection pool, use the global cluster composition provider to fetch a new cluster
-        # composition, which would be used to update the routing table of the given database and global connection pool.
-
-        # @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 = 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
-              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
-
-        def resolve
-          exception = nil
-
-          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 SocketError => e
-            exception ||= e
-            []
-          end
-
-          # give up only if there are no addresses to work with at all
-          raise exception if resolved_addresses.empty? && exception
-
-          resolved_addresses
-        end
-
-        private
-
-        def lookup(routing_table, connection_pool, bookmark, impersonated_user, base_error)
-          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 = 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
-
-        def lookup_on_initial_router_then_on_known_routers(routing_table, connection_pool, bookmark, impersonated_user, base_error)
-          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)
-          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)
-          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 = 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 error if must_abort_discovery(error)
-
-          # Retriable error happened during discovery.
-          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(discovery_error)
-          routing_table.forget(router_address)
-          nil
-        end
-
-        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)
-          resolved_address = resolve_all_by_domain_name(address)
-          routing_table.replace_router_if_present(address, resolved_address)
-
-          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.call(address.host))
-        end
-      end
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Cluster
-      # This implementation of the {@link RoutingProcedureRunner} access the routing procedure
-      # through the bolt's ROUTE message.
-      class RouteMessageRoutingProcedureRunner
-        attr_writer :routing_table
-
-        def initialize(routing_context)
-          @routing_context = routing_context.to_h
-        end
-
-        def run(connection, database_name, bookmark, impersonated_user)
-          direct_connection = to_direct_connection(connection, database_name, impersonated_user)
-          direct_connection.write_and_flush(
-            Messaging::Request::RouteMessage.new(@routing_context, bookmark, database_name.database_name,
-                                                 impersonated_user),
-            Handlers::RouteMessageResponseHandler.new(self))
-          RoutingProcedureResponse.new(query(database_name), records: [to_record(@routing_table)])
-        rescue => e
-          RoutingProcedureResponse.new(query(database_name), error: e)
-        ensure
-          direct_connection.release
-        end
-
-        private
-
-        def to_record(routing_table)
-          InternalRecord.new(routing_table.keys, routing_table.values)
-        end
-
-        def to_direct_connection(connection, database_name, impersonated_user)
-          Async::Connection::DirectConnection.new(connection, database_name, AccessMode::READ, impersonated_user)
-        end
-
-        def query(database_name)
-          Query.new('ROUTE $routing_context $database_name', routing_context: @routing_context,
-                    database_name: database_name.database_name)
-        end
-      end
-    end
-  end
-end

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

@@ -1,77 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Cluster
-      class RoutingContext
-        include Scheme
-        EMPTY = new
-        ROUTING_ADDRESS_KEY = :address
-
-        def initialize(uri = nil)
-          if uri
-            @server_routing_enabled = routing_scheme?(uri.scheme)
-            @context = parse_parameters(uri).freeze
-          else
-            @server_routing_enabled = true
-            @context = {}
-          end
-        end
-
-        def defined?
-          @context.size > 1
-        end
-
-        def to_h
-          @context
-        end
-
-        def server_routing_enabled?
-          @server_routing_enabled
-        end
-
-        def to_s
-          "RoutingContext #{@context} ServerRoutingEnabled=#{@server_routing_enabled}"
-        end
-
-        private
-
-        def parse_parameters(uri)
-          query = uri.query
-          address = "#{uri.host}:#{uri.port || BoltServerAddress::DEFAULT_PORT}"
-          parameters = { ROUTING_ADDRESS_KEY => address }
-          return parameters if query.blank?
-
-          pairs = query.split('&')
-          pairs.each do |pair|
-            key_value = pair.split('=')
-
-            if key_value.size != 2
-              raise ArgumentError, "Invalid parameters: '#{pair}' in URI '#{uri}'"
-            end
-
-            key = trim_and_verify_key(key_value[0], 'key', uri)
-            if parameters.key?(key)
-              raise ArgumentError, "Duplicated query parameters with key '#{key}' in URI '#{uri}'"
-            end
-            parameters[key] = trim_and_verify(key_value[1], 'value', uri)
-          end
-
-          parameters
-        end
-
-        def trim_and_verify_key(s, key, uri)
-          trim_and_verify(s, key, uri).tap do |trimmed|
-            if trimmed == ROUTING_ADDRESS_KEY
-              raise ArgumentError, "The key 'address' is reserved for routing context."
-            end
-          end
-        end
-
-        def trim_and_verify(string, name, uri)
-          string.strip.tap do |result|
-            raise ArgumentError, "Illegal empty #{name} in URI query '#{uri}'" if result.empty?
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-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)
-          @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
-
-          process_routing_response(runner.run(connection, database_name, bookmark, impersonated_user))
-        end
-
-        def process_routing_response(response)
-          unless response.success?
-            raise response.error, "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
-
-          # 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], Time.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

@@ -1,35 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Cluster
-      class RoutingProcedureResponse
-        attr_reader :procedure
-
-        def initialize(procedure, records: nil, error: nil)
-          @procedure = procedure
-          @records = records
-          @error = error
-        end
-
-        def success?
-          !@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
-  end
-end

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

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

@@ -1,95 +0,0 @@
-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.merge(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

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

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