neospace 0.0.1 → 1.7.0

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

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

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

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

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

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

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      class SessionFactoryImpl
+        attr_reader :connection_provider
+        delegate :close, :verify_connectivity, to: :connection_provider
+
+        def initialize(connection_provider, retry_logic, config)
+          @connection_provider = connection_provider
+          @retry_logic = retry_logic
+          @config = config
+        end
+
+        def new_instance(mode, bookmarks)
+          create_session(connection_provider, @retry_logic, mode).tap { |session| session.bookmarks = bookmarks }
+        end
+
+        private
+
+        def create_session(connection_provider, retry_logic, mode, logging = nil)
+          NetworkSession.new(connection_provider, mode, retry_logic, logging)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Summary
+        class InternalResultSummary
+          attr_reader :server, :counters, :statement, :result_available_after, :result_consumed_after
+          delegate :notifications, :profile, to: :@metadata
+
+          def initialize(statement, result_available_after, bolt_connection)
+            @statement = statement
+            @result_available_after = result_available_after
+            @server = InternalServerInfo.new(bolt_connection)
+            @metadata = RecursiveOpenStruct.new(
+              underscore_keys(Value::ValueAdapter.to_ruby(Bolt::Connection.metadata(bolt_connection))),
+              recurse_over_arrays: true
+            )
+            @result_consumed_after = @metadata.result_consumed_after || @metadata.t_last
+            @counters = InternalSummaryCounters.new(@metadata.stats)
+          end
+
+          def notifications
+            @metadata.notifications || []
+          end
+
+          def plan
+            @metadata.plan || profile
+          end
+
+          alias has_plan? plan
+          alias has_profile? profile
+
+          def method_missing(method)
+            @metadata.send(method)
+          end
+
+          private
+
+          def underscore_keys(arg)
+            case arg
+            when Array
+              arg.map(&method(:underscore_keys))
+            when Hash
+              arg.map { |key, value| [translate_key(key), underscore_keys(value)] }.to_h
+            else
+              arg
+            end
+          end
+
+          def translate_key(key)
+            case key
+            when :type
+              :statement_type
+            when :args
+              :arguments
+            when :rows
+              :records
+            else
+              key.to_s.underscore.to_sym
+            end
+          end
+        end
+      end
+    end
+  end
+end