neo4j-ruby-driver 6.0.3.alpha.0 → 6.2.1.beta.2

data/ruby/neo4j/driver/internal/handlers/pulln/auto_pull_response_handler.rb

@@ -1,169 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Handlers
-      module Pulln
-        class AutoPullResponseHandler < BasicPullResponseHandler
-          delegate :signal, to: :@queue_notification
-          LONG_MAX_VALUE = 2 ** 63 - 1
-
-          def initialize(query, run_response_handler, connection, metadata_extractor, completion_listener, fetch_size)
-            super(query, run_response_handler, connection, metadata_extractor, completion_listener)
-            @fetch_size = fetch_size
-
-            # For pull everything ensure conditions for disabling auto pull are never met
-            if fetch_size == FetchSizeUtil::UNLIMITED_FETCH_SIZE
-              @high_record_watermark = LONG_MAX_VALUE
-              @low_record_watermark = LONG_MAX_VALUE
-            else
-              @high_record_watermark = fetch_size * 0.7
-              @low_record_watermark = fetch_size * 0.3
-            end
-
-            @queue_notification = ::Async::Notification.new
-            @records = ::Async::Queue.new(available: @queue_notification)
-            @auto_pull_enabled = true
-
-            install_record_and_summary_consumers
-          end
-
-          private def install_record_and_summary_consumers
-            install_record_consumer do |record, error|
-              if record
-                enqueue_record(record)
-                complete_record_future(record)
-              end
-
-              # if !error.nil? Handled by summary.error already
-              if record.nil? && error.nil?
-                # complete
-                complete_record_future(nil)
-              end
-            end
-
-            install_summary_consumer do |summary, error|
-              handle_failure(error) if error
-
-              if summary
-                @summary = summary
-                complete_summary_future(summary)
-              end
-
-              if error.nil? && summary.nil? # has_more
-                request(@fetch_size) if @auto_pull_enabled
-              end
-            end
-          end
-
-          private def handle_failure(error)
-            # error has not been propagated to the user, remember it
-            unless fail_record_future(error) || fail_summary_future(error)
-              @failure = error
-            end
-          end
-
-          def peek_async
-            while @records.empty? && !done?
-              @records.wait
-            end
-            @records.items.first&.then(&Util::ResultHolder.method(:successful)) or
-              completed_with_value_if_no_failure(nil)
-          end
-
-          def next_async
-            peek_async.then { |record| dequeue_record if record }
-          end
-
-          def consume_async
-            @records.items.clear
-            cancel unless done?
-            completed_with_value_if_no_failure(@summary)
-          end
-
-          def list_async(&block)
-            pull_all_async.then do
-              unless done?
-                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 pull_all_failure_async
-            pull_all_async.chain { |_, error| error }
-          end
-
-          def pre_populate_records
-            request(@fetch_size)
-          end
-
-          private
-
-          def pull_all_async
-            return completed_with_value_if_no_failure(@summary) if done?
-            (@summary_future ||= Util::ResultHolder.new).tap do |_|
-              request(FetchSizeUtil::UNLIMITED_FETCH_SIZE)
-            end
-          end
-
-          def enqueue_record(record)
-            @records << record
-
-            # too many records in the queue, pause auto request gathering
-            @auto_pull_enabled = false if @records.size > @high_record_watermark
-          end
-
-          def dequeue_record
-            record = @records.dequeue
-
-            if @records.size <= @low_record_watermark
-              # if not in streaming state we need to restart streaming
-              request(@fetch_size) if state != State::STREAMING_STATE
-
-              @auto_pull_enabled = true
-            end
-
-            record
-          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 complete_summary_future(summary)
-            @summary_future&.succeed(summary)
-            @summary_future = nil
-          end
-
-          def fail_record_future(error)
-            @record_future&.fail(error)
-          ensure
-            @record_future = nil
-          end
-
-          def fail_summary_future(error)
-            @summary_future&.fail(error)
-          ensure
-            @summary_future = nil
-          end
-
-          def completed_with_value_if_no_failure(value)
-            if @failure
-              Util::ResultHolder.failed(extract_failure)
-            else
-              Util::ResultHolder.successful(value)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/handlers/pulln/basic_pull_response_handler.rb

@@ -1,298 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Handlers
-      module Pulln
-        class BasicPullResponseHandler
-          include Spi::ResponseHandler
-          attr :state
-
-          def initialize(query, run_response_handler, connection, metadata_extractor, completion_listener)
-            super()
-            @query = Validator.require_non_nil!(query)
-            @run_response_handler = Validator.require_non_nil!(run_response_handler)
-            @metadata_extractor = Validator.require_non_nil!(metadata_extractor)
-            @connection = Validator.require_non_nil!(connection)
-            @completion_listener = Validator.require_non_nil!(completion_listener)
-            @state = State::READY_STATE
-            @to_request = 0
-          end
-
-          def state=(state)
-            @state = state
-            signal
-          end
-
-          def on_success(metadata)
-            assert_record_and_summary_consumer_installed
-            @state.on_success(self, metadata)
-          end
-
-          def on_failure(error)
-            assert_record_and_summary_consumer_installed
-            @state.on_failure(self, error)
-          end
-
-          def on_record(fields)
-            assert_record_and_summary_consumer_installed
-            @state.on_record(self, fields)
-          end
-
-          def request(size)
-            assert_record_and_summary_consumer_installed
-            @state.request(self, size)
-          end
-
-          def cancel
-            assert_record_and_summary_consumer_installed
-            @state.cancel(self)
-          end
-
-          def complete_with_failure(error)
-            @completion_listener.after_failure(error)
-            complete(extract_result_summary, error)
-          end
-
-          def complete_with_success(metadata)
-            @completion_listener.after_success(metadata)
-            summary, exception =
-              begin
-                [extract_result_summary(**metadata), nil]
-              rescue Exceptions::Neo4jException => e
-                [extract_result_summary, e]
-              end
-            complete(summary, exception)
-          end
-
-          def success_has_more
-            if @to_request > 0 || @to_request == FetchSizeUtil::UNLIMITED_FETCH_SIZE
-              request(@to_request)
-              @to_request = 0
-            end
-
-            # summary consumer use (null, null) to identify done handling of success with has_more
-            @summary_consumer.call(nil, nil)
-          end
-
-          def handle_record(fields)
-            record = InternalRecord.new(@run_response_handler.query_keys, fields)
-            @record_consumer.call(record, nil)
-          end
-
-          def write_pull(n)
-            @connection.write_and_flush(Messaging::Request::PullMessage.new(n, @run_response_handler.query_id), self)
-          end
-
-          def discard_all
-            @connection.write_and_flush(Messaging::Request::DiscardMessage.new_discard_all_message(@run_response_handler.query_id), self)
-          end
-
-          def install_summary_consumer(&summary_consumer)
-            raise Exceptions::IllegalStateException, 'Summary consumer already installed.' if @summary_consumer
-
-            @summary_consumer = summary_consumer
-          end
-
-          def install_record_consumer(&record_consumer)
-            raise Exceptions::IllegalStateException, 'Record consumer already installed.' if @record_consumer
-
-            @record_consumer = record_consumer
-          end
-
-          def done?
-            @state == State::SUCCEEDED_STATE || @state == State::FAILURE_STATE
-          end
-
-          private 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
-
-          private def add_to_request(to_add)
-            return if @to_request == FetchSizeUtil::UNLIMITED_FETCH_SIZE
-
-            # pull all
-            return @to_request = FetchSizeUtil::UNLIMITED_FETCH_SIZE if to_add == FetchSizeUtil::UNLIMITED_FETCH_SIZE
-
-            if to_add <= 0
-              raise ArgumentError, "Cannot request record amount that is less than or equal to 0. Request amount: #{to_add}"
-            end
-
-            @to_request += to_add
-
-            # to_add is already at least 1, we hit buffer overflow
-            @to_request = [@to_request, LONG_MAX_VALUE].min
-          end
-
-          private def assert_record_and_summary_consumer_installed
-            # no need to check if we've finished.
-            return if done?
-
-            if @record_consumer.nil? || @summary_consumer.nil?
-              raise Exceptions::IllegalStateException, "Access record stream without record consumer and/or summary consumer. Record consumer=#{@record_consumer}, Summary consumer=#{@summary_consumer}"
-            end
-          end
-
-          private def complete(summary, error)
-            # we first inform the summary consumer to ensure when streaming finished, summary is definitely available.
-            @summary_consumer.call(summary, error)
-            # record consumer use (nil, nil) to identify the end of record stream
-            @record_consumer.call(nil, error)
-            dispose
-          end
-
-          private def dispose
-            # release the reference to the consumers who hold the reference to subscribers which shall be released when subscription is completed.
-            @record_consumer = nil
-            @summary_consumer = nil
-          end
-
-          module State
-            class Ready
-              def on_success(context, metadata)
-                context.state = SUCCEEDED_STATE
-                context.complete_with_success(metadata)
-              end
-
-              def on_failure(context, error)
-                context.state = FAILURE_STATE
-                context.complete_with_failure(error)
-              end
-
-              def on_record(context, _fields)
-                context.state = READY_STATE
-              end
-
-              def request(context, n)
-                context.state = STREAMING_STATE
-                context.write_pull(n)
-              end
-
-              def cancel(context)
-                context.state = CANCELLED_STATE
-                context.discard_all
-              end
-            end
-
-            READY_STATE = Ready.new
-
-            class Streaming
-              def on_success(context, metadata)
-                if metadata[:has_more]
-                  context.state = READY_STATE
-                  context.success_has_more
-                else
-                  context.state = SUCCEEDED_STATE
-                  context.complete_with_success(metadata)
-                end
-              end
-
-              def on_failure(context, error)
-                context.state = FAILURE_STATE
-                context.complete_with_failure(error)
-              end
-
-              def on_record(context, fields)
-                context.state = STREAMING_STATE
-                context.handle_record(fields)
-              end
-
-              def request(context, n)
-                context.state = STREAMING_STATE
-                context.add_to_request(n)
-              end
-
-              def cancel(context)
-                context.state = CANCELLED_STATE
-              end
-            end
-
-            STREAMING_STATE = Streaming.new
-
-            class Cancelled
-              def on_success(context, metadata)
-                if metadata[:has_more]
-                  context.state = CANCELLED_STATE
-                  context.discard_all
-                else
-                  context.state = SUCCEEDED_STATE
-                  context.complete_with_success(metadata)
-                end
-              end
-
-              def on_failure(context, error)
-                context.state = FAILURE_STATE
-                context.complete_with_failure(error)
-              end
-
-              def on_record(context, _fields)
-                context.state = CANCELLED_STATE
-              end
-
-              def request(context, _n)
-                context.state = CANCELLED_STATE
-              end
-
-              def cancel(context)
-                context.state = CANCELLED_STATE
-              end
-            end
-
-            CANCELLED_STATE = Cancelled.new
-
-            class Succeeded
-              def on_success(context, metadata)
-                context.state = SUCCEEDED_STATE
-                context.complete_with_success(metadata)
-              end
-
-              def on_failure(context, error)
-                context.state = FAILURE_STATE
-                context.complete_with_failure(error)
-              end
-
-              def on_record(context, _fields)
-                context.state = SUCCEEDED_STATE
-              end
-
-              def request(context, _n)
-                context.state = SUCCEEDED_STATE
-              end
-
-              def cancel(context)
-                context.state = SUCCEEDED_STATE
-              end
-            end
-
-            SUCCEEDED_STATE = Succeeded.new
-
-            class Failed
-              def on_success(context, metadata)
-                context.state = SUCCEEDED_STATE
-                context.complete_with_success(metadata)
-              end
-
-              def on_failure(context, error)
-                context.state = FAILURE_STATE
-                context.complete_with_failure(error)
-              end
-
-              def on_record(context, _fields)
-                context.state = FAILURE_STATE
-              end
-
-              def request(context, _n)
-                context.state = FAILURE_STATE
-              end
-
-              def cancel(context)
-                context.state = FAILURE_STATE
-              end
-            end
-
-            FAILURE_STATE = Failed.new
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/handlers/pulln/fetch_size_util.rb

@@ -1,20 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Handlers
-      module Pulln
-        class FetchSizeUtil
-          UNLIMITED_FETCH_SIZE = -1
-          DEFAULT_FETCH_SIZE = 1000
-
-          def self.assert_valid_fetch_size(size)
-            if size <= 0 && size != UNLIMITED_FETCH_SIZE
-              raise ArgumentError, "The record fetch size may not be 0 or negative. Illegal record fetch size: #{size}."
-            end
-
-            size
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Handlers
-      class ResetResponseHandler
-        include Spi::ResponseHandler
-
-        def initialize(message_dispatcher, completion_future = nil)
-          @message_dispatcher = message_dispatcher
-          @completion_future = completion_future
-        end
-
-        def on_success(_metadata = {})
-          reset_completed(true)
-        end
-
-        def on_failure(_error)
-          reset_completed(false)
-        end
-
-        def on_record(_fields)
-          raise java.lang.UnsupportedOperationException
-        end
-
-        private def reset_completed(_success)
-          @message_dispatcher.clear_current_error
-
-          unless @completion_future.nil?
-            @completion_future.complete(nil)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Handlers
-      class RollbackTxResponseHandler
-        include Spi::ResponseHandler
-
-        def initialize(result_holder)
-          @result_holder = result_holder
-        end
-
-        def on_success(_metadata)
-          @result_holder.succeed
-        end
-
-        def on_failure(error)
-          @result_holder.fail(error)
-        end
-
-        def on_record(fields)
-          raise "Transaction rollback is not expected to receive records: #{fields}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Handlers
-      class RouteMessageResponseHandler < Struct.new(:completion_listener)
-        include Spi::ResponseHandler
-
-        def on_success(metadata)
-          completion_listener.routing_table = metadata[:rt]
-        end
-
-        def on_failure(error)
-          raise error
-        end
-
-        def on_record(fields)
-          raise "Route is not expected to receive records: #{fields}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Handlers
-      class RoutingResponseHandler
-        include Spi::ResponseHandler
-        delegate :on_success, :on_record, :can_manage_auto_read, :disable_auto_read_management, to: :@delegate
-
-        def initialize(delegate, address, access_mode, error_handler)
-          @delegate = delegate
-          @address = address
-          @access_mode = access_mode
-          @error_handler = error_handler
-        end
-
-        def on_failure(error)
-          new_error = handled_error(error)
-          @delegate.on_failure(new_error)
-        end
-
-        private
-
-        def handled_error(error)
-          case error
-          when Exceptions::ServiceUnavailableException
-            handled_service_unavailable_exception(error)
-          when Exceptions::ProtocolException
-            handled_protocol_exception(error)
-          when Exceptions::ClientException
-            handled_client_exception(error)
-          when Exceptions::TransientException
-            handled_transient_exception(error)
-          else
-            error
-          end
-        end
-
-        def handled_service_unavailable_exception(e)
-          record_connection_failure
-          Exceptions::SessionExpiredException.new("Server at #{@address} is no longer available", e)
-        end
-
-        def handled_transient_exception(e)
-          record_connection_failure if e.code == "Neo.TransientError.General.DatabaseUnavailable"
-          e
-        end
-
-        def handled_protocol_exception(e)
-          record_connection_failure
-          e
-        end
-
-        def record_connection_failure
-          @error_handler.on_connection_failure(@address)
-        end
-
-        def handled_client_exception(e)
-          return e unless failure_to_write?(e)
-
-          # The server is unaware of the session mode, so we have to implement this logic in the driver.
-          # In the future, we might be able to move this logic to the server.
-          case @access_mode
-          when AccessMode::READ
-            Exceptions::ClientException.new('Write queries cannot be performed in READ access mode.')
-          when AccessMode::WRITE
-            @error_handler.on_write_failure(@address)
-            Exceptions::SessionExpiredException.new('Server at %s no longer accepts writes' % @address)
-          else
-            raise ArgumentError, @accessMode + ' not supported.'
-          end
-        end
-
-        def failure_to_write?(e)
-          %w[Neo.ClientError.Cluster.NotALeader
-             Neo.ClientError.General.ForbiddenOnReadOnlyDatabase].include?(e.code)
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Handlers
-      class RunResponseHandler
-        include Spi::ResponseHandler
-        attr :query_keys, :result_available_after, :query_id, :error
-
-        def initialize(metadata_extractor, connection, tx)
-          @query_keys = []
-          @metadata_extractor = metadata_extractor
-          @connection = connection
-          @tx = tx
-        end
-
-        def on_success(metadata)
-          @query_keys = @metadata_extractor.extract_query_keys(metadata)
-          @result_available_after = @metadata_extractor.extract_result_available_after(metadata)
-          @query_id = @metadata_extractor.extract_query_id(metadata)
-        end
-
-        def on_failure(error)
-          if @tx
-            @tx.mark_terminated(error)
-          elsif error.is_a?(Exceptions::AuthorizationExpiredException)
-            connection.terminate_and_release(Exceptions::AuthorizationExpiredException::DESCRIPTION)
-          elsif error.is_a?(Exceptions::ConnectionReadTimeoutException)
-            connection.terminate_and_release(error.message)
-          end
-          @error = error
-        end
-
-        def on_record(_fields)
-          raise 'unsupported operation'
-        end
-      end
-    end
-  end
-end