neo4j-ruby-driver 1.7.4 → 4.4.0

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

@@ -0,0 +1,168 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      module Pulln
+        class AutoPullResponseHandler < BasicPullResponseHandler
+          delegate :signal, to: :@records
+          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
+
+            @records = ::Async::Queue.new
+            @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

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

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

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

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

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

@@ -0,0 +1,70 @@
+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(received_error)
+          # TODO: probably not necessary with concurrent-ruby as it might not wrap exceptions like java
+          error = Futures.completion_exception_cause(received_error)
+
+          case error
+          when Exceptions::ServiceUnavailableException
+            handled_service_unavailable_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)
+          @error_handler.on_connection_failure(@address)
+          Exceptions::SessionExpiredException("Server at #{@address} is no longer available", e)
+        end
+
+        def handled_transient_exception(e)
+          e.code == "Neo.TransientError.General.DatabaseUnavailable" ? error_handler.on_connection_failure(@address) : e
+        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

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