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

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

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

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

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

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

@@ -1,48 +0,0 @@
-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)
-          new(true, all_context(requires_hostname_verification), requires_hostname_verification, revocation_strategy)
-        end
-
-        def for_custom_ca_signed_certificates(cert_files, requires_hostname_verification, revocation_strategy)
-          new(true, custom_ca_signed_context(cert_files, requires_hostname_verification),
-              requires_hostname_verification, revocation_strategy)
-        end
-
-        def for_system_ca_signed_certificates(requires_hostname_verification, revocation_strategy)
-          new(true, ca_signed_context(requires_hostname_verification), requires_hostname_verification,
-              revocation_strategy)
-        end
-
-        def insecure
-          new(false, nil, false, RevocationStrategy::NO_CHECKS)
-        end
-
-        private
-
-        def all_context(requires_hostname_verification)
-          ssl_context(verify_mode: OpenSSL::SSL::VERIFY_NONE, verify_hostname: requires_hostname_verification)
-        end
-
-        def ca_signed_context(requires_hostname_verification)
-          ssl_context(verify_hostname: requires_hostname_verification)
-        end
-
-        def custom_ca_signed_context(cert_files, requires_hostname_verification)
-          ssl_context(
-            cert_store: OpenSSL::X509::Store.new.tap do |store|
-              cert_files.each(&store.method(:add_file))
-            end,
-            verify_hostname: requires_hostname_verification)
-        end
-
-        def ssl_context(**params)
-          OpenSSL::SSL::SSLContext.new.tap { |context| context.set_params(params) }
-        end
-      end
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j::Driver
-  module Internal
-    class SecuritySetting
-      include Scheme
-
-      attr_reader :encrypted, :trust_strategy, :customized
-
-      def initialize(encrypted, trust_strategy, customized)
-        @encrypted = encrypted
-        @trust_strategy = trust_strategy
-        @customized = customized
-      end
-
-      def create_security_plan(uri_scheme)
-        validate_scheme!(uri_scheme)
-        if security_scheme?(uri_scheme)
-          assert_security_settings_not_user_configured(uri_scheme)
-          create_security_plan_from_scheme(uri_scheme)
-        else
-          create_security_plan_impl(encrypted, trust_strategy)
-        end
-      rescue IOError
-        raise Neo4j::Driver::Exceptions::ClientException, 'Unable to establish SSL parameters'
-      end
-
-      def create_security_plan_from_scheme(uri_scheme)
-        if high_trust_scheme?(uri_scheme)
-          Security::SecurityPlanImpl.for_system_ca_signed_certificates(true, RevocationStrategy::NO_CHECKS)
-        else
-          Security::SecurityPlanImpl.for_all_certificates(false, RevocationStrategy::NO_CHECKS)
-        end
-      end
-
-      private
-
-      def assert_security_settings_not_user_configured(uri_scheme)
-        if customized
-          raise Neo4j::Driver::Exceptions::ClientException,
-                "Scheme #{uri_scheme} is not configurable with manual encryption and trust settings"
-        end
-      end
-
-      def create_security_plan_impl(encrypted, trust_strategy)
-        return Security::SecurityPlanImpl.insecure unless encrypted
-
-        hostname_verification_enabled = trust_strategy.hostname_verification_enabled?
-        revocation_strategy = trust_strategy.revocation_strategy
-
-        case trust_strategy.strategy
-        when Config::TrustStrategy::TRUST_CUSTOM_CA_SIGNED_CERTIFICATES
-          Security::SecurityPlanImpl.for_custom_ca_signed_certificates(
-            trust_strategy.cert_files, hostname_verification_enabled, revocation_strategy)
-        when Config::TrustStrategy::TRUST_SYSTEM_CA_SIGNED_CERTIFICATES
-          Security::SecurityPlanImpl
-            .for_system_ca_signed_certificates(hostname_verification_enabled, revocation_strategy)
-        when Config::TrustStrategy::TRUST_ALL_CERTIFICATES
-          Security::SecurityPlanImpl.for_all_certificates(hostname_verification_enabled, revocation_strategy)
-        else
-          raise ClientException, "Unknown TLS authentication strategy: #{trust_strategy.strategy}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    class SessionFactoryImpl
-      attr_reader :connection_provider
-      delegate :verify_connectivity, :close, :supports_multi_db?, to: :connection_provider
-
-      def initialize(connection_provider, retry_logic, config)
-        @connection_provider = connection_provider
-        @leaked_sessions_logging_enabled = config[:leaked_session_logging]
-        @retry_logic = retry_logic
-        @logger = config[:logger]
-        @default_fetch_size = config[:fetch_size]
-      end
-
-      def new_instance(fetch_size: @default_fetch_size, default_access_mode: AccessMode::WRITE, **config)
-        bookmark_holder = DefaultBookmarkHolder.new(InternalBookmark.from(*config[:bookmarks]))
-        create_session(parse_database_name(config), default_access_mode, bookmark_holder, fetch_size, config[:impersonated_user])
-      end
-
-      private
-
-      def parse_database_name(config)
-        config[:database]&.then(&DatabaseNameUtil.method(:database)) || DatabaseNameUtil.default_database
-      end
-
-      def create_session(database_name, mode, bookmark_holder, fetch_size, impersonated_user)
-        (@leaked_sessions_logging_enabled ? org.neo4j.driver.internal.async.LeakLoggingNetworkSession : Async::NetworkSession)
-          .new(@connection_provider, @retry_logic, database_name, mode, bookmark_holder, impersonated_user, fetch_size, @logger)
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/spi/connection.rb

@@ -1,19 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Spi
-      module Connection
-        def mode
-          raise java.lang.UnsupportedOperationException, "#{self.class} does not support access mode."
-        end
-
-        def database_name
-          raise java.lang.UnsupportedOperationException, "#{self.class} does not support database name."
-        end
-
-        def impersonated_user
-          raise java.lang.UnsupportedOperationException, "#{self.class} does not support impersonated user."
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/spi/connection_pool.rb

@@ -1,9 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Spi
-      module ConnectionPool
-        CONNECTION_POOL_CLOSED_ERROR_MESSAGE = 'Pool closed'
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/spi/response_handler.rb

@@ -1,23 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Spi
-      module ResponseHandler
-        # Tells whether this response handler is able to manage auto-read of the underlying connection using {@link Connection#enableAutoRead()} and
-        # {@link Connection#disableAutoRead()}.
-        # <p>
-        # Implementations can use auto-read management to apply network-level backpressure when receiving a stream of records.
-        # There should only be a single such handler active for a connection at one point in time. Otherwise, handlers can interfere and turn on/off auto-read
-        # racing with each other. {@link InboundMessageDispatcher} is responsible for tracking these handlers and disabling auto-read management to maintain just
-        # a single auto-read managing handler per connection.
-        def can_manage_auto_read?
-          false
-        end
-        
-        # If this response handler is able to manage auto-read of the underlying connection, then this method signals it to
-        # stop changing auto-read setting for the connection.
-        def disable_auto_read_management
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/summary/internal_database_info.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j::Driver::Internal::Summary
-  class InternalDatabaseInfo < Struct.new(:name)
-    DEFAULT_DATABASE_INFO = new
-  end
-end

data/ruby/neo4j/driver/internal/summary/internal_input_position.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j::Driver::Internal::Summary
-  # Creating a position from and offset, line number and a column number.
-  #
-  # @param offset the offset from the start of the string, starting from 0.
-  # @param line the line number, starting from 1.
-  # @param column the column number, starting from 1.
-  class InternalInputPosition < Struct.new(:offset, :line, :column)
-  end
-end

data/ruby/neo4j/driver/internal/summary/internal_notification.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j::Driver::Internal::Summary
-  class InternalNotification < Struct.new(:code, :title, :description, :severity, :position)
-
-    VALUE_TO_NOTIFICATION = lambda do |value|
-      severity = value[:severity] || 'N/A'
-
-      position = value[:position]&.then do |pos_value|
-        InternalInputPosition.new(*pos_value.values_at(:offset, :line, :column).map(&:to_i))
-      end
-
-      InternalNotification.new(*value.values_at(:code, :title, :description), severity, position)
-    end
-  end
-end

data/ruby/neo4j/driver/internal/summary/internal_plan.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j::Driver::Internal::Summary
-  # Only call #initialize when sub-classing, for constructing plans, use .plan instead
-  class InternalPlan < Struct.new(:operator_type, :arguments, :identifiers, :children)
-    # Since a plan with or without profiling looks almost the same, we just keep two impls. of this
-    # around to contain the small difference, and share the rest of the code for building plan trees.
-    # @param <T>
-
-    class Converter
-      def initialize(&plan_creator)
-        @plan_creator = plan_creator
-      end
-
-      def apply(plan)
-        operator_type = plan[:operatorType]
-
-        arguments_value = plan[:args]
-        arguments = arguments_value || {}
-
-        identifiers_value = plan[:identifiers]
-        identifiers = identifiers_value || []
-
-        children_value = plan[:children]
-        children = children_value || []
-
-        @plan_creator.call(operator_type, arguments, identifiers, children, plan)
-      end
-    end
-
-    EXPLAIN_PLAN = lambda { |operator_type, arguments, identifiers, children, _original_plan_value|
-      new(operator_type, arguments, identifiers, children) }
-
-    # Builds a regular plan without profiling information - eg. a plan that came as a result of an `EXPLAIN` query
-    EXPLAIN_PLAN_FROM_VALUE = Converter.new(&EXPLAIN_PLAN).method(:apply)
-
-    def self.plan(operator_type, arguments, identifiers, children)
-      EXPLAIN_PLAN.call(operator_type, arguments, identifiers, children, nil)
-    end
-  end
-end

data/ruby/neo4j/driver/internal/summary/internal_profiled_plan.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j::Driver::Internal::Summary
-  class InternalProfiledPlan < InternalPlan
-    attr_reader :db_hits, :records, :page_cache_hits, :page_cache_misses, :page_cache_hit_ratio, :time
-
-    PROFILED_PLAN = lambda { |operator_type, arguments, identifiers, children, original_plan_value|
-      new(
-        operator_type, arguments, identifiers, children, original_plan_value[:db_hits].to_i,
-        original_plan_value[:rows].to_i, original_plan_value[:page_cache_hits].to_i,
-        original_plan_value[:page_cache_misses].to_i, original_plan_value[:page_cache_hit_ratio].to_f,
-        original_plan_value[:time].to_i
-      ) }
-
-    # Builds a regular plan without profiling information - eg. a plan that came as a result of an `EXPLAIN` query
-    PROFILED_PLAN_FROM_VALUE = Converter.new(&PROFILED_PLAN).method(:apply)
-
-    def initialize(operator_type, arguments, identifiers, children, db_hits, records, page_cache_hits, page_cache_misses, page_cache_hit_ratio, time)
-      super(operator_type, arguments, identifiers, children)
-      @db_hits = db_hits
-      @records = records
-      @page_cache_hits = page_cache_hits
-      @page_cache_misses = page_cache_misses
-      @page_cache_hit_ratio = page_cache_hit_ratio
-      @time = time
-    end
-
-    def page_cache_stats?
-      page_cache_hits.positive? || page_cache_misses.positive? || page_cache_hit_ratio.positive?
-    end
-  end
-end

data/ruby/neo4j/driver/internal/summary/internal_result_summary.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j::Driver::Internal::Summary
-  class InternalResultSummary < Struct.new(:query, :server, :database, :query_type, :counters, :plan, :profile,
-                                           :notifications, :result_available_after, :result_consumed_after)
-    alias has_plan? plan
-    alias has_profile? profile
-
-    def initialize(*args)
-      super
-      self.plan = resolve_plan(plan, profile)
-    end
-
-    def counters
-      super || InternalSummaryCounters::EMPTY_STATS
-    end
-
-    def notifications
-      super || []
-    end
-
-    private
-
-    # Profiled plan is a superset of plan. This method returns profiled plan if plan is {@code null}.
-    #
-    # @param plan the given plan, possibly {@code null}.
-    # @param profiled_plan the given profiled plan, possibly {@code null}.
-    # @return available plan.
-    def resolve_plan(plan, profiled_plan)
-      plan || profiled_plan
-    end
-  end
-end

data/ruby/neo4j/driver/internal/summary/internal_server_info.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j::Driver::Internal::Summary
-  class InternalServerInfo < Struct.new(:agent, :address, :version, :protocol_version)
-  end
-end

data/ruby/neo4j/driver/internal/summary/internal_summary_counters.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j::Driver::Internal::Summary
-  class InternalSummaryCounters < Struct.new(:nodes_created, :nodes_deleted, :relationships_created,
-                                             :relationships_deleted, :properties_set, :labels_added, :labels_removed,
-                                             :indexes_added, :indexes_removed, :constraints_added, :constraints_removed,
-                                             :system_updates)
-    EMPTY_STATS = InternalSummaryCounters.new(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
-
-    def contains_updates?
-      any?(&:positive?)
-    end
-
-    def contains_system_updates?
-      system_updates.positive?
-    end
-  end
-end