neo4j-ruby-driver 1.7.5 → 4.4.0.alpha.2

data/ffi/neo4j/driver/internal/handlers/response_handler.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Handlers
-        class ResponseHandler
-          include ErrorHandling
-
-          delegate :bolt_connection, to: :connection
-          attr_reader :connection, :failure
-          attr_accessor :request, :previous
-
-          def initialize(connection)
-            @connection = connection
-          end
-
-          def finalize
-            return if @finished
-            @finished = true
-            begin
-              previous&.finalize
-            ensure
-              Bolt::Connection.fetch_summary(bolt_connection, request)
-              check_summary_failure
-            end
-          end
-
-          private
-
-          def check_summary_failure
-            summary
-            if Bolt::Connection.summary_success(bolt_connection) == 1
-              after_success(nil)
-            else
-              return if previous&.failure
-              failure = Value::ValueAdapter.to_ruby(Bolt::Connection.failure(bolt_connection))
-              raise @failure = new_neo4j_error(**failure)
-            end
-          end
-
-          def summary; end
-
-          def after_success(metadata); end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/handlers/run_response_handler.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Handlers
-        class RunResponseHandler < ResponseHandler
-          attr_reader :result_available_after
-
-          def initialize(connection, metadata_extractor)
-            super(connection)
-            @statement_keys = []
-            @metadata_extractor = metadata_extractor
-          end
-
-          def statement_keys
-            finalize
-            @statement_keys
-          end
-
-          def finalize
-            return if @finished
-            super
-            @statement_keys = Value::ValueAdapter.to_ruby(Bolt::Connection.field_names(bolt_connection)).map(&:to_sym)
-            metadata = Value::ValueAdapter.to_ruby(Bolt::Connection.metadata(bolt_connection))
-            @result_available_after = metadata[:result_available_after] || metadata[:t_first]
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/handlers/session_pull_all_response_handler.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Handlers
-        class SessionPullAllResponseHandler < PullAllResponseHandler
-          def initialize(statement, run_handler, connection, bookmarks_holder, metadata_extractor)
-            super(statement, run_handler, connection, metadata_extractor)
-            @bookmarks_holder = bookmarks_holder
-          end
-
-          def after_success(metadata)
-            @bookmarks_holder.bookmarks = connection.last_bookmark
-            release_connection
-            # @bookmarks_holder.bookmarks = @metadata_extractor.extract_bookmarks(metadata)
-          end
-
-          def after_failure(_error)
-            release_connection
-          end
-
-          private
-
-          def release_connection
-            connection.release
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/handlers/transaction_pull_all_response_handler.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Handlers
-        class TransactionPullAllResponseHandler < PullAllResponseHandler
-          def initialize(statement, run_handler, connection, tx, metadata_extractor)
-            super(statement, run_handler, connection, metadata_extractor)
-            @tx = tx
-            @tx.chain run_handler, self
-          end
-
-          def after_success(_metadata); end
-
-          def after_failure(_error)
-            @tx.mark_terminated
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/internal_driver.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      class InternalDriver
-        extend AutoClosable
-        include ErrorHandling
-
-        attr_reader :session_factory
-        delegate :verify_connectivity, to: :session_factory
-        auto_closable :session
-
-        def initialize(session_factory, logger, resolver)
-          @session_factory = session_factory
-          @closed = Concurrent::AtomicBoolean.new(false)
-          # The below hold references to callbacks called from c,
-          # this prevents garbage collection before driver is garbage collected
-          @logger = logger
-          @resolver = resolver
-        end
-
-        def session(*args)
-          new_session(*Neo4j::Driver::Internal::RubySignature.session(args))
-        end
-
-        def close
-          session_factory.close if @closed.make_true
-          # Bolt::Connector.destroy(@connector)
-        end
-
-        private
-
-        def new_session(mode, bookmarks)
-          assert_open
-          session_factory.new_instance(mode, bookmarks)
-        end
-
-        def assert_open
-          raise Exceptions::IllegalStateException, 'This driver instance has already been closed' if @closed.true?
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/internal_logger.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      class InternalLogger
-        include ErrorHandling
-
-        class << self
-          def register(bolt_config, logger)
-            return unless logger
-            new(bolt_config, logger)
-          end
-        end
-
-        def initialize(bolt_config, logger)
-          @logger = logger
-          @funcs = []
-          bolt_log = Bolt::Log.create(nil)
-          %i[error warning info debug].each do |method|
-            Bolt::Log.send("set_#{method}_func", bolt_log, func(method))
-          end
-          check_error Bolt::Config.set_log(bolt_config, bolt_log)
-        end
-
-        def func(method)
-          Proc.new { |_ptr, message| @logger.send(method, message) }.tap(&@funcs.method(:<<))
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/internal_resolver.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      class InternalResolver
-        include ErrorHandling
-
-        class << self
-          def register(bolt_config, resolver)
-            return unless resolver
-            new(bolt_config, resolver)
-          end
-        end
-
-        def initialize(bolt_config, resolver)
-          @address_resolver_func = ->(_ptr, address, set) {
-            resolver.call(BoltServerAddress.new(Bolt::Address.host(address).first,
-                                                Bolt::Address.port(address).first.to_i)).each do |server_address|
-              bolt_address = Bolt::Address.create(server_address.host, server_address.port.to_s)
-              check_error Bolt::AddressSet.add(set, bolt_address)
-            end
-          }
-
-          address_resolver = Bolt::AddressResolver.create(nil, @address_resolver_func)
-          check_error Bolt::Config.set_address_resolver(bolt_config, address_resolver)
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/internal_statement_result.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      class InternalStatementResult
-        include Enumerable
-
-        delegate :consume, :failure, :summary, :finalize, to: :@pull_all_handler
-
-        def initialize(run_handler, pull_all_handler)
-          @run_handler = run_handler
-          @pull_all_handler = pull_all_handler
-        end
-
-        def single
-          @pull_all_handler.next.tap do |record|
-            raise Exceptions::NoSuchRecordException.empty unless record
-            raise Exceptions::NoSuchRecordException.too_many if has_next?
-          end
-        end
-
-        def next
-          @pull_all_handler.next.tap do |record|
-            raise Exceptions::NoSuchRecordException.no_more unless record
-          end
-        end
-
-        def peek
-          @pull_all_handler.peek.tap do |record|
-            raise Exceptions::NoSuchRecordException.no_peek_past unless record
-          end
-        end
-
-        def has_next?
-          @pull_all_handler.peek
-        end
-
-        def each
-          yield @pull_all_handler.next while has_next?
-        end
-
-        def keys
-          @keys ||= begin
-            @pull_all_handler.peek
-            @pull_all_handler.statement_keys
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/messaging/bolt_protocol.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Messaging
-        module BoltProtocol
-          def self.for_version(version)
-            case version
-            when V1::BoltProtocolV1::VERSION
-              V1::BoltProtocolV1::INSTANCE
-            when V2::BoltProtocolV2::VERSION
-              V2::BoltProtocolV2::INSTANCE
-            when V3::BoltProtocolV3::VERSION
-              V3::BoltProtocolV3::INSTANCE
-            else
-              raise Exceptions::ClientException, "Unknown protocol version: #{version}"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/messaging/v1/bolt_protocol_v1.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Messaging
-        module V1
-          class BoltProtocolV1
-            VERSION = 1
-            INSTANCE = new
-
-            METADATA_EXTRACTOR = Util::MetadataExtractor.new('result_available_after', 'result_consumed_after')
-
-            def run_in_auto_commit_transaction(connection, statement, bookmarks_holder, config)
-              # bookmarks are ignored for auto-commit transactions in this version of the protocol
-
-              self.class.tx_config_not_supported if config&.present?
-
-              self.class.run_statement(connection, statement, nil)
-            end
-
-            def run_in_explicit_transaction(connection, statement, tx)
-              self.class.run_statement(connection, statement, tx)
-            end
-
-            class << self
-              def run_statement(connection, statement, tx)
-                query = statement.text
-                params = statement.parameters
-
-                run_handler = Handlers::RunResponseHandler.new(METADATA_EXTRACTOR)
-                pull_all_handler = new_pull_all_handler(statement, run_handler, connection, tx)
-
-                connection.write_and_flush(query, params, run_handler, pull_all_handler)
-                InternalStatementResult.new(run_handler, pull_all_handler)
-              end
-
-              def new_pull_all_handler(statement, run_handler, connection, tx)
-                if tx
-                  Handlers::TransactionPullAllResponseHandler.new(statement, run_handler, connection, tx,
-                                                                  METADATA_EXTRACTOR)
-                else
-                  Handlers::SessionPullAllResponseHandler.new(statement, run_handler, connection,
-                                                              BookmarksHolder::NO_OP, METADATA_EXTRACTOR)
-                end
-              end
-
-              def tx_config_not_supported
-                raise ClientException,
-                      'Driver is connected to the database that does not support transaction configuration. ' \
-                      'Please upgrade to neo4j 3.5.0 or later in order to use this functionality'
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/messaging/v2/bolt_protocol_v2.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Messaging
-        module V2
-          class BoltProtocolV2 < V1::BoltProtocolV1
-            VERSION = 2
-            INSTANCE = new
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/messaging/v3/bolt_protocol_v3.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Messaging
-        module V3
-          class BoltProtocolV3
-            VERSION = 3
-            INSTANCE = new
-            METADATA_EXTRACTOR = Util::MetadataExtractor.new('t_first', 't_last')
-
-            def run_in_auto_commit_transaction(connection, statement, bookmarks_holder, config)
-              self.class.run_statement(connection, statement, bookmarks_holder, nil, config)
-            end
-
-            def run_in_explicit_transaction(connection, statement, tx)
-              self.class.run_statement(connection, statement, BookmarksHolder::NO_OP, tx, nil)
-            end
-
-            def begin_transaction(connection, bookmarks, config)
-              begin_handler = Handlers::ResponseHandler.new(connection)
-              connection.begin(bookmarks, config, begin_handler)
-              connection.flush if bookmarks.present?
-              begin_handler
-            end
-
-            def commit_transaction(connection)
-              Handlers::ResponseHandler.new(connection).tap(&connection.method(:commit))
-            end
-
-            def rollback_transaction(connection)
-              Handlers::ResponseHandler.new(connection).tap(&connection.method(:rollback))
-            end
-
-            class << self
-              def run_statement(connection, statement, boomarks_holder, tx, config)
-                query = statement.text
-                params = statement.parameters
-
-                run_handler = Handlers::RunResponseHandler.new(connection, METADATA_EXTRACTOR)
-                pull_all_handler = new_pull_all_handler(statement, run_handler, connection, boomarks_holder, tx)
-
-                connection.write_and_flush(query, params, boomarks_holder, config, run_handler, pull_all_handler)
-                InternalStatementResult.new(run_handler, pull_all_handler)
-              end
-
-              def new_pull_all_handler(statement, run_handler, connection, bookmarks_holder, tx)
-                if tx
-                  Handlers::TransactionPullAllResponseHandler.new(statement, run_handler, connection, tx,
-                                                                  METADATA_EXTRACTOR)
-                else
-                  Handlers::SessionPullAllResponseHandler.new(statement, run_handler, connection, bookmarks_holder,
-                                                              METADATA_EXTRACTOR)
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/network_session.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      class NetworkSession
-        include BookmarksHolder
-        include ErrorHandling
-        extend AutoClosable
-
-        auto_closable :begin_transaction
-
-        def initialize(connection_provider, mode, retry_logic = nil, logging = nil)
-          super()
-          @open = Concurrent::AtomicBoolean.new(true)
-          @connection_provider = connection_provider
-          @mode = mode
-          @retry_logic = retry_logic
-        end
-
-        def run(statement, parameters = {}, config = {})
-          ensure_session_is_open
-          ensure_no_open_tx_before_running_query
-          acquire_connection(@mode)
-          @result = @connection.protocol.run_in_auto_commit_transaction(
-            @connection, Statement.new(statement, parameters), self, config
-          )
-        end
-
-        def read_transaction(**config, &block)
-          transaction(Neo4j::Driver::AccessMode::READ, config, &block)
-        end
-
-        def write_transaction(**config, &block)
-          transaction(Neo4j::Driver::AccessMode::WRITE, config, &block)
-        end
-
-        def close
-          return unless @open.make_false
-          begin
-            @result&.finalize
-            @result&.failure
-          ensure
-            close_transaction_and_release_connection
-          end
-        end
-
-        def release_connection
-          @connection&.release
-        end
-
-        def begin_transaction(**config)
-          private_begin_transaction(@mode, config)
-        end
-
-        def last_bookmark
-          bookmarks&.max
-        end
-
-        def open?
-          @open.true?
-        end
-
-        private
-
-        def private_begin_transaction(mode, config)
-          ensure_session_is_open
-          ensure_no_open_tx_before_starting_tx
-          acquire_connection(mode)
-          @transaction = ExplicitTransaction.new(@connection, self).begin(bookmarks, config)
-        end
-
-        def transaction(mode, config)
-          @retry_logic.retry do
-            tx = private_begin_transaction(mode, config)
-            result = yield tx
-            tx.success
-            result
-          rescue StandardError => e
-            tx&.failure
-            raise e
-          ensure
-            tx&.close
-          end
-        end
-
-        def acquire_connection(mode)
-          # make sure previous result is fully consumed and connection is released back to the pool
-          @result&.failure
-
-          # there is no unconsumed error, so one of the following is true:
-          #   1) this is first time connection is acquired in this session
-          #   2) previous result has been successful and is fully consumed
-          #   3) previous result failed and error has been consumed
-
-          raise Exceptions::IllegalStateException, 'Existing open connection detected' if @connection&.open?
-          @connection = @connection_provider.acquire_connection(mode)
-        end
-
-        def close_transaction_and_release_connection
-          @transaction&.close
-        ensure
-          @transaction = nil
-          release_connection
-        end
-
-        def ensure_session_is_open
-          return if open?
-          raise Exceptions::ClientException,
-                'No more interaction with this session are allowed as the current session is already closed.'
-        end
-
-        def ensure_no_open_tx_before_running_query
-          ensure_no_open_tx('Statements cannot be run directly on a session with an open transaction; ' \
-                            'either run from within the transaction or use a different session.')
-        end
-
-        def ensure_no_open_tx_before_starting_tx
-          ensure_no_open_tx('You cannot begin a transaction on a session with an open transaction; ' \
-                            'either run from within the transaction or use a different session.')
-        end
-
-        def ensure_no_open_tx(error_message)
-          raise Exceptions::ClientException, error_message if @transaction&.open?
-        end
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module 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 = nil, logger = nil)
-            @max_retry_time = max_retry_time || DEFAULT_MAX_RETRY_TIME
-            @log = logger
-          end
-
-          def retry
-            next_delay = INITIAL_RETRY_DELAY
-            start_time = nil
-            errors = nil
-            begin
-              yield
-            rescue Exceptions::Neo4jException => error
-              if can_retry_on?(error)
-                curr_time = current_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 ||= []) << error
-                  retry
-                end
-              end
-              add_suppressed(error, errors)
-              raise error
-            end
-          end
-
-          private
-
-          def can_retry_on?(error)
-            error.is_a?(Exceptions::SessionExpiredException) ||
-              error.is_a?(Exceptions::ServiceUnavailableException) ||
-              transient_error?(error)
-          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 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 current_time
-            Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          end
-
-          def add_suppressed(error, suppressed_errors)
-            suppressed_errors&.reject(&error.method(:equal?))&.each(&error.method(:add_suppressed))
-          end
-        end
-      end
-    end
-  end
-end