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

data/ruby/neo4j/driver/internal/async/pool/channel.rb

@@ -1,66 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Pool
-        class Channel
-          attr :stream
-          attr_accessor :version, :protocol, :message_format, :message_dispatcher
-          attr :attributes # should be attr
-          attr_accessor :auto_read
-
-          def initialize(address, connector, logger)
-            @attributes = Connection::ChannelAttributes.new
-            @attributes[:server_address] = address
-            @stream = Connection::Stream.new(connect_to_io_socket(connector, address))
-            @stream.write(Connection::BoltProtocolUtil.handshake_buf)
-            @stream.flush
-            Connection::HandshakeHandler.new(logger).decode(self)
-            stream_writer = Outbound::ChunkAwareByteBufOutput.new(@stream)
-            @message_dispatcher = Inbound::InboundMessageDispatcher.new(self, logger)
-            @attributes[:message_dispatcher] = @message_dispatcher
-            @outbound_handler = Outbound::OutboundMessageHandler.new(stream_writer, message_format, logger)
-            @common_message_reader = message_format.new_reader(@stream)
-            connector.initialize_channel(self, protocol)
-          end
-
-          def close
-            @stream.close
-          end
-
-          def write(message)
-            @outbound_handler.encode(message)
-          end
-
-          def write_and_flush(message)
-            write(message)
-            @stream.flush
-            ensure_response_handling
-          end
-
-          private
-
-          def connect_to_io_socket(connector, address)
-            Sync { connector.connect(address) }
-          end
-
-          def bracketless(host)
-            host.delete_prefix('[').delete_suffix(']')
-          end
-
-          def ensure_response_handling
-            # probably should be synchronized
-            return if @handling_active
-            @handling_active = true
-            while @message_dispatcher.queued_handlers_count > 0 do
-              @common_message_reader.read(@message_dispatcher)
-            end
-            @handling_active = false
-          rescue
-            @handling_active = false
-            raise
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/pool/channel_pool.rb

@@ -1,31 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Pool
-        class ChannelPool < ConnectionPool
-          def initialize(limit: nil, acquisition_timeout: nil, &block)
-            super(size: limit, timeout: acquisition_timeout, &block)
-            @available = TimedStack.new(@size, &block)
-          end
-
-          def acquire(options = {})
-            @available.pop(options[:timeout] || @timeout)
-          end
-
-          def release(resource)
-            @available.push(resource)
-            nil
-          end
-
-          def close
-            @available.shutdown(&:close)
-          end
-
-          def busy?
-            @available.any_resource_busy?
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/pool/channel_tracker.rb

@@ -1,135 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Pool
-        class ChannelTracker
-          attr_reader :lock, :read, :write, :address_to_in_use_channel_count, :address_to_idle_channel_count, :log,
-                      :metrics_listener, :close_listener, :all_channels
-
-          def initialize(metrics_listener, logger, **options)
-            @metrics_listener = metrics_listener
-            @log = logger
-            @all_channels = options[:channels]
-            @lock = Concurrent::ReentrantReadWriteLock.new
-            @close_listener = method(:channel_closed)
-          end
-
-          def channel_released(channel)
-            @lock.with_write_lock do
-              decrement_in_use(channel)
-              increment_idle(channel)
-              channel.close_future.add_listener(close_listener)
-            end
-
-            log.debug("Channel [0x#{channel.id}] acquired from the pool. Local address: #{channel.local_address}, remote address: #{channel.remote_address}")
-          end
-
-          def channel_created(channel, creating_event = nil)
-            if creating_event.nil?
-              raise Neo4j::Driver::Exceptions::IllegalStateException.new('Untraceable channel created.')
-            else
-              # when it is created, we count it as idle as it has not been acquired out of the pool
-              do_in_write_lock(->() { increment_idle(channel) })
-
-              metrics_listener.after_created(Connection::ChannelAttributes.pool_id(channel), creating_event)
-              all_channels.add(channel)
-              log.debug( "Channel [0x#{channel.id}] created. Local address: #{channel.local_address}, remote address: #{channel.remote_address}")
-            end
-          end
-
-          def channel_creating(pool_id)
-            creating_event = metrics_listener.create_listener_event
-            metrics_listener.before_creating(pool_id, creating_event)
-            creating_event
-          end
-
-          def channel_failed_to_create(pool_id)
-            metrics_listener.after_failed_to_create(pool_id)
-          end
-
-          def channel_closed(channel)
-            do_in_write_lock(-> () { decrement_idle(channel) })
-            metrics_listener.after_closed(Connection::ChannelAttributes.pool_id(channel))
-          end
-
-          def in_use_channel_count(address)
-            retrieve_in_read_lock(-> () { address_to_in_use_channel_count.get_or_default(address, 0) })
-          end
-
-          def idle_channel_count(address)
-            retrieve_in_read_lock(-> () { address_to_idle_channel_count.get_or_default(address, 0) })
-          end
-
-          def prepare_to_close_channels
-            all_channels.each do |channel|
-              protocol = Messaging::BoltProtocol.for_channel(channel)
-              begin
-                protocol.prepare_to_close_channel(channel)
-              rescue Exception => e
-                # only logging it
-                log.debug( "Failed to prepare to close Channel #{channel} due to error #{e.get_message}. It is safe to ignore this error as the channel will be closed despite if it is successfully prepared to close or not.")
-              end
-            end
-          end
-
-
-          private
-
-          def increment_in_use(channel)
-            increment(channel, address_to_in_use_channel_count)
-          end
-
-          def decrement_in_use(channel)
-            address = Connection::ChannelAttributes.server_address(channel)
-
-            unless address_to_in_use_channel_count.contains_key(address)
-              raise Neo4j::Driver::Exceptions::IllegalStateException.new("No count exists for address '#{address}' in the 'in use' count")
-            end
-
-            count = address_to_in_use_channel_count.get(address)
-            address_to_in_use_channel_count.put(address, count - 1)
-          end
-
-          def increment_idle(channel)
-            increment(channel, address_to_idle_channel_count)
-          end
-
-          def decrement_idle(channel)
-            address = Connection::ChannelAttributes.server_address(channel)
-
-            unless address_to_idle_channel_count.contains_key(address)
-              raise Neo4j::Driver::Exceptions::IllegalStateException.new("No count exists for address '#{address}' in the 'idle' count")
-            end
-
-            count = address_to_idle_channel_count.get(address)
-            address_to_idle_channel_count.put(address, count - 1)
-          end
-
-          def increment(channel, count_map)
-            address = Connection::ChannelAttributes.server_address(channel)
-            count = count_map.compute_if_absent(address, -> (k) { 0 })
-            count_map.put(address, count + 1)
-          end
-
-          def do_in_write_lock(work)
-            begin
-              write.lock
-              work.run
-            ensure
-              write.unlock
-            end
-          end
-
-          def retrieve_in_read_lock(work)
-            begin
-              read.lock
-              work.get
-            ensure
-              read.unlock
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/pool/connection_pool_impl.rb

@@ -1,156 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Pool
-        class ConnectionPoolImpl
-          def initialize(connector, settings, logger)
-            @connector = connector
-            @settings = settings
-            @log = logger
-            @address_to_pool_lock = Concurrent::ReentrantReadWriteLock.new
-            @address_to_pool = {}
-            @closed = Concurrent::AtomicBoolean.new
-          end
-
-          def acquire(address)
-            @log.debug("Acquiring a connection from pool towards #{address}")
-
-            assert_not_closed
-            pool = get_or_create_pool(address)
-
-            begin
-              channel = pool.acquire
-              @log.debug { "Channel #{channel.object_id} acquired" }
-            rescue => error
-              process_acquisition_error(pool, address, error)
-            end
-            assert_not_closed(address, channel, pool)
-            NetworkConnection.new(channel, pool, @log) { remove(pool) }
-          end
-
-          def retain_all(addresses_to_retain)
-            @address_to_pool_lock.with_write_lock do
-              @address_to_pool.each do |address, pool|
-                unless addresses_to_retain.include?(address)
-                  unless pool.busy?
-                    # address is not present in updated routing table and has no active connections
-                    # it's now safe to terminate corresponding connection pool and forget about it
-                    @address_to_pool.delete(address)
-                    if pool
-                      @log.info("Closing connection pool towards #{address}, it has no active connections and is not in the routing table registry.")
-                      close_pool_in_background(address, pool)
-                    end
-                  end
-                end
-              end
-            end
-          end
-
-          def remove(pool)
-            @address_to_pool_lock.with_write_lock do
-              @address_to_pool.each { |address, value| @address_to_pool.delete(address) if value == pool }
-            end
-          end
-
-          def in_use_connections(address)
-            @address_to_pool[address]&.size || 0
-            # @netty_channel_tracker.in_use_channel_count(address)
-          end
-
-          def idle_connections(address)
-            @netty_channel_tracker.idle_channel_count(address)
-          end
-
-          def close
-            if @closed.make_true
-              @address_to_pool_lock.with_write_lock do
-                # We can only shutdown event loop group when all netty pools are fully closed,
-                # otherwise the netty pools might missing threads (from event loop group) to execute clean ups.
-                close_all_pools
-                @address_to_pool.clear
-              end
-            end
-          end
-
-          def open?(address)
-            @address_to_pool_lock.with_read_lock { @address_to_pool.key?(address) }
-          end
-
-          def to_string
-            @address_to_pool_lock.with_read_lock { "ConnectionPoolImpl{ pools=#{@address_to_pool}}" }
-          end
-
-          private
-
-          def process_acquisition_error(pool, server_address, error)
-            if error.is_a?(ConnectionPool::TimeoutError)
-              # NettyChannelPool returns future failed with TimeoutException if acquire operation takes more than
-              # configured time, translate this exception to a prettier one and re-throw
-              raise Neo4j::Driver::Exceptions::ClientException.new("Unable to acquire connection from the pool within configured maximum time of #{@settings.connection_acquisition_timeout.inspect}")
-              # elsif pool.closed?
-              # There is a race condition where a thread tries to acquire a connection while the pool is closed by another concurrent thread.
-              # Treat as failed to obtain connection for a direct driver. For a routing driver, this error should be retried.
-              # raise Neo4j::Driver::Exceptions::ServiceUnavailableException, "Connection pool for server #{server_address} is closed while acquiring a connection."
-            else
-              # some unknown error happened during connection acquisition, propagate it
-              raise error
-            end
-          end
-
-          def assert_not_closed(address = nil, channel = nil, pool = nil)
-            if @closed.true?
-              if address
-                pool.release(channel)
-                close_pool_in_background(address, pool)
-                @address_to_pool_lock.with_write_lock { @address_to_pool.delete(address) }
-                assert_not_closed
-              end
-              raise Exceptions::IllegalStateException, Spi::ConnectionPool::CONNECTION_POOL_CLOSED_ERROR_MESSAGE
-            end
-          end
-
-          # for testing only
-          protected def pool(address)
-            @address_to_pool_lock.with_read_lock { @address_to_pool[address] }
-          end
-
-          def new_pool(address)
-            ChannelPool.new(limit: @settings.max_connection_pool_size, acquisition_timeout: @settings.connection_acquisition_timeout) { Channel.new(address, @connector, @log) }
-          end
-
-          def get_or_create_pool(address)
-            @address_to_pool_lock.with_read_lock { @address_to_pool[address] } ||
-              @address_to_pool_lock.with_write_lock do
-                new_pool(address)&.tap do |pool|
-                  # before the connection pool is added I can add the metrics for the pool.
-                  # @metrics_listener.put_pool_metrics(pool.object_id, address, self)
-                  @address_to_pool[address] = pool
-                end
-              end
-          end
-
-          def close_pool(pool)
-            pool.close
-          end
-
-          def close_pool_in_background(address, pool)
-            Async do
-              # Close in the background
-              close_pool(pool)
-            rescue => error
-              @log.warn("An error occurred while closing connection pool towards #{address}.", error)
-            end
-          end
-
-          def close_all_pools
-            @address_to_pool.map do |address, pool|
-              @log.info("Closing connection pool towards #{address}")
-              # Wait for all pools to be closed.
-              close_pool(pool)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/pool/netty_channel_health_checker.rb

@@ -1,87 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Pool
-        class NettyChannelHealthChecker
-          attr_reader :pool_settings, :clock, :logger, :log, :min_creation_timestamp_millis_opt
-
-          def initialize(pool_settings, clock, logger)
-            @pool_settings = pool_settings
-            @clock = clock
-            @log = logger
-            @min_creation_timestamp_millis_opt = java.util.concurrent.atomic.AtomicReference.new(java.util.Optional.empty)
-          end
-
-          def is_healthy(channel)
-            return channel.event_loop.new_succeeded_future(false) if is_too_old?(channel)
-
-            return ping(channel) if has_been_idle_for_too_long?(channel)
-
-            ACTIVE.is_healthy(channel)
-          end
-
-          def on_expired(e, channel)
-            ts = Connection::ChannelAttributes.creation_timestamp(channel)
-
-            # Override current value ONLY if the new one is greater
-            min_creation_timestamp_millis_opt.get_and_update do |prev|
-              java.util.Optional.of(prev.filter(-> (prev_ts) { ts <= prev_ts }.or_else(ts)))
-            end
-          end
-
-          private
-
-          def is_too_old?(channel)
-            creation_timestamp_millis = Connection::ChannelAttributes.creation_timestamp(channel)
-            min_creation_timestamp_millis_opt = min_creation_timestamp_millis_opt.get
-
-            if min_creation_timestamp_millis_opt.present? && creation_timestamp_millis <= min_creation_timestamp_millis_opt.get
-              log.debug("The channel #{channel} is marked for closure as its creation timestamp is older than or equal to the acceptable minimum timestamp: #{creation_timestamp_millis} <= #{min_creation_timestamp_millis_opt.get}")
-              return true
-            end
-
-            if pool_settings.max_connection_lifetime_enabled
-              current_timestamp_millis = clock.millis
-
-              age_millis = current_timestamp_millis - creation_timestamp_millis
-              max_age_millis = pool_settings.max_connection_lifetime
-
-              too_old = age_millis > max_age_millis
-
-              if too_old
-                log.debug("Failed acquire channel #{channel} from the pool because it is too old: #{age_millis} > #{max_age_millis}")
-              end
-              return too_old
-            end
-
-            false
-          end
-
-          def has_been_idle_for_too_long?(channel)
-            if pool_settings.idle_time_before_connection_test_enabled?
-              last_used_timestamp = Connection::ChannelAttributes.last_used_timestamp(channel)
-              if !last_used_timestamp.nil?
-                idle_time = clock.millis - last_used_timestamp
-                idle_too_long = idle_time > pool_settings.idle_time_before_connection_test
-
-                if idle_too_long
-                  log.debug( "Channel #{channel} has been idle for #{idle_time} and needs a ping")
-                end
-
-                return idle_too_long
-              end
-            end
-            false
-          end
-
-          def ping(channel)
-            result = channel.event_loop.new_promise
-            Connection::ChannelAttributes.message_dispatcher.enqueue(Handlers::PingResponseHandler.new(result, channel, logger))
-            channel.write_and_flush(Messaging::Request::ResetMessage::RESET, channel.void_promise)
-            result
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/pool/netty_channel_pool.rb

@@ -1,52 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Pool
-        class NettyChannelPool
-          # Unlimited amount of parties are allowed to request channels from the pool.
-          MAX_PENDING_ACQUIRES = nil
-
-          # Do not check channels when they are returned to the pool.
-          RELEASE_HEALTH_CHECK = false
-
-          attr_reader :id
-
-          def initialize(address, connector, bootstrap, handler, health_check, acquire_timeout_millis, max_connections)
-            java.util.Objects.require_non_null(address)
-            java.util.Objects.require_non_null(connector)
-            java.util.Objects.require_non_null(handler)
-            @id = pool_id(address)
-            @delegate = Java::IoNettyChannelPool::FixedChannelPool.new(bootstrap, handler, health_check,
-                        Java::IoNettyChannelPool::FixedChannelPool::AcquireTimeoutAction::FAIL, acquire_timeout_millis,
-                        max_connections, MAX_PENDING_ACQUIRES, RELEASE_HEALTH_CHECK)
-          end
-
-          def close
-            if closed.compare_and_set(false, true)
-              Util::Futurs.as_completion_stage(delegate.close_async, close_future)
-            end
-            close_future
-          end
-
-          def acquire
-            Util::Futurs.as_completion_stage(delegate.acquire)
-          end
-
-          def release(channel)
-            Util::Futurs.as_completion_stage(delegate.release(channel))
-          end
-
-          def is_closed?
-            closed.get
-          end
-
-          private
-
-          def pool_id(server_address)
-            [server_address.host, server_address.port, self.hash_code]
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/pool/network_connection_factory.rb

@@ -1,21 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Pool
-        class NetworkConnectionFactory
-          attr_reader :clock, :metrics_listener, :logger
-
-          def initialize(clock, metrics_listener, logger)
-            @clock = clock
-            @metrics_listener = metrics_listener
-            @logger = logger
-          end
-
-          def create_connection(channel, pool)
-            NetworkConnection.new(channel, pool, clock, metrics_listener, @logger)
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/pool/pool_settings.rb

@@ -1,34 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Pool
-        class PoolSettings
-          attr_reader :max_connection_pool_size, :connection_acquisition_timeout, :max_connection_lifetime,
-                      :idle_time_before_connection_test
-
-          NOT_CONFIGURED = nil
-          DEFAULT_MAX_CONNECTION_POOL_SIZE = 100
-          DEFAULT_IDLE_TIME_BEFORE_CONNECTION_TEST = NOT_CONFIGURED
-          DEFAULT_MAX_CONNECTION_LIFETIME = 1.hour
-          DEFAULT_CONNECTION_ACQUISITION_TIMEOUT = 60.seconds
-
-          def initialize(max_connection_pool_size, connection_acquisition_timeout, max_connection_lifetime,
-                         idle_time_before_connection_test)
-            @max_connection_pool_size = max_connection_pool_size
-            @connection_acquisition_timeout = connection_acquisition_timeout
-            @max_connection_lifetime = max_connection_lifetime
-            @idle_time_before_connection_test = idle_time_before_connection_test
-          end
-
-          def idle_time_before_connection_test_enabled?
-            idle_time_before_connection_test&.send(:>=, 0)
-          end
-
-          def max_connection_lifetime_enabled?
-            max_connection_lifetime&.send(:>, 0)
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/async/pool/timed_stack.rb

@@ -1,15 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Pool
-        class TimedStack < ConnectionPool::TimedStack
-          def any_resource_busy?
-            @mutex.synchronize do
-              @created > @que.length
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      class ResultCursorsHolder < Array
-        def retrieve_not_consumed_error
-          retrieve_all_failures.find { |failure| failure }
-        end
-
-        private
-
-        def retrieve_all_failures
-          map(&:discard_all_failure_async)
-        end
-      end
-    end
-  end
-end