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

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

@@ -0,0 +1,172 @@
+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)
+              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.trace_or_debug('Closing channel because of a failure', error)
+            @channel.close
+          end
+
+          def clear_current_error
+            raise @current_error if @current_error
+          ensure
+            @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.config.set_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

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

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

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

@@ -0,0 +1,98 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      class InternalAsyncSession
+        def initialize(session)
+          @session = session
+        end
+
+        delegate :last_bookmark, :close_async, to: :@session
+
+        def run_async(query, parameters = {}, config = {})
+          @session.run_async(org.neo4j.driver.Query.new(query, **parameters), **config)
+        end
+
+        def begin_transaction_async(**config)
+          @session.begin_transaction_async(**config).then(&InternalAsyncTransaction.method(:new))
+        end
+
+        def read_transaction_async(**config, &work)
+          transaction_async(org.neo4j.driver.AccessMode::READ, **config, &work)
+        end
+
+        def write_transaction_async(**config, &work)
+          transaction_async(org.neo4j.driver.AccessMode::WRITE, **config, &work)
+        end
+
+        private
+
+        def transaction_async(mode, **config, &work)
+          @session.retry_logic.retry_async do
+            result_future = java.util.concurrent.CompletableFuture.new
+            tx_future = @session.begin_transaction_async(mode, ** config)
+
+            tx_future.when_complete do |tx, completion_error|
+              error = Util::Futures.completion_exception_cause(completion_error)
+
+              if !error.nil?
+                result_future.complete_exceptionally(error)
+              else
+                execute_work(result_future, tx, &work)
+              end
+            end
+            result_future
+          end
+        end
+
+        def execute_work(result_future, tx, &work)
+          work_future = safe_execute_work(tx, &work)
+
+          work_future.when_complete do |result, completion_error|
+            error = Util::Futures.completion_exception_cause(completion_error)
+
+            if !error.nil?
+              close_tx_after_failed_transaction_work(tx, result_future, error)
+            else
+              close_tx_after_succeeded_transaction_work(tx, result_future, result)
+            end
+          end
+        end
+
+        def safe_execute_work(tx)
+          # given work might fail in both async and sync way
+          # async failure will result in a failed future being returned
+          # sync failure will result in an exception being thrown
+          begin
+            result = yield InternalAsyncTransaction.new(tx)
+
+            # protect from given transaction function returning null
+            result == nil ? Util::Futures.completed_with_null : result
+          rescue StandardError => work_error
+            # work threw an exception, wrap it in a future and proceed
+            Util::Futures.failed_future(work_error)
+          end
+        end
+
+        def close_tx_after_failed_transaction_work(tx, result_future, error)
+          tx.close_async.when_complete do |_ignored, rollback_error|
+            error.add_suppressed(rollback_error) unless rollback_error.nil?
+
+            result_future.complete_exceptionally(error)
+          end
+        end
+
+        def close_tx_after_succeeded_transaction_work(tx, result_future, result)
+          tx.close_async(true).when_complete do |_ignored, completion_error|
+            commit_error = Util::Futures.completion_exception_cause(completion_error)
+
+            if !commit_error.nil?
+              result_future.complete_exceptionally(commit_error)
+            else
+              result_future.complete(result)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      class InternalAsyncTransaction
+        delegate :run_async, :commit_async, :rollback_async, :open?, to: :@tx
+
+        def initialize(tx)
+          @tx = tx
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      class LeakLoggingNetworkSession < NetworkSession
+        def initialize(connection_provider, retry_logic, database_name, mode, bookmark_holder, impersonated_user, fetch_size, logger)
+          super
+          @stack_trace = capture_stack_trace
+        end
+
+        def finalize
+          log_leak_if_needed
+          super
+        end
+
+        private
+
+        def log_leak_if_needed
+          is_open = Util::Futures.blocking_get(current_connection_is_open)
+          if is_open
+            @log.error do
+              "Neo4j Session object leaked, please ensure that your application fully consumes results in "\
+              "Sessions or explicitly calls `close` on Sessions before disposing of the objects.\n"\
+              "Session was created at:\n#{@stack_trace}"
+            end
+          end
+        end
+
+        def capture_stack_trace
+          Thread.current.backtrace.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,196 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      class NetworkConnection < ::Async::Pool::Resource
+        include Spi::Connection
+        delegate :protocol, to: :@channel
+
+        attr_reader :server_agent, :server_address, :server_version
+
+        def initialize(channel, channel_pool, logger)
+          super()
+          @log = logger
+          @channel = channel
+          @message_dispatcher = channel.attributes[:message_dispatcher]
+          @server_agent = channel.attributes[:server_agent]
+          @server_address = channel.attributes[:server_address]
+          @server_version = channel.attributes[:server_version]
+          @protocol = Messaging::BoltProtocol.for_channel(channel)
+          @channel_pool = channel_pool
+          # @release_future = java.util.concurrent.CompletableFuture.new
+          # @clock = clock
+          # @connection_read_timeout = Connection::ChannelAttributes.connection_read_timeout(channel) || nil
+          @status = Concurrent::AtomicReference.new(Status::OPEN)
+        end
+
+        # def close
+        #   super
+        #   @io.close
+        # end
+
+        def open?
+          @status.get == Status::OPEN
+        end
+
+        def enable_auto_read
+          set_auto_read(true) if open?
+        end
+
+        def disable_auto_read
+          set_auto_read(false) if open?
+        end
+
+        def flush
+          flush_in_event_loop if verify_open(nil, nil)
+        end
+
+        def write(message1, handler1, message2 = nil, handler2 = nil)
+          if message2.nil? && handler2.nil?
+            write_message_in_event_loop(message1, handler1, false) if verify_open(handler1, nil)
+          else
+            write_messages_in_event_loop(message1, handler1, message2, handler2, false) if verify_open(handler1, handler2)
+          end
+        end
+
+        def write_and_flush(message1, handler1, message2 = nil, handler2 = nil)
+          if message2.nil? && handler2.nil?
+            write_message_in_event_loop(message1, handler1, true) if verify_open(handler1, nil)
+          else
+            write_messages_in_event_loop(message1, handler1, message2, handler2, true) if verify_open(handler1, handler2)
+          end
+        end
+
+        def reset
+          result = java.util.concurrent.CompletableFuture.new
+          handler = Handlers::ResetResponseHandler.new(@message_dispatcher, result)
+          write_reset_message_if_needed(handler, true)
+          result
+        end
+
+        def release
+          if @status.compare_and_set(Status::OPEN, Status::RELEASED)
+            @channel_pool.release(@channel)
+          end
+          # handler = Handlers::ChannelReleasingResetResponseHandler.new(@channel, @channel_pool, @message_dispatcher, @clock, @release)
+          # write_reset_message_if_needed(handler, false)
+          # @metrics_listener.after_connection_released(Connection::ChannelAttributes.pool_id(@channel), @in_use_event)
+          # end
+          # @release_future
+        end
+
+        def terminate_and_release(reason)
+          if @status.compare_and_set(Status::OPEN, Status::TERMINATED)
+            Connection::ChannelAttributes.set_termination_reason(@channel, reason)
+            Util::Futures.as_completion_stage(@channel.close).exceptionally(-> (_throwable) { nil }).then_compose(-> (_ignored) { @channel_pool.release(@channel) }).when_complete do |_ignored, _throwable|
+              @release_future.complete(nil)
+              @metrics_listener.after_connection_released(Connection::ChannelAttributes.pool_id(@channel), @in_use_event)
+            end
+          end
+        end
+
+        private
+
+        def write_reset_message_if_needed(reset_handler, is_session_reset)
+          @channel.event_loop.execute do
+            if is_session_reset && !open?
+              reset_handler.on_success(java.util.Collections.empty_map)
+            else
+              # auto-read could've been disabled, re-enable it to automatically receive response for RESET
+              set_auto_read(true)
+              @message_dispatcher.enqueue(reset_handler)
+              @channel.write_and_flush(Messaging::Request::ResetMessage::RESET).add_listener(-> (_future) { register_connection_read_timeout(@channel) })
+            end
+          end
+        end
+
+        def flush_in_event_loop
+          @channel.event_loop.execute do
+            @channel.flush
+            register_connection_read_timeout(@channel)
+          end
+        end
+
+        def write_message_in_event_loop(message, handler, flush)
+          @message_dispatcher.enqueue(handler)
+
+          if flush
+            @channel.write_and_flush(message)#.add_listener(-> (_future) { register_connection_read_timeout(@channel) })
+          else
+            @channel.write(message)
+          end
+        end
+
+        def write_messages_in_event_loop(message1, handler1, message2, handler2, flush)
+          @channel.event_loop.execute do
+            @message_dispatcher.enqueue(handler1)
+            @message_dispatcher.enqueue(handler2)
+
+            @channel.write(message1, channel.void_promise)
+
+            if flush
+              @channel.write_and_flush(message2).add_listener(-> (_future) { register_connection_read_timeout(@channel) })
+            else
+              @channel.write(message2, @channel.void_promise)
+            end
+          end
+        end
+
+        def set_auto_read(value)
+          @channel.config.set_auto_read(value)
+        end
+
+        def verify_open(handler1, handler2)
+          connection_status = @status.get
+
+          case connection_status
+          when 'open'
+            true
+          when 'released'
+            error = Neo4j::Driver::Exceptions::IllegalStateException.new("Connection has been released to the pool and can't be used")
+
+            handler1.on_failure(error) unless handler1.nil?
+
+            handler2.on_failure(error) unless handler2.nil?
+
+            false
+          when 'terminated'
+            terminated_error = Neo4j::Driver::Exceptions::IllegalStateException.new("Connection has been terminated and can't be used")
+
+            handler1.on_failure(terminated_error) unless handler1.nil?
+
+            handler2.on_failure(terminated_error) unless handler2.nil?
+
+            false
+          else
+            raise Neo4j::Driver::Exceptions::IllegalStateException.new("Unknown status: #{connection_status}")
+          end
+        end
+
+        def register_connection_read_timeout(channel)
+          if !channel.event_loop.in_event_loop
+            raise Neo4j::Driver::Exceptions::IllegalStateException.new('This method may only be called in the EventLoop')
+          end
+
+          if !@connection_read_timeout.nil? && @connection_read_timeout_handler.nil?
+            connection_read_timeout_handler = Inbound::ConnectionReadTimeoutHandler.new(@connection_read_timeout, java.util.concurrent.TimeUnit::SECONDS)
+            channel.pipeline.add_first(connection_read_timeout_handler)
+            @log.debug('Added ConnectionReadTimeoutHandler')
+
+            @message_dispatcher.set_before_last_handler_hook do |message_type|
+              channel.pipeline.remove(connection_read_timeout_handler)
+              connection_read_timeout_handler = nil
+              @message_dispatcher.set_before_last_handler_hook(nil)
+              log.debug('Removed ConnectionReadTimeoutHandler')
+            end
+          end
+        end
+
+        class Status
+          OPEN = 'open'
+          RELEASED = 'released'
+          TERMINATED = 'terminated'
+        end
+      end
+    end
+  end
+end