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

data/ffi/neo4j/driver/internal/async/direct_connection.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Async
-        class DirectConnection
-          include ErrorHandling
-
-          attr_reader :protocol
-          attr_reader :bolt_connection
-
-          def initialize(connector, mode, config)
-            @connector = connector
-            @config = config
-            @bolt_connection = with_status { |status| Bolt::Connector.acquire(@connector, mode, status) }
-
-            # @protocol = Messaging::BoltProtocol.for_version(Bolt::Connection.server(bolt_connection).first)
-            @protocol = Messaging::BoltProtocol.for_version(3)
-            @status = Concurrent::AtomicReference.new(:open)
-          end
-
-          def write_and_flush(statement, parameters, boomarks_holder, config, run_handler, pull_handler)
-            check_error Bolt::Connection.clear_run(bolt_connection)
-            check_error Bolt::Connection.set_run_cypher(bolt_connection, statement, statement.bytesize, parameters.size)
-            parameters.each_with_index do |(name, object), index|
-              name = name.to_s
-              Value::ValueAdapter.to_neo(
-                Bolt::Connection.set_run_cypher_parameter(bolt_connection, index, name, name.bytesize), object
-              )
-            end
-            set_bookmarks(:set_run_bookmarks, boomarks_holder.bookmarks)
-            set_config(:set_run, config)
-            register(run_handler, Bolt::Connection.load_run_request(bolt_connection))
-            register(pull_handler, Bolt::Connection.load_pull_request(bolt_connection, -1))
-            flush
-          end
-
-          def flush
-            check_error Bolt::Connection.flush(bolt_connection)
-          end
-
-          def begin(bookmarks, config, begin_handler)
-            check_error Bolt::Connection.clear_begin(bolt_connection)
-            set_bookmarks(:set_begin_bookmarks, bookmarks)
-            set_config(:set_begin, config)
-            register(begin_handler, Bolt::Connection.load_begin_request(bolt_connection))
-          end
-
-          def commit(handler)
-            register(handler, Bolt::Connection.load_commit_request(bolt_connection))
-            flush
-          end
-
-          def rollback(handler)
-            register(handler, Bolt::Connection.load_rollback_request(bolt_connection))
-            flush
-          end
-
-          def release
-            return unless @status.compare_and_set(:open, :terminated)
-            Bolt::Connector.release(@connector, bolt_connection)
-            @bolt_connection = nil
-          end
-
-          def open?
-            @status.get == :open
-          end
-
-          def last_bookmark
-            Bolt::Connection.last_bookmark(bolt_connection).first.force_encoding(Encoding::UTF_8)
-          end
-
-          private
-
-          def register(handler, error_code)
-            check_error(error_code)
-            handler.request = Bolt::Connection.last_request(bolt_connection)
-          end
-
-          def set_bookmarks(method, bookmarks)
-            return unless bookmarks.present?
-            value = Bolt::Value.create
-            Value::ValueAdapter.to_neo(value, bookmarks)
-            check_error Bolt::Connection.send(method, bolt_connection, value)
-          end
-
-          def set_config(method_prefix, config)
-            return unless config
-            config.each do |key, value|
-              case key
-              when :timeout
-                check_error Bolt::Connection.send("#{method_prefix}_tx_timeout", bolt_connection,
-                                                  DurationNormalizer.milliseconds(value))
-              when :metadata
-                bolt_value = Bolt::Value.create
-                Value::ValueAdapter.to_neo(bolt_value, value)
-                check_error Bolt::Connection.send("#{method_prefix}_tx_metadata", bolt_connection, bolt_value)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      class BoltServerAddress
-        include Net::ServerAddress
-
-        attr_reader :host, :port
-
-        def initialize(host, port)
-          @host = host
-          @port = port
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module BookmarksHolder
-        extend ActiveSupport::Concern
-
-        included do
-          attr_reader :bookmarks
-        end
-
-        def initialize
-          @bookmarks = []
-        end
-
-        def bookmarks=(bookmarks)
-          bookmarks = Array(bookmarks).select(&:present?)
-          @bookmarks = bookmarks if bookmarks.present?
-        end
-
-        NO_OP = Class.new do
-          include BookmarksHolder
-
-          def bookmarks=; end
-        end.new
-      end
-    end
-  end
-end

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,126 +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)
-          # callbacks from C to ruby used in logger may cause deadlocks on MRI
-          logger = InternalLogger.register(bolt_config, config[:logger]) if RUBY_PLATFORM.match?(/java/)
-          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