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

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

@@ -0,0 +1,288 @@
+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::SUCEEDED_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
+            READY_STATE = Class.new do
+              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.new
+
+            STREAMING_STATE = Class.new do
+              def on_success(context, metadata)
+                if metadata[:has_more]
+                  context.state = READY_STATE
+                  context.success_has_more
+                else
+                  context.state = SUCEEDED_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.new
+
+            CANCELLED_STATE = Class.new do
+              def on_success(context, metadata)
+                if metadata[:has_more]
+                  context.state = CANCELLED_STATE
+                  context.discard_all
+                else
+                  context.state = SUCEEDED_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.new
+
+            SUCEEDED_STATE = Class.new do
+              def on_success(context, metadata)
+                context.state = SUCEEDED_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 = SUCEEDED_STATE
+              end
+
+              def request(context, _n)
+                context.state = SUCEEDED_STATE
+              end
+
+              def cancel(context)
+                context.state = SUCEEDED_STATE
+              end
+            end.new
+
+            FAILURE_STATE = Class.new do
+              def on_success(context, metadata)
+                context.state = SUCEEDED_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.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,19 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      class RollbackTxResponseHandler
+        include Spi::ResponseHandler
+        def on_success(_metadata)
+        end
+
+        def on_failure(error)
+          raise 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,37 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      class RunResponseHandler
+        include Spi::ResponseHandler
+        attr_reader :query_keys, :result_available_after, :query_id
+
+        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
+        end
+
+        def on_record(_fields)
+          raise 'unsupported operation'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      class SessionPullResponseCompletionListener
+        def initialize(connection, bookmark_holder)
+          @connection = connection
+          @bookmark_holder = bookmark_holder
+        end
+
+        def after_success(metadata)
+          release_connection
+          @bookmark_holder.bookmark = Util::MetadataExtractor.extract_bookmarks(metadata)
+        end
+
+        def after_failure(error)
+          case error
+          when Exceptions::AuthorizationExpiredException
+            @connection.terminate_and_release(Exceptions::AuthorizationExpiredException::DESCRIPTION)
+          when Exceptions::ConnectionReadTimeoutException
+            @connection.terminate_and_release(error.message)
+          else
+            release_connection
+          end
+        end
+
+        private
+
+        def release_connection
+          @connection.release
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      class TransactionPullResponseCompletionListener
+        def initialize(tx)
+          @tx = Validator.require_non_nil!(tx)
+        end
+
+        def after_success(_metadata) end
+
+        def after_failure(error)
+          # always mark transaction as terminated because every error is "acknowledged" with a RESET message
+          # so database forgets about the transaction after the first error
+          # such transaction should not attempt to commit and can be considered as rolled back
+          @tx.mark_terminated(error)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Neo4j::Driver
+  module Internal
+    class ImpersonationUtil
+      IMPERSONATION_UNSUPPORTED_ERROR_MESSAGE = 'Detected connection that does not support impersonation, please make sure to have all servers running 4.4 version or above and communicating over Bolt version 4.4 or above when using impersonation feature'
+
+      def self.ensure_impersonation_support(connection, impersonated_user)
+        if !impersonated_user.nil? && !supports_impersonation?(connection)
+          raise Neo4j::Driver::Exceptions::ClientException, IMPERSONATION_UNSUPPORTED_ERROR_MESSAGE
+        end
+
+        connection
+      end
+
+      private
+
+      def self.supports_impersonation?(connection)
+        connection.server_version.greater_than_or_equal(Util::ServerVersion::V4_4_0) &&
+        connection.protocol.version.compare_to( Messaging::V44::BoltProtocolV44::VERSION ) >= 0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Neo4j::Driver
+  module Internal
+    class InternalBookmark
+      include Bookmark
+      EMPTY = new
+      attr :values
+      delegate :hash, :empty?, to: :values
+
+      private def initialize(*values)
+        @values = values.to_set
+      end
+
+      def eql?(other)
+        values.eql?(other.values)
+      end
+
+      def ==(other)
+        values == other.values
+      end
+
+      def to_s
+        "Bookmark{values=#{values}}"
+      end
+
+      class << self
+        def empty
+          EMPTY
+        end
+
+        def from(*bookmarks)
+          new(*bookmarks.reduce(Set.new) { |set, bookmark| set + bookmark.values })
+        end
+
+        alias parse new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Neo4j::Driver
+  module Internal
+    class InternalDatabaseName < Struct.new(:database_name)
+      alias description database_name
+
+      def initialize(database_name)
+        super(Validator.require_non_nil!(database_name))
+      end
+    end
+  end
+end