neo4j-ruby-driver 5.7.0.alpha.4 → 6.0.3.alpha.0-java

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

@@ -1,16 +0,0 @@
-module Neo4j::Driver
-  module Internal
-
-    # The connection settings are used whenever a new connection is
-    # established to a server, specifically as part of the INIT request.
-    class ConnectionSettings
-      attr_reader :auth_token, :user_agent, :connect_timeout_millis
-
-      def initialize(auth_token, user_agent, connect_timeout_millis)
-        @auth_token = auth_token
-        @user_agent = user_agent
-        @connect_timeout_millis = connect_timeout_millis
-      end
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Cursor
-      class AsyncResultCursorImpl
-        delegate :consume_async, :next_async, :peek_async, to: :@pull_all_handler
-
-        def initialize(run_handler, pull_all_handler)
-          @run_handler = run_handler
-          @pull_all_handler = pull_all_handler
-        end
-
-        def keys
-          @run_handler.query_keys
-        end
-
-        def single_async
-          next_async.compose do |first_record|
-            unless first_record
-              raise Exceptions::NoSuchRecordException, 'Cannot retrieve a single record, because this result is empty.'
-            end
-            next_async.then do |second_record|
-              if second_record
-                raise Exceptions::NoSuchRecordException,
-                      'Expected a result with a single record, but this result contains at least one more. Ensure your query returns only one record.'
-              end
-              first_record
-            end
-          end
-        end
-
-        def list_async(&map_function)
-          @pull_all_handler.list_async(&block_given? ? map_function : :itself)
-        end
-
-        def discard_all_failure_async
-          # runError has priority over other errors and is expected to have been reported to user by now
-          consume_async.error.then { |error| run_error ? nil : error }
-        end
-
-        def pull_all_failure_async
-          # runError has priority over other errors and is expected to have been reported to user by now
-          @pull_all_handler.pull_all_failure_async.then { |error| run_error ? nil : error }
-        end
-
-        def map_successful_run_completion_async
-          run_error&.then(&Util::ResultHolder.method(:failed)) || Util::ResultHolder.successful(self)
-        end
-
-        def run_error
-          @run_handler.error
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Cursor
-      # Used by Bolt V1, V2, V3
-      class AsyncResultCursorOnlyFactory
-        def initialize(connection, run_message, run_handler, pull_handler)
-          @connection = Internal::Validator.require_non_nil!(connection)
-          @run_message = Internal::Validator.require_non_nil!(run_message)
-          @run_handler = Internal::Validator.require_non_nil!(run_handler)
-
-          @pull_all_handler = Internal::Validator.require_non_nil!(pull_handler)
-        end
-
-        def async_result
-          # only write and flush messages when async result is wanted.
-          @connection.write(@run_message, @run_handler) # queues the run message, will be flushed with pull message together
-          @pull_all_handler.pre_populate_records
-
-          DisposableAsyncResultCursor.new(AsyncResultCursorImpl.new(@run_handler, @pull_all_handler))
-        end
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Cursor
-      class DisposableAsyncResultCursor
-        include Enumerable
-        delegate :keys, :pull_all_failure_async, to: :@delegate
-
-        def initialize(delegate)
-          @delegate = delegate
-        end
-
-        def consume_async
-          @disposed = true
-          @delegate.consume_async
-        end
-
-        def next_async
-          assert_not_disposed
-          @delegate.next_async
-        end
-
-        def peek_async
-          assert_not_disposed
-          @delegate.peek_async
-        end
-
-        def single_async
-          assert_not_disposed
-          @delegate.single_async
-        end
-
-        def each(&action)
-          assert_not_disposed
-          @delegate.each(&action)
-        end
-
-        def list_async(&block)
-          assert_not_disposed
-          @delegate.list_async(&block)
-        end
-
-        def discard_all_failure_async
-          @disposed = true
-          @delegate.discard_all_failure_async
-        end
-
-        private def assert_not_disposed
-          raise Util::ErrorUtil.new_result_consumed_error if @disposed
-        end
-
-        def disposed?
-          @disposed
-        end
-
-        def map_successful_run_completion_async
-          @delegate.map_successful_run_completion_async.then { self }
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Cursor
-      # Bolt V4
-      class ResultCursorFactoryImpl
-        def initialize(connection, run_message, run_handler, pull_handler, pull_all_handler)
-          @connection = Internal::Validator.require_non_nil!(connection)
-          @run_message = Internal::Validator.require_non_nil!(run_message)
-          @run_handler = Internal::Validator.require_non_nil!(run_handler)
-          @pull_handler = Internal::Validator.require_non_nil!(pull_handler)
-          @pull_all_handler = Internal::Validator.require_non_nil!(pull_all_handler)
-        end
-
-        def async_result
-          # only write and flush messages when async result is wanted.
-          @connection.write(@run_message, @run_handler) # queues the run message, will be flushed with pull message together
-          @pull_all_handler.pre_populate_records
-
-          DisposableAsyncResultCursor.new(AsyncResultCursorImpl.new(@run_handler, @pull_all_handler))
-        end
-      end
-    end
-  end
-end

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

@@ -1,110 +0,0 @@
-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_util.rb

@@ -1,37 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    class DatabaseNameUtil
-      DEFAULT_DATABASE_NAME = nil
-      SYSTEM_DATABASE_NAME = 'system'
-
-      private
-
-      DEFAULT_DATABASE = InternalDatabaseName.new(description: '<default database>')
-      SYSTEM_DATABASE = InternalDatabaseName.new(database_name: 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(database_name: name)
-          end
-        end
-      end
-    end
-  end
-end
-

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

@@ -1,9 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    class DefaultBookmarkHolder < ReadOnlyBookmarkHolder
-      def bookmark=(bookmark)
-        @bookmark = bookmark if bookmark.present?
-      end
-    end
-  end
-end

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

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

@@ -1,40 +0,0 @@
-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|
-          Messaging::Request::MultiDatabaseUtil.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

@@ -1,126 +0,0 @@
-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)
-      @domain_name_resolver = domain_name_resolver || ->(name) { [name] }
-    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

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

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

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

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