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

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

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

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

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

@@ -1,194 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      class NetworkConnection
-        include Spi::Connection
-        delegate :protocol, to: :@channel
-
-        attr_reader :server_agent, :server_address, :server_version
-
-        def initialize(channel, channel_pool, logger, &on_pool_shutdown)
-          @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
-          @on_pool_shutdow = on_pool_shutdown
-          # @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 open?
-          @status.get == Status::OPEN
-        end
-
-        def enable_auto_read
-          @channel.auto_read = true if open?
-        end
-
-        def disable_auto_read
-          @channel.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)
-            handler = Handlers::ChannelReleasingResetResponseHandler.new(@channel, @channel_pool, @message_dispatcher, @log, @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
-        end
-
-        def terminate_and_release(reason)
-          if @status.compare_and_set(Status::OPEN, Status::TERMINATED)
-            @channel.attributes[:termination_reason] = reason
-            @channel.close rescue nil
-            @channel_pool.release(@channel)
-            # @metrics_listener.after_connection_released(Connection::ChannelAttributes.pool_id(@channel), @in_use_event)
-          end
-        end
-
-        private
-
-        def write_reset_message_if_needed(reset_handler, is_session_reset)
-          if is_session_reset && !open?
-            reset_handler.on_success
-          else
-            # auto-read could've been disabled, re-enable it to automatically receive response for RESET
-            @channel.auto_read = true
-            @message_dispatcher.enqueue(reset_handler)
-            write_to_channel(Messaging::Request::ResetMessage::RESET, true)
-          end
-        end
-
-        def write_to_channel(message, flush = false)
-          if flush
-            @channel.write_and_flush(message) #.add_listener(-> (_future) { register_connection_read_timeout(@channel) })
-          else
-            @channel.write(message)
-          end
-        rescue EOFError, Errno::ECONNRESET, Errno::EPIPE => e
-          terminate_and_release(e.message)
-          @log.debug("Shutting down connection pool towards #{@server_address} due to error: #{e.message}")
-          @channel_pool.shutdown(&:close)
-          @on_pool_shutdow.call
-          # should remove routing table entry as well
-          raise Exceptions::SessionExpiredException, e.message
-        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)
-
-          write_to_channel(message, flush)
-        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 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

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

@@ -1,150 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      class NetworkSession
-        attr_reader :retry_logic
-
-        def initialize(connection_provider, retry_logic, database_name, mode, bookmark_holder, impersonated_user, fetch_size, logger)
-          @connection_provider = connection_provider
-          @mode = mode
-          @retry_logic = retry_logic
-          @log = Logging::PrefixedLogger.new("[#{hash}]", logger)
-          @bookmark_holder = bookmark_holder
-          # @database_name = database_name.database_name
-          @connection_context = NetworkSessionConnectionContext.new(database_name, @bookmark_holder.bookmark, impersonated_user)
-          @fetch_size = fetch_size
-          @open = Concurrent::AtomicBoolean.new(true)
-        end
-
-        def run_async(query, **config)
-          new_result_cursor = build_result_cursor_factory(query, config).async_result
-          @result_cursor = new_result_cursor
-          new_result_cursor.map_successful_run_completion_async
-        end
-
-        def begin_transaction_async(mode = @mode, **config)
-          ensure_session_is_open
-          ensure_no_open_tx_before_starting_tx
-          acquire_connection(mode).then do |connection|
-            ImpersonationUtil.ensure_impersonation_support(connection, connection.impersonated_user)
-            tx = UnmanagedTransaction.new(connection, @bookmark_holder, @fetch_size)
-            tx.begin_async(@bookmark_holder.bookmark, config)
-          end&.tap { |new_transaction| @transaction = new_transaction }
-        end
-
-        def reset_async
-          existing_transaction_or_null
-            .then_accept { |tx| tx&.mark_terminated }
-            .then_flat { @connection_stage }
-            .then_flat do |connection|
-            # there exists an active connection, send a RESET message over it
-            connection&.reset || Util::Futures.completed_with_null
-          end
-        end
-
-        def last_bookmark
-          @bookmark_holder.bookmark
-        end
-
-        def release_connection_async
-          @connection&.release
-        end
-
-        def connection_async
-          @connection
-        end
-
-        def open?
-          @open.true?
-        end
-
-        def close_async
-          return unless @open.make_false
-          # there exists a cursor with potentially unconsumed error, try to extract and propagate it
-          error = @result_cursor&.discard_all_failure_async
-          close_transaction_and_release_connection
-        rescue => tx_close_error
-          error = Util::Futures.combine_errors(error, tx_close_error)
-        ensure
-          raise error if error
-        end
-
-        def current_connection_open?
-          @connection&.open? # some connection has actually been acquired and it's still open
-        end
-
-        private
-
-        def build_result_cursor_factory(query, config)
-          ensure_session_is_open
-          ensure_no_open_tx_before_running_query
-          connection = acquire_connection(@mode)
-          ImpersonationUtil.ensure_impersonation_support(connection, connection.impersonated_user)
-          connection.protocol.run_in_auto_commit_transaction(connection, query, @bookmark_holder, config,
-                                                             @fetch_size)
-        end
-
-        def acquire_connection(mode)
-          # make sure previous result is fully consumed and connection is released back to the pool
-          @result_cursor&.pull_all_failure_async&.result!&.then(&method(:raise))
-          if @connection&.open?
-            # there somehow is an existing open connection, this should not happen, just a precondition
-            raise Neo4j::Driver::Exceptions::IllegalStateException.new('Existing open connection detected')
-          end
-
-          @connection = @connection_provider.acquire_connection(@connection_context.context_with_mode(mode))
-        end
-
-        def close_transaction_and_release_connection
-          existing_transaction_or_null&.close_async
-        ensure
-          release_connection_async
-        end
-
-        def ensure_no_open_tx_before_running_query
-          ensure_no_open_tx('Queries cannot be run directly on a session with an open transaction; either run from within the transaction or use a different session.')
-        end
-
-        def ensure_no_open_tx_before_starting_tx
-          ensure_no_open_tx('You cannot begin a transaction on a session with an open transaction; either run from within the transaction or use a different session.')
-        end
-
-        def ensure_no_open_tx(error_message)
-          existing_transaction_or_null&.then do
-            raise Neo4j::Driver::Exceptions::TransactionNestingException.new(error_message)
-          end
-        end
-
-        def existing_transaction_or_null
-          @transaction if @transaction&.open?
-        end
-
-        def ensure_session_is_open
-          unless @open.true?
-            raise Neo4j::Driver::Exceptions::ClientException.new('No more interaction with this session are allowed as the current session is already closed.')
-          end
-        end
-
-        # The {@link NetworkSessionConnectionContext#mode} can be mutable for a session connection context
-        class NetworkSessionConnectionContext
-          # This bookmark is only used for rediscovery.
-          # It has to be the initial bookmark given at the creation of the session.
-          # As only that bookmark could carry extra system bookmarks
-          attr_accessor :database_name
-          attr :mode, :rediscovery_bookmark, :impersonated_user
-
-          def initialize(database_name, bookmark, impersonated_user)
-            @database_name = database_name
-            @rediscovery_bookmark = bookmark
-            @impersonated_user = impersonated_user
-          end
-
-          def context_with_mode(mode)
-            @mode = mode
-            self
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/outbound/chunk_aware_byte_buf_output.rb

@@ -1,110 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Outbound
-        class ChunkAwareByteBufOutput
-          include Packstream::PackStream::Packer
-          include Messaging::Common::CommonValuePacker
-
-          class ChunkBuffer < ::Async::IO::Buffer
-            include Packstream::PackOutput
-            alias write <<
-          end
-
-          def initialize(output, max_chunk_size: Connection::BoltProtocolUtil::DEFAULT_MAX_OUTBOUND_CHUNK_SIZE_BYTES)
-            @output = output
-            @max_chunk_size = verify_max_chunk_size(max_chunk_size)
-            @chunk = ChunkBuffer.new
-          end
-
-          def start
-            assert_not_started
-            @chunk.clear
-          end
-
-          def write_byte(value)
-            ensure_can_fit_in_current_chunk(1)
-            @chunk.write_byte(value)
-            self
-          end
-
-          def write(data)
-            offset = 0
-            length = data.bytesize
-
-            while offset < length
-              # Ensure there is an open chunk, and that it has at least one byte of space left
-              ensure_can_fit_in_current_chunk(1)
-
-              # Write as much as we can into the current chunk
-              amount_to_write = [available_bytes_in_current_chunk, length - offset].min
-
-              @chunk.write(data.byteslice(offset, amount_to_write))
-              offset += amount_to_write
-            end
-
-            self
-          end
-
-          def write_short(value)
-            ensure_can_fit_in_current_chunk(2)
-            @chunk.write_short(value)
-            self
-          end
-
-          def write_int(value)
-            ensure_can_fit_in_current_chunk(4)
-            @chunk.write_int(value)
-            self
-          end
-
-          def write_long(value)
-            ensure_can_fit_in_current_chunk(8)
-            @chunk.write_long(value)
-            self
-          end
-
-          def write_double(value)
-            ensure_can_fit_in_current_chunk(8)
-            @chunk.write_double(value)
-            self
-          end
-
-          def write_message_boundary
-            @output.write_short(0)
-          end
-
-          def write_chunk
-            @output.write_short(@chunk.bytesize)
-            @output.write(@chunk)
-            @chunk.clear
-          end
-
-          alias stop write_chunk
-
-          private
-
-          def ensure_can_fit_in_current_chunk(number_of_bytes)
-            write_chunk if @chunk.bytesize + number_of_bytes > @max_chunk_size
-          end
-
-          def available_bytes_in_current_chunk
-            @max_chunk_size - @chunk.bytesize
-          end
-
-          def assert_not_started
-            raise Neo4j::Driver::Exceptions::IllegalStateException.new('Already started') unless @chunk.empty?
-          end
-
-          def verify_max_chunk_size(max_chunk_size)
-            if max_chunk_size <= 0
-              raise ArgumentError.new("Max chunk size should be > 0, given: #{max_chunk_size}")
-            end
-
-            max_chunk_size
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/outbound/outbound_message_handler.rb

@@ -1,39 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Outbound
-        class OutboundMessageHandler
-          NAME = self.class.name
-
-          def initialize(output, message_format, logger)
-            @output = output
-            @writer = message_format.new_writer(output)
-            @log = logger
-          end
-
-          def handler_added(ctx)
-            @log = Logging::ChannelActivityLogger.new(ctx.channel, @log, self.class)
-          end
-
-          def handler_removed(ctx)
-            @log = nil
-          end
-
-          def encode(msg)
-            @log.debug("C: #{msg}")
-
-            @output.start
-            begin
-              @writer.write(msg)
-            ensure
-              @output.stop
-            end
-
-            @output.write_message_boundary
-            # @log.debug( "C: #{}") if @log.debug_enabled?
-          end
-        end
-      end
-    end
-  end
-end