neo4j-ruby-driver 1.7.4 → 4.4.0

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

@@ -0,0 +1,126 @@
+module Neo4j::Driver::Internal
+  class DriverFactory
+    include Scheme
+    NO_ROUTING_CONTEXT_ERROR_MESSAGE = "Routing parameters are not supported with scheme 'bolt'. Given URI: "
+
+    def initialize(domain_name_resolver = ->(name) { [name] })
+      @domain_name_resolver = domain_name_resolver
+    end
+
+    def new_instance(uri, auth_token, routing_settings, retry_settings, config, security_plan, event_loop_group = nil)
+      bootstrap = create_bootstrap(
+        **event_loop_group ? { event_loop_group: event_loop_group } : { thread_count: config[:event_loop_threads] }
+      )
+
+      address = BoltServerAddress.new(uri: uri)
+      new_routing_settings = routing_settings.with_routing_context(Cluster::RoutingContext.new(uri))
+
+      # org.neo4j.driver.internal.shaded.io.netty.util.internal.logging.InternalLoggerFactory.setDefaultFactory(org.neo4j.driver.internal.logging.NettyLogging.new(config.logging))
+      _event_executor_group = nil #bootstrap.group
+      retry_logic = Retry::ExponentialBackoffRetryLogic.new(retry_settings, _event_executor_group, config[:logger])
+
+      metrics_provider = create_driver_metrics(config)
+      connection_pool = create_connection_pool(auth_token, security_plan, bootstrap, metrics_provider, config,
+                                               event_loop_group.nil?, new_routing_settings.routing_context)
+
+      create_driver(uri, security_plan, address, connection_pool, _event_executor_group, new_routing_settings, retry_logic, metrics_provider, config)
+    end
+
+    private
+
+    def create_connection_pool(auth_token, security_plan, bootstrap, metrics_provider, config, owns_event_loop_group, routing_context)
+      clock = Util::Clock::System
+      settings = ConnectionSettings.new(auth_token, config[:user_agent], config[:connection_timeout].in_milliseconds)
+      connector = create_connector(settings, security_plan, config, clock, routing_context)
+      pool_settings = Async::Pool::PoolSettings.new(
+        config[:max_connection_pool_size],
+        config[:connection_acquisition_timeout],
+        config[:max_connection_lifetime].in_milliseconds,
+        config[:idle_time_before_connection_test]&.in_milliseconds || -1 # TODO: remember to get rid of -1
+      )
+      Async::Pool::ConnectionPoolImpl.new(connector, pool_settings, config[:logger])
+    end
+
+    def create_driver_metrics(config)
+      if config[:metrics_enabled]
+        Metrics::InternalMetricsProvider.new(config[:logger])
+      else
+        Metrics::MetricsProvider::METRICS_DISABLED_PROVIDER
+      end
+    end
+
+    def create_resolver(config)
+      config[:resolver] || ->(address) { [address] }
+    end
+
+    def assert_no_routing_context(uri, routing_settings)
+      routing_context = routing_settings.routing_context
+      if routing_context.defined?
+        raise ArgumentError, "Routing parameters are not supported with scheme 'bolt'. Given URI: '#{uri}'"
+      end
+    end
+
+    def create_connector(settings, security_plan, config, clock, routing_context)
+      Async::Connection::ChannelConnectorImpl.new(
+        settings, security_plan, config[:logger], clock, routing_context, &method(:domain_name_resolver))
+    end
+
+    def create_driver(uri, security_plan, address, connection_pool, eventExecutorGroup, routing_settings, retryLogic, metricsProvider, config)
+      if routing_scheme?(uri.scheme.downcase)
+        create_routing_driver(security_plan, address, connection_pool, eventExecutorGroup, routing_settings, retryLogic, metricsProvider, config)
+      else
+        assert_no_routing_context(uri, routing_settings)
+        create_direct_driver(security_plan, address, connection_pool, retryLogic, metricsProvider, config)
+      end
+    rescue => driver_error
+      # we need to close the connection pool if driver creation threw exception
+      close_connection_pool_and_suppress_error(connection_pool, driver_error)
+      raise
+    end
+
+    def create_direct_driver(securityPlan, address, connection_pool, retryLogic, metricsProvider, config)
+      connection_provider = DirectConnectionProvider.new(address, connection_pool)
+      driver(:Direct, securityPlan, address, connection_provider, retryLogic, metricsProvider, config)
+    end
+
+    def create_routing_driver(securityPlan, address, connection_pool, eventExecutorGroup, routing_settings, retryLogic, metricsProvider, config)
+      connection_provider = create_load_balancer(address, connection_pool, eventExecutorGroup, config, routing_settings)
+      driver(:Routing, securityPlan, address, connection_provider, retryLogic, metricsProvider, config)
+    end
+
+    def driver(type, security_plan, address, connection_provider, retry_logic, metrics_provider, config)
+      session_factory = SessionFactoryImpl.new(connection_provider, retry_logic, config)
+      InternalDriver.new(security_plan, session_factory, metrics_provider, config[:logger]).tap do |driver|
+        config[:logger]&.info { "#{type} driver instance #{driver.object_id} created for server address #{address}" }
+      end
+    end
+
+    def create_load_balancer(address, connection_pool, eventExecutorGroup, config, routing_settings)
+      load_balancing_strategy = Cluster::Loadbalancing::LeastConnectedLoadBalancingStrategy.new(connection_pool, config[:logger])
+      resolver = create_resolver(config)
+      Cluster::Loadbalancing::LoadBalancer.new(
+        address, routing_settings, connection_pool, eventExecutorGroup,
+        config[:logger], load_balancing_strategy, resolver, &method(:domain_name_resolver))
+    end
+
+    def create_bootstrap(**args)
+      Async::Connection::BootstrapFactory.new_bootstrap(**args)
+    end
+
+    protected
+
+    def close_connection_pool_and_suppress_error(connection_pool, main_error)
+      connection_pool.close
+    rescue => close_error
+      Util::ErrorUtil.add_suppressed(main_error, close_error)
+    end
+
+    # def getDomainNameResolver(name)
+    #   domain_name_resolver(name).map { |addrinfo| java.net.InetAddress.getByName(addrinfo.canonname) }.to_java(java.net.InetAddress)
+    # end
+
+    def domain_name_resolver(name)
+      @domain_name_resolver.call(name).flat_map { |n| Addrinfo.getaddrinfo(n, nil, nil, nil, Socket::IPPROTO_TCP) }
+    end
+  end
+end

data/ruby/neo4j/driver/internal/handlers/begin_tx_response_handler.rb

@@ -0,0 +1,20 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      class BeginTxResponseHandler
+        include Spi::ResponseHandler
+
+        def on_success(_metadata)
+        end
+
+        def on_failure(error)
+          raise error
+        end
+
+        def on_record(fields)
+          raise "Transaction begin is not expected to receive records: #{fields}"
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/handlers/channel_releasing_reset_response_handler.rb

@@ -0,0 +1,30 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      class ChannelReleasingResetResponseHandler < ResetResponseHandler
+        def initialize(channel, pool, message_dispatcher, log, release_future)
+          super(message_dispatcher, release_future)
+          @channel = channel
+          @pool = pool
+          @log = log
+        end
+
+        def reset_completed(success)
+          if success
+            # update the last-used timestamp before returning the channel back to the pool
+            # Async::Connection::ChannelAttributes.set_last_used_timestamp(@channel, @clock.millis)
+            # closure_stage = Util::Futures.completed_with_null
+          else
+            # close the channel before returning it back to the pool if RESET failed
+            @channel.close
+          end
+        rescue
+          nil
+        ensure
+          @pool.release(@channel)
+          @log.debug { "Channel #{@channel.object_id} released." }
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/handlers/commit_tx_response_handler.rb

@@ -0,0 +1,25 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      class CommitTxResponseHandler
+        include Spi::ResponseHandler
+
+        def initialize(result_holder)
+          @result_holder = result_holder
+        end
+
+        def on_success(metadata)
+          @result_holder.succeed(metadata[:bookmark]&.then(&InternalBookmark.method(:parse)))
+        end
+
+        def on_failure(error)
+          @result_holder.fail(error)
+        end
+
+        def on_record(fields)
+          raise "Transaction commit is not expected to receive records: #{fields}"
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/handlers/hello_response_handler.rb

@@ -0,0 +1,65 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      class HelloResponseHandler
+        include Spi::ResponseHandler
+        CONNECTION_ID_METADATA_KEY = :connection_id
+        CONFIGURATION_HINTS_KEY = :hints
+        CONNECTION_RECEIVE_TIMEOUT_SECONDS_KEY = :'connection.recv_timeout_seconds'
+        delegate :attributes, to: :@channel
+
+        def initialize(channel, protocol_version)
+          @channel = channel
+          @protocol_version = protocol_version
+        end
+
+        def on_success(metadata)
+          begin
+            attributes[:server_agent] = Util::MetadataExtractor.extract_server(metadata)
+            # From Server V4 extracting server from metadata in the success message is unreliable
+            # so we fix the Server version against the Bolt Protocol version for Server V4 and above.
+            attributes[:server_version] =
+              if Messaging::V3::BoltProtocolV3::VERSION == @protocol_version
+                Util::MetadataExtractor.extract_neo4j_server_version(metadata)
+              else
+                Util::ServerVersion.from_bolt_protocol_version(@protocol_version)
+              end
+
+            attributes[:connection_id] = extract_connection_id(metadata)
+            process_configuration_hints(metadata)
+          rescue => error
+            on_failure(error)
+            raise error
+          end
+        end
+
+        def on_failure(error)
+          @channel.close
+          raise error ### Not sure about that
+        end
+
+        def on_record(_fields)
+          raise NotImplementedError
+        end
+
+        private
+
+        def extract_connection_id(metadata)
+          value = metadata[CONNECTION_ID_METADATA_KEY]
+
+          if value.nil?
+            raise Exceptions::IllegalStateException, "Unable to extract #{CONNECTION_ID_METADATA_KEY} from a response to HELLO message. Received metadata: #{metadata}"
+          end
+
+          value
+        end
+
+        def process_configuration_hints(metadata)
+          metadata[CONFIGURATION_HINTS_KEY]&.dig(CONNECTION_RECEIVE_TIMEOUT_SECONDS_KEY)&.tap do |value|
+            attributes[:connection_read_timeout] = value
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/handlers/init_response_handler.rb

@@ -0,0 +1,34 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      class InitResponseHandler
+        include Spi::ResponseHandler
+
+        def initialize(connection_initialized_promise)
+          @connection_initialized_promise = connection_initialized_promise
+          @channel = connection_initialized_promise
+        end
+
+        def on_success(_metadata)
+          begin
+            server_version = Util::MetadataExtractor.extract_neo4j_server_version(metadata)
+            Async::Connection::ChannelAttributes.set_server_version(@channel, server_version)
+
+            @connection_initialized_promise.set_success
+          rescue StandardError => error
+            @connection_initialized_promise.set_failure(error)
+            raise error
+          end
+        end
+
+        def on_failure(error)
+          @channel.close.add_listener(-> (_future) { @connection_initialized_promise.set_failure(error) })
+        end
+
+        def on_record(fields)
+          raise java.lang.UnsupportedOperationException
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/handlers/legacy_pull_all_response_handler.rb

@@ -0,0 +1,199 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      # This is the Pull All response handler that handles pull all messages in Bolt v3 and previous protocol versions.
+      class LegacyPullAllResponseHandler
+        include Spi::ResponseHandler
+        RECORD_BUFFER_LOW_WATERMARK = ENV['record_buffer_low_watermark']&.to_i || 300
+        RECORD_BUFFER_HIGH_WATERMARK = ENV['record_buffer_high_watermark']&.to_i || 1000
+
+        def initialize(query, run_response_handler, connection, metadata_extractor, completion_listener)
+          @query = Internal::Validator.require_non_nil!(query)
+          @run_response_handler = Internal::Validator.require_non_nil!(run_response_handler)
+          @metadata_extractor = Internal::Validator.require_non_nil!(metadata_extractor)
+          @connection = Internal::Validator.require_non_nil!(connection)
+          @completion_listener = Internal::Validator.require_non_nil!(completion_listener)
+          @records = ::Async::Queue.new
+        end
+
+        def can_manage_auto_read?
+          true
+        end
+
+        def on_success(metadata)
+          @finished = true
+          @summary = extract_result_summary(metadata)
+
+          @completion_listener.after_success(metadata)
+
+          complete_record_future(nil)
+          complete_failure_future(nil)
+        end
+
+        def on_failure(error)
+          @finished = true
+          @summary = extract_result_summary({})
+
+          @completion_listener.after_failure(error)
+
+          failed_record_future = fail_record_future(error)
+
+          if failed_record_future
+            # error propagated through the record future
+            complete_failure_future(nil)
+          else
+            completed_failure_future = complete_failure_future(error)
+
+            # error has not been propagated to the user, remember it
+            @failure = error unless completed_failure_future
+          end
+        end
+
+        def on_record(fields)
+          if @ignore_records
+            complete_record_future(nil)
+          else
+            record = InternalRecord.new(@run_response_handler.query_keys, fields)
+            enqueue_record(record)
+            complete_record_future(record)
+          end
+        end
+
+        def disable_auto_read_management
+          @auto_read_management_enabled = false
+        end
+
+        def peek_async
+          while @records.empty? && !(@ignore_records || @finished)
+            @records.wait
+          end
+          @records.items.first&.then(&Util::ResultHolder.method(:successful)) or
+            @failure ? Util::ResultHolder.failed(extract_failure) : Util::ResultHolder.successful(nil)
+        end
+
+        def next_async
+          peek_async.then { |record| dequeue_record if record }
+        end
+
+        def consume_async
+          @ignore_records = true
+          @records.items.clear
+          pull_all_failure_async.result!&.then(&Util::ResultHolder.method(:failed)) or
+            Util::ResultHolder.successful(@summary)
+        end
+
+        def list_async(&block)
+          pull_all_failure_async.then do |error|
+            raise error if error
+            unless @finished
+              raise Exceptions::IllegalStateException, "Can't get records as list because SUCCESS or FAILURE did not arrive"
+            end
+            @records.items.map(&block)
+          ensure
+            @records.items.clear
+          end
+        end
+
+        def pre_populate_records
+          @connection.write_and_flush(Messaging::Request::PullAllMessage::PULL_ALL, self)
+        end
+
+        def pull_all_failure_async
+          if @failure
+            Util::ResultHolder.successful(extract_failure)
+          elsif @finished
+            Util::ResultHolder.successful
+          else
+            (@failed_future ||= Util::ResultHolder.new).tap do |_|
+              # neither SUCCESS nor FAILURE message has arrived, register future to be notified when it arrives
+              # future will be completed with null on SUCCESS and completed with Throwable on FAILURE
+              # enable auto-read, otherwise we might not read SUCCESS/FAILURE if records are not consumed
+              enable_auto_read
+            end
+          end
+        end
+
+        private
+
+        def enqueue_record(record)
+          @records << record
+
+          should_buffer_all_records = !@failure_future.nil?
+
+          # when failure is requested we have to buffer all remaining records and then return the error
+          # do not disable auto-read in this case, otherwise records will not be consumed and trailing
+          # SUCCESS or FAILURE message will not arrive as well, so callers will get stuck waiting for the error
+          if !should_buffer_all_records && @records.size > RECORD_BUFFER_HIGH_WATERMARK
+            # more than high watermark records are already queued, tell connection to stop auto-reading from network
+            # this is needed to deal with slow consumers, we do not want to buffer all records in memory if they are
+            # fetched from network faster than consumed
+            disable_auto_read
+          end
+        end
+
+        def dequeue_record
+          record = @records.dequeue
+
+          if @records.size < RECORD_BUFFER_LOW_WATERMARK
+            # less than low watermark records are now available in the buffer, tell connection to pre-fetch more
+            # and populate queue with new records from network
+            enable_auto_read
+          end
+
+          record
+        end
+
+        def records_as_list(map_function)
+          unless @finished
+            raise Exceptions::IllegalStateException, "Can't get records as list because SUCCESS or FAILURE did not arrive"
+          end
+
+          result = []
+
+          @records.each do |record|
+            result << map_function.apply(record)
+          end
+
+          @records.items.clear
+          result
+        end
+
+        def extract_failure
+          @failure or raise Exceptions::IllegalStateException, "Can't extract failure because it does not exist"
+        ensure
+          @failure = nil # propagate failure only once
+        end
+
+        def complete_record_future(record)
+          @record_future&.succeed(record)
+          @record_future = nil
+        end
+
+        def fail_record_future(error)
+          @record_future&.fail(error)
+        ensure
+          @record_future = nil
+        end
+
+        def complete_failure_future(error)
+          @failure_future&.fail(error)
+        ensure
+          @failure_future = nil
+        end
+
+        def extract_result_summary(metadata)
+          result_available_after = @run_response_handler.result_available_after
+          @metadata_extractor.extract_summary(@query, @connection, result_available_after, metadata)
+        end
+
+        def enable_auto_read
+          @connection.enable_auto_read if @auto_read_management_enabled
+        end
+
+        def disable_auto_read
+          @connection.disable_auto_read if @auto_read_management_enabled
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/handlers/no_op_response_handler.rb

@@ -0,0 +1,16 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      class NoOpResponseHandler
+        include Spi::ResponseHandler
+        INSTANCE = new
+
+        def on_success(metadata) end
+
+        def on_failure(error) end
+
+        def on_record(fields) end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/handlers/ping_response_handler.rb

@@ -0,0 +1,29 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      class PingResponseHandler
+        include Spi::ResponseHandler
+
+        def initialize(result, channel, logger)
+          @result = result
+          @channel = channel
+          @log = logger
+        end
+
+        def on_success(_metadata)
+          @log.debug("Channel #{@channel} pinged successfully")
+          @result.set_success(true)
+        end
+
+        def on_failure(error)
+          @log.debug("Channel #{@channel} failed ping #{error}")
+          @result.set_success(false)
+        end
+
+        def on_record(fields)
+          raise java.lang.UnsupportedOperationException
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/handlers/pull_handlers.rb

@@ -0,0 +1,32 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      class PullHandlers
+        include Spi::ResponseHandler
+
+        class << self
+          def new_bolt_v3_pull_all_handler(query, run_handler, connection, bookmark_holder, tx)
+            completion_listener = create_pull_response_completion_listener(connection, bookmark_holder, tx)
+            LegacyPullAllResponseHandler.new(query, run_handler, connection, Messaging::V3::BoltProtocolV3::METADATA_EXTRACTOR, completion_listener)
+          end
+
+          def new_bolt_v4_auto_pull_handler(query, run_handler, connection, bookmark_holder, tx, fetch_size)
+            completion_listener = create_pull_response_completion_listener(connection, bookmark_holder, tx)
+            Pulln::AutoPullResponseHandler.new(query, run_handler, connection, Messaging::V3::BoltProtocolV3::METADATA_EXTRACTOR, completion_listener, fetch_size)
+          end
+
+          def new_bolt_v4_basic_pull_handler(query, run_handler, connection, bookmark_holder, tx)
+            completion_listener = create_pull_response_completion_listener(connection, bookmark_holder, tx)
+            Pulln::BasicPullResponseHandler.new(query, run_handler, connection, Messaging::V3::BoltProtocolV3::METADATA_EXTRACTOR, completion_listener)
+          end
+
+          private
+
+          def create_pull_response_completion_listener(connection, bookmark_holder, tx)
+            tx.nil? ? SessionPullResponseCompletionListener.new(connection, bookmark_holder) : TransactionPullResponseCompletionListener.new(tx)
+          end
+        end
+      end
+    end
+  end
+end