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

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

@@ -0,0 +1,137 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      module Pool
+        class NettyChannelTracker
+          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 = {},event_executor = nil, channels = nil)
+            @metrics_listener = metrics_listener
+            @log = logger
+            @all_channels = options[:channels] ? channels : Java::IoNettyChannelGroup::DefaultChannelGroup.new("all-connections", options[:event_executor])
+            @lock = java.util.concurrent.locks.ReentrantReadWriteLock.new
+            @read = lock.read_lock
+            @write = lock.write_lock
+            @close_listener = -> (future) { channel_closed(future.channel) }
+          end
+
+          def channel_released(channel)
+            do_in_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/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/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,214 @@
+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?
+              nil
+            elsif @state == State::COMMITTED
+              raise Neo4j::Driver::Exceptions::ClientException, commit ? CANT_COMMIT_COMMITTED_MSG : CANT_ROLLBACK_COMMITTED_MSG
+            elsif @state == State::ROLLED_BACK
+              raise Neo4j::Driver::Exceptions::ClientException, commit ? CANT_COMMIT_ROLLED_BACK_MSG : CANT_ROLLBACK_ROLLED_BACK_MSG
+            else
+              if commit
+                if @rollback_pending
+                  raise Neo4j::Driver::Exceptions::ClientException, CANT_COMMIT_ROLLING_BACK_MSG
+                elsif @commit_pending
+                  @commit_pending
+                else
+                  @commit_pending = true
+                  nil
+                end
+              else
+                if @commit_pending
+                  raise Neo4j::Driver::Exceptions::ClientException, CANT_ROLLBACK_COMMITTING_MSG
+                elsif @rollback_pending
+                  @rollback_pending
+                else
+                  @rollback_pending = true
+                  nil
+                end
+              end
+            end
+          end ||
+            begin
+              if commit
+                target_future = @commit_pending
+                target_action = lambda { |throwable|
+                  do_commit_async(throwable)
+                  handle_commit_or_rollback(throwable)
+                }
+              else
+                target_future = @rollback_pending
+                target_action = lambda { |throwable|
+                  do_rollback_async
+                  handle_commit_or_rollback(throwable)
+                }
+              end
+
+              @result_cursors.retrieve_not_consumed_error.then(&target_action)
+              handle_transaction_completion(commit, nil)
+              target_future
+            rescue => throwable
+              handle_transaction_completion(commit, throwable)
+            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::Futures.failed_future(exception)
+          else
+            @protocol.commit_transaction(@connection, @bookmark_holder)
+          end
+        end
+
+        def do_rollback_async
+          if @lock.synchronize { @state } == State::TERMINATED
+            Util::Futures.completed_with_null
+          else
+            @protocol.rollback_transaction(@connection)
+          end
+        end
+
+        def handle_commit_or_rollback(cursor_failure)
+          lambda { |_fulfilled, _value, commit_or_rollback_error|
+            combined_error = Util::Futures.combined_error(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,58 @@
+module Neo4j::Driver
+  module Internal
+    module Cluster
+      class ClusterComposition < Struct.new(:expiration_timestamp, :readers, :writers, :routers, :database_name)
+        private
+
+        MAX_LONG = 2 ^ 63 - 1
+        MAX_TTL = MAX_LONG / 1000
+
+        public
+
+        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 if record.nil?
+          new(expiration_timestamp: expiration_timestamp(now, record), database_name: record['db'],
+              **record['servers'].to_h { |value| [servers(value['role']), BoltServerAddress.new(value['addresses'])] })
+        end
+
+        private
+
+        def self.expiration_timestamp(now, record)
+          ttl = record['ttl']
+          expiration_timestamp = now + ttl * 1000
+
+          if ttl < 0 || ttl >= MAX_TTL || expiration_timestamp < 0
+            expiration_timestamp = MAX_LONG
+          end
+
+          expiration_timestamp
+        end
+
+        def 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 :composition, :resolved_initial_routers
+
+        def initialize(composition, resolved_initial_routers = nil)
+          @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,139 @@
+module Neo4j::Driver
+  module Internal
+    module Cluster
+      class ClusterRoutingTable
+        MIN_ROUTERS = 1
+
+        attr_reader :database_name
+
+        def initialize(of_database, clock, routing_addresses)
+          @database_name = of_database
+          @clock = clock
+          @expiration_timestamp = clock.millis - 1
+          @routers = routing_addresses.freeze
+          @table_lock = java.util.concurrent.locks.ReentrantReadWriteLock.new
+          @prefer_initial_router = true
+          @disused = {}
+          @readers = []
+          @writers = []
+        end
+
+        def stale_for?(mode)
+          Util::LockUtil.execute_with_lock(@table_lock.read_lock) do
+            @expiration_timestamp < @clock.millis ||
+            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)
+          total_time = Util::LockUtil.execute_with_lock(@table_lock.read_lock, -> () { @expiration_timestamp }) + extra_time
+
+          total_time = java.lang.Long::MAX_VALUE if total_time < 0
+
+          total_time < @clock.millis
+        end
+
+        def update(cluster)
+          Util::LockUtil.execute_with_lock(@table_lock.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)
+          Util::LockUtil.execute_with_lock(@table_lock.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
+          Util::LockUtil.execute_with_lock(@table_lock.read_lock, -> () { @readers })
+        end
+
+        def writers
+          Util::LockUtil.execute_with_lock(@table_lock.read_lock, -> () { @writers })
+        end
+
+        def routers
+          Util::LockUtil.execute_with_lock(@table_lock.read_lock, -> () { @routers })
+        end
+
+        def servers
+          Util::LockUtil.execute_with_lock(@table_lock.write_lock) do
+            servers = []
+            servers << (@readers)
+            servers << (@writers)
+            servers << (@routers)
+            servers << (@disused)
+          end
+        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)
+          Util::LockUtil.execute_with_lock(@table_lock.write_lock, -> () { @routers = new_with_address_replaced_if_present(@routers, old_router, new_router) } )
+        end
+
+        def prefer_initial_router
+          Util::LockUtil.execute_with_lock(@table_lock.read_lock, -> () { @prefer_initial_router })
+        end
+
+        def expiration_timestamp
+          Util::LockUtil.execute_with_lock(@table_lock.read_lock, -> () { @expiration_timestamp })
+        end
+
+        def to_s
+          Util::LockUtil.execute_with_lock(@table_lock.read_lock) do
+            "Ttl #{@expiration_timestamp}, currentTime #{@clock.millis}, routers #{@routers}, writers #{@writers}, readers #{@readers}, database '#{database_name.description}'"
+          end
+        end
+
+        private
+
+        def new_without_address_if_present(addresses, address_to_skip)
+          new_list = []
+
+          addresses.each do |address|
+            new_list << address unless address.eql?(address_to_skip)
+          end
+
+          new_list.freeze
+        end
+
+        def new_with_address_replaced_if_present(addresses, old_address, new_address)
+          new_list = []
+
+          addresses.each { |address| new_list << address.eql?(old_address) ? new_address : address }
+
+          new_list.freeze
+        end
+
+        def new_with_reused_addresses(current_addresses, disused_addresses, new_addresses)
+          new_list = java.util.stream.Stream.concat(current_addresses.stream, disused_addresses.stream)
+                                            .filter(-> (address) { new_addresses.remove(to_bolt_server_address(address)) })
+                                            .collect(java.util.stream.Collectors.to_collection(-> () { Array.new(new_addresses.size) }))
+          new_list << new_addresses
+          new_list.freeze
+        end
+
+        def to_bolt_server_address(address)
+          BoltServerAddress.class.eql?(address.class) ? address : BoltServerAddress.new(address.host, address.port)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Neo4j::Driver
+  module Internal
+    module Cluster
+      class IdentityResolver
+        IDENTITY_RESOLVER = new
+
+        def resolve(initial_router)
+          java.util.Collections.singleton(initial_router)
+        end
+      end
+    end
+  end
+end