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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,171 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Inbound
-        class InboundMessageDispatcher
-          attr_reader :fatal_error_occurred, :current_error
-
-          def initialize(channel, logger)
-            @handlers = []
-            @channel = Validator.require_non_nil!(channel)
-            @log = Logging::ChannelActivityLogger.new(channel, logger, self.class)
-            @error_log = Logging::ChannelErrorLogger.new(channel, logger)
-          end
-
-          def enqueue(handler)
-            if fatal_error_occurred
-              handler.on_failure(@current_error)
-            else
-              @handlers << handler
-              update_auto_read_managing_handler_if_needed(handler)
-            end
-          end
-
-          def set_before_last_handler_hook(before_last_handler_hook)
-            unless @channel.event_loop.in_event_loop
-              raise Neo4j::Driver::Exceptions::IllegalStateException.new('This method may only be called in the EventLoop')
-            end
-            @before_last_handler_hook = before_last_handler_hook
-          end
-
-          def queued_handlers_count
-            @handlers.size
-          end
-
-          def handle_success_message(meta)
-            @log.debug("S: SUCCESS #{meta}")
-            invoke_before_last_handler_hook(HandlerHook::SUCCESS)
-            handler = remove_handler
-            handler.on_success(meta)
-          end
-
-          def handle_record_message(fields)
-            @log.debug { "S: RECORD #{fields}" }
-
-            (@handlers.first or
-              raise Exceptions::IllegalStateException,
-                    "No handler exists to handle RECORD message with fields #{fields}")
-              .on_record(fields)
-          end
-
-          def handle_failure_message(code:, message:)
-            @log.debug("S: FAILURE #{code}, '#{message}'")
-            @current_error = Util::ErrorUtil.new_neo4j_error(code, message)
-
-            # we should not continue using channel after a fatal error
-            # fire error event back to the pipeline and avoid sending RESET
-
-            # return @channel.pipeline.fire_exception_caught(current_error) if Util::ErrorUtil.fatal?(current_error)
-            raise @current_error if Util::ErrorUtil.fatal?(@current_error) # TODO clarify
-
-            if @current_error.is_a?(Exceptions::AuthorizationExpiredException)
-              # TODO: ??????
-              # Connection::ChannelAttributes.authorization_state_listener(@channel).on_expired(@current_error, @channel)
-            else
-              # write a RESET to "acknowledge" the failure
-              enqueue(Handlers::ResetResponseHandler.new(self))
-              @channel.write_and_flush(Messaging::Request::ResetMessage::RESET)
-            end
-
-            invoke_before_last_handler_hook(HandlerHook::FAILURE)
-            handler = remove_handler
-            handler.on_failure(@current_error)
-          end
-
-          def handle_ignored_message
-            @log.debug('S: IGNORED')
-            handler = remove_handler
-
-            if @current_error
-              error = @current_error
-            else
-              @log.warn("Received IGNORED message for handler #{handler} but error is missing and RESET is not in progress. Current handlers #{@handlers}")
-              error = Exceptions::ClientException.new('Database ignored the request')
-            end
-
-            handler.on_failure(error)
-          end
-
-          def handle_channel_inactive(cause)
-            # report issue if the connection has not been terminated as a result of a graceful shutdown request from its
-            # parent pool
-            if !@gracefully_closed
-              handle_channel_error(cause)
-            else
-              @channel.close
-            end
-          end
-
-          def handle_channel_error(error)
-            if @current_error
-              # we already have an error, this new error probably is caused by the existing one, thus we chain the new error on this current error
-              Util::ErrorUtil.add_suppressed(@current_error, error)
-            else
-              @current_error = error
-            end
-
-            @fatal_error_occurred = true
-
-            while !@handlers.empty?
-              handler = remove_handler
-              handler.on_failure(@current_error)
-            end
-
-            @error_log.debug('Closing channel because of a failure', error)
-            @channel.close
-          end
-
-          def clear_current_error
-            @current_error = nil
-          end
-
-          def prepare_to_close_channel
-            @gracefully_closed = true
-          end
-
-          def remove_handler
-            handler = @handlers.shift
-
-            if handler == @auto_read_managing_handler
-              # the auto-read managing handler is being removed
-              # make sure this dispatcher does not hold on to a removed handler
-              update_auto_read_managing_handler(nil)
-            end
-            handler
-          end
-
-          private
-
-          def update_auto_read_managing_handler_if_needed(handler)
-            if handler.can_manage_auto_read?
-              update_auto_read_managing_handler(handler)
-            end
-          end
-
-          def update_auto_read_managing_handler(new_handler)
-            if @auto_read_managing_handler
-
-              # there already exists a handler that manages channel's auto-read
-              # make it stop because new managing handler is being added and there should only be a single such handler
-              @auto_read_managing_handler.disable_auto_read_management
-
-              # restore the default value of auto-read
-              @channel.auto_read = true
-            end
-
-            @auto_read_managing_handler = new_handler
-          end
-
-          def invoke_before_last_handler_hook(message_type)
-            @before_last_handler_hook&.run(message_type) if @handlers.size == 1
-          end
-
-          module HandlerHook
-            SUCCESS = :success
-            FAILURE = :failure
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Inbound
-        class InboundMessageHandler #< org.neo4j.driver.internal.shaded.io.netty.channel.SimpleChannelInboundHandler
-          def initialize(message_format, logger)
-            @input = ByteBufInput.new
-            @reader = message_format.new_reader(input)
-            @logger = logger
-          end
-
-          def handler_added(ctx)
-            @message_dispatcher = Validator::require_non_nil!(connection.ChannelAttributes.message_dispatcher(ctx.channel))
-            @log = Logging::ChannelActivityLogger.new(ctx.channel, logger, self.class)
-          end
-
-          def handler_removed(_ctx)
-            @message_dispatcher = nil
-            @log = nil
-          end
-
-          def channel_read0(_ctx, msg)
-            if message_dispatcher.fatal_error_occurred
-              return @log.warn( "Message ignored because of the previous fatal error. Channel will be closed. Message:\n#{org.neo4j.driver.internal.shaded.io.netty.buffer.ByteBufUtil.hex_dump(msg)}")
-            end
-
-            @log.debug( "S: #{org.neo4j.driver.internal.shaded.io.netty.buffer.ByteBufUtil.hex_dump(msg)}") if @log.is_trace_enabled?
-
-            @input.start(msg)
-            begin
-              @reader.read(@message_dispatcher)
-            rescue StandardError => error
-              org.neo4j.driver.internal.shaded.io.netty.handler.codec.DecoderException.new("Failed to read inbound message:\n#{org.neo4j.driver.internal.shaded.io.netty.buffer.ByteBufUtil.hex_dump(msg)}\n", error)
-            ensure
-              @input.stop
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Inbound
-        class MessageDecoder #<  org.neo4j.driver.internal.shaded.io.netty.handler.codec.ByteToMessageDecoder
-          class << self
-            def determine_default_cumulator
-              value = ENV['message_decoder_cumulator']
-              # 'merge' ==  value ? org.neo4j.driver.internal.shaded.io.netty.handler.codec.ByteToMessageDecoder::MERGE_CUMULATOR : org.neo4j.driver.internal.shaded.io.netty.handler.codec.ByteToMessageDecoder::COMPOSITE_CUMULATOR
-            end
-          end
-
-          DEFAULT_CUMULATOR = determine_default_cumulator
-
-          def initialize
-            set_cumulator(DEFAULT_CUMULATOR)
-          end
-
-          def channel_read(ctx, msg)
-            if msg.is_a?(org.neo4j.driver.internal.shaded.io.netty.buffer.ByteBuf)
-
-              # on every read check if input buffer is empty or not
-              # if it is empty then it's a message boundary and full message is in the buffer
-              @read_message_boundary = msg.readable_bytes == 0
-            end
-
-            org.neo4j.driver.internal.shaded.io.netty.handler.codec.ByteToMessageDecoder.channel_read(ctx, msg)
-          end
-
-          def decode(ctx, inward, out)
-            if @read_message_boundary
-
-              # now we have a complete message in the input buffer
-
-              # increment ref count of the buffer and create it's duplicate that shares the content
-              # duplicate will be the output of this decoded and input for the next one
-              message_buf = inward.retained_duplicate
-
-              # signal that whole message was read by making input buffer seem like it was fully read/consumed
-              inward.reader_index(inward.readable_bytes)
-
-              # pass the full message to the next handler in the pipeline
-              out.add(message_buf)
-              @read_message_boundary = false
-            end
-          end
-        end
-      end
-    end
-  end
-end