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

data/ruby/neo4j/driver/internal/cursor/rx_result_cursor_impl.rb

@@ -0,0 +1,110 @@
+module Neo4j::Driver
+  module Internal
+    module Cursor
+      class RxResultCursorImpl
+        DISCARD_RECORD_CONSUMER = -> (record, throwable) {}
+
+        delegate :cancel, to: :@pull_handler
+        delegate :done?, to: :@summary_future
+
+        def initialize(run_error, run_handler, pull_handler)
+          java.util.Objects.require_non_null(run_handler)
+          java.util.Objects.require_non_null(pull_handler)
+
+          @run_response_error = run_error
+          @run_handler = @run_handler
+          @pull_handler = @pull_handler
+          @summary_future = java.util.concurrent.CompletableFuture.new
+          @consumer_status = RecordConsumerStatus::NOT_INSTALLED
+          install_summary_consumer
+        end
+
+        def keys
+          @run_handler.query_keys.keys
+        end
+
+        def install_record_consumer(record_consumer)
+          raise Util::ErrorUtil.new_result_consumed_error if result_consumed
+
+          return if @consumer_status.installed?
+
+          @consumer_status = record_consumer == DISCARD_RECORD_CONSUMER ? RecordConsumerStatus::DISCARD_INSTALLED : RecordConsumerStatus::INSTALLED
+          @pull_handler.install_record_consumer(record_consumer)
+          assert_run_completed_successfully
+        end
+
+        def request(n)
+          n = -1 if n == java.lang.Long::MAX_VALUE
+
+          @pull_handler.request(n)
+        end
+
+        def discard_all_failure_async
+          # calling this method will enforce discarding record stream and finish running cypher query
+          summary_stage.then_apply(-> (_summary) { nil }).exceptionally do |throwable|
+            @summary_future_exposed ? null : throwable
+          end
+        end
+
+        def pull_all_failure_async
+          if @consumer_status.installed? && !done?
+            return java.util.concurrent.CompletableFuture.completed_future(Exceptions::TransactionNestingException.new("You cannot run another query or begin a new transaction in the same session before you've fully consumed the previous run result."))
+          end
+
+          # It is safe to discard records as either the streaming has not started at all, or the streaming is fully finished.
+          discard_all_failure_async
+        end
+
+        def summary_async
+          @summary_future_exposed = true
+          summary_stage
+        end
+
+        def summary_stage
+          unless done? && @result_consumed # the summary is called before record streaming
+            install_record_consumer(DISCARD_RECORD_CONSUMER)
+            cancel
+            @result_consumed = true
+          end
+
+          @summary_future
+        end
+
+        private
+
+        def assert_run_completed_successfully
+          unless @run_response_error.nil?
+            @pull_handler.on_failure(@run_response_error)
+          end
+        end
+
+        def install_summary_consumer
+          @pull_handler.install_summary_consumer do |summary, error|
+            if !error.nil? && @consumer_status.discard_consumer?
+              # We will only report the error to summary if there is no user record consumer installed
+              # When a user record consumer is installed, the error will be reported to record consumer instead.
+              @summary_future.complete_exceptionally(error)
+            elsif !summary.nil?
+              @summary_future.complete(summary)
+            end
+
+            # else (nil, nil) to indicate a has_more success
+          end
+        end
+
+        class RecordConsumerStatus
+          attr_reader :installed, :discard_consumer
+
+          def initialize(installed, discard_consumer)
+            @installed = installed
+            @discard_consumer = discard_consumer
+          end
+
+          NOT_INSTALLED = new(false, false)
+          INSTALLED = new(true, false)
+          DISCARD_INSTALLED = new(true, true)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Neo4j::Driver
+  module Internal
+    class DatabaseName
+      attr_accessor :database_name, :description
+
+      def initialize(database_name, description = nil)
+        @database_name = database_name
+        @description = description
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Neo4j::Driver
+  module Internal
+    class DatabaseNameUtil
+      DEFAULT_DATABASE_NAME = nil
+      SYSTEM_DATABASE_NAME = 'system'
+
+      private
+
+      DEFAULT_DATABASE = Struct.new(:database_name, :description).new(nil, '<default database>')
+      SYSTEM_DATABASE = InternalDatabaseName.new(SYSTEM_DATABASE_NAME)
+
+      public
+
+      class << self
+        def default_database
+          DEFAULT_DATABASE
+        end
+
+        def system_database
+          SYSTEM_DATABASE
+        end
+
+        def database(name)
+          case name
+          when DEFAULT_DATABASE_NAME
+            default_database
+          when SYSTEM_DATABASE_NAME
+            system_database
+          else
+            InternalDatabaseName.new(name)
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,15 @@
+module Neo4j::Driver
+  module Internal
+    class DefaultBookmarkHolder
+      attr_reader :bookmark
+
+      def initialize(bookmark = InternalBookmark.empty)
+        @bookmark = bookmark
+      end
+
+      def bookmark=(bookmark)
+        @bookmark = bookmark if bookmark.present?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Neo4j::Driver
+  module Internal
+    class DefaultDomainNameResolver
+      INSTANCE = new
+
+      def resolve(name)
+        java.net.InetAddress.get_all_by_name(name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Neo4j::Driver
+  module Internal
+    class DirectConnectionProvider
+      attr_reader :address
+
+      def initialize(address, connection_pool)
+        @address = address
+        @connection_pool = connection_pool
+      end
+
+      delegate :close, to: :@connection_pool
+
+      def acquire_connection(context)
+        database_name = context.database_name || DatabaseNameUtil::DEFAULT_DATABASE
+        Async::Connection::DirectConnection.new(private_acquire_connection, database_name, context.mode,
+                                                context.impersonated_user)
+      end
+
+      def verify_connectivity
+        private_acquire_connection&.release
+      end
+
+      def supports_multi_db?
+        private_acquire_connection.then do |conn|
+          supports_multi_database?(conn)
+        ensure
+          conn.release
+        end
+      end
+
+      private
+
+      # Used only for grabbing a connection with the server after hello message.
+      # This connection cannot be directly used for running any queries as it is missing necessary connection context
+      def private_acquire_connection
+        @connection_pool.acquire(@address)
+      end
+    end
+  end
+end

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, routingSettings, retryLogic, metricsProvider, config)
+      connection_provider = create_load_balancer(address, connection_pool, eventExecutorGroup, config, routingSettings)
+      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, routingSettings)
+      load_balancing_strategy = Cluster::Loadbalancing::LeastConnectedLoadBalancingStrategy.new(connection_pool, config[:logger])
+      resolver = create_resolver(config)
+      Cluster::Loadbalancing::LoadBalancer.new(
+        address, routingSettings, 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,29 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      class ChannelReleasingResetResponseHandler < ResetResponseHandler
+        def initialize(channel, pool, message_dispatcher, clock, release_future)
+          super(message_dispatcher, release_future)
+          @channel = channel
+          @pool = pool
+          @clock = clock
+        end
+
+        def reset_completed(completion_future, 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
+            closure_stage = Util::Futures.as_completion_stage(@channel.close)
+          end
+
+          closure_stage.exceptionally(-> (_throwable) { nil }).then_compose(-> (_ignored) { @pool.release(@channel) }).when_complete do |_, _error|
+            completion_future.complete(nil)
+          end
+        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(completion_listener)
+          @completion_listener = completion_listener
+        end
+
+        def on_success(metadata)
+          @completion_listener.bookmark = metadata[:bookmark]&.then(&InternalBookmark.method(:parse))
+        end
+
+        def on_failure(error)
+          raise 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