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

data/ffi/bolt/auth.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module Auth
-    extend Bolt::Library
-    attach_function :basic, :BoltAuth_basic, %i[string string string], :auto_pointer,
-                    releaser: Bolt::Value.method(:destroy)
-    attach_function :none, :BoltAuth_none, [], :auto_pointer, releaser: Bolt::Value.method(:destroy)
-  end
-end

data/ffi/bolt/auto_releasable.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module AutoReleasable
-    def attach_function(name, func, args, returns = nil, options = nil)
-      return super unless returns == :auto_pointer
-
-      super(name, func, args, :pointer, options)
-      singleton_class.prepend with_auto_releaser(name, options&.dig(:releaser))
-    end
-
-    private
-
-    def with_auto_releaser(method, releaser)
-      Module.new do
-        define_method(method) do |*args|
-          FFI::AutoPointer.new(super(*args), releaser || self.method(:destroy))
-        end
-      end
-    end
-  end
-end

data/ffi/bolt/boolean.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module Boolean
-    extend Bolt::Library
-
-    attach_function :get, :BoltBoolean_get, %i[pointer], :char
-  end
-end

data/ffi/bolt/bytes.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module Bytes
-    extend Bolt::Library
-
-    attach_function :get, :BoltBytes_get, %i[pointer int32], :char
-    attach_function :get_all, :BoltBytes_get_all, %i[pointer], :pointer
-  end
-end

data/ffi/bolt/config.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module Config
-    extend Bolt::Library
-
-    BOLT_SCHEME_DIRECT = 0
-    BOLT_SCHEME_NEO4J = 1
-
-    typedef :int32_t, :bolt_scheme
-
-    BOLT_TRANSPORT_PLAINTEXT = 0
-    BOLT_TRANSPORT_ENCRYPTED = 1
-
-    typedef :int32_t, :bolt_transport
-
-    attach_function :create, :BoltConfig_create, [], :auto_pointer
-    attach_function :destroy, :BoltConfig_destroy, [:pointer], :void
-    attach_function :get_scheme, :BoltConfig_get_scheme, [:pointer], :bolt_scheme
-    attach_function :set_scheme, :BoltConfig_set_scheme, %i[pointer bolt_scheme], :int32_t
-    attach_function :get_transport, :BoltConfig_get_transport, [:pointer], :bolt_transport
-    attach_function :set_transport, :BoltConfig_set_transport, %i[pointer bolt_transport], :int32_t
-    attach_function :get_trust, :BoltConfig_get_trust, [:pointer], :pointer
-    attach_function :set_trust, :BoltConfig_set_trust, %i[pointer pointer], :int32_t
-    attach_function :get_user_agent, :BoltConfig_get_user_agent, [:pointer], :string
-    attach_function :set_user_agent, :BoltConfig_set_user_agent, %i[pointer string], :int32
-    attach_function :get_routing_context, :BoltConfig_get_routing_context, [:pointer], :pointer
-    attach_function :set_routing_context, :BoltConfig_set_routing_context, %i[pointer pointer], :int32_t
-    attach_function :get_address_resolver, :BoltConfig_get_address_resolver, [:pointer], :pointer
-    attach_function :set_address_resolver, :BoltConfig_set_address_resolver, %i[pointer pointer], :int32_t
-    attach_function :get_log, :BoltConfig_get_log, [:pointer], :pointer
-    attach_function :set_log, :BoltConfig_set_log, %i[pointer pointer], :int32
-    attach_function :get_max_pool_size, :BoltConfig_get_max_pool_size, [:pointer], :int32_t
-    attach_function :set_max_pool_size, :BoltConfig_set_max_pool_size, %i[pointer int32_t], :int32_t
-    attach_function :get_max_connection_life_time, :BoltConfig_get_max_connection_life_time, [:pointer], :int32_t
-    attach_function :set_max_connection_life_time, :BoltConfig_set_max_connection_life_time, %i[pointer int32_t],
-                    :int32_t
-    attach_function :get_max_connection_acquisition_time, :BoltConfig_get_max_connection_acquisition_time, [:pointer],
-                    :int32_t
-    attach_function :set_max_connection_acquisition_time, :BoltConfig_set_max_connection_acquisition_time,
-                    %i[pointer int32_t], :int32_t
-    attach_function :get_socket_options, :BoltConfig_get_socket_options, [:pointer], :pointer
-    attach_function :set_socket_options, :BoltConfig_set_socket_options, %i[pointer pointer], :int32_t
-  end
-end

data/ffi/bolt/connection.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module Connection
-    extend Bolt::Library
-
-    typedef :uint64, :bolt_request
-
-    attach_function :flush, :BoltConnection_send, [:pointer], :int32
-    attach_function :fetch, :BoltConnection_fetch, %i[pointer bolt_request], :int32
-    attach_function :fetch_summary, :BoltConnection_fetch_summary, %i[pointer bolt_request], :int32
-    attach_function :clear_begin, :BoltConnection_clear_begin, %i[pointer], :int32
-    attach_function :set_begin_bookmarks, :BoltConnection_set_begin_bookmarks, %i[pointer pointer], :int32
-    attach_function :set_begin_tx_timeout, :BoltConnection_set_begin_tx_timeout, %i[pointer int64], :int32
-    attach_function :set_begin_tx_metadata, :BoltConnection_set_begin_tx_metadata, %i[pointer pointer], :int32
-    attach_function :load_begin_request, :BoltConnection_load_begin_request, %i[pointer], :int32
-    attach_function :load_commit_request, :BoltConnection_load_commit_request, %i[pointer], :int32
-    attach_function :load_rollback_request, :BoltConnection_load_rollback_request, %i[pointer], :int32
-    attach_function :clear_run, :BoltConnection_clear_run, %i[pointer], :int32
-    attach_function :set_run_bookmarks, :BoltConnection_set_run_bookmarks, %i[pointer pointer], :int32
-    attach_function :set_run_tx_timeout, :BoltConnection_set_run_tx_timeout, %i[pointer int64], :int32
-    attach_function :set_run_tx_metadata, :BoltConnection_set_run_tx_metadata, %i[pointer pointer], :int32
-    attach_function :set_run_cypher, :BoltConnection_set_run_cypher, %i[pointer string uint64 int32], :int32
-    attach_function :set_run_cypher_parameter, :BoltConnection_set_run_cypher_parameter,
-                    %i[pointer int32 string uint64], :pointer
-    attach_function :load_run_request, :BoltConnection_load_run_request, [:pointer], :int32
-    attach_function :load_discard_request, :BoltConnection_load_discard_request, %i[pointer int32], :int32
-    attach_function :load_pull_request, :BoltConnection_load_pull_request, %i[pointer int32], :int32
-    attach_function :load_reset_request, :BoltConnection_load_reset_request, [:pointer], :int32
-    attach_function :last_request, :BoltConnection_last_request, [:pointer], :bolt_request
-    attach_function :server, :BoltConnection_server, %i[pointer], :strptr
-    attach_function :id, :BoltConnection_id, %i[pointer], :strptr
-    attach_function :address, :BoltConnection_address, %i[pointer], :pointer
-    attach_function :remote_endpoint, :BoltConnection_remote_endpoint, %i[pointer], :pointer
-    attach_function :local_endpoint, :BoltConnection_local_endpoint, %i[pointer], :pointer
-    attach_function :last_bookmark, :BoltConnection_last_bookmark, %i[pointer], :strptr
-    attach_function :summary_success, :BoltConnection_summary_success, [:pointer], :int32
-    attach_function :failure, :BoltConnection_failure, [:pointer], :pointer
-    attach_function :field_names, :BoltConnection_field_names, [:pointer], :pointer
-    attach_function :field_values, :BoltConnection_field_values, [:pointer], :pointer
-    attach_function :metadata, :BoltConnection_metadata, %i[pointer], :pointer
-    attach_function :status, :BoltConnection_status, [:pointer], :pointer
-  end
-end

data/ffi/bolt/connector.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module Connector
-    extend Bolt::Library
-
-    BoltAccessMode = enum(
-      :bolt_access_mode_write,
-      :bolt_access_mode_read
-    )
-
-    attach_function :create, :BoltConnector_create, %i[pointer pointer pointer], :pointer
-    attach_function :destroy, :BoltConnector_destroy, [:pointer], :void
-    attach_function :acquire, :BoltConnector_acquire, [:pointer, BoltAccessMode, :pointer], :pointer
-    attach_function :release, :BoltConnector_release, %i[pointer pointer], :void
-  end
-end

data/ffi/bolt/dictionary.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module Dictionary
-    extend Bolt::Library
-
-    attach_function :key, :BoltDictionary_key, %i[pointer int32], :pointer
-    attach_function :get_key, :BoltDictionary_get_key, %i[pointer int32], :pointer
-    attach_function :get_key_size, :BoltDictionary_get_key_size, %i[pointer int32], :int32
-    attach_function :get_key_index, :BoltDictionary_get_key_index, %i[pointer string int32 int32], :int32
-    attach_function :set_key, :BoltDictionary_set_key, %i[pointer int32 string int32], :int32
-    attach_function :value, :BoltDictionary_value, %i[pointer int32], :pointer
-    attach_function :value_by_key, :BoltDictionary_value_by_key, %i[pointer string int32], :pointer
-  end
-end

data/ffi/bolt/error.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module Error
-    extend Bolt::Library
-
-    # Identifies a successful operation which is defined as 0
-    BOLT_SUCCESS = 0
-    # Unknown error
-    BOLT_UNKNOWN_ERROR = 1
-    # Unsupported protocol or address family
-    BOLT_UNSUPPORTED = 2
-    # Operation interrupted
-    BOLT_INTERRUPTED = 3
-    # Connection reset by peer
-    BOLT_CONNECTION_RESET = 4
-    # No valid resolved addresses found to connect
-    BOLT_NO_VALID_ADDRESS = 5
-    # Operation timed out
-    BOLT_TIMED_OUT = 6
-    # Permission denied
-    BOLT_PERMISSION_DENIED = 7
-    # Too may open files
-    BOLT_OUT_OF_FILES = 8
-    # Out of memory
-    BOLT_OUT_OF_MEMORY = 9
-    # Too many open ports
-    BOLT_OUT_OF_PORTS = 10
-    # Connection refused
-    BOLT_CONNECTION_REFUSED = 11
-    # Network unreachable
-    BOLT_NETWORK_UNREACHABLE = 12
-    # An unknown TLS error
-    BOLT_TLS_ERROR = 13
-    # Connection closed by remote peer
-    BOLT_END_OF_TRANSMISSION = 15
-    # Server returned a FAILURE message, more info available through \ref BoltConnection_failure
-    BOLT_SERVER_FAILURE = 16
-    # Unsupported bolt transport
-    BOLT_TRANSPORT_UNSUPPORTED = 0x400
-    # Unsupported protocol usage
-    BOLT_PROTOCOL_VIOLATION = 0x500
-    # Unsupported bolt type
-    BOLT_PROTOCOL_UNSUPPORTED_TYPE = 0x501
-    # Unknown pack stream type
-    BOLT_PROTOCOL_NOT_IMPLEMENTED_TYPE = 0x502
-    # Unexpected marker
-    BOLT_PROTOCOL_UNEXPECTED_MARKER = 0x503
-    # Unsupported bolt protocol version
-    BOLT_PROTOCOL_UNSUPPORTED = 0x504
-    # Connection pool is full
-    BOLT_POOL_FULL = 0x600
-    # Connection acquisition from the connection pool timed out
-    BOLT_POOL_ACQUISITION_TIMED_OUT = 0x601
-    # Address resolution failed
-    BOLT_ADDRESS_NOT_RESOLVED = 0x700
-    # Routing table retrieval failed
-    BOLT_ROUTING_UNABLE_TO_RETRIEVE_ROUTING_TABLE = 0x800
-    # No servers to select for the requested operation
-    BOLT_ROUTING_NO_SERVERS_TO_SELECT = 0x801
-    # Connection pool construction for server failed
-    BOLT_ROUTING_UNABLE_TO_CONSTRUCT_POOL_FOR_SERVER = 0x802
-    # Routing table refresh failed
-    BOLT_ROUTING_UNABLE_TO_REFRESH_ROUTING_TABLE = 0x803
-    # Invalid discovery response
-    BOLT_ROUTING_UNEXPECTED_DISCOVERY_RESPONSE = 0x804
-    # Error set in connection
-    BOLT_CONNECTION_HAS_MORE_INFO = 0xFFE
-    # Error set in connection
-    BOLT_STATUS_SET = 0xFFF
-
-    attach_function :get_string, :BoltError_get_string, [:int32], :string
-  end
-end

data/ffi/bolt/float.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module Float
-    extend Bolt::Library
-
-    attach_function :get, :BoltFloat_get, %i[pointer], :double
-  end
-end

data/ffi/bolt/integer.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module Integer
-    extend Bolt::Library
-
-    attach_function :get, :BoltInteger_get, %i[pointer], :int64
-  end
-end

data/ffi/bolt/library.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module Library
-    include FFI::Library
-    include Bolt::AutoReleasable
-
-    def self.extended(mod)
-      mod.ffi_lib 'libseabolt17'
-    end
-  end
-end

data/ffi/bolt/lifecycle.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module Lifecycle
-    extend Bolt::Library
-    attach_function :startup, :Bolt_startup, [], :void
-    attach_function :shutdown, :Bolt_shutdown, [], :void
-  end
-end

data/ffi/bolt/list.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module List
-    extend Bolt::Library
-
-    attach_function :resize, :BoltList_resize, %i[pointer int32], :void
-    attach_function :value, :BoltList_value, %i[pointer int32], :pointer
-  end
-end

data/ffi/bolt/log.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module Log
-    extend Bolt::Library
-
-    callback :log_func, %i[pointer string], :void
-
-    attach_function :create, :BoltLog_create, %i[pointer], :auto_pointer
-    attach_function :destroy, :BoltLog_destroy, %i[pointer], :void
-    attach_function :set_error_func, :BoltLog_set_error_func, %i[pointer log_func], :void
-    attach_function :set_warning_func, :BoltLog_set_warning_func, %i[pointer log_func], :void
-    attach_function :set_info_func, :BoltLog_set_info_func, %i[pointer log_func], :void
-    attach_function :set_debug_func, :BoltLog_set_debug_func, %i[pointer log_func], :void
-  end
-end

data/ffi/bolt/socket_options.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module SocketOptions
-    extend Bolt::Library
-
-    attach_function :create, :BoltSocketOptions_create, [], :auto_pointer
-    attach_function :destroy, :BoltSocketOptions_destroy, [:pointer], :void
-    attach_function :get_connect_timeout, :BoltSocketOptions_get_connect_timeout, [:pointer], :int32_t
-    attach_function :set_connect_timeout, :BoltSocketOptions_set_connect_timeout, %i[pointer int32_t], :int32_t
-    attach_function :get_keep_alive, :BoltSocketOptions_get_keep_alive, [:pointer], :int32_t
-    attach_function :set_keep_alive, :BoltSocketOptions_set_keep_alive, %i[pointer int32_t], :int32_t
-  end
-end

data/ffi/bolt/status.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module Status
-    extend Bolt::Library
-    # Not connected
-    BOLT_CONNECTION_STATE_DISCONNECTED = 0
-    # Connected but not authenticated
-    BOLT_CONNECTION_STATE_CONNECTED = 1
-    # Connected and authenticated
-    BOLT_CONNECTION_STATE_READY = 2
-    # Recoverable failure
-    BOLT_CONNECTION_STATE_FAILED = 3
-    # Unrecoverable failure
-    BOLT_CONNECTION_STATE_DEFUNCT = 4
-
-    typedef :int32, :bolt_connection_state
-
-    attach_function :create, :BoltStatus_create, [], :auto_pointer
-    attach_function :destroy, :BoltStatus_destroy, [:pointer], :void
-    attach_function :get_state, :BoltStatus_get_state, [:pointer], :bolt_connection_state
-    attach_function :get_error, :BoltStatus_get_error, [:pointer], :int32
-    attach_function :get_error_context, :BoltStatus_get_error_context, [:pointer], :string
-  end
-end

data/ffi/bolt/string.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module String
-    extend Bolt::Library
-
-    attach_function :get, :BoltString_get, [:pointer], :pointer
-  end
-end

data/ffi/bolt/structure.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module Structure
-    extend Bolt::Library
-
-    attach_function :code, :BoltStructure_code, %i[pointer], :int16
-    attach_function :value, :BoltStructure_value, %i[pointer int32], :pointer
-  end
-end

data/ffi/bolt/value.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module Value
-    extend Bolt::Library
-
-    enum :bolt_type,
-         %i[bolt_null
-            bolt_boolean
-            bolt_integer
-            bolt_float
-            bolt_string
-            bolt_dictionary
-            bolt_list
-            bolt_bytes
-            bolt_structure]
-
-    attach_function :create, :BoltValue_create, [], :auto_pointer
-    attach_function :destroy, :BoltValue_destroy, %i[pointer], :void
-    attach_function :duplicate, :BoltValue_duplicate, %i[pointer], :auto_pointer
-    attach_function :copy, :BoltValue_copy, %i[pointer pointer], :void
-    attach_function :size, :BoltValue_size, %i[pointer], :int32
-    attach_function :type, :BoltValue_type, %i[pointer], :bolt_type
-    attach_function :to_string, :BoltValue_to_string, %i[pointer pointer int32 pointer], :int32
-    attach_function :format_as_null, :BoltValue_format_as_Null, %i[pointer], :void
-    attach_function :format_as_boolean, :BoltValue_format_as_Boolean, %i[pointer char], :void
-    attach_function :format_as_integer, :BoltValue_format_as_Integer, %i[pointer int64], :void
-    attach_function :format_as_float, :BoltValue_format_as_Float, %i[pointer double], :void
-    attach_function :format_as_string, :BoltValue_format_as_String, %i[pointer string int32], :void
-    attach_function :format_as_dictionary, :BoltValue_format_as_Dictionary, %i[pointer int32], :void
-    attach_function :format_as_list, :BoltValue_format_as_List, %i[pointer int32], :void
-    attach_function :format_as_bytes, :BoltValue_format_as_Bytes, %i[pointer pointer int32], :void
-    attach_function :format_as_structure, :BoltValue_format_as_Structure, %i[pointer int16 int32], :void
-  end
-end

data/ffi/neo4j/driver/auth_tokens.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    class AuthTokens
-      class << self
-        def basic(username, password)
-          Internal::Validator.require_non_nil_credentials!(username, password)
-          Bolt::Auth.basic(username, password, nil)
-        end
-
-        def none
-          Bolt::Auth.none
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/config.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    class Config < Hash
-      class TrustStrategy
-        class << self
-          def trust_all_certificates; end
-        end
-      end
-
-      class << self
-        # How can following Java config options be expressed in seabolt:
-        # withLeakedSessionsLogging
-        # withConnectionLivenessCheckTimeout
-        # withTrustStrategy TRUST_ALL_CERTIFICATES, TRUST_CUSTOM_CA_SIGNED_CERTIFICATES, TRUST_SYSTEM_CA_SIGNED_CERTIFICATE
-        # and in the reverse what those seabolt options correspond to in java:
-        # BoltConfig_set_user_agent
-
-        def default_config
-          {
-             logger: ActiveSupport::Logger.new(STDOUT, level: ::Logger::ERROR), # :set_log
-             leaked_session_logging: false,
-             #connection_liveness_check_timeout: -1, # Not configured
-             max_connection_lifetime: 1.hour, # :set_max_connection_life_time
-             max_connection_pool_size: 100, #:set_max_pool_size
-             connection_acquisition_timeout: 1.minute, #:set_max_connection_acquisition_time
-             encryption: true, # :set_transport
-             trust_strategy: :trust_all_certificates,
-             connection_timeout: 30.seconds, # BoltSocketOptions_set_connect_timeout
-             max_transaction_retry_time: Internal::Retry::ExponentialBackoffRetryLogic::DEFAULT_MAX_RETRY_TIME,
-             #resolver: nil # :set_address_resolver
-             keep_alive: true, # BoltSocketOptions_set_keep_alive
-             # ???? BoltConfig_set_user_agent
-          }
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/graph_database.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    class GraphDatabase
-      VALID_ROUTING_SCHEMES =
-        [Internal::DriverFactory::BOLT_ROUTING_URI_SCHEME, Internal::DriverFactory::NEO4J_URI_SCHEME].freeze
-
-      Bolt::Lifecycle.startup
-
-      at_exit do
-        Bolt::Lifecycle.shutdown
-      end
-
-      class << self
-        extend AutoClosable
-
-        auto_closable :driver, :routing_driver
-
-        def driver(uri, auth_token = Neo4j::Driver::AuthTokens.none, config = nil)
-          unless auth_token.is_a? FFI::Pointer
-            raise Exceptions::AuthenticationException, 'Unsupported authentication token'
-          end
-          config = Config.default_config.merge(config || {})
-
-          Internal::DriverFactory.new.new_instance(uri, auth_token, config)
-        end
-
-        def routing_driver(routing_uris, auth_toke, config)
-          assert_routing_uris(routing_uris)
-
-          routing_uris.each do |uri|
-            return driver(uri, auth_toke, config)
-          rescue Exceptions::ServiceUnavailableException => e
-            # log.warn("Unable to create routing driver for URI: #{uri}", e)
-          end
-
-          raise Exceptions::ServiceUnavailableException, 'Failed to discover an available server'
-        end
-
-        private
-
-        def assert_routing_uris(uris)
-          scheme = (uris.map(&method(:URI)).map(&:scheme) - VALID_ROUTING_SCHEMES).first
-          return unless scheme
-          raise ArgumentError,
-                "Illegal URI scheme, expected URI scheme '#{scheme}' to be among '[#{VALID_ROUTING_SCHEMES.join ', '}]'"
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Async
-        class AccessModeConnection
-          attr_reader :connection, :mode
-          delegate :open?, :protocol, :release, :reset, :write_and_flush, to: :connection
-
-          def initialize(connection, mode)
-            @connection = connection
-            @mode = mode
-          end
-        end
-      end
-    end
-  end
-end

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