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

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

@@ -0,0 +1,228 @@
+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
+        UNINITIALIZED_RECORDS = []
+        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 = Util::Validator.require_non_nil!(query)
+          @run_response_handler = Util::Validator.require_non_nil!(run_response_handler)
+          @metadata_extractor = Util::Validator.require_non_nil!(metadata_extractor)
+          @connection = Util::Validator.require_non_nil!(connection)
+          @completion_listener = Util::Validator.require_non_nil!(completion_listener)
+          @records = UNINITIALIZED_RECORDS
+        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 fail_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
+          record = @records.first
+
+          if record.nil?
+            return Util::Futures.failed_future(extract_failure) unless @failure.nil?
+
+            return Util::Futures.completed_with_null if @ignore_records || @finished
+
+            @record_future = java.util.concurrent.CompletableFuture.new if @record_future.nil?
+
+            @record_future
+          else
+            java.util.concurrent.CompletableFuture.completed_future(record)
+          end
+        end
+
+        def next_async
+          peek_async.then_apply(-> (_ignore) { dequeue_record })
+        end
+
+        def consume_async
+          @ignore_records = true
+          @records.clear
+
+          pull_all_failure_async.then_apply do |error|
+            unless error.nil?
+              raise Util::Futures.as_completion_exception, error
+            end
+
+            @summary
+          end
+        end
+
+        def list_async(map_function)
+          pull_all_failure_async.then_apply do |error|
+            unless error.nil?
+              raise Util::Futures.as_completion_exception, error
+            end
+
+            records_as_list(map_function)
+          end
+        end
+
+        def pre_populate_records
+          @connection.write_and_flush(Messaging::Request::PullAllMessage::PULL_ALL, self)
+        end
+
+        def pull_all_failure_async
+          if !@failure.nil?
+            return java.util.concurrent.CompletableFuture.completed_future(extract_failure)
+          elsif @finished
+            return Util::Futures.completed_with_null
+          else
+            if @failure_future.nil?
+              # 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
+              @failure_future = java.util.concurrent.CompletableFuture.new
+            end
+
+            @failure_future
+          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.drop(1)
+
+          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.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)
+          unless @record_future.nil?
+            future = @record_future
+            @record_future = nil
+            future.complete(record)
+          end
+        end
+
+        def fail_record_future(error)
+          unless @record_future.nil?
+            future = @record_future
+            @record_future = nil
+            future.complete_exceptionally(error)
+            return true
+          end
+
+          false
+        end
+
+        def complete_failure_future(error)
+          unless @failure_future.nil?
+            future = @failure_future
+            @failure_future = nil
+            future.complete(error)
+            return true
+          end
+
+          false
+        end
+
+        def extract_result_summary(metadata)
+          result_available_after = @run_response_handler.result_available_after
+          @metadataExtractor.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

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

@@ -0,0 +1,174 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      module Pulln
+        class AutoPullResponseHandler < BasicPullResponseHandler
+          delegate :signal, to: :@records
+          UNINITIALIZED_RECORDS = ::Async::Queue.new
+          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 = UNINITIALIZED_RECORDS
+            @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
+          end
+
+          def next_async
+            dequeue_record if peek_async
+          end
+
+          def consume_async
+            @records.items.clear
+            return completed_with_value_if_no_failure(@summary) if done?
+            cancel
+            @summary
+          end
+
+          def list_async(map_function)
+            pull_all_async.then_apply(-> (summary) { records_as_list(map_function) })
+          end
+
+          def pull_all_failure_async
+            pull_all_async
+          end
+
+          def pre_populate_records
+            request(@fetch_size)
+          end
+
+          private
+
+          def pull_all_async
+            return completed_with_value_if_no_failure(@summary) if done?
+
+            request(FetchSizeUtil::UNLIMITED_FETCH_SIZE)
+
+            @summary_future = java.util.concurrent.CompletableFuture.new if @summary_future.nil?
+
+            @summary_future
+          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 records_as_list(&map_function)
+            unless done?
+              raise Exceptions::IllegalStateException, "Can't get records as list because SUCCESS or FAILURE did not arrive"
+            end
+
+            @records.each.map(&map_function)
+          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)
+            unless @record_future.nil?
+              future = @record_future
+              @record_future = nil
+              future.complete(record)
+            end
+          end
+
+          def complete_summary_future(summary)
+            unless @summary_future.nil?
+              future = @summary_future
+              @summary_future = nil
+              future.complete(summary)
+            end
+          end
+
+          def fail_record_future(error)
+            unless @record_future.nil?
+              future = @record_future
+              @record_future = nil
+              future.complete(record)
+              return true
+            end
+
+            false
+          end
+
+          def completed_with_value_if_no_failure(value)
+            @failure ? extract_failure : value
+          end
+        end
+      end
+    end
+  end
+end