neo4j-ruby-driver 6.0.3.alpha.0 → 6.2.1.beta.2

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

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

@@ -1,212 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      class UnmanagedTransaction
-        class State
-          # The transaction is running with no explicit success or failure marked
-          ACTIVE = 'active'
-
-          # This transaction has been terminated either because of explicit {@link Session#reset()} or because of a fatal connection error.
-          TERMINATED = 'terminated'
-
-          # This transaction has successfully committed
-          COMMITTED = 'committed'
-
-          # This transaction has been rolled back
-          ROLLED_BACK = 'rolled_back'
-        end
-
-        CANT_COMMIT_COMMITTED_MSG = "Can't commit, transaction has been committed"
-        CANT_ROLLBACK_COMMITTED_MSG = "Can't rollback, transaction has been committed"
-        CANT_COMMIT_ROLLED_BACK_MSG = "Can't commit, transaction has been rolled back"
-        CANT_ROLLBACK_ROLLED_BACK_MSG = "Can't rollback, transaction has been rolled back"
-        CANT_COMMIT_ROLLING_BACK_MSG = "Can't commit, transaction has been requested to be rolled back"
-        CANT_ROLLBACK_COMMITTING_MSG = "Can't rollback, transaction has been requested to be committed"
-        OPEN_STATES = [State::ACTIVE, State::TERMINATED]
-        attr :connection
-
-        def initialize(connection, bookmark_holder, fetch_size, result_cursors = ResultCursorsHolder.new)
-          @connection = connection
-          @protocol = connection.protocol
-          @bookmark_holder = bookmark_holder
-          @result_cursors = result_cursors
-          @fetch_size = fetch_size
-          @lock = Util::Mutex.new
-          @state = State::ACTIVE
-        end
-
-        def begin_async(initial_bookmarks, config)
-          @protocol.begin_transaction(@connection, initial_bookmarks, config)
-          self
-        rescue Neo4j::Driver::Exceptions::AuthorizationExpiredException
-          @connection.terminate_and_release(Neo4j::Driver::Exceptions::AuthorizationExpiredException::DESCRIPTION)
-          raise
-        rescue Neo4j::Driver::Exceptions::ConnectionReadTimeoutException => begin_error
-          @connection.terminate_and_release(begin_error.message)
-          raise
-        rescue
-          @connection.release
-          raise
-        end
-
-        def close_async(commit = false, complete_with_null_if_not_open = true)
-          @lock.synchronize do
-            if complete_with_null_if_not_open && !open?
-              Util::ResultHolder.successful(nil)
-            elsif @state == State::COMMITTED
-              Util::ResultHolder.failed(Neo4j::Driver::Exceptions::ClientException.new(
-                commit ? CANT_COMMIT_COMMITTED_MSG : CANT_ROLLBACK_COMMITTED_MSG))
-            elsif @state == State::ROLLED_BACK
-              Util::ResultHolder.failed(Neo4j::Driver::Exceptions::ClientException.new(
-                commit ? CANT_COMMIT_ROLLED_BACK_MSG : CANT_ROLLBACK_ROLLED_BACK_MSG))
-            else
-              if commit
-                if @rollback_pending
-                  Util::ResultHolder.failed(Neo4j::Driver::Exceptions::ClientException.new(CANT_COMMIT_ROLLING_BACK_MSG))
-                elsif @commit_pending
-                  @commit_pending
-                else
-                  @commit_pending = Util::ResultHolder.new
-                  nil
-                end
-              else
-                if @commit_pending
-                  Util::ResultHolder.failed(Neo4j::Driver::Exceptions::ClientException.new(CANT_ROLLBACK_COMMITTING_MSG))
-                elsif @rollback_pending
-                  @rollback_pending
-                else
-                  @rollback_pending = Util::ResultHolder.new
-                  nil
-                end
-              end
-            end
-          end ||
-            begin
-              if commit
-                target_future = @commit_pending
-                target_action = lambda { |throwable|
-                  do_commit_async(throwable).chain(&handle_commit_or_rollback(throwable))
-                }
-              else
-                target_future = @rollback_pending
-                target_action = lambda { |throwable|
-                  do_rollback_async.chain(&handle_commit_or_rollback(throwable))
-                }
-              end
-
-              @result_cursors.retrieve_not_consumed_error.then(&target_action)
-                             .side { |_, error| handle_transaction_completion(commit, error) }.copy_to(target_future)
-              target_future
-            end
-        end
-
-        def commit_async
-          close_async(true, false)
-        end
-
-        def rollback_async
-          close_async(false, false)
-        end
-
-        def run_async(query)
-          ensure_can_run_queries
-          cursor = @protocol.run_in_unmanaged_transaction(@connection, query, self, @fetch_size).async_result
-          @result_cursors << cursor
-          cursor.map_successful_run_completion_async
-        end
-
-        def run_rx(query)
-          ensure_can_run_queries
-          cursor_stage = @protocol.run_in_unmanaged_transaction(@connection, query, self, @fetch_size).rx_result
-          @result_cursors << cursor_stage
-          cursor_stage
-        end
-
-        def open?
-          OPEN_STATES.include?(@lock.synchronize { @state })
-        end
-
-        def mark_terminated(cause)
-          @lock.synchronize do
-            if @state == State::TERMINATED
-              add_suppressed_when_not_captured(@cause_of_termination, cause) if @cause_of_termination
-            else
-              @state = State::TERMINATED
-              @cause_of_termination = cause
-            end
-          end
-        end
-
-        def ensure_can_run_queries
-          @lock.synchronize do
-            case @state
-            when State::COMMITTED
-              raise Neo4j::Driver::Exceptions::ClientException, 'Cannot run more queries in this transaction, it has been committed'
-            when State::ROLLED_BACK
-              raise Neo4j::Driver::Exceptions::ClientException, 'Cannot run more queries in this transaction, it has been rolled back'
-            when State::TERMINATED
-              # TODO clunky positional arguments of Neo4jException#initialize, move to named parameters
-              raise Neo4j::Driver::Exceptions::ClientException, 'Cannot run more queries in this transaction, it has either experienced an fatal error or was explicitly terminated' #, # TODO should be able to pass @cause_of_termination
-            end
-          end
-        end
-
-        private
-
-        def add_suppressed_when_not_captured(current_cause, new_cause)
-          if current_cause != new_cause
-            none_match = current_cause.get_suppressed.none? { |suppressed| suppressed == new_cause }
-
-            if none_match
-              current_cause.add_suppressed(new_cause)
-            end
-          end
-        end
-
-        def do_commit_async(cursor_failure)
-          exception = @lock.synchronize do
-            if @state == State::TERMINATED
-              Neo4j::Driver::Exceptions::ClientException.new(
-                "Transaction can't be committed. It has been rolled back either because of an error or explicit termination",
-                cursor_failure != @cause_of_termination ? @cause_of_termination : nil)
-            end
-          end
-
-          if exception
-            Util::ResultHolder.failed(exception)
-          else
-            @protocol.commit_transaction(@connection).then { @bookmark_holder.bookmarks = Set[it] }
-          end
-        end
-
-        def do_rollback_async
-          if @lock.synchronize { @state } == State::TERMINATED
-            Util::ResultHolder.successful(nil)
-          else
-            @protocol.rollback_transaction(@connection)
-          end
-        end
-
-        def handle_commit_or_rollback(cursor_failure)
-          lambda { |_value, commit_or_rollback_error|
-            combined_error = Util::Futures.combine_errors(cursor_failure, commit_or_rollback_error)
-            raise combined_error if combined_error
-          }
-        end
-
-        def handle_transaction_completion(commit_attempt, throwable)
-          @lock.synchronize { @state = commit_attempt && throwable.nil? ? State::COMMITTED : State::ROLLED_BACK }
-
-          case throwable
-          when Neo4j::Driver::Exceptions::AuthorizationExpiredException
-            @connection.terminate_and_release(Neo4j::Driver::Exceptions::AuthorizationExpiredException::DESCRIPTION)
-          when Neo4j::Driver::Exceptions::ConnectionReadTimeoutException
-            @connection.terminate_and_release(throwable.message)
-          else
-            @connection.release # release in background
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/bookmark_holder.rb

@@ -1,9 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    class BookmarkHolder
-      NO_OP = Class.new(DefaultBookmarkHolder) do
-        def bookmark=(_value) end
-      end.new
-    end
-  end
-end

data/ruby/neo4j/driver/internal/cluster/cluster_composition.rb

@@ -1,48 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Cluster
-      class ClusterComposition < Struct.new(:expiration_timestamp, :readers, :writers, :routers, :database_name)
-        def initialize(expiration_timestamp:, database_name:, readers: [], writers: [], routers: [])
-          super(expiration_timestamp, readers, writers, routers, database_name)
-        end
-
-        def has_writers?
-          writers.present?
-        end
-
-        def has_routers_and_readers?
-          routers.present? && readers.present?
-        end
-
-        def self.parse(record, now)
-          return unless record
-          new(expiration_timestamp: expiration_timestamp(now, record), database_name: record[:db],
-              **record[:servers].to_h do |value|
-                [servers(value[:role]),
-                 value[:addresses].map { |address| BoltServerAddress.new(uri: BoltServerAddress.uri_from(address)) }]
-              end)
-        end
-
-        private
-
-        def self.expiration_timestamp(now, record)
-          ttl = record['ttl']
-          now + (ttl.negative? ? 1000.years : ttl.seconds)
-        end
-
-        def self.servers(role)
-          case role
-          when 'READ'
-            :readers
-          when 'WRITE'
-            :writers
-          when 'ROUTE'
-            :routers
-          else
-            raise ArgumentError, "invalid server role: #{role}"
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/cluster/cluster_composition_lookup_result.rb

@@ -1,14 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Cluster
-      class ClusterCompositionLookupResult
-        attr_reader :cluster_composition, :resolved_initial_routers
-
-        def initialize(composition, resolved_initial_routers = nil)
-          @cluster_composition = composition
-          @resolved_initial_routers = resolved_initial_routers
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/cluster/cluster_routing_table.rb

@@ -1,122 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Cluster
-      class ClusterRoutingTable
-        MIN_ROUTERS = 1
-
-        def initialize(of_database, _clock, *routing_addresses)
-          @database_name = of_database
-          @expiration_timestamp = Time.now
-          @routers = routing_addresses.to_set.freeze
-          @table_lock = Concurrent::ReentrantReadWriteLock.new
-          @prefer_initial_router = true
-          @disused = Set.new
-          @readers = Set.new
-          @writers = Set.new
-        end
-
-        def stale_for?(mode)
-          @table_lock.with_read_lock do
-            @expiration_timestamp <= Time.now ||
-              routers.size < MIN_ROUTERS ||
-              (mode == AccessMode::READ && @readers.size == 0) ||
-              (mode == AccessMode::WRITE && @writers.size == 0)
-          end
-        end
-
-        def has_been_stale_for?(extra_time)
-          Time.now - @table_lock.with_read_lock { @expiration_timestamp } >= extra_time
-        end
-
-        def update(cluster)
-          @table_lock.with_write_lock do
-            @expiration_timestamp = cluster.expiration_timestamp
-            @readers = new_with_reused_addresses(@readers, @disused, cluster.readers)
-            @writers = new_with_reused_addresses(@writers, @disused, cluster.writers)
-            @routers = new_with_reused_addresses(@routers, @disused, cluster.routers)
-            @disused.clear
-            @prefer_initial_router = !cluster.has_writers?
-          end
-        end
-
-        def forget(address)
-          @table_lock.with_write_lock do
-            @routers = new_without_address_if_present(@routers, address)
-            @readers = new_without_address_if_present(@readers, address)
-            @writers = new_without_address_if_present(@writers, address)
-            @disused << address
-          end
-        end
-
-        def readers
-          @table_lock.with_read_lock { @readers }
-        end
-
-        def writers
-          @table_lock.with_read_lock { @writers }
-        end
-
-        def routers
-          @table_lock.with_read_lock { @routers }
-        end
-
-        def servers
-          @table_lock.with_write_lock do
-            [@readers, @writers, @routers, @disused].reduce(&:+)
-          end
-        end
-
-        def database
-          @database_name
-        end
-
-        def forget_writer(to_remove)
-          Util::LockUtil.execute_with_lock(@table_lock.write_lock) do
-            @writers = new_without_address_if_present(@writers, to_remove)
-            @disused << to_remove
-          end
-        end
-
-        def replace_router_if_present(old_router, new_router)
-          @table_lock.with_write_lock { @routers = new_with_address_replaced_if_present(@routers, old_router, new_router) }
-        end
-
-        def prefer_initial_router
-          @table_lock.with_read_lock { @prefer_initial_router }
-        end
-
-        def expiration_timestamp
-          @table_lock.with_read_lock { @expiration_timestamp }
-        end
-
-        def to_s
-          @table_lock.with_read_lock do
-            "Ttl #{@expiration_timestamp}, currentTime #{Time.now}, routers #{@routers}, writers #{@writers}, readers #{@readers}, database '#{@database_name.description}'"
-          end
-        end
-
-        private
-
-        def new_without_address_if_present(addresses, address_to_skip)
-          (addresses - [address_to_skip]).freeze
-        end
-
-        def new_with_address_replaced_if_present(addresses, old_address, new_address)
-          addresses.map { |address| address == old_address ? new_address : address }.freeze
-        end
-
-        def new_with_reused_addresses(*addresses)
-          addresses.map(&:to_set).reduce(&:+).freeze
-        end
-
-        def to_bolt_server_address(address)
-          if BoltServerAddress.class == address.class
-            address
-          else
-            BoltServerAddress.new(host: address.host, port: address.port)
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/cluster/identity_resolver.rb

@@ -1,10 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Cluster
-      class IdentityResolver
-        IDENTITY_RESOLVER = new
-        alias resolve Array
-      end
-    end
-  end
-end