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

data/ruby/neo4j/driver/auth_tokens.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    class AuthTokens
+      class << self
+        def basic(username, password, realm = nil)
+          Internal::Validator.require_non_nil_credentials!(username, password)
+          Internal::Security::InternalAuthToken[
+            { scheme: 'basic', principal: username, credentials: password, realm: realm }.compact]
+        end
+
+        def bearer(token)
+          Internal::Validator.require_non_nil!(token, "Token")
+          Internal::Security::InternalAuthToken[scheme: 'bearer', credentials: token]
+        end
+
+        def kerberos(base64_encoded_ticket)
+          Internal::Validator.require_non_nil!(base64_encoded_ticket, "Ticket")
+          Internal::Security::InternalAuthToken[scheme: 'bearer', credentials: base64_encoded_ticket]
+        end
+
+        def custom(principal, credentials, realm, scheme, **parameters)
+          Internal::Security::InternalAuthToken[{ scheme: scheme, principal: principal, credentials: credentials,
+                                                  realm: realm, parameters: parameters.presence || nil }.compact]
+        end
+
+        def none
+          Internal::Security::InternalAuthToken[scheme: 'none']
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/bookmark.rb

@@ -0,0 +1,21 @@
+module Neo4j
+  module Driver
+    # Causal chaining is carried out by passing bookmarks between transactions.
+
+    # When starting a session with initial bookmarks, the first transaction will be ensured to run at least after
+    # the database is as up-to-date as the latest transaction referenced by the supplied bookmarks.
+
+    # Within a session, bookmark propagation is carried out automatically.
+    # Thus all transactions in a session (both managed and unmanaged) are guaranteed to be carried out one after another.
+
+    # To opt out of this mechanism for unrelated units of work, applications can use multiple sessions.
+    module Bookmark
+      # Reconstruct bookmark from \bookmarks string values.
+      # @param values values obtained from a previous bookmark.
+      # @return A bookmark.
+      def self.from(*values)
+        Internal::InternalBookmark.parse(*values)
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/config.rb

@@ -0,0 +1,91 @@
+# 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
+
+        #
+        # {
+        #   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: TrustStrategy.trust_all_certificates,
+      }.freeze
+
+      def initialize(**config)
+        merge!(DEFAULTS).merge!(config.compact)
+        init_security_and_trust_config(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(config)
+        trust_strategy = config.key?(:trust_strategy) ? TrustStrategy.new(**config) : DEFAULTS[:trust_strategy]
+        encryption = config.key?(:encryption) ? config[:encryption] : DEFAULTS[:encryption]
+        customized = %i[encryption trust_strategy].any?(&config.method(:key?))
+        merge!(
+          security_settings: Neo4j::Driver::Internal::SecuritySetting.new(encryption, trust_strategy, customized),
+          trust_strategy: trust_strategy
+        )
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/graph_database.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver
+  class GraphDatabase
+    class << self
+      extend AutoClosable
+      extend Synchronizable
+      auto_closable :driver, :routing_driver
+      sync :driver
+
+      GOGOBOLT = ["6060B017"].pack('H*')
+
+      def handshake_concurrent(*versions)
+        remote_port = 7687
+        remote_addr = 'localhost'
+        selector = NIO::Selector.new
+        socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+        begin
+          socket.connect_nonblock Socket.sockaddr_in(remote_port, remote_addr)
+        rescue Errno::EINPROGRESS
+          # Ruby's a-tryin' to connect us, we swear!
+          selector.register(socket, :w)
+        end
+        selector.select do |monitor|
+          case monitor.io
+          when Socket
+            if monitor.writable?
+              begin
+                socket.connect_nonblock Socket.sockaddr_in(remote_port, remote_addr)
+              rescue Errno::EISCONN
+                # SUCCESS! Since Ruby is crazy we discover we're successful via an exception
+              end
+            end
+          end
+        end
+        socket.write_nonblock(GOGOBOLT)
+        socket.write_nonblock(bolt_versions(*versions))
+
+        @data = nil
+        begin
+          @data = socket.read_nonblock(16384)
+        rescue IO::WaitReadable
+          monitor = selector.register(socket, :r)
+          monitor.value = proc do
+            @data = socket.read_nonblock(16384)
+          end
+        end
+        Concurrent::Promises.future do
+          selector.select do |monitor|
+            monitor.value.call
+          end
+          ruby_version(@data)
+        end
+      end
+
+      class Connection < Async::Pool::Resource
+        attr :version, true
+        attr :io
+
+        def initialize
+          super
+          @io = Async::IO::Endpoint.tcp('localhost', 7687).connect
+        end
+
+        def close
+          super
+          @io.close
+        end
+      end
+
+      def driver(uri, auth_token = nil, **config)
+        internal_driver(uri, auth_token, config, Internal::DriverFactory.new)
+      end
+
+      def internal_driver(uri, auth_token, config, factory)
+        uri = URI(uri)
+        config = Config.new(**config)
+
+        factory.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_toke, **config)
+        assert_routing_uris(routing_uris)
+        log = Config.new(**config)[:logger]
+
+        routing_uris.each do |uri|
+          driver = driver(uri, auth_toke, **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 StandardError => 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

@@ -0,0 +1,51 @@
+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::V44::BoltProtocolV44::VERSION.to_int_range(Messaging::V42::BoltProtocolV42::VERSION),
+            Messaging::V41::BoltProtocolV41::VERSION.to_int,
+            Messaging::V4::BoltProtocolV4::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

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

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

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

@@ -0,0 +1,77 @@
+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)
+
+            channel_connected = ::Async::IO::Endpoint.tcp(socket_host, address.port).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

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

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

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

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