neo4j-ruby-driver 1.7.4 → 4.4.0

data/ruby/neo4j/driver/internal/metrics/time_recorder_listener_event.rb

@@ -0,0 +1,15 @@
+module Neo4j::Driver
+  module Internal
+    module Metrics
+      class TimeRecorderListenerEvent
+        def start
+          @start_time = Util::Clock::System.millis
+        end
+
+        def elapsed
+          Util::Clock::System.millis - @start_time
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/packstream/byte_array_incompatible_packer.rb

@@ -0,0 +1,12 @@
+module Neo4j::Driver
+  module Internal
+    module Packstream
+      class ByteArrayIncompatiblePacker
+        include PackStream::Packer
+        def pack_bytes_header(_size)
+          raise PackStream::UnPackable.new('Packing bytes is not supported as the current server this driver connected to does not support unpack bytes.')
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/packstream/pack_input.rb

@@ -0,0 +1,47 @@
+module Neo4j::Driver
+  module Internal
+    module Packstream
+      module PackInput
+        def read_char
+          read_exactly(1)
+        end
+
+        def read_byte
+          read_exactly(1).unpack1('c')
+        end
+
+        def read_ubyte
+          read_exactly(1).unpack1('C')
+        end
+
+        def read_short
+          read_exactly(2).unpack1('s>')
+        end
+
+        def read_ushort
+          read_exactly(2).unpack1('S>')
+        end
+
+        def read_int
+          read_exactly(4).unpack1('l>')
+        end
+
+        def read_uint
+          read_exactly(4).unpack1('L>')
+        end
+
+        def read_long
+          read_exactly(8).unpack1('q>')
+        end
+
+        def read_ulong
+          read_exactly(8).unpack1('Q>')
+        end
+
+        def read_double
+          read_exactly(8).unpack1('G')
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/packstream/pack_output.rb

@@ -0,0 +1,39 @@
+module Neo4j::Driver
+  module Internal
+    module Packstream
+      module PackOutput
+        ## Produce a single byte
+        def write_byte(value)
+          value.is_a?(String) ? write(value) : write_value(value, 'c')
+        end
+
+        ## Produce a 4-byte signed integer
+        def write_short(value)
+          write_value(value, 's>')
+        end
+
+        ## Produce a 4-byte signed integer
+        def write_int(value)
+          write_value(value, 'l>')
+        end
+
+        ## Produce an 8-byte signed integer
+        def write_long(value)
+          write_value(value, 'q>')
+        end
+
+        ## Produce an 8-byte IEEE 754 "double format" floating-point number
+        def write_double(value)
+          write_value(value, 'G')
+        end
+
+        private
+
+        def write_value(value, directive)
+          write([value].pack(directive))
+          self
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/packstream/pack_stream.rb

@@ -0,0 +1,326 @@
+module Neo4j::Driver
+  module Internal
+    module Packstream
+      module PackStream
+        module Common
+          TINY_STRING = 0x80
+          TINY_LIST = 0x90
+          TINY_MAP = 0xA0
+          TINY_STRUCT = 0xB0
+          NULL = 0xC0
+          FLOAT_64 = 0xC1
+          FALSE = 0xC2
+          TRUE = 0xC3
+          RESERVED_C4 = 0xC4
+          RESERVED_C5 = 0xC5
+          RESERVED_C6 = 0xC6
+          RESERVED_C7 = 0xC7
+          INT_8 = 0xC8
+          INT_16 = 0xC9
+          INT_32 = 0xCA
+          INT_64 = 0xCB
+          BYTES_8 = 0xCC
+          BYTES_16 = 0xCD
+          BYTES_32 = 0xCE
+          RESERVED_CF = 0xCF
+          STRING_8 = 0xD0
+          STRING_16 = 0xD1
+          STRING_32 = 0xD2
+          RESERVED_D3 = 0xD3
+          LIST_8 = 0xD4
+          LIST_16 = 0xD5
+          LIST_32 = 0xD6
+          RESERVED_D7 = 0xD7
+          MAP_8 = 0xD8
+          MAP_16 = 0xD9
+          MAP_32 = 0xDA
+          RESERVED_DB = 0xDB
+          STRUCT_8 = 0xDC
+          STRUCT_16 = 0xDD
+          RESERVED_DE = 0xDE
+          RESERVED_DF = 0xDF
+          RESERVED_E0 = 0xE0
+          RESERVED_E1 = 0xE1
+          RESERVED_E2 = 0xE2
+          RESERVED_E3 = 0xE3
+          RESERVED_E4 = 0xE4
+          RESERVED_E5 = 0xE5
+          RESERVED_E6 = 0xE6
+          RESERVED_E7 = 0xE7
+          RESERVED_E8 = 0xE8
+          RESERVED_E9 = 0xE9
+          RESERVED_EA = 0xEA
+          RESERVED_EB = 0xEB
+          RESERVED_EC = 0xEC
+          RESERVED_ED = 0xED
+          RESERVED_EE = 0xEE
+          RESERVED_EF = 0xEF
+        end
+
+        PLUS_2_TO_THE_63 = 2 ** 63
+        PLUS_2_TO_THE_31 = 2147483648
+        PLUS_2_TO_THE_16 = 65536
+        PLUS_2_TO_THE_15 = 32768
+        PLUS_2_TO_THE_8 = 256
+        PLUS_2_TO_THE_7 = 128
+        MINUS_2_TO_THE_4 = -16
+        MINUS_2_TO_THE_7 = -128
+        MINUS_2_TO_THE_15 = -32768
+        MINUS_2_TO_THE_31 = -2147483648
+        MINUS_2_TO_THE_63 = -2 ** 63
+
+        module Packer
+          include Common
+          private def pack_raw(data)
+            write(data)
+          end
+
+          def pack_null
+            write_byte(NULL)
+          end
+
+          def pack(value)
+            case value
+            when nil
+              pack_null
+            when TrueClass
+              write_byte(TRUE)
+            when FalseClass
+              write_byte(FALSE)
+            when Integer
+              pack_integer(value)
+            when Float
+              pack_float(value)
+            when String
+              case value.encoding
+              when Encoding::BINARY
+                pack_bytes(value)
+              when Encoding::UTF_8
+                pack_string(value)
+              else
+                pack_string(value.encode(Encoding::UTF_8))
+              end
+            when Symbol
+              pack_string(value.to_s)
+            when InternalPath
+              unpackable(value)
+            when Hash
+              pack_map_header(value.size)
+              value.each do |key, val|
+                pack(key)
+                pack(val)
+              end
+            when Enumerable
+              value = value.to_a
+              pack_list_header(value.size)
+              value.each(&method(:pack))
+            when Bookmark
+              pack(value.values)
+            else
+              unpackable(value)
+            end
+          end
+
+          private def unpackable(value)
+            raise UnPackable, "Cannot pack object #{value}"
+          end
+
+          def pack_integer(value)
+            if value >= MINUS_2_TO_THE_4 && value < PLUS_2_TO_THE_7
+              write_byte(value)
+            elsif value >= MINUS_2_TO_THE_7 && value < MINUS_2_TO_THE_4
+              write_byte(INT_8).write_byte(value)
+            elsif value >= MINUS_2_TO_THE_15 && value < PLUS_2_TO_THE_15
+              write_byte(INT_16).write_short(value)
+            elsif value >= MINUS_2_TO_THE_31 && value < PLUS_2_TO_THE_31
+              write_byte(INT_32).write_int(value)
+            elsif value >= MINUS_2_TO_THE_63 && value < PLUS_2_TO_THE_63
+              write_byte(INT_64).write_long(value)
+            else
+              pack_string(value.to_s)
+            end
+          end
+
+          def pack_float(value)
+            write_byte(FLOAT_64).write_double(value)
+          end
+
+          private def pack_bytes(value)
+            pack_bytes_header(value.bytesize)
+            pack_raw(value)
+          end
+
+          private def pack_string(value)
+            pack_string_header(value.bytesize)
+            pack_raw(value)
+          end
+
+          def pack_bytes_header(size)
+            if size < PLUS_2_TO_THE_8
+              write_byte(BYTES_8).write_byte(size)
+            elsif size < PLUS_2_TO_THE_16
+              write_byte(BYTES_16).write_short(size)
+            else
+              write_byte(BYTES_32).write_int(size)
+            end
+          end
+
+          def pack_string_header(size)
+            if size < 0x10
+              write_byte(TINY_STRING | size)
+            elsif size < PLUS_2_TO_THE_8
+              write_byte(STRING_8).write_byte(size)
+            elsif size < PLUS_2_TO_THE_16
+              write_byte(STRING_16).write_short(size)
+            else
+              write_byte(STRING_32).write_int(size)
+            end
+          end
+
+          def pack_list_header(size)
+            if size < 0x10
+              write_byte(TINY_LIST | size)
+            elsif size < PLUS_2_TO_THE_8
+              write_byte(LIST_8).write_byte(size)
+            elsif size < PLUS_2_TO_THE_16
+              write_byte(LIST_16).write_short(size)
+            else
+              write_byte(LIST_32).write_int(size)
+            end
+          end
+
+          def pack_map_header(size)
+            if size < 0x10
+              write_byte(TINY_MAP | size)
+            elsif size < PLUS_2_TO_THE_8
+              write_byte(MAP_8).write_byte(size)
+            elsif size < PLUS_2_TO_THE_16
+              write_byte(MAP_16).write_short(size)
+            else
+              write_byte(MAP_32).write_int(size)
+            end
+          end
+
+          def pack_struct_header(size, signature)
+            if size < 0x10
+              write_byte(TINY_STRUCT | size).write_byte(signature)
+            elsif size size < PLUS_2_TO_THE_8
+              write_byte(STRUCT_8).write_byte(size).write_byte(signature)
+            elsif size < PLUS_2_TO_THE_16
+              write_byte(STRUCT_16).write_short(size).write_byte(signature)
+            else
+              raise Overflow, "Structures cannot have more than #{PLUS_2_TO_THE_16 - 1} fields"
+            end
+          end
+        end
+
+        module Unpacker
+          include Common
+
+          def unpack_struct_header
+            marker_byte = read_byte
+            marker_high_nibble = marker_byte & 0xF0
+            marker_low_nibble = marker_byte & 0x0F
+
+            return marker_low_nibble if marker_high_nibble == TINY_STRUCT
+
+            case marker_byte
+            when STRUCT_8
+              unpack_u_int8
+            when STRUCT_16
+              unpack_u_int16
+            else
+              raise Unexpected, "Expected a struct, but got: #{marker_byte.to_s(16)}"
+            end
+          end
+
+          def unpack_struct_signature
+            read_byte
+          end
+
+          def unpack_list_header
+            marker_byte = read_byte
+            marker_high_nibble = marker_byte & 0xF0
+            marker_low_nibble = marker_byte & 0x0F
+
+            return marker_low_nibble if marker_high_nibble == TINY_LIST
+
+            case marker_byte
+            when LIST_8
+              unpack_uint8
+            when LIST_16
+              unpack_uint16
+            when LIST_32
+              unpack_uint32
+            else
+              raise Unexpected, "Expected a list, but got: #{(markerByte & 0xFF).to_s(16)}"
+            end
+          end
+
+          def unpack_map_header
+            marker_byte = read_byte
+            marker_high_nibble = marker_byte & 0xF0
+            marker_low_nibble = marker_byte & 0x0F
+
+            return marker_low_nibble if marker_high_nibble == TINY_MAP
+
+            case marker_byte
+            when MAP_8
+              unpack_u_int8
+            when MAP_16
+              unpack_u_int16
+            when MAP_32
+              unpack_u_int32
+            else
+              raise Unexpected, "Expected a map, but got: #{marker_byte.to_s(16)}"
+            end
+          end
+
+          def unpack_long(marker_byte)
+            return marker_byte if marker_byte >= MINUS_2_TO_THE_4
+            marker_byte &= 0xFF
+            case marker_byte
+            when INT_8
+              read_byte
+            when INT_16
+              read_short
+            when INT_32
+              read_int
+            when INT_64
+              read_long
+            else
+              raise Unexpected, "Expected an integer, but got: #{marker_byte.to_s(16)}"
+            end
+          end
+
+          def unpack_double
+            read_double
+          end
+
+          def unpack_bytes(size)
+            read_exactly(size)
+          end
+
+          def unpack_string(size)
+            read_exactly(size).force_encoding(Encoding::UTF_8)
+          end
+        end
+
+        class PackStreamException < IOError
+        end
+
+        class EndOfStream < PackStreamException
+        end
+
+        class Overflow < PackStreamException
+        end
+
+        class Unexpected < PackStreamException
+        end
+
+        class UnPackable < PackStreamException
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/packstream/pack_type.rb

@@ -0,0 +1,17 @@
+module Neo4j::Driver
+  module Internal
+    module Packstream
+      class PackType
+        NULL = :null
+        BOOLEAN = :boolean
+        INTEGER = :integer
+        FLOAT = :float
+        BYTES = :bytes
+        STRING = :string
+        LIST = :list
+        MAP = :map
+        STRUCT = :struct
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Neo4j::Driver
+  module Internal
+    class ReadOnlyBookmarkHolder
+      attr_reader :bookmark
+
+      def initialize(bookmark = InternalBookmark.empty)
+        @bookmark = bookmark
+      end
+
+      def bookmark=(_value) end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Neo4j::Driver
+  module Internal
+    class ResolvedBoltServerAddress < BoltServerAddress
+      MAX_HOST_ADDRESSES_IN_STRING_VALUE = 5
+
+      def initialize(host, port, *resolved_addresses_arr)
+        super(host: host, port: port)
+        if resolved_addresses_arr.empty?
+          raise ArgumentError,
+                'The resolvedAddressesArr must not be empty, check your DomainNameResolver is compliant with the interface contract'
+        end
+        @resolved_addresses = resolved_addresses_arr.to_set.freeze
+        @string_value = create_string_representation
+      end
+
+      def unicast_stream
+        @resolved_addresses
+          .map { |address| BoltServerAddress.new(host: host, connection_host: address.ip_address, port: port) }
+      end
+
+      def to_s
+        @string_value
+      end
+
+      def attributes
+        super + [@resolved_addresses]
+      end
+
+      def create_string_representation
+        host_addresses = @resolved_addresses.take(MAX_HOST_ADDRESSES_IN_STRING_VALUE).map(&:ip_address).join(',')
+        "#{host}(#{host_addresses}#{',...' if @resolved_addresses.size > MAX_HOST_ADDRESSES_IN_STRING_VALUE}):#{port}"
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/retry/exponential_backoff_retry_logic.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver
+  module Internal
+    module Retry
+      class ExponentialBackoffRetryLogic
+        DEFAULT_MAX_RETRY_TIME = 30.seconds
+        INITIAL_RETRY_DELAY = 1.second
+        RETRY_DELAY_MULTIPLIER = 2.0
+        RETRY_DELAY_JITTER_FACTOR = 0.2
+
+        def initialize(max_retry_time, event_executor_group, logger = nil)
+          @max_retry_time = max_retry_time || DEFAULT_MAX_RETRY_TIME
+          @event_executor_group = event_executor_group
+          @log = logger
+        end
+
+        def retry
+          errors = nil
+          start_time = nil
+          next_delay = INITIAL_RETRY_DELAY
+          begin
+            yield
+          rescue StandardError => error
+            if can_retry_on?(error)
+              curr_time = Util::Clock::System.time
+              start_time ||= curr_time
+              elapsed_time = curr_time - start_time
+              if elapsed_time < @max_retry_time
+                delay_with_jitter = compute_delay_with_jitter(next_delay)
+                @log&.warn { "Transaction failed and will be retried in #{delay_with_jitter}ms\n#{error}" }
+                sleep(delay_with_jitter)
+                next_delay *= RETRY_DELAY_MULTIPLIER
+                errors = record_error(error, errors)
+                retry
+              end
+            end
+            add_suppressed(error, errors)
+            raise error
+          end
+        end
+
+        def retry_async(&work)
+          result_future = Concurrent::Promises.resolvable_future
+          execute_work_in_event_loop(result_future, &work)
+          result_future
+        end
+
+        protected
+
+        def can_retry_on?(error)
+          error.is_a?(Exceptions::SessionExpiredException) ||
+            error.is_a?(Exceptions::ServiceUnavailableException) ||
+            transient_error?(error)
+        end
+
+        private
+
+        def extract_possible_termination_cause(error)
+          # Having a dedicated "TerminatedException" inheriting from ClientException might be a good idea.
+          error.is_a? Exceptions::ClientException && error.cause || error
+        end
+
+        def execute_work_in_event_loop(result_future, &work)
+          # this is the very first time we execute given work
+          event_executor = @event_executor_group.next
+
+          event_executor.execute do
+            execute_work(result_future, -1, INITIAL_RETRY_DELAY, nil, &work)
+          end
+        end
+
+        def retry_work_in_event_loop(result_future, error, start_time, delay, errors, &work)
+          # work has failed before, we need to schedule retry with the given delay
+          event_executor = event_executor_group.next
+
+          delay_with_jitter = compute_delay_with_jitter(delay)
+          @log.warn("Async transaction failed and is scheduled to retry in " + delay_with_jitter + "s", error);
+
+          event_executor.schedule(->() { execute_work(result_future, start_time, delay * multiplier, errors, &work) },
+                                  DurationNormalizer.milliseconds(delay_with_jitter),
+                                  java.util.concurrent.TimeUnit::MILLISECONDS)
+        end
+
+        def execute_work(result_future, start_time, retry_delay, errors, &work)
+          begin
+            work_stage = work.call
+          rescue StandardError => error
+            # work failed in a sync way, attempt to schedule a retry
+            retry_on_error(result_future, start_time, retry_delay, error, errors, &work)
+            return
+          end
+
+          work_stage.on_resolution do |fulfilled, result, completion_error|
+            error = Futures.completion_exception_cause(completion_error)
+            if error
+              # work failed in async way, attempt to schedule a retry
+              retry_on_error(result_future, work, start_time, retry_delay, error, errors)
+            else
+              result_future.fulfill(result)
+            end
+          end
+        end
+
+        def retry_on_error(result_future, start_time, retry_delay, throwable, errors, &work)
+          error = extract_possible_termination_cause(throwable)
+          if can_retry_on?(error)
+            current_time = Util::Clock::System.time
+            start_time ||= current_time
+
+            elapsed_time = current_time - start_time
+            if elapsed_time < @max_retry_time
+              errors = record_error(error, errors)
+              retry_work_in_event_loop(result_future, error, start_time, retry_delay, errors, &work)
+              return
+            end
+          end
+
+          add_suppressed(throwable, errors)
+          result_future.reject(throwable)
+        end
+
+        def compute_delay_with_jitter(delay)
+          jitter = delay * RETRY_DELAY_JITTER_FACTOR
+          min = delay - jitter
+          max = delay + jitter
+          @rand ||= Random.new
+          @rand.rand(min..max)
+        end
+
+        def transient_error?(error)
+          # Retries should not happen when transaction was explicitly terminated by the user.
+          # Termination of transaction might result in two different error codes depending on where it was
+          # terminated. These are really client errors but classification on the server is not entirely correct and
+          # they are classified as transient.
+          error.is_a?(Exceptions::TransientException) &&
+            !%w[Neo.TransientError.Transaction.Terminated Neo.TransientError.Transaction.LockClientStopped]
+               .include?(error.code)
+        end
+
+        def record_error(error, errors)
+          (errors || []) << error
+        end
+
+        def add_suppressed(error, suppressed_errors)
+          suppressed_errors&.reject(&error.method(:equal?))&.each(&error.method(:add_suppressed)) if error.is_a? Exceptions::Neo4jException
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver::Internal
+  module RevocationStrategy
+    # Don't do any OCSP revocation checks, regardless whether there are stapled revocation statuses or not.
+    NO_CHECKS = :no_checks
+
+    # Verify OCSP revocation checks when the revocation status is stapled to the certificate, continue if not.
+    VERIFY_IF_PRESENT = :verify_if_present
+
+    # Require stapled revocation status and verify OCSP revocation checks,
+    # fail if no revocation status is stapled to the certificate.
+    STRICT = :strict
+
+    def self.requires_revocation_checking?(revocation_strategy)
+      revocation_strategy == STRICT || revocation_strategy == VERIFY_IF_PRESENT
+    end
+  end
+end