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

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 nil
+            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 = java.lang.Integer::MAX_VALUE
+
+            # iterate over the array to find the least connected address
+            loop do
+              address = addresses[index]
+              active_connections = @connection_pool.in_use_connections(address)
+
+              if 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 == size - 1) ? 0 : index += 1
+
+              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,159 @@
+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 = []
+
+          attr_reader :routing_tables
+
+          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)
+            @routing_tables.ensure_routing_table(context).then_flat do |handler|
+              acquire(context.mode, handler.routing_table).then do |connection|
+                Async::Connection::RoutingConnection.new(connection,
+                                                         Util::Futures.join_now_or_else_throw(context.database_name, Async::ConnectionContext::PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER),
+                                                         context.mode, context.impersonated_user, handler)
+              end
+            end
+          end
+
+          def verify_connectivity
+            supports_multi_db?.then_flat do |supports|
+              @routing_tables.ensure_routing_table(Async::ImmutableConnectionContext.simple(supports)) do |_, error|
+                if error.is_a? Exceptions::ServiceUnavailableException
+                  raise Exceptions::ServiceUnavailableException.new(
+                    'Unable to connect to database management service, ensure the database is running and that there is a working network connection to it.',
+                    error)
+                end
+              end
+            end
+          end
+
+          def supports_multi_db?
+            begin
+              addresses = @rediscovery.resolve
+            rescue StandardError => error
+              return Util::Futures.failed_future(error)
+            end
+
+            result = Util::Futures.completed_with_null
+            base_error = Exceptions::ServiceUnavailableException.new("Failed to perform multi-databases feature detection with the following servers: #{addresses}")
+
+            addresses.each do |address|
+              result = Util::Futures.on_error_continue(result, base_error) do |error|
+                # We fail fast on security errors
+                if error.is_a? Exceptions::SecurityException
+                  Util::Futures.failed_future(error)
+                else
+                  private_suports_multi_db?(address)
+                end
+              end
+            end
+
+            Util::Futures.on_error_continue(result, base_error) do |error|
+              # If we failed with security errors, then we rethrow the security error out, otherwise we throw the chained errors.
+              Util::Futures.failed_future((error.is_a? Exceptions::SecurityException) ? error : base_error)
+            end
+          end
+
+          private
+
+          def private_suports_multi_db?(address)
+            @connection_pool.acquire(address).then_flat do |conn|
+              supports_multi_database = Messaging::Request::MultiDatabaseUtil.supports_multi_database(conn)
+              conn.release.then_apply(-> (_ignored) { supports_multi_database })
+            end
+          end
+
+          def acquire(mode, routing_table, result = nil, attempt_errors = nil)
+            unless result.present? && attempt_errors.present?
+              result = java.util.concurrent.CompletableFuture.new
+              attempt_exceptions = []
+            end
+
+            addresses = addresses_by_mode(mode, routing_table)
+            address = select_address(mode, addresses)
+
+            if address.nil?
+              completion_error = Exceptions::SessionExpiredException.new(CONNECTION_ACQUISITION_COMPLETION_EXCEPTION_MESSAGE % [mode, routing_table])
+              attempt_errors.each { completion_error::add_suppressed }
+
+              @log.error(CONNECTION_ACQUISITION_COMPLETION_FAILURE_MESSAGE % completion_error)
+              result.complete_exceptionally(completion_error)
+              return
+            end
+
+            @connection_pool.acquire(address).when_complete do |connection, completion_error|
+              error = Util::Futures.completion_exception_cause(completion_error)
+
+              if error.nil?
+                result.complete(connection)
+              else
+                if !error.is_a? Exceptions::ServiceUnavailableException
+                  result.complete_exceptionally(error)
+                else
+                  attempt_message = CONNECTION_ACQUISITION_ATTEMPT_FAILURE_MESSAGE % address
+                  @log.warn(attempt_message)
+                  @log.debug(attempt_message, error)
+                  attempt_errors << error
+                  routing_table.forget(address)
+                  @event_executor_group.next.execute(-> () { acquire(mode, routing_table, result, attempt_errors) })
+                end
+              end
+            end
+          end
+
+          def addresses_by_mode(mode, routing_table)
+            case mode
+            when READ
+              routing_table.readers
+            when WRITE
+              routing_table.writers
+            else
+              raise unknown_mode mode
+            end
+          end
+
+          def select_address(mode, addresses)
+            case mode
+            when READ
+              @load_balancing_strategy.select_reader(addresses)
+            when 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, DurationNormalizer.milliseconds(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,34 @@
+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]
+
+        def initialize(context)
+          super(context)
+        end
+
+        private
+
+        def bookmark_holder(bookmark)
+          ReadOnlyBookmarkHolder.new(bookmark)
+        end
+
+        def procedure_query(server_version, database_name)
+          map = {}
+          map[SingleDatabaseRoutingProcedureRunner::ROUTING_CONTEXT] = Values.value(context.to_map)
+          map[DATABASE_NAME] = Values.value(database_name.database_name)
+          Query.new(MULTI_DB_GET_ROUTING_TABLE, Values.value(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,238 @@
+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 = nil, previous_delay = nil, result = nil, base_error = nil)
+          result = java.util.concurrent.CompletableFuture.new
+
+          # if we failed discovery, we will chain all errors into this one.
+          base_error = Exceptions::ServiceUnavailableException.new(NO_ROUTERS_AVAILABLE % routing_table.database.description)
+
+          lookup(routing_table, connection_pool, bookmark, impersonated_user, base_error).when_complete do |composition_lookup_result, completion_error|
+            error = Util::Futures.completion_exception_cause(completion_error)
+
+            if !error.nil?
+              result.complete_exceptionally(error)
+            elsif !composition_lookup_result.nil?
+              result.complete(composition_lookup_result)
+            else
+              new_failures = failures + 1
+
+              if new_failures >= @settings.max_routing_failures
+                # now we throw our saved error out
+                result.complete_exceptionally(base_error)
+              else
+                next_delay = java.lang.Math.max(@settings.retry_timeout_delay, previous_delay * 2)
+                @log.info("Unable to fetch new routing table, will try again in #{next_delay} ms")
+
+                @event_executor_group.next.schedule(next_delay, java.util.concurrent.TimeUnit::MILLISECONDS) do
+                  lookup_cluster_composition(routing_table, connection_pool, bookmark, impersonated_user, new_failures, next_delay, result, base_error)
+                end
+              end
+            end
+          end
+
+          result
+        end
+
+        def resolve
+          resolved_addresses = java.util.LinkedList.new
+          exception = nil
+
+          @resolver.resolve(initial_router).each do |server_address|
+            begin
+              resolve_all_by_domain_name(server_address).unicast_stream.for_each(resolved_addresses::add)
+            rescue java.net.UnknownHostException => e
+              if exception.nil?
+                exception = e
+              else
+                exception.add_suppressed(e)
+              end
+            end
+          end
+
+          # give up only if there are no addresses to work with at all
+          if resolved_addresses.empty? && !exception.nil?
+            raise exception
+          end
+
+          resolved_addresses
+        end
+
+        private
+
+        def lookup(routing_table, connection_pool, bookmark, impersonated_user, base_error)
+          composition_stage =  if routing_table.prefer_initial_router
+                                lookup_on_initial_router_then_on_known_routers(routing_table, connection_pool, bookmark, impersonated_user, base_error)
+                              else
+                                lookup_on_known_routers_then_on_initial_router(routing_table, connection_pool, bookmark, impersonated_user, base_error)
+                              end
+        end
+
+        def lookup_on_known_routers_then_on_initial_router(routing_table, connection_pool, bookmark, impersonated_user, base_error)
+          seen_servers = {}
+
+          lookup_on_known_routers(routing_table, connection_pool, seen_servers, bookmark, impersonated_user, base_error).then_compose do |composition_lookup_result|
+            if composition_lookup_result.nil?
+              java.util.concurrent.CompletableFuture.completed_future(composition_lookup_result)
+            end
+
+            lookup_on_initial_router(routing_table, connection_pool, seen_servers, bookmark, impersonated_user, base_error)
+          end
+        end
+
+        def lookup_on_initial_router_then_on_known_routers(routing_table, connection_pool, bookmark, impersonated_user, base_error)
+          seen_servers = [].freeze
+
+          lookup_on_initial_router(routing_table, connection_pool, seen_servers, bookmark, impersonated_user, base_error).then_compose do |composition_lookup_result|
+            if composition_lookup_result.nil?
+              java.util.concurrent.CompletableFuture.completed_future(composition_lookup_result)
+            end
+
+            lookup_on_known_routers(routing_table, connection_pool, {}, bookmark, impersonated_user, base_error)
+          end
+        end
+
+        def lookup_on_known_routers(routing_table, connection_pool, seen_servers, bookmark, impersonated_user, base_error)
+          result = Util::Futures.completed_with_null
+
+          routing_table.routers.each do |address|
+            result = result.then_compose do |composition|
+                       if !composition.nil?
+                         java.util.concurrent.CompletableFuture.completed_future(composition)
+                       else
+                         lookup_on_router(address, true, routing_table, connection_pool, seen_servers, bookmark, impersonated_user, base_error)
+                       end
+                     end
+          end
+
+          result.then_apply do |composition|
+            composition.nil? ? nil : ClusterCompositionLookupResult.new(composition)
+          end
+        end
+
+        def lookup_on_initial_router(routing_table, connection_pool, seen_servers, bookmark, impersonated_user, base_error)
+          begin
+            resolved_routers = resolve
+          rescue StandardError => error
+            Util::Futures.failed_future(error)
+          end
+
+          resolved_router_set = [resolved_routers]
+          resolved_routers - seen_servers
+
+          result = Util::Futures.completed_with_null
+
+          resolved_routers.each do |address|
+            result = result.then_compose do |composition|
+                       if !composition.nil?
+                         java.util.concurrent.CompletableFuture.completed_future(composition)
+                       else
+                         lookup_on_router(address, false, routing_table, connection_pool, nil, bookmark, impersonated_user, base_error)
+                       end
+                     end
+          end
+
+          result.then_apply do |composition|
+            composition.nil? ? nil : ClusterCompositionLookupResult.new(composition, resolved_router_set)
+          end
+        end
+
+        def lookup_on_router(router_address, resolve_address, routing_table, connection_pool, seen_servers, bookmark, impersonated_user, base_error)
+          address_future = java.util.concurrent.CompletableFuture.completed_future(router_address)
+
+          address_future.then_apply do |address|
+            resolve_address ? resolve_by_domain_name_or_throw_completion_exception(address, routing_table) : address
+          end.then_apply do |address|
+                add_and_return(seen_servers, address)
+              end.then_compose do
+                    connection_pool::acquire
+                  end.then_apply do |connection|
+                        ImpersonationUtil.ensure_impersonation_support(connection, impersonated_user)
+                      end.then_compose do |connection|
+                            @provider.get_cluster_composition(connection, routing_table.database, bookmark, impersonated_user)
+                          end.handle do |response, error|
+                                cause = Util::Futures.completion_exception_cause(error)
+
+                                if !cause.nil?
+                                  handle_routing_procedure_error(cause, routing_table, router_address, base_error)
+                                else
+                                  response
+                                end
+                              end
+        end
+
+        def handle_routing_procedure_error(error, routing_table, router_address, base_error)
+          raise java.util.concurrent.CompletionException, error if must_abort_discovery(error)
+
+          # Retriable error happened during discovery.
+          discovery_error = Exceptions::DiscoveryException.new(RECOVERABLE_ROUTING_ERROR % router_address, error)
+          Util::Futures.combine_errors(base_error, discovery_error) # we record each failure here
+          warning_message = RECOVERABLE_DISCOVERY_ERROR_WITH_SERVER % router_address
+          @log.warn(warning_message)
+          @log.debug(warning_message, discovery_error)
+          routing_table.forget(router_address)
+          nil
+        end
+
+        def must_abort_discovery(throwable)
+          abort = if !(throwable.is_a? Exceptions::AuthorizationExpiredException) && (throwable.is_a? Exceptions::SecurityException)
+                    true
+                  elsif throwable.is_a? Exceptions::FatalDiscoveryException
+                    true
+                  elsif throwable.is_a? Exceptions::IllegalStateException && Spi::ConnectionPool::CONNECTION_POOL_CLOSED_ERROR_MESSAGE == throwable.message
+                    true
+                  elsif throwable.is_a? Exceptions::ClientException
+                    code = throwable.code
+                    INVALID_BOOKMARK_CODE.eql?(code) || INVALID_BOOKMARK_MIXTURE_CODE.eql?(code)
+                  end
+        end
+
+        def add_and_return(collection, element)
+          collection << element unless collection.nil?
+
+          element
+        end
+
+        def resolve_by_domain_name_or_throw_completion_exception(address, routing_table)
+          begin
+            resolved_address = resolve_all_by_domain_name(address)
+            routing_table.replace_router_if_present(address, resolved_address)
+
+            resolved_address.unicast_stream.find_first.or_else_throw do
+              Exceptions::IllegalStateException.new('Unexpected condition, the ResolvedBoltServerAddress must always have at least one unicast address')
+            end
+          rescue StandardError => e
+            raise java.util.concurrent.CompletionException, e
+          end
+        end
+
+        def resolve_all_by_domain_name(address)
+          ResolvedBoltServerAddress.new(address.host, address.port, domain_name_resolver.resolve(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), to_record(routing_table))
+        rescue => e
+          RoutingProcedureResponse.new(query(database_name), 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