neo4j-ruby-driver 1.7.4 → 4.4.0

data/ruby/neo4j/driver/internal/cluster/loadbalancing/least_connected_load_balancing_strategy.rb

@@ -0,0 +1,68 @@
+module Neo4j::Driver
+  module Internal
+    module Cluster
+      module Loadbalancing
+
+        # Load balancing strategy that finds server with the least amount of active (checked out of the pool) connections from given readers or writers. It finds a
+        # start index for iteration in a round-robin fashion. This is done to prevent choosing same first address over and over when all addresses have the same amount
+        # of active connections.
+        class LeastConnectedLoadBalancingStrategy
+
+          def initialize(connection_pool, logger)
+            @readers_index = RoundRobinArrayIndex.new
+            @writers_index = RoundRobinArrayIndex.new
+
+            @connection_pool = connection_pool
+            @log = logger
+          end
+
+          def select_reader(known_readers)
+            select(known_readers, @readers_index, 'reader')
+          end
+
+          def select_writer(known_writers)
+            select(known_writers, @writers_index, 'writer')
+          end
+
+          private
+
+          def select(addresses, addresses_index, address_type)
+            size = addresses.size
+            if size == 0
+              @log.debug("Unable to select #{address_type}, no known addresses given")
+              return
+            end
+
+            # choose start index for iteration in round-robin fashion
+            start_index = addresses_index.next(size)
+            index = start_index
+
+            least_connected_address = nil
+            least_active_connections = nil
+
+            # iterate over the array to find the least connected address
+            addresses = addresses.to_a
+            loop do
+              address = addresses[index]
+              active_connections = @connection_pool.in_use_connections(address)
+
+              if least_active_connections.nil? || active_connections < least_active_connections
+                least_connected_address = address
+                least_active_connections = active_connections
+              end
+
+              # loop over to the start of the array when end is reached
+              index = (index + 1) % size
+
+              break if index == start_index
+            end
+
+            @log.debug("Selected #{address_type} with address: '#{least_connected_address}' and active connections: #{least_active_connections}")
+
+            least_connected_address
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/cluster/loadbalancing/load_balancer.rb

@@ -0,0 +1,125 @@
+module Neo4j::Driver
+  module Internal
+    module Cluster
+      module Loadbalancing
+        class LoadBalancer
+          CONNECTION_ACQUISITION_COMPLETION_FAILURE_MESSAGE = 'Connection acquisition failed for all available addresses.'
+          CONNECTION_ACQUISITION_COMPLETION_EXCEPTION_MESSAGE = "Failed to obtain connection towards %s server. Known routing table is: %s"
+          CONNECTION_ACQUISITION_ATTEMPT_FAILURE_MESSAGE = "Failed to obtain a connection towards address %s, will try other addresses if available. Complete failure is reported separately from this entry."
+          BOLT_SERVER_ADDRESSES_EMPTY_ARRAY = []
+
+          delegate :close, to: :@connection_pool
+
+          def initialize(initial_router, settings, connection_pool, event_executor_group, logger, load_balancing_strategy, resolver, &domain_name_resolver)
+            clock = Util::Clock::System
+            @connection_pool = connection_pool
+            @rediscovery = create_rediscovery(event_executor_group, initial_router, resolver, settings, clock, logger, domain_name_resolver)
+            @routing_tables = create_routing_tables(connection_pool, @rediscovery, settings, clock, logger)
+            @load_balancing_strategy = load_balancing_strategy
+            @event_executor_group = event_executor_group
+            @log = logger
+          end
+
+          def acquire_connection(context)
+            handler = @routing_tables.ensure_routing_table(context)
+            connection = acquire(context.mode, handler.routing_table)
+            Async::Connection::RoutingConnection.new(connection, context.database_name, context.mode,
+                                                     context.impersonated_user, handler)
+          end
+
+          def verify_connectivity
+            @routing_tables.ensure_routing_table(Async::ImmutableConnectionContext.simple(supports_multi_db?))
+          rescue Exceptions::ServiceUnavailableException
+            raise Exceptions::ServiceUnavailableException,
+                  'Unable to connect to database management service, ensure the database is running and that there is a working network connection to it.'
+          end
+
+          def routing_table_registry
+            @routing_tables
+          end
+
+          def supports_multi_db?
+            addresses = @rediscovery.resolve
+            base_error = Exceptions::ServiceUnavailableException.new("Failed to perform multi-databases feature detection with the following servers: #{addresses}")
+            addresses.each do |address|
+              return private_suports_multi_db?(address)
+            rescue Exceptions::SecurityException
+              raise
+            rescue => error
+              Util::Futures.combine_errors(base_error, error)
+            end
+
+            raise base_error
+          end
+
+          private
+
+          def private_suports_multi_db?(address)
+            conn = @connection_pool.acquire(address)
+            Messaging::Request::MultiDatabaseUtil.supports_multi_database?(conn)
+          ensure
+            conn&.release
+          end
+
+          def acquire(mode, routing_table, attempt_errors = [])
+            addresses = addresses_by_mode(mode, routing_table)
+            address = select_address(mode, addresses)
+
+            unless address
+              error = Exceptions::SessionExpiredException.new(CONNECTION_ACQUISITION_COMPLETION_EXCEPTION_MESSAGE % [mode, routing_table])
+              attempt_errors.each(&error.method(:add_suppressed))
+              @log.error(CONNECTION_ACQUISITION_COMPLETION_FAILURE_MESSAGE)
+              @log.error(error)
+              raise error
+            end
+
+            begin
+              @connection_pool.acquire(address)
+            rescue Exceptions::ServiceUnavailableException => error
+              @log.warn { CONNECTION_ACQUISITION_ATTEMPT_FAILURE_MESSAGE % address }
+              @log.debug(error)
+              attempt_errors << error
+              routing_table.forget(address)
+              acquire(mode, routing_table, attempt_errors)
+            end
+          end
+
+          def addresses_by_mode(mode, routing_table)
+            case mode
+            when AccessMode::READ
+              routing_table.readers
+            when AccessMode::WRITE
+              routing_table.writers
+            else
+              raise unknown_mode mode
+            end
+          end
+
+          def select_address(mode, addresses)
+            case mode
+            when AccessMode::READ
+              @load_balancing_strategy.select_reader(addresses)
+            when AccessMode::WRITE
+              @load_balancing_strategy.select_writer(addresses)
+            else
+              raise unknown_mode mode
+            end
+          end
+
+          def create_routing_tables(connection_pool, rediscovery, settings, clock, logger)
+            RoutingTableRegistryImpl.new(connection_pool, rediscovery, clock, logger, settings.routing_table_purge_delay)
+          end
+
+          def create_rediscovery(event_executor_group, initial_router, resolver, settings, clock, logger, domain_name_resolver)
+            cluster_composition_provider = RoutingProcedureClusterCompositionProvider.new(clock, settings.routing_context)
+            RediscoveryImpl.new(initial_router, settings, cluster_composition_provider, event_executor_group, resolver, logger, domain_name_resolver)
+          end
+
+          def unknown_mode(mode)
+            ArgumentError.new("Mode '#{mode}' is not supported")
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/cluster/loadbalancing/round_robin_array_index.rb

@@ -0,0 +1,13 @@
+module Neo4j::Driver
+  module Internal
+    module Cluster
+      module Loadbalancing
+        class RoundRobinArrayIndex < Concurrent::AtomicFixnum
+          def next(array_length)
+            (increment - 1) % array_length if array_length.positive?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Neo4j::Driver
+  module Internal
+    module Cluster
+
+      # This implementation of the {@link RoutingProcedureRunner} works with multi database versions of Neo4j calling
+      # the procedure `dbms.routing.getRoutingTable`
+      class MultiDatabasesRoutingProcedureRunner < SingleDatabaseRoutingProcedureRunner
+        DATABASE_NAME = :database
+        MULTI_DB_GET_ROUTING_TABLE = "CALL dbms.routing.getRoutingTable($%s, $%s)" % [SingleDatabaseRoutingProcedureRunner::ROUTING_CONTEXT, DATABASE_NAME]
+
+        private
+
+        def bookmark_holder(bookmark)
+          ReadOnlyBookmarkHolder.new(bookmark)
+        end
+
+        def procedure_query(server_version, database_name)
+          map = {
+            SingleDatabaseRoutingProcedureRunner::ROUTING_CONTEXT => @context.to_h,
+            DATABASE_NAME => database_name.database_name
+          }
+          Query.new(MULTI_DB_GET_ROUTING_TABLE, **map)
+        end
+
+        def connection(connection)
+          Async::Connection::DirectConnection.new(connection, DatabaseNameUtil::SYSTEM_DATABASE, AccessMode::READ, nil)
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

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

@@ -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