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

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(BYTES_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/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))
+        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

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

@@ -0,0 +1,32 @@
+module Neo4j::Driver::Internal::Scheme
+  BOLT_URI_SCHEME = 'bolt'
+  BOLT_HIGH_TRUST_URI_SCHEME = 'bolt+s'
+  BOLT_LOW_TRUST_URI_SCHEME = 'bolt+ssc'
+  NEO4J_URI_SCHEME = 'neo4j'
+  NEO4J_HIGH_TRUST_URI_SCHEME = 'neo4j+s'
+  NEO4J_LOW_TRUST_URI_SCHEME = 'neo4j+ssc'
+
+  def validate_scheme!(scheme)
+    unless [BOLT_URI_SCHEME, BOLT_LOW_TRUST_URI_SCHEME, BOLT_HIGH_TRUST_URI_SCHEME, NEO4J_URI_SCHEME,
+            NEO4J_LOW_TRUST_URI_SCHEME, NEO4J_HIGH_TRUST_URI_SCHEME].include?(scheme)
+      raise ArgumentError, scheme ? "Invalid address format #{scheme}" : 'Scheme must not be null'
+    end
+  end
+
+  def high_trust_scheme?(scheme)
+    [BOLT_HIGH_TRUST_URI_SCHEME, NEO4J_HIGH_TRUST_URI_SCHEME].include?(scheme)
+  end
+
+  def low_trust_scheme?(scheme)
+    [BOLT_LOW_TRUST_URI_SCHEME, NEO4J_LOW_TRUST_URI_SCHEME].include?(scheme)
+  end
+
+  def security_scheme?(scheme)
+    [BOLT_LOW_TRUST_URI_SCHEME, NEO4J_LOW_TRUST_URI_SCHEME, BOLT_HIGH_TRUST_URI_SCHEME, NEO4J_HIGH_TRUST_URI_SCHEME]
+      .include?(scheme)
+  end
+
+  def routing_scheme?(scheme)
+    [NEO4J_LOW_TRUST_URI_SCHEME, NEO4J_HIGH_TRUST_URI_SCHEME, NEO4J_URI_SCHEME].include?(scheme)
+  end
+end

data/ruby/neo4j/driver/internal/security/internal_auth_token.rb

@@ -0,0 +1,15 @@
+module Neo4j::Driver
+  module Internal
+    module Security
+      # A simple common token for authentication schemes that easily convert to
+      # an auth token map
+      class InternalAuthToken < Hash
+        SCHEME_KEY = :scheme
+        PRINCIPAL_KEY = :principal
+        CREDENTIALS_KEY = :credentials
+        REALM_KEY = :realm
+        PARAMETERS_KEY = :parameters
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/security/security_plan_impl.rb

@@ -0,0 +1,92 @@
+module Neo4j::Driver::Internal
+  module Security
+    class SecurityPlanImpl < Struct.new(:requires_encryption, :ssl_context, :requires_hostname_verification,
+                                        :revocation_strategy)
+      class << self
+        def for_all_certificates(requires_hostname_verification, revocation_strategy)
+          ssl_context = javax.net.ssl.SSLContext.get_instance('TLS')
+          ssl_context.init(javax.net.ssl.KeyManager[0].new, [TrustAllTrustManager.new].to_java(javax.net.ssl.KeyManager), nil)
+          new(true, ssl_context, requires_hostname_verification, revocation_strategy)
+        end
+
+        def for_custom_ca_signed_certificate(cert_file, requires_hostname_verification, revocation_strategy)
+          ssl_context = config_ssl_context(cert_file, revocation_strategy)
+          new(true, ssl_context, requires_hostname_verification, revocation_strategy)
+        end
+
+        def for_system_ca_signed_certificate(requires_hostname_verification, revocation_strategy)
+          ssl_context = config_ssl_context(nil, revocation_strategy)
+          new(true, ssl_context, requires_hostname_verification, revocation_strategy)
+        end
+
+        def insecure
+          new(false, nil, false, RevocationStrategy::NO_CHECKS)
+        end
+
+        private
+
+        def configure_ssl_context(custom_cert_file, revocation_strategy)
+          trusted_key_store = java.security.KeyStore.get_instance(java.security.KeyStore.get_default_type)
+          trusted_key_store.load(nil, nil)
+
+          if !custom_cert_file.nil?
+            Util::CertificateTool.loadX509_cert(custom_cert_file, trusted_key_store)
+          else
+            load_system_certificates(trusted_key_store)
+          end
+
+          pkix_builder_parameters = java.security.cert.PKIXBuilderParameters.new(trusted_key_store, java.security.cert.X509CertSelector.new)
+          pkix_builder_parameters.set_revocation_enabled(RevocationStrategy.requires_revocation_checking?(revocation_strategy))
+
+          if RevocationStrategy.requires_revocation_checking?(revocation_strategy)
+            java.lang.System.set_property('jdk.tls.client.enableStatusRequestExtension', true)
+            if revocation_strategy == RevocationStrategy::VERIFY_IF_PRESENT
+              java.security.Security.set_property('ocsp.enable', true)
+            end
+          end
+
+          ssl_context = javax.net.ssl.SSLContext.get_instance('TLS')
+
+          trust_manager_factory = javax.net.ssl.TrustManager.get_instance(javax.net.ssl.TrustManagerFactory.get_default_algorithm)
+          trust_manager_factory.init(javax.net.ssl.CertPathTrustManagerParameters.new(pkix_builder_parameters))
+          ssl_context.init(javax.net.ssl.KeyManager[0].new, trust_manager_factory.get_trust_managers, nil)
+          ssl_context
+        end
+
+        def load_system_certificates(trusted_key_store)
+          temp_factory = javax.net.ssl.TrustManagerFactory.get_instance(javax.net.ssl.TrustManagerFactory.get_default_algorithm)
+          temp_factory.init(nil)
+
+          x509_trust_manager = nil
+          temp_factory.get_trust_managers.each do |trust_manager|
+            if trust_manager.is_a?(javax.net.ssl.X509TrustManager)
+              x509_trust_manager = javax.net.ssl.X509TrustManager.java_class.cast(trust_manager)
+              break
+            end
+          end
+
+          if x509_trust_manager.nil?
+            raise Neo4j::Driver::Exceptions::CertificateException, 'No system certificates found'
+          else
+            Util::CertificateTool.load_x509_cert(x509_trust_manager.get_accepted_issuer, trusted_key_store)
+          end
+        end
+      end
+
+      class TrustAllTrustManager
+        def check_client_trusted(chain, auth_type)
+          raise Neo4j::Driver::Exceptions::CertificateException, 'All client connections to this client are forbidden.'
+        end
+
+        def check_server_trusted(chain, auth_type)
+        end
+
+        def get_accepted_issuers
+          java.security.cert.X509Certificate[0].new
+        end
+      end
+
+      private_constant :TrustAllTrustManager
+    end
+  end
+end