neo4j-ruby-driver 4.4.0.alpha.5 → 4.4.0.alpha.8

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

@@ -8,8 +8,6 @@ module Neo4j::Driver
           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)
@@ -23,106 +21,72 @@ module Neo4j::Driver
           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
+            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
-            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
+            @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 supports_multi_db?
-            begin
-              addresses = @rediscovery.resolve
-            rescue StandardError => error
-              return Util::Futures.failed_future(error)
-            end
+          def routing_table_registry
+            @routing_tables
+          end
 
-            result = Util::Futures.completed_with_null
+          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|
-              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
+            addresses.lazy.map do |address|
+              private_suports_multi_db?(address)
+            rescue Exceptions::SecurityException
+              raise
+            rescue => error
+              Util::Futures.combine_errors(base_error, error)
+            end.find { |result| !result.nil? } or raise base_error
           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
+            conn = @connection_pool.acquire(address)
+            Messaging::Request::MultiDatabaseUtil.supports_multi_database?(conn)
+          ensure
+            conn&.release
           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
-
+          def acquire(mode, routing_table, attempt_errors = [])
             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
+            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
 
-            @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
+            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 READ
+            when AccessMode::READ
               routing_table.readers
-            when WRITE
+            when AccessMode::WRITE
               routing_table.writers
             else
               raise unknown_mode mode
@@ -131,9 +95,9 @@ module Neo4j::Driver
 
           def select_address(mode, addresses)
             case mode
-            when READ
+            when AccessMode::READ
               @load_balancing_strategy.select_reader(addresses)
-            when WRITE
+            when AccessMode::WRITE
               @load_balancing_strategy.select_writer(addresses)
             else
               raise unknown_mode mode
@@ -141,7 +105,7 @@ module Neo4j::Driver
           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))
+            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)

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

@@ -5,13 +5,9 @@ module Neo4j::Driver
       # 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'
+        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)
@@ -19,10 +15,11 @@ module Neo4j::Driver
         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))
+          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)

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

@@ -24,59 +24,38 @@ module Neo4j::Driver
         # @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)
+        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
-              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
+              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
-
-          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
+          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 => e
+            exception&.add_suppressed(e)
+            exception ||= e
+            []
           end
 
           # give up only if there are no addresses to work with at all
-          if resolved_addresses.empty? && !exception.nil?
-            raise exception
-          end
+          raise exception if resolved_addresses.empty? && exception
 
           resolved_addresses
         end
@@ -84,153 +63,84 @@ module Neo4j::Driver
         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
+          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
-
+          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
         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
+          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)
-          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
+          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)
-          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
+          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_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
+          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 java.util.concurrent.CompletionException, error if must_abort_discovery(error)
+          raise error if must_abort_discovery(error)
 
           # Retriable error happened during discovery.
-          discovery_error = Exceptions::DiscoveryException.new(RECOVERABLE_ROUTING_ERROR % router_address, error)
+          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(warning_message, discovery_error)
+          @log.debug(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
+        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)
-          begin
-            resolved_address = resolve_all_by_domain_name(address)
-            routing_table.replace_router_if_present(address, resolved_address)
+          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
+          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.resolve(address.host))
+          ResolvedBoltServerAddress.new(address.host, address.port, *@domain_name_resolver.call(address.host))
         end
       end
     end

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

@@ -16,9 +16,9 @@ module Neo4j::Driver
             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))
+          RoutingProcedureResponse.new(query(database_name), records: [to_record(@routing_table)])
         rescue => e
-          RoutingProcedureResponse.new(query(database_name), e)
+          RoutingProcedureResponse.new(query(database_name), error: e)
         ensure
           direct_connection.release
         end

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

@@ -4,34 +4,30 @@ module Neo4j::Driver
       class RoutingProcedureClusterCompositionProvider
         PROTOCOL_ERROR_MESSAGE = "Failed to parse '%s' result received from server due to "
 
-        def initialize(clock, routing_context)
-          @clock = clock
+        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)
+          runner = if Messaging::Request::MultiDatabaseUtil.supports_route_message?(connection)
                     @route_message_routing_procedure_runner
-                  elsif Messaging::Request::MultiDatabaseUtil.supports_multi_database(connection)
+                  elsif Messaging::Request::MultiDatabaseUtil.supports_multi_database?(connection)
                     @multi_database_routing_procedure_runner
                   else
                     @single_database_routing_procedure_runner
                   end
 
-          runner.run(connection, database_name, bookmark, impersonated_user).then_apply do
-            self::process_routing_response
-          end
+          process_routing_response(runner.run(connection, database_name, bookmark, impersonated_user))
         end
 
         def process_routing_response(response)
-          if !response.success?
-            raise java.util.concurrent.CompletionException, "Failed to run '#{invoked_procedure_string(response)}' on server. Please make sure that there is a Neo4j server or cluster up running.", response.error
+          unless response.success?
+            raise response.error.class, "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
-          now = clock.millis
 
           # the record size is wrong
           if records.size != 1
@@ -40,7 +36,7 @@ module Neo4j::Driver
 
           # failed to parse the record
           begin
-            cluster = ClusterComposition.parse( records[0], now)
+            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
@@ -56,7 +52,7 @@ module Neo4j::Driver
 
         def invoked_procedure_string(response)
           query = response.procedure
-          query.text + '' + query.parameters
+          "#{query.text} #{query.parameters}"
         end
       end
     end

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

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