neo4j-ruby-driver 5.7.0.alpha.4 → 6.0.3.alpha.0-java

data/ruby/neo4j/driver/config.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    class Config < Hash
-      class TrustStrategy
-        TRUST_ALL_CERTIFICATES = :trust_all_certificates
-        TRUST_CUSTOM_CA_SIGNED_CERTIFICATES = :trust_custom_certificates
-        TRUST_SYSTEM_CA_SIGNED_CERTIFICATES = :trust_system_certificates
-
-        attr_reader :strategy, :cert_files, :revocation_strategy
-
-        # Sample config:
-        # {
-        #   trust_strategy: {
-        #     strategy: :trust_custom_certificates,
-        #     cert_files: ['some_path', 'another_path'],
-        #     revocation_strategy: :no_checks, # or :verify_if_present, :strict
-        #     hostname_verification: true
-        #   },
-        #   encryption: true
-        # }
-        def initialize(**config)
-          @strategy = config[:strategy]
-          @cert_files = config[:cert_files]
-          @revocation_strategy = config[:revocation_strategy] || Neo4j::Driver::Internal::RevocationStrategy::NO_CHECKS
-          @hostname_verification_enabled = config[:hostname_verification] || false
-        end
-
-        def self.trust_all_certificates
-          new(trust_strategy: TRUST_ALL_CERTIFICATES)
-        end
-
-        def hostname_verification_enabled?
-          @hostname_verification_enabled
-        end
-      end
-
-      # Console.logger = ::Logger.new(STDOUT, level: :debug)
-      DEFAULTS = {
-        logger: ::Logger.new(nil),
-        # logger: ::Logger.new(STDOUT, level: :debug),
-        # logger: Console.logger,
-        leaked_sessions_logging: false,
-        max_connection_pool_size: Internal::Async::Pool::PoolSettings::DEFAULT_MAX_CONNECTION_POOL_SIZE,
-        idle_time_before_connection_test: Internal::Async::Pool::PoolSettings::DEFAULT_IDLE_TIME_BEFORE_CONNECTION_TEST,
-        max_connection_lifetime: Internal::Async::Pool::PoolSettings::DEFAULT_MAX_CONNECTION_LIFETIME,
-        connection_acquisition_timeout: Internal::Async::Pool::PoolSettings::DEFAULT_CONNECTION_ACQUISITION_TIMEOUT,
-        routing_failure_limit: Internal::Cluster::RoutingSettings::DEFAULT.max_routing_failures,
-        routing_retry_delay: Internal::Cluster::RoutingSettings::DEFAULT.retry_timeout_delay,
-        routing_table_purge_delay: Internal::Cluster::RoutingSettings::DEFAULT.routing_table_purge_delay,
-        user_agent: "neo4j-ruby/#{Neo4j::Driver::VERSION}",
-        connection_timeout: 30.seconds,
-        driver_metrics: false,
-        fetch_size: Internal::Handlers::Pulln::FetchSizeUtil::DEFAULT_FETCH_SIZE,
-        event_loop_threads: 0,
-
-        # TODO: Still to cleanup
-        encryption: false, # :set_transport
-        keep_alive: true, # BoltSocketOptions_set_keep_alive
-        # connection_liveness_check_timeout: -1, # Not configured
-        max_transaction_retry_time: Internal::Retry::ExponentialBackoffRetryLogic::DEFAULT_MAX_RETRY_TIME,
-        metrics_enabled: false,
-        # resolver: nil # :set_address_resolver
-        trust_strategy: { strategy: :trust_all_certificates }
-      }.freeze
-
-      def initialize(**config)
-        merge!(DEFAULTS).merge!(config.compact)
-        init_security_and_trust_config
-      end
-
-      def routing_settings
-        Internal::Cluster::RoutingSettings.new(
-          *values_at(:routing_failure_limit, :routing_retry_delay, :routing_table_purge_delay))
-      end
-
-      private
-
-      def init_security_and_trust_config
-        relevant = %i[encryption trust_strategy]
-        customized = slice(*relevant) != DEFAULTS.slice(*relevant)
-        merge!(security_settings: Neo4j::Driver::Internal::SecuritySetting.new(
-          fetch(:encryption), TrustStrategy.new(**fetch(:trust_strategy)), customized),
-        )
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/graph_database.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j::Driver
-  class GraphDatabase
-    class << self
-      extend AutoClosable
-      auto_closable :driver, :routing_driver
-
-      def driver(uri, auth_token = nil, **config)
-        internal_driver(uri, auth_token, config)
-      end
-
-      def internal_driver(uri, auth_token, config, &domain_name_resolver)
-        uri = URI(uri)
-        config = Config.new(**config)
-
-        Internal::DriverFactory.new(&domain_name_resolver).new_instance(
-          uri,
-          auth_token || AuthTokens.none,
-          config.routing_settings,
-          config[:max_transaction_retry_time],
-          config,
-          config[:security_settings].create_security_plan(uri.scheme)
-        )
-      end
-
-      def routing_driver(routing_uris, auth_token, **config)
-        assert_routing_uris(routing_uris)
-        log = Config.new(**config)[:logger]
-
-        routing_uris.each do |uri|
-          driver = driver(uri, auth_token, **config)
-          begin
-            return driver.tap(&:verify_connectivity)
-          rescue Exceptions::ServiceUnavailableException => e
-            log.warn { "Unable to create routing driver for URI: #{uri}\n#{e}" }
-            close_driver(driver, uri, log)
-          rescue Exception => e
-            close_driver(driver, uri, log)
-            raise e
-          end
-        end
-
-        raise Exceptions::ServiceUnavailableException, 'Failed to discover an available server'
-      end
-
-      private
-
-      def bolt_version(version)
-        pad(version.split(/[.\-]/).map(&:to_i), 4).reverse
-      end
-
-      def ruby_version(bolt_version)
-        bolt_version.unpack('C*').reverse.map(&:to_s).join('.')
-      end
-
-      def bolt_versions(*versions)
-        pad(versions[0..3].map(&method(:bolt_version)).flatten, 16).pack('C*')
-      end
-
-      def pad(arr, n)
-        arr + [0] * [0, n - arr.size].max
-      end
-
-      def close_driver(driver, uri, log)
-        driver.close
-      rescue => close_error
-        log.warn { "Unable to close driver towards URI: #{uri}\n#{close_error}" }
-      end
-
-      def assert_routing_uris(uris)
-        uris.find { |uri| URI(uri).scheme != Neo4j::Driver::Internal::Scheme::NEO4J_URI_SCHEME }&.tap do |uri|
-          raise ArgumentError, "Illegal URI scheme, expected '#{Internal::Scheme::NEO4J_URI_SCHEME}' in '#{uri}'"
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/connection/bolt_protocol_util.rb

@@ -1,51 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Connection
-        class BoltProtocolUtil
-          BOLT_MAGIC_PREAMBLE = 0x6060B017
-          NO_PROTOCOL_VERSION = Messaging::BoltProtocolVersion.new(0, 0)
-          CHUNK_HEADER_SIZE_BYTES = 2
-          DEFAULT_MAX_OUTBOUND_CHUNK_SIZE_BYTES = 2 ** 15 - 1
-          HANDSHAKE = [
-            BOLT_MAGIC_PREAMBLE,
-            Messaging::V5::BoltProtocolV5::VERSION.to_int,
-            Messaging::V44::BoltProtocolV44::VERSION.to_int_range(Messaging::V42::BoltProtocolV42::VERSION),
-            Messaging::V41::BoltProtocolV41::VERSION.to_int,
-            Messaging::V3::BoltProtocolV3::VERSION.to_int]
-          HANDSHAKE_BUF = HANDSHAKE.pack('N*').freeze
-
-          class << self
-            def handshake_buf
-              HANDSHAKE_BUF
-            end
-
-            def handshake_string
-              HANDSHAKE_STRING
-            end
-
-            def write_message_boundary(buf)
-              buf.write_short(0)
-            end
-
-            def write_empty_chunk_header(buf)
-              buf.write_short(0)
-            end
-
-            def write_chunk_header(buf, chunk_start_index, header_value)
-              buf.set_short(chunk_start_index, header_value)
-            end
-
-            private
-
-            def create_handshake_string
-              "[0x#{HANDSHAKE.first.to_s(16)}, %s, %s, %s, %s]" % HANDSHAKE[1, 4]
-            end
-          end
-
-          HANDSHAKE_STRING = create_handshake_string
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/connection/bootstrap_factory.rb

@@ -1,22 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Connection
-        class BootstrapFactory
-          class << self
-            def new_bootstrap(thread_count: nil,
-                              event_loop_group: EventLoopGroupFactory.new_event_loop_group(thread_count))
-              # Ione::Io::IoReactor.new
-              # Io::Bootstrap.new.tap do |bootstrap|
-              #   bootstrap.group = event_loop_group
-              #   bootstrap.channel(EventLoopGroupFactory.channel_class)
-                # bootstrap.option(org.neo4j.driver.internal.shaded.io.netty.channel.ChannelOption::SO_KEEPALIVE, true)
-                # bootstrap.option(org.neo4j.driver.internal.shaded.io.netty.channel.ChannelOption::SO_REUSEADDR, true)
-              # end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/connection/channel_attributes.rb

@@ -1,31 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Connection
-        class ChannelAttributes < Hash
-          # CONNECTION_ID = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('connectionId')
-          # POOL_ID = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('poolId')
-          # PROTOCOL_VERSION = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('protocolVersion')
-          # SERVER_AGENT = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('serverAgent')
-          # ADDRESS = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('serverAddress')
-          # SERVER_VERSION = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('serverVersion')
-          # CREATION_TIMESTAMP = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('creationTimestamp')
-          # LAST_USED_TIMESTAMP = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('lastUsedTimestamp')
-          # MESSAGE_DISPATCHER = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('messageDispatcher')
-          # TERMINATION_REASON = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('terminationReason')
-          # AUTHORIZATION_STATE_LISTENER = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('authorizationStateListener')
-          # CONNECTION_READ_TIMEOUT = org.neo4j.driver.internal.shaded.io.netty.util.AttributeKey.new_instance('connectionReadTimeout')
-
-          UPDATABLE_KEYS = %i[last_used_timestamp authorization_state_listener]
-
-          def []=(key, value)
-            if !UPDATABLE_KEYS.include?(key) && key?(key)
-              raise Neo4j::Driver::Exceptions::IllegalStateException, "Unable to set #{key} because it is already set to #{self[key]}"
-            end
-            super
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/connection/channel_connected_listener.rb

@@ -1,32 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Connection
-        class ChannelConnectedListener < Struct.new(:address, :pipeline_builder, :handshake_completed_promise, :logger)
-          # include org.neo4j.driver.internal.shaded.io.netty.channel.ChannelFutureListener
-          def operationComplete(future)
-            channel = future.channel
-            log = Logging::ChannelActivityLogger.new(channel, logger, self.class)
-
-            if future.fulfilled?
-              log.debug("Channel #{channel} connected, initiating bolt handshake")
-
-              pipeline = channel.pipeline
-              pipeline.add_last(HandshakeHandler.new(pipeline_builder, handshake_completed_promise, logger))
-              log.debug("C: [Bolt Handshake] #{BoltProtocolUtil.handshake_string}")
-              channel.write_and_flush(BoltProtocolUtil.handshake_buf, channel.void_promise)
-            else
-              handshake_completed_promise.set_failure(self.class.database_unavailable_error(address, future.cause))
-            end
-          end
-
-          def self.database_unavailable_error(address, cause)
-            Neo4j::Driver::Exceptions::ServiceUnavailableException.new(
-              "Unable to connect to #{address}, ensure the database is running and that there is a working network connection to it.",
-              cause)
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/connection/channel_connector_impl.rb

@@ -1,83 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Connection
-        class ChannelConnectorImpl
-          def initialize(connection_settings, security_plan, logger, clock, routing_context, pipeline_builder = ChannelPipelineBuilderImpl.new, &domain_name_resolver)
-            @user_agent = connection_settings.user_agent
-            @auth_token = self.class.require_valid_auth_token(connection_settings.auth_token)
-            @routing_context = routing_context
-            @connect_timeout_millis = connection_settings.connect_timeout_millis
-            @security_plan = Validator.require_non_nil!(security_plan)
-            @pipeline_builder = pipeline_builder
-            @logger = Validator.require_non_nil!(logger)
-            @clock = Validator.require_non_nil!(clock)
-            @domain_name_resolver = Validator.require_non_nil!(domain_name_resolver)
-          end
-
-          def connect(address)
-            socket_host = (@domain_name_resolver.call(address.connection_host).first.ip_address rescue nil) ||
-              bracketless(address.connection_host)
-
-            endpoint = ::Async::IO::Endpoint.tcp(socket_host, address.port)
-            if @security_plan.requires_encryption?
-              endpoint = ::Async::IO::SSLEndpoint.new(endpoint, ssl_context: @security_plan.ssl_context,
-                                                    hostname: address.host)
-            end
-            channel_connected = endpoint.connect
-
-            # install_channel_connected_listeners(address, channel_connected, handshake_completed)
-            # install_handshake_completed_listeners(handshake_completed, connection_initialized)
-
-            channel_connected
-          rescue Errno::ECONNREFUSED => e
-            raise Exceptions::ServiceUnavailableException, e.message
-          end
-
-          def initialize_channel(channel, protocol)
-            protocol.initialize_channel(channel, @user_agent, @auth_token, @routing_context)
-          end
-
-          private
-
-          def bracketless(host)
-            host.delete_prefix('[').delete_suffix(']')
-          end
-
-          def install_channel_connected_listeners(address, channel_connected, handshake_completed)
-            pipeline = channel_connected.channel.pipeline
-
-            # add timeout handler to the pipeline when channel is connected. it's needed to limit amount of time code
-            # spends in TLS and Bolt handshakes. prevents infinite waiting when database does not respond
-            channel_connected.add_listener { pipeline.add_first(Inbound::ConnectTimeoutHandler.new(@connect_timeout_millis)) }
-
-            # add listener that sends Bolt handshake bytes when channel is connected
-            channel_connected.add_listener(ChannelConnectedListener.new(address, @pipeline_builder, handshake_completed, @logger))
-          end
-
-          def install_handshake_completed_listeners(handshake_completed, connection_initialized)
-            pipeline = handshake_completed.channel.pipeline
-
-            # remove timeout handler from the pipeline once TLS and Bolt handshakes are completed. regular protocol
-            # messages will flow next and we do not want to have read timeout for them
-            handshake_completed.add_listener { pipeline.remove(Inbound::ConnectTimeoutHandler.java_class) }
-
-            # add listener that sends an INIT message. connection is now fully established. channel pipeline if fully
-            # set to send/receive messages for a selected protocol version
-            handshake_completed.add_listener(HandshakeCompletedListener.new(@user_agent, @auth_token, @routing_context, connection_initialized))
-          end
-
-          class << self
-            def require_valid_auth_token(token)
-              if token.is_a? Internal::Security::InternalAuthToken
-                token
-              else
-                raise Exceptions::ClientException, "Unknown authentication token, `#{token}`. Please use one of the supported tokens from `#{AuthTokens.class}`."
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/connection/channel_pipeline_builder_impl.rb

@@ -1,22 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Connection
-        class ChannelPipelineBuilderImpl
-          def build(message_format, pipeline, logger)
-            # inbound handlers
-            pipeline.add_last(Inbound::ChunkDecoder.new(logger))
-            pipeline.add_last(Inbound::MessageDecoder.new)
-            pipeline.add_last(Inbound::InboundMessageHandler.new(message_format, logger))
-
-            # outbound handlers
-            pipeline.add_last(Outbound::OutboundMessageHandler::NAME, Outbound::OutboundMessageHandler.new(message_format, logger))
-
-            # last one - error handler
-            pipeline.add_last(Inbound::ChannelErrorHandler.new(logger))
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/connection/direct_connection.rb

@@ -1,30 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Connection
-        # This is a connection used by {@link DirectConnectionProvider} to connect to a remote database.
-        class DirectConnection < Struct.new(:delegate, :database_name, :mode, :impersonated_user)
-          delegate *%i[enable_auto_read disable_auto_read reset open? release terminate_and_release server_agent
-          server_address server_version protocol flush], to: :delegate
-          alias connection delegate
-
-          def write(message1, handler1, message2 = nil, handler2 = nil)
-            if message2.present? && handler2.present?
-              delegate.write(message1, handler1, message2, handler2)
-            else
-              delegate.write(message1, handler1)
-            end
-          end
-
-          def write_and_flush(message1, handler1, message2 = nil, handler2 = nil)
-            if message2.present? && handler2.present?
-              delegate.write_and_flush(message1, handler1, message2, handler2)
-            else
-              delegate.write_and_flush(message1, handler1)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/connection/event_loop_group_factory.rb

@@ -1,83 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Connection
-        class EventLoopGroupFactory
-          THREAD_NAME_PREFIX = "Neo4jDriverIO"
-          THREAD_PRIORITY = 10
-          THREAD_IS_DAEMON = true
-
-          class << self
-            # Get class of {@link Channel} for {@link Bootstrap#channel(Class)} method.
-
-            # @return class of the channel, which should be consistent with {@link EventLoopGroup}s returned by
-            # {@link #newEventLoopGroup(int)}.
-            def channel_class
-              # org.neo4j.driver.internal.shaded.io.netty.channel.socket.nio.NioSocketChannel
-            end
-
-            # Create new {@link EventLoopGroup} with specified thread count. Returned group should by given to
-            # {@link Bootstrap#group(EventLoopGroup)}.
-
-            # @param threadCount amount of IO threads for the new group.
-            # @return new group consistent with channel class returned by {@link #channelClass()}.
-            def new_event_loop_group(thread_count)
-              DriverEventLoopGroup.new(thread_count)
-            end
-
-            # Assert that current thread is not an event loop used for async IO operations. This check is needed because
-            # blocking API methods like {@link Session#run(String)} are implemented on top of corresponding async API methods
-            # like {@link AsyncSession#runAsync(String)} using basically {@link Future#get()} calls. Deadlocks might happen when IO
-            # thread executes blocking API call and has to wait for itself to read from the network.
-
-            # @throws IllegalStateException when current thread is an event loop IO thread.
-            def assert_not_in_event_loop_thread
-              if event_loop_thread?(Thread.current)
-                raise Exceptions::IllegalStateException, "Blocking operation can't be executed in IO thread because it might result in a deadlock. Please do not use blocking API when chaining futures returned by async API methods."
-              end
-            end
-
-            # Check if given thread is an event loop IO thread.
-
-            # @param thread the thread to check.
-            # @return {@code true} when given thread belongs to the event loop, {@code false} otherwise.
-            def event_loop_thread?(thread)
-              thread.is_a?(DriverThread)
-            end
-          end
-
-          private
-
-          # Same as {@link NioEventLoopGroup} but uses a different {@link ThreadFactory} that produces threads of
-          # {@link DriverThread} class. Such threads can be recognized by {@link #assertNotInEventLoopThread()}.
-          class DriverEventLoopGroup #< org.neo4j.driver.internal.shaded.io.netty.channel.nio.NioEventLoopGroup
-            def initialize(n_threads = nil)
-            end
-
-            protected
-
-            def new_default_thread_factory
-              DriverThreadFactory.new
-            end
-          end
-
-          #  Same as {@link DefaultThreadFactory} created by {@link NioEventLoopGroup} by default, except produces threads of
-          # {@link DriverThread} class. Such threads can be recognized by {@link #assertNotInEventLoopThread()}.
-
-          class DriverThreadFactory #< org.neo4j.driver.internal.shaded.io.netty.util.concurrent.DefaultThreadFactory
-            def initialize()
-              super(THREAD_NAME_PREFIX, THREAD_IS_DAEMON, THREAD_PRIORITY)
-            end
-
-            def new_thread(r, name)
-              DriverThread.new(@thread_group, r, name)
-            end
-          end
-
-          class DriverThread #< org.neo4j.driver.internal.shaded.io.netty.util.concurrent.FastThreadLocalThread
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/connection/handshake_completed_listener.rb

@@ -1,27 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Connection
-        class HandshakeCompletedListener
-          attr_reader :user_agent, :auth_token, :routing_context, :connection_initialized_promise
-
-          def initialize(user_agent, auth_token, routing_context, connection_initialized_promise)
-            @user_agent = java.util.Objects.require_non_null(user_agent)
-            @auth_token = java.util.Objects.require_non_null(auth_token)
-            @routing_context = routing_context
-            @connection_initialized_promise = java.util.Objects.require_non_null(connection_initialized_promise)
-          end
-
-          def operation_complete(future)
-            if future.is_success?
-              protocol = Messaging::BoltProtocol.for_channel(future.channel)
-              protocol.initialize_channel(user_agent, auth_token, routing_context, connection_initialized_promise)
-            else
-              connection_initialized_promise.set_failure(future.cause)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/connection/handshake_handler.rb

@@ -1,113 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Connection
-        class HandshakeHandler
-          def initialize(logger)
-            # @pipeline_builder = pipeline_builder
-            @log = logger
-          end
-
-          def handler_added(ctx)
-            @log = Logging::ChannelActivityLogger.new(ctx.channel, @logger, self.class)
-            @error_log = Logging::ChannelErrorLogger.new(ctx.channel, @logger)
-          end
-
-          def handler_removed0(ctx)
-            @failed = false
-            @log = nil
-          end
-
-          def channel_inactive(ctx)
-            @log.debug('Channel is inactive')
-
-            unless @failed
-              # channel became inactive while doing bolt handshake, not because of some previous error
-              error = Util::ErrorUtil.new_connection_terminated_error
-              fail(ctx, error)
-            end
-          end
-
-          def exception_caught(ctx, error)
-            if @failed
-              @error_log.debug('Another fatal error occurred in the pipeline', error)
-            else
-              @failed = true
-              cause = transform_error(error)
-              fail(ctx, cause)
-            end
-          end
-
-          def decode(connection)
-            server_suggested_version = Messaging::BoltProtocolVersion.from_raw_bytes(connection.stream.read_int)
-            @log.debug("S: [Bolt Handshake] #{server_suggested_version}")
-            # ::Logger.new(STDOUT, level: :debug).debug("S: [Bolt Handshake] #{server_suggested_version}")
-
-            protocol = protocol_for_version(server_suggested_version)
-            if protocol
-              protocol_selected(server_suggested_version, protocol, connection)
-            else
-              handle_unknown_suggested_protocol_version(server_suggested_version, connection)
-            end
-          end
-
-          private
-
-          def protocol_for_version(version)
-            Messaging::BoltProtocol.for_version(version)
-          rescue Neo4j::Driver::Exceptions::ClientException
-            nil
-          end
-
-          def protocol_selected(version, protocol, connection)
-            connection.attributes[:protocol_version] = version
-            connection.version = version
-            connection.protocol = protocol
-            connection.message_format = protocol.create_message_format
-          end
-
-          def handle_unknown_suggested_protocol_version(version, ctx)
-            if BoltProtocolUtil::NO_PROTOCOL_VERSION == version
-              fail(ctx, protocol_no_supported_by_server_error)
-            elsif Messaging::BoltProtocolVersion.http?(version)
-              fail(ctx, http_endpoint_error)
-            else
-              fail(ctx, protocol_no_supported_by_driver_error(version))
-            end
-          end
-
-          def fail(ctx, error)
-            ctx.close.add_listener { @handshake_completed_promise.try_failure(error) }
-          end
-
-          class << self
-            def protocol_no_supported_by_server_error
-              raise Neo4j::Driver::Exception::ClientException, 'The server does not support any of the protocol versions supported by this driver. Ensure that you are using driver and server versions that are compatible with one another.'
-            end
-
-            def http_endpoint_error
-              raise Neo4j::Driver::Exception::ClientException, 'Server responded HTTP. Make sure you are not trying to connect to the http endpoint (HTTP defaults to port 7474 whereas BOLT defaults to port 7687)'
-            end
-
-            def protocol_no_supported_by_driver_error(suggested_protocol_version)
-              raise Neo4j::Driver::Exception::ClientException, "Protocol error, server suggested unexpected protocol version: #{suggested_protocol_version}"
-            end
-
-            def transform_error(error)
-              # unwrap the DecoderException if it has a cause
-              error = error.cause if error.is_a?(org.neo4j.driver.internal.shaded.io.netty.handler.codec.DecoderException) && error.cause
-              case error
-              when Neo4j::Driver::Exception::ServiceUnavailableException
-                error
-              when javax.net.ssl.SSLHandshakeException
-                Neo4j::Driver::Exception::SecurityException.new('Failed to establish secured connection with the server', error)
-              else
-                Neo4j::Driver::Exception::ServiceUnavailableException('Failed to establish connection with the server', error)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end