neo4j-ruby-driver 1.7.4 → 4.4.0

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

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

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

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

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

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

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

@@ -0,0 +1,212 @@
+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_bookmark, config)
+          @protocol.begin_transaction(@connection, initial_bookmark, 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.method(:bookmark=))
+          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

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

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

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

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

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