neo4j-ruby-driver 1.7.4 → 4.4.0

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      class DirectConnectionProvider
-        include ErrorHandling
-
-        def initialize(connector, config)
-          @connector = connector
-          @config = config
-        end
-
-        def acquire_connection(mode)
-          Async::DirectConnection.new(@connector, mode, @config)
-        end
-
-        def verify_connectivity
-          acquire_connection(AccessMode::READ).release
-        end
-
-        def close
-          Bolt::Connector.destroy(@connector)
-        end
-      end
-    end
-  end
-end

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

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      class DriverFactory
-        include ErrorHandling
-        BOLT_URI_SCHEME = 'bolt'
-        BOLT_ROUTING_URI_SCHEME = 'bolt+routing'
-        NEO4J_URI_SCHEME = 'neo4j'
-        DEFAULT_PORT = 7687
-
-        def new_instance(uri, auth_token, config)
-          uri = URI(uri)
-          routing_context = routing_context(uri)
-          connector, logger, resolver = create_connector(uri, auth_token, routing_context, config)
-          retry_logic = Retry::ExponentialBackoffRetryLogic.new(config[:max_transaction_retry_time], config[:logger])
-          create_driver(connector, logger, resolver, retry_logic, config).tap(&:verify_connectivity)
-        end
-
-        private
-
-        def create_connector(uri, auth_token, routing_context, config)
-          address = Bolt::Address.create(host(uri).gsub(/^\[(.*)\]$/, '\\1'), port(uri).to_s)
-          bolt_config = bolt_config(config)
-          logger = InternalLogger.register(bolt_config, config[:logger])
-          set_socket_options(bolt_config, config)
-          set_routing_context(bolt_config, routing_context)
-          set_scheme(bolt_config, uri, routing_context)
-          resolver = InternalResolver.register(bolt_config, config[:resolver])
-          [Bolt::Connector.create(address, auth_token, bolt_config), logger, resolver]
-        end
-
-        def bolt_config(config)
-          bolt_config = Bolt::Config.create
-          config.each do |key, value|
-            case key
-            when :max_connection_pool_size
-              check_error Bolt::Config.set_max_pool_size(bolt_config, value)
-            when :max_connection_life_time
-              check_error Bolt::Config.set_max_connection_life_time(bolt_config, DurationNormalizer.milliseconds(value))
-            when :connection_acquisition_timeout
-              check_error Bolt::Config.set_max_connection_acquisition_time(bolt_config,
-                                                                           DurationNormalizer.milliseconds(value))
-            when :encryption
-              check_error Bolt::Config.set_transport(
-                bolt_config,
-                value ? Bolt::Config::BOLT_TRANSPORT_ENCRYPTED : Bolt::Config::BOLT_TRANSPORT_PLAINTEXT
-              )
-            end
-          end
-          check_error Bolt::Config.set_user_agent(bolt_config, "neo4j-ruby-driver #{Neo4j::Driver::VERSION}")
-          bolt_config
-        end
-
-        def set_socket_options(bolt_config, config)
-          socket_options = Bolt::SocketOptions.create
-          config.each do |key, value|
-            case key
-            when :connection_timeout
-              check_error Bolt::SocketOptions.set_connect_timeout(socket_options,
-                                                                  DurationNormalizer.milliseconds(value))
-            when :keep_alive
-              check_error Bolt::SocketOptions.set_keep_alive(socket_options, value ? 1 : 0)
-            end
-          end
-          check_error Bolt::Config.set_socket_options(bolt_config, socket_options)
-        end
-
-        def routing_context(uri)
-          query = uri.query
-          return if query.blank?
-          URI.decode_www_form(query).to_h
-        end
-
-        def set_routing_context(bolt_config, routing_context)
-          value = Bolt::Value.create
-          check_error Bolt::Config.set_routing_context(bolt_config, Value::ValueAdapter.to_neo(value, routing_context))
-        end
-
-        def host(uri)
-          uri.host.tap { |host| raise ArgumentError, "Invalid address format `#{uri}`" unless host }
-        end
-
-        def port(uri)
-          uri.port&.tap { |port| raise ArgumentError, "Illegal port:  #{port}" unless (0..65_535).cover?(port) } ||
-            DEFAULT_PORT
-        end
-
-        def set_scheme(bolt_config, uri, routing_context)
-          check_error Bolt::Config.set_scheme(bolt_config, scheme(uri, routing_context))
-        end
-
-        def scheme(uri, routing_context)
-          scheme = uri.scheme
-          case scheme
-          when BOLT_URI_SCHEME
-            assert_no_routing_context(uri, routing_context)
-            Bolt::Config::BOLT_SCHEME_DIRECT
-          when BOLT_ROUTING_URI_SCHEME, NEO4J_URI_SCHEME
-            Bolt::Config::BOLT_SCHEME_NEO4J
-          else
-            raise Exceptions::ClientException, "Unsupported URI scheme: #{scheme}"
-          end
-        end
-
-        def assert_no_routing_context(uri, routing_context)
-          if routing_context
-            raise ArgumentError, "Routing parameters are not supported with scheme 'bolt'. Given URI: '#{uri}'"
-          end
-        end
-
-        def create_driver(connector, logger, resolver, retry_logic, config)
-          connection_provider = DirectConnectionProvider.new(connector, config)
-          session_factory = create_session_factory(connection_provider, retry_logic, config)
-          InternalDriver.new(session_factory, logger, resolver)
-        end
-
-        def create_session_factory(connection_provider, retry_logic = nil, config = nil)
-          SessionFactoryImpl.new(connection_provider, retry_logic, config)
-        end
-      end
-    end
-  end
-end

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

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module ErrorHandling
-        def check_error(error_code, status = nil)
-          case error_code
-            # Identifies a successful operation which is defined as 0
-          when Bolt::Error::BOLT_SUCCESS # 0
-            nil
-
-            # Permission denied
-          when Bolt::Error::BOLT_PERMISSION_DENIED # 7
-            throw Exceptions::AuthenticationException.new(error_code, 'Permission denied')
-
-            # Connection refused
-          when Bolt::Error::BOLT_CONNECTION_REFUSED # 11
-            throw Exceptions::ServiceUnavailableException.new(error_code, 'unable to acquire connection')
-
-            # Connection pool is full
-          when Bolt::Error::BOLT_POOL_FULL # 0x600
-            throw Exceptions::ClientException.new(
-              error_code,
-              'Unable to acquire connection from the pool within configured maximum time of ' \
-              "#{DurationNormalizer.milliseconds(@config[:connection_acquisition_timeout])}ms"
-            )
-
-            # Routing table retrieval failed
-          when Bolt::Error::BOLT_ROUTING_UNABLE_TO_RETRIEVE_ROUTING_TABLE # 0x800
-            throw Exceptions::ServiceUnavailableException.new(
-              error_code,
-              'Could not perform discovery. No routing servers available.'
-            )
-
-            # Error set in connection
-          when Bolt::Error::BOLT_CONNECTION_HAS_MORE_INFO, Bolt::Error::BOLT_STATUS_SET # 0xFFE, 0xFFF
-            status = Bolt::Connection.status(bolt_connection)
-            unqualified_error(error_code, status)
-          else
-            unqualified_error(error_code, status)
-          end
-        end
-
-        def on_failure(_error); end
-
-        def check_status(status)
-          check_error(Bolt::Status.get_error(status), status)
-        end
-
-        def with_status
-          status = Bolt::Status.create
-          yield status
-        ensure
-          check_status(status)
-        end
-
-        def new_neo4j_error(code:, message:)
-          case code.split('.')[1]
-          when 'ClientError'
-            if code.casecmp('Neo.ClientError.Security.Unauthorized').zero?
-              Exceptions::AuthenticationException
-            else
-              Exceptions::ClientException
-            end
-          when 'TransientError'
-            Exceptions::TransientException
-          else
-            Exceptions::DatabaseException
-          end.new(code, message)
-        end
-
-        private
-
-        def exception_class(state)
-          case state
-          when Bolt::Status::BOLT_CONNECTION_STATE_DEFUNCT
-            Exceptions::SessionExpiredException
-          else
-            Exceptions::Neo4jException
-          end
-        end
-
-        def throw(error)
-          if @failure
-            error.add_suppressed(@failure)
-          else
-            on_failure(error)
-          end
-          raise error
-        end
-
-        def unqualified_error(error_code, status)
-          details = details(error_code, status)
-          throw exception_class(details[:state]).new(error_code,
-                                                     details.map { |key, value| "#{key}: `#{value}`" }.join(', '))
-        end
-
-        def details(error_code, status)
-          details = {
-            code: error_code.to_s(16),
-            error: Bolt::Error.get_string(error_code)
-          }
-          return details unless status
-          details.merge(state: Bolt::Status.get_state(status),
-                        error: Bolt::Status.get_error(status),
-                        error_context: Bolt::Status.get_error_context(status))
-        end
-      end
-    end
-  end
-end

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

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      class ExplicitTransaction
-        include ErrorHandling
-
-        delegate :finalize, to: :@handler
-
-        def initialize(connection, session)
-          @connection = connection
-          @protocol = connection.protocol
-          @session = session
-          @state = :active
-        end
-
-        def begin(initial_bookmarks, config)
-          chain @protocol.begin_transaction(@connection, initial_bookmarks, config)
-          finalize if initial_bookmarks.present?
-          self
-        rescue StandardError => e
-          @connection.release
-          raise e
-        end
-
-        def run(query, parameters = {})
-          ensure_can_run_queries
-          @result&.failure
-          @result = @protocol.run_in_explicit_transaction(@connection, Statement.new(query, parameters), self)
-        end
-
-        def success
-          @state = :marked_success if @state == :active
-        end
-
-        def failure
-          @state = :marked_failed if %i[active marked_success].include? @state
-        end
-
-        def mark_terminated
-          @state = :terminated
-        end
-
-        def close
-          case @state
-          when :marked_success
-            commit
-          when :committed, :rolled_back
-            nil
-          else
-            rollback
-          end
-        end
-
-        def open?
-          !%i[committed rolled_back].include? @state
-        end
-
-        def chain(*handlers)
-          handlers.each do |handler|
-            handler.previous = @handler
-            @handler = handler
-          end
-        end
-
-        private
-
-        def commit
-          case @state
-          when :committed
-            nil
-          when :rolled_back
-            raise Exceptions::ClientExceptiom, "Can't commit, transaction has been rolled back"
-          else
-            begin
-              do_commit
-              # handleCommitOrRollback( error )
-            ensure
-              transaction_closed(:committed)
-            end
-          end
-        end
-
-        def do_commit
-          if @state == :terminated
-            raise Exceptions::ClientException, "Transaction can't be committed. " \
-          'It has been rolled back either because of an error or explicit termination'
-          end
-
-          # @session.bookmarks = @protocol.commit_transaction(@connection)
-          chain @protocol.commit_transaction(@connection)
-          finalize
-          @session.bookmarks = @connection.last_bookmark
-        end
-
-        def rollback
-          case @state
-          when :committed
-            raise ClientException, "Can't rollback, transaction has been committed"
-          when :rolled_back
-            nil
-          else
-            begin
-              do_rollback
-              # resultCursors.retrieveNotConsumedError()
-              # handleCommitOrRollback( error )
-            ensure
-              transaction_closed(:rolled_back)
-            end
-          end
-        end
-
-        def do_rollback
-          return if @state == :terminated
-
-          chain @protocol.rollback_transaction(@connection)
-          finalize
-        end
-
-        def transaction_closed(new_state)
-          @state = new_state
-          @session.release_connection
-        end
-
-        def ensure_can_run_queries
-          reason =
-            case @state
-            when :committed
-              'Cannot run more statements in this transaction, it has been committed'
-            when :rolled_back
-              'Cannot run more statements in this transaction, it has been rolled back'
-            when :marked_failed
-              'Cannot run more statements in this transaction, it has been marked for failure. ' \
-            'Please either rollback or close this transaction'
-            when :terminated
-              'Cannot run more statements in this transaction, ' \
-            'it has either experienced an fatal error or was explicitly terminated'
-            end
-
-          raise Exceptions::ClientException, reason if reason
-        end
-      end
-    end
-  end
-end

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

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Handlers
-        class PullAllResponseHandler < ResponseHandler
-          delegate :bolt_connection, to: :connection
-          delegate :statement_keys, to: :run_handler
-          attr_reader :connection
-
-          def initialize(statement, run_handler, connection, metadata_extractor)
-            super(connection)
-            @statement = statement
-            @previous = run_handler
-            @metadate_extractor = metadata_extractor
-            @records = []
-          end
-
-          def consume
-            @ignore_records = true
-            @records.clear
-            finalize
-            @summary
-          rescue StandardError => e
-            on_failure(e)
-            raise e
-          end
-
-          def summary
-            unless @finished
-              while (record = fetch)
-                @records << record
-              end
-            end
-            @summary ||= Summary::InternalResultSummary.new(@statement, run_handler.result_available_after,
-                                                            bolt_connection)
-          end
-
-          def peek
-            @records.first || ((@records << fetch).first unless @finished)
-          end
-
-          def next
-            peek
-            @records.shift
-          end
-
-          def on_success
-            @finished = true
-            summary
-
-            after_success(nil)
-
-            @failure = nil
-          end
-
-          def failure
-            summary
-            super
-          end
-
-          def on_failure(error)
-            @failure = error
-            summary
-            @finished = true
-
-            after_failure(error)
-          end
-
-          def finalize
-            summary unless @ignore_records
-            super
-          end
-
-          private
-
-          def run_handler
-            @previous
-          end
-
-          def fetch
-            run_handler.finalize
-            bolt_connection_fetch = Bolt::Connection.fetch(bolt_connection, request)
-            case bolt_connection_fetch
-            when -1
-              check_status(Bolt::Connection.status(bolt_connection))
-            when 1
-              InternalRecord.new(run_handler.statement_keys,
-                                 Value::ValueAdapter.to_ruby(Bolt::Connection.field_values(bolt_connection)))
-            else
-              @finished = true
-              check_summary_failure
-              nil
-            end
-          rescue StandardError => e
-            on_failure(e) unless @failure
-            raise e
-          end
-        end
-      end
-    end
-  end
-end

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