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

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_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

@@ -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

data/ruby/neo4j/driver/internal/cluster/loadbalancing/least_connected_load_balancing_strategy.rb

@@ -1,68 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Cluster
-      module Loadbalancing
-
-        # Load balancing strategy that finds server with the least amount of active (checked out of the pool) connections from given readers or writers. It finds a
-        # start index for iteration in a round-robin fashion. This is done to prevent choosing same first address over and over when all addresses have the same amount
-        # of active connections.
-        class LeastConnectedLoadBalancingStrategy
-
-          def initialize(connection_pool, logger)
-            @readers_index = RoundRobinArrayIndex.new
-            @writers_index = RoundRobinArrayIndex.new
-
-            @connection_pool = connection_pool
-            @log = logger
-          end
-
-          def select_reader(known_readers)
-            select(known_readers, @readers_index, 'reader')
-          end
-
-          def select_writer(known_writers)
-            select(known_writers, @writers_index, 'writer')
-          end
-
-          private
-
-          def select(addresses, addresses_index, address_type)
-            size = addresses.size
-            if size == 0
-              @log.debug("Unable to select #{address_type}, no known addresses given")
-              return
-            end
-
-            # choose start index for iteration in round-robin fashion
-            start_index = addresses_index.next(size)
-            index = start_index
-
-            least_connected_address = nil
-            least_active_connections = nil
-
-            # iterate over the array to find the least connected address
-            addresses = addresses.to_a
-            loop do
-              address = addresses[index]
-              active_connections = @connection_pool.in_use_connections(address)
-
-              if least_active_connections.nil? || active_connections < least_active_connections
-                least_connected_address = address
-                least_active_connections = active_connections
-              end
-
-              # loop over to the start of the array when end is reached
-              index = (index + 1) % size
-
-              break if index == start_index
-            end
-
-            @log.debug("Selected #{address_type} with address: '#{least_connected_address}' and active connections: #{least_active_connections}")
-
-            least_connected_address
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/cluster/loadbalancing/load_balancer.rb

@@ -1,125 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Cluster
-      module Loadbalancing
-        class LoadBalancer
-          CONNECTION_ACQUISITION_COMPLETION_FAILURE_MESSAGE = 'Connection acquisition failed for all available addresses.'
-          CONNECTION_ACQUISITION_COMPLETION_EXCEPTION_MESSAGE = "Failed to obtain connection towards %s server. Known routing table is: %s"
-          CONNECTION_ACQUISITION_ATTEMPT_FAILURE_MESSAGE = "Failed to obtain a connection towards address %s, will try other addresses if available. Complete failure is reported separately from this entry."
-          BOLT_SERVER_ADDRESSES_EMPTY_ARRAY = []
-
-          delegate :close, to: :@connection_pool
-
-          def initialize(initial_router, settings, connection_pool, event_executor_group, logger, load_balancing_strategy, resolver, &domain_name_resolver)
-            clock = Util::Clock::System
-            @connection_pool = connection_pool
-            @rediscovery = create_rediscovery(event_executor_group, initial_router, resolver, settings, clock, logger, domain_name_resolver)
-            @routing_tables = create_routing_tables(connection_pool, @rediscovery, settings, clock, logger)
-            @load_balancing_strategy = load_balancing_strategy
-            @event_executor_group = event_executor_group
-            @log = logger
-          end
-
-          def acquire_connection(context)
-            handler = @routing_tables.ensure_routing_table(context)
-            connection = acquire(context.mode, handler.routing_table)
-            Async::Connection::RoutingConnection.new(connection, context.database_name, context.mode,
-                                                     context.impersonated_user, handler)
-          end
-
-          def verify_connectivity
-            @routing_tables.ensure_routing_table(Async::ImmutableConnectionContext.simple(supports_multi_db?))
-          rescue Exceptions::ServiceUnavailableException
-            raise Exceptions::ServiceUnavailableException,
-                  'Unable to connect to database management service, ensure the database is running and that there is a working network connection to it.'
-          end
-
-          def routing_table_registry
-            @routing_tables
-          end
-
-          def supports_multi_db?
-            addresses = @rediscovery.resolve
-            base_error = Exceptions::ServiceUnavailableException.new("Failed to perform multi-databases feature detection with the following servers: #{addresses}")
-            addresses.each do |address|
-              return private_suports_multi_db?(address)
-            rescue Exceptions::SecurityException
-              raise
-            rescue => error
-              Util::Futures.combine_errors(base_error, error)
-            end
-
-            raise base_error
-          end
-
-          private
-
-          def private_suports_multi_db?(address)
-            conn = @connection_pool.acquire(address)
-            Messaging::Request::MultiDatabaseUtil.supports_multi_database?(conn)
-          ensure
-            conn&.release
-          end
-
-          def acquire(mode, routing_table, attempt_errors = [])
-            addresses = addresses_by_mode(mode, routing_table)
-            address = select_address(mode, addresses)
-
-            unless address
-              error = Exceptions::SessionExpiredException.new(CONNECTION_ACQUISITION_COMPLETION_EXCEPTION_MESSAGE % [mode, routing_table])
-              attempt_errors.each(&error.method(:add_suppressed))
-              @log.error(CONNECTION_ACQUISITION_COMPLETION_FAILURE_MESSAGE)
-              @log.error(error)
-              raise error
-            end
-
-            begin
-              @connection_pool.acquire(address)
-            rescue Exceptions::ServiceUnavailableException => error
-              @log.warn { CONNECTION_ACQUISITION_ATTEMPT_FAILURE_MESSAGE % address }
-              @log.debug(error)
-              attempt_errors << error
-              routing_table.forget(address)
-              acquire(mode, routing_table, attempt_errors)
-            end
-          end
-
-          def addresses_by_mode(mode, routing_table)
-            case mode
-            when AccessMode::READ
-              routing_table.readers
-            when AccessMode::WRITE
-              routing_table.writers
-            else
-              raise unknown_mode mode
-            end
-          end
-
-          def select_address(mode, addresses)
-            case mode
-            when AccessMode::READ
-              @load_balancing_strategy.select_reader(addresses)
-            when AccessMode::WRITE
-              @load_balancing_strategy.select_writer(addresses)
-            else
-              raise unknown_mode mode
-            end
-          end
-
-          def create_routing_tables(connection_pool, rediscovery, settings, clock, logger)
-            RoutingTableRegistryImpl.new(connection_pool, rediscovery, clock, logger, settings.routing_table_purge_delay)
-          end
-
-          def create_rediscovery(event_executor_group, initial_router, resolver, settings, clock, logger, domain_name_resolver)
-            cluster_composition_provider = RoutingProcedureClusterCompositionProvider.new(clock, settings.routing_context)
-            RediscoveryImpl.new(initial_router, settings, cluster_composition_provider, event_executor_group, resolver, logger, domain_name_resolver)
-          end
-
-          def unknown_mode(mode)
-            ArgumentError.new("Mode '#{mode}' is not supported")
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/cluster/loadbalancing/round_robin_array_index.rb

@@ -1,13 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Cluster
-      module Loadbalancing
-        class RoundRobinArrayIndex < Concurrent::AtomicFixnum
-          def next(array_length)
-            (increment - 1) % array_length if array_length.positive?
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Cluster
-
-      # This implementation of the {@link RoutingProcedureRunner} works with multi database versions of Neo4j calling
-      # the procedure `dbms.routing.getRoutingTable`
-      class MultiDatabasesRoutingProcedureRunner < SingleDatabaseRoutingProcedureRunner
-        DATABASE_NAME = :database
-        MULTI_DB_GET_ROUTING_TABLE = "CALL dbms.routing.getRoutingTable($%s, $%s)" % [SingleDatabaseRoutingProcedureRunner::ROUTING_CONTEXT, DATABASE_NAME]
-
-        private
-
-        def bookmark_holder(bookmark)
-          ReadOnlyBookmarkHolder.new(bookmark)
-        end
-
-        def procedure_query(server_version, database_name)
-          map = {
-            SingleDatabaseRoutingProcedureRunner::ROUTING_CONTEXT => @context.to_h,
-            DATABASE_NAME => database_name.database_name
-          }
-          Query.new(MULTI_DB_GET_ROUTING_TABLE, **map)
-        end
-
-        def connection(connection)
-          Async::Connection::DirectConnection.new(connection, DatabaseNameUtil::SYSTEM_DATABASE, AccessMode::READ, nil)
-        end
-      end
-    end
-  end
-end