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

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

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

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

@@ -0,0 +1,57 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      module Connection
+        class NettyChannelInitializer #< org.neo4j.driver.internal.shaded.io.netty.channel.ChannelInitializer
+          def initialize(address, security_plan, connect_timeout_millis, clock, logger)
+            super()
+            @address = address
+            @security_plan = security_plan
+            @connect_timeout_millis = connect_timeout_millis
+            @clock = clock
+            @logger = logger
+          end
+
+          protected
+
+          def initChannel(channel)
+            if @security_plan.requires_encryption?
+              ssl_handler = create_ssl_handler
+              channel.pipeline.add_first(ssl_handler)
+            end
+
+            update_channel_attributes(channel)
+          end
+
+          private
+
+          def create_ssl_handler
+            ssl_engine = create_ssl_engine
+            ssl_handler = org.neo4j.driver.internal.shaded.io.netty.handler.ssl.SslHandler.new(ssl_engine)
+            ssl_handler.set_handshake_timeout_millis(@connect_timeout_millis)
+            ssl_handler
+          end
+
+          def create_ssl_engine
+            ssl_context = @security_plan.ssl_context
+            ssl_engine = ssl_context.create_ssl_engine(@address.host, @address.port)
+            ssl_engine.set_use_client_mode(true)
+
+            if @security_plan.requires_hostname_verification
+              ssl_parameters = ssl_engine.get_ssl_parameters
+              ssl_parameters.set_endpoint_identification_algorithm('HTTPS')
+              ssl_engine.set_ssl_parameters(ssl_parameters)
+            end
+            ssl_engine
+          end
+
+          def update_channel_attributes(channel)
+            ChannelAttributes.set_server_address(channel, @address)
+            ChannelAttributes.set_creation_timestamp(channel, @clock.millis)
+            ChannelAttributes.set_message_dispatcher(channel, Inbound::InboundMessageDispatcher.new(channel, @logger))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      module Connection
+        class NettyDomainNameResolver #< org.neo4j.driver.internal.shaded.io.netty.resolver.InetNameResolver
+          def initialize(executor, domain_name_resolver)
+            # super(executor)
+            @domain_name_resolver = domain_name_resolver
+          end
+
+          def doResolve(inet_host, promise)
+            promise.set_success(@domain_name_resolver.call(inet_host).first)
+          rescue java.net.UnknownHostException => e
+            promise.set_failure(e)
+          end
+
+          def doResolveAll(inet_host, promise)
+            promise.set_success(@domain_name_resolver.call(inet_host))
+          rescue java.net.UnknownHostException => e
+            promise.set_failure(e)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      module Connection
+        class NettyDomainNameResolverGroup #< org.neo4j.driver.internal.shaded.io.netty.resolver.AddressResolverGroup
+          attr_reader :domain_name_resolver
+
+          def initialize(&domain_name_resolver)
+            @domain_name_resolver = domain_name_resolver
+          end
+
+          def newResolver(executor)
+            NettyDomainNameResolver.new(executor, domain_name_resolver).as_address_resolver
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      module Connection
+        # A connection used by the routing driver.
+        class RoutingConnection < Struct.new(:delegate, :database_name, :access_mode, :impersonated_user, :error_handler)
+          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 mode access_mode
+
+          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
+
+          private
+
+          def new_routing_response_handler(handler)
+            Handlers::RoutingResponseHandler.new(handler, server_address, access_mode, error_handler)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      module Connection
+        class Stream < ::Async::IO::Stream
+          include Packstream::PackInput
+          include Packstream::PackOutput
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      module Connection
+        class StreamReader
+          include Inbound::ChunkDecoder
+          include Packstream::PackInput
+          include Packstream::PackStream::Unpacker
+          include Messaging::Common::CommonValueUnpacker
+          # delegate_missing_to :@input
+
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/async/connection_context.rb

@@ -0,0 +1,10 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      module ConnectionContext
+        PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER =
+          ->() { Exceptions::IllegalStateException.new('Pending database name encountered') }
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/async/immutable_connection_context.rb

@@ -0,0 +1,24 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      class ImmutableConnectionContext
+        attr :database_name, :mode, :rediscovery_bookmark, :impersonated_user
+
+        def initialize(database_name, bookmark, mode)
+          @database_name = database_name
+          @rediscovery_bookmark = bookmark
+          @mode = mode
+        end
+
+        SINGLE_DB_CONTEXT = new(DatabaseNameUtil::DEFAULT_DATABASE, InternalBookmark::EMPTY, AccessMode::READ)
+        MULTI_DB_CONTEXT = new(DatabaseNameUtil::SYSTEM_DATABASE, InternalBookmark::EMPTY, AccessMode::READ)
+
+        # A simple context is used to test connectivity with a remote server/cluster. As long as there is a read only service, the connection shall be established
+        # successfully. Depending on whether multidb is supported or not, this method returns different context for routing table discovery.
+        def self.simple(supports_multi_db)
+          supports_multi_db ? MULTI_DB_CONTEXT : SINGLE_DB_CONTEXT
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/async/inbound/byte_buf_input.rb

@@ -0,0 +1,30 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      module Inbound
+        class ByteBufInput
+          delegate :read_byte, :read_short, :read_int, :read_long, :read_double, :read_bytes, to: :@buf
+
+          def start(new_buf)
+            assert_not_started
+            @buf = Validator.require_non_nil!(new_buf)
+          end
+
+          def stop
+            @buf = nil
+          end
+
+          def peek_byte
+            @buf.get_byte(@buf.read_index)
+          end
+
+          private
+
+          def assert_not_started
+            raise Neo4j::Driver::Exceptions::IllegalStateException, 'Already started' if @buf
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/async/inbound/channel_error_handler.rb

@@ -0,0 +1,77 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      module Inbound
+        class ChannelErrorHandler
+          def initialize(logger)
+            @logger = logger
+          end
+
+          def handler_added(ctx)
+            @message_dispatcher = java.util.Objects.require_non_null(Connection::ChannelAttributes.message_dispatcher(ctx.channel))
+            @log = Logging::ChannelActivityLogger.new(ctx.channel, @logger, self.class)
+            @error_log = Logging::ChannelErrorLogger.new(ctx.channel, @logger)
+          end
+
+          def handler_removed(ctx)
+            @message_dispatcher = @log = nil
+            @failed = false
+          end
+
+          def channel_inactive(ctx)
+            @log.debug('Channel is inactive')
+
+            termination_reason = Connection::ChannelAttributes.termination_reason(ctx.channel)
+            error = Util::ErrorUtil.new_connection_terminated_error(termination_reason)
+
+            if @failed
+
+              # channel became inactive not because of a fatal exception that came from exceptionCaught
+              # it is most likely inactive because actual network connection broke or was explicitly closed by the driver
+              @message_dispatcher.handle_channel_inactive(error)
+              ctx.channel.close
+            else
+              fail(error)
+            end
+          end
+
+          def exception_caught(ctx, error)
+            if @failed
+              @error_log.trace_or_debug('Another fatal error occurred in the pipeline', error)
+            else
+              @failed = true
+              log_unexpected_error_warning(error)
+              fail(error)
+            end
+          end
+
+          private
+
+          def log_unexpected_error_warning(error)
+            unless error.is_a?(Exceptions::ConnectionReadTimeoutException)
+              @error_log.trace_or_debug('Fatal error occurred in the pipeline', error)
+            end
+          end
+
+          def fail(error)
+            cause = transform_error(error)
+            @message_dispatcher.handle_channel_error(cause)
+          end
+
+          class << self
+            def transform_error(error)
+              # unwrap the CodecException if it has a cause
+              error = error.cause if error.is_a?(io.netty.handler.codec.CodecException) && error.cause
+
+              if error.is_a?(java.io.IOException)
+                Neo4j::Driver::Exceptions::ServiceUnavailableException.new('Connection to the database failed', error)
+              else
+                error
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/async/inbound/chunk_decoder.rb

@@ -0,0 +1,41 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      module Inbound
+        module ChunkDecoder
+          def initialize(input)
+            @input = input
+            @remaining = 0
+          end
+
+          def read_exactly(size, buffer = nil)
+            while @remaining.zero?
+              @remaining = read_length_field
+            end
+            if size > @remaining
+              # (buffer ||= Buffer.new(capacity: size)) << super(@remaining)
+              (buffer ||= ::Async::IO::Buffer.new) << @input.read_exactly(@remaining)
+              size -= @remaining
+              @remaining = 0
+              read_exactly(size, buffer)
+            else
+              data = @input.read_exactly(size)
+              @remaining -= size
+              buffer ? buffer << data : data
+            end
+          end
+
+          def ensure_termination
+            raise 'Chunking problem' unless @remaining.zero? && read_length_field.zero?
+          end
+
+          private
+
+          def read_length_field
+            @input.read_exactly(2).unpack1('S>')
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/async/inbound/connect_timeout_handler.rb

@@ -0,0 +1,32 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      module Inbound
+        # Handler needed to limit amount of time connection performs TLS and Bolt handshakes.
+        # It should only be used when connection is established and removed from the pipeline afterwards.
+        # Otherwise it will make long running queries fail.
+        class ConnectTimeoutHandler #< org.neo4j.driver.internal.shaded.io.netty.handler.timeout.ReadTimeoutHandler
+          def initialize(timeout_millis)
+            super(timeout_millis, java.util.concurrent.TimeUnit::MILLISECONDS)
+            @timeout_millis = timeout_millis
+          end
+
+          protected
+
+          def readTimedOut(ctx)
+            unless @triggered
+              @triggered = true
+              ctx.fire_exception_caught(unable_to_connect_error)
+            end
+          end
+
+          private
+
+          def unable_to_connect_error
+            Neo4j::Driver::Exceptions::ServiceUnavailableException.new("Unable to establish connection in #{@timeout_millis}ms")
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/async/inbound/connection_read_timeout_handler.rb

@@ -0,0 +1,17 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      module Inbound
+        class ConnectionReadTimeoutHandler #< org.neo4j.driver.internal.shaded.io.netty.handler.timeout.ReadTimeoutHandler
+          def read_timeout(ctx)
+            unless @triggered
+              ctx.fire_exception_caught(Neo4j::Driver::Exception::ConnectionReadTimeoutException::INSTANCE)
+              ctx.close
+              @triggered = true
+            end
+          end
+        end
+      end
+    end
+  end
+end