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

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

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

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

@@ -1,199 +0,0 @@
-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
-        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 = Internal::Validator.require_non_nil!(query)
-          @run_response_handler = Internal::Validator.require_non_nil!(run_response_handler)
-          @metadata_extractor = Internal::Validator.require_non_nil!(metadata_extractor)
-          @connection = Internal::Validator.require_non_nil!(connection)
-          @completion_listener = Internal::Validator.require_non_nil!(completion_listener)
-          @records = ::Async::Queue.new
-        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 failed_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
-          while @records.empty? && !(@ignore_records || @finished)
-            @records.wait
-          end
-          @records.items.first&.then(&Util::ResultHolder.method(:successful)) or
-            @failure ? Util::ResultHolder.failed(extract_failure) : Util::ResultHolder.successful(nil)
-        end
-
-        def next_async
-          peek_async.then { |record| dequeue_record if record }
-        end
-
-        def consume_async
-          @ignore_records = true
-          @records.items.clear
-          pull_all_failure_async.result!&.then(&Util::ResultHolder.method(:failed)) or
-            Util::ResultHolder.successful(@summary)
-        end
-
-        def list_async(&block)
-          pull_all_failure_async.then do |error|
-            raise error if error
-            unless @finished
-              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 pre_populate_records
-          @connection.write_and_flush(Messaging::Request::PullAllMessage::PULL_ALL, self)
-        end
-
-        def pull_all_failure_async
-          if @failure
-            Util::ResultHolder.successful(extract_failure)
-          elsif @finished
-            Util::ResultHolder.successful
-          else
-            (@failed_future ||= Util::ResultHolder.new).tap do |_|
-              # 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
-            end
-          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.dequeue
-
-          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.items.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)
-          @record_future&.succeed(record)
-          @record_future = nil
-        end
-
-        def fail_record_future(error)
-          @record_future&.fail(error)
-        ensure
-          @record_future = nil
-        end
-
-        def complete_failure_future(error)
-          @failure_future&.fail(error)
-        ensure
-          @failure_future = nil
-        end
-
-        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
-
-        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

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

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

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

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