neo4j-ruby-driver 4.4.0.alpha.5 → 4.4.0.alpha.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92d999b42ad79f180328388f8b50e610e35190b2efc0b5ad9f799773a3d5d006
-  data.tar.gz: 759f1058c5dcf0c12d970dec2793bd2f6a5600aecfcdeb43f63b19630f038fb2
+  metadata.gz: d282964e01764e3a21d07c1e836567b3bc1f334e08d45b7392984db661faa14a
+  data.tar.gz: afc45978f3583f6f491c75c5f4f9da89099620d0be88c0367c8e9469554ecc20
 SHA512:
-  metadata.gz: 50d2744664faa1596e8fe964db0b083e216f58b001a4d3d7d70218752814a164d4e83ea71f5d4b4b2330432aa58d74b12875ea182bb8f99aad701a831032cc73
-  data.tar.gz: 5d8f9e3e8eb358d7aa494d7be74d3ee49507ff2496f346d0b5ab9defea5c92a6017e147ae51b0e128728a667ef924cdf8b7e13f69ff398a1f6f6606d24cddeef
+  metadata.gz: 0a40657edbf022793691d6926f93ae779d4b671878cdbd29538a0ff83bd82de1912210380715390219503a1fbfb3ada37ae70cce66e6184664b1a90fbff12f80
+  data.tar.gz: 4ae8f0cb141fc923df3fc8bfab0696adb979a40331e76a440096eb64b3d8060a2f70e49934ed6af06015f734cc1d4f85468b0118b3231db1df4369ff93c0fa63

data/lib/neo4j/driver/exceptions/protocol_exception.rb

@@ -8,8 +8,8 @@ module Neo4j
       class ProtocolException < Neo4jException
         CODE = "Protocol violation: "
 
-        def initialize(message, e)
-          super("#{CODE}message", e)
+        def initialize(message, e = nil)
+          super(nil, "#{CODE}#{message}", e)
         end
       end
     end

data/lib/neo4j/driver/internal/bolt_server_address.rb

@@ -67,13 +67,15 @@ module Neo4j::Driver
       LOCAL_DEFAULT = new(host: 'localhost', port: DEFAULT_PORT)
 
       def self.from(address)
-        address.is_a?(BoltServerAddress) ? address : new(address.host, address.port)
+        address.is_a?(BoltServerAddress) ? address : new(host: address.host, port: address.port)
       end
 
-      def eql?(other)
-        attributes.eql?(other&.attributes)
+      def ==(other)
+        attributes == other&.attributes
       end
 
+      alias eql? ==
+
       def to_s
         "#{host}#{"(#{connection_host})" unless host == connection_host}:#{port}"
       end
@@ -84,11 +86,9 @@ module Neo4j::Driver
 
       # @return stream of unicast addresses.
       def unicast_stream
-        [self]
+        Set[self]
       end
 
-      private
-
       def attributes
         [@host, @connection_host, @port]
       end

data/lib/neo4j/driver/types/time.rb

@@ -30,10 +30,12 @@ module Neo4j
           end
         end
 
-        def eql?(other)
-          other.is_a?(self.class) && self.class.significant_fields.all? { |elem| send(elem).eql?(other.send(elem)) }
+        def ==(other)
+          other.is_a?(self.class) && self.class.significant_fields.all? { |elem| send(elem) == other.send(elem) }
         end
 
+        alias eql? ==
+
         def +(numeric)
           self.class.new(@time + numeric)
         end

data/ruby/neo4j/driver/config.rb

@@ -79,7 +79,7 @@ module Neo4j
 
       def init_security_and_trust_config
         relevant = %i[encryption trust_strategy]
-        customized = slice(*relevant) == DEFAULTS.slice(*relevant)
+        customized = slice(*relevant) != DEFAULTS.slice(*relevant)
         merge!(security_settings: Neo4j::Driver::Internal::SecuritySetting.new(
           fetch(:encryption), TrustStrategy.new(**fetch(:trust_strategy)), customized),
         )

data/ruby/neo4j/driver/graph_database.rb

@@ -26,12 +26,12 @@ module Neo4j::Driver
         )
       end
 
-      def routing_driver(routing_uris, auth_toke, **config)
+      def routing_driver(routing_uris, auth_token, **config)
         assert_routing_uris(routing_uris)
         log = Config.new(**config)[:logger]
 
         routing_uris.each do |uri|
-          driver = driver(uri, auth_toke, **config)
+          driver = driver(uri, auth_token, **config)
           begin
             return driver.tap(&:verify_connectivity)
           rescue Exceptions::ServiceUnavailableException => e

data/ruby/neo4j/driver/internal/async/inbound/inbound_message_dispatcher.rb

@@ -59,7 +59,8 @@ module Neo4j::Driver
             raise @current_error if Util::ErrorUtil.fatal?(@current_error) # TODO clarify
 
             if @current_error.is_a?(Exceptions::AuthorizationExpiredException)
-              Connection::ChannelAttributes.authorization_state_listener(@channel).on_expired(@current_error, @channel)
+              # TODO: ??????
+              # Connection::ChannelAttributes.authorization_state_listener(@channel).on_expired(@current_error, @channel)
             else
               # write a RESET to "acknowledge" the failure
               enqueue(Handlers::ResetResponseHandler.new(self))
@@ -115,8 +116,6 @@ module Neo4j::Driver
           end
 
           def clear_current_error
-            raise @current_error if @current_error
-          ensure
             @current_error = nil
           end
 

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

@@ -10,8 +10,8 @@ module Neo4j::Driver
           @retry_logic = retry_logic
           @log = Logging::PrefixedLogger.new("[#{hash}]", logger)
           @bookmark_holder = bookmark_holder
-          @database_name = database_name.database_name
-          @connection_context = NetworkSessionConnectionContext.new(@database_name, @bookmark_holder.bookmark, impersonated_user)
+          # @database_name = database_name.database_name
+          @connection_context = NetworkSessionConnectionContext.new(database_name, @bookmark_holder.bookmark, impersonated_user)
           @fetch_size = fetch_size
           @open = Concurrent::AtomicBoolean.new(true)
         end
@@ -133,7 +133,8 @@ module Neo4j::Driver
           # This bookmark is only used for rediscovery.
           # It has to be the initial bookmark given at the creation of the session.
           # As only that bookmark could carry extra system bookmarks
-          attr_reader :database_name, :mode, :rediscovery_bookmark, :impersonated_user
+          attr_accessor :database_name
+          attr :mode, :rediscovery_bookmark, :impersonated_user
 
           def initialize(database_name, bookmark, impersonated_user)
             @database_name = database_name

data/ruby/neo4j/driver/internal/async/pool/{netty_channel_tracker.rb → channel_tracker.rb}

@@ -2,22 +2,20 @@ module Neo4j::Driver
   module Internal
     module Async
       module Pool
-        class NettyChannelTracker
+        class ChannelTracker
           attr_reader :lock, :read, :write, :address_to_in_use_channel_count, :address_to_idle_channel_count, :log,
                       :metrics_listener, :close_listener, :all_channels
 
-          def initialize(metrics_listener, logger, options = {},event_executor = nil, channels = nil)
+          def initialize(metrics_listener, logger, **options)
             @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) }
+            @all_channels = options[:channels]
+            @lock = Concurrent::ReentrantReadWriteLock.new
+            @close_listener = method(:channel_closed)
           end
 
           def channel_released(channel)
-            do_in_write_lock do
+            @lock.with_write_lock do
               decrement_in_use(channel)
               increment_idle(channel)
               channel.close_future.add_listener(close_listener)

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

@@ -32,8 +32,7 @@ module Neo4j::Driver
             @address_to_pool_lock.with_write_lock do
               @address_to_pool.each do |address, pool|
                 unless addresses_to_retain.include?(address)
-                  active_channels = @netty_channel_tracker.in_use_channel_count(address)
-                  if active_channels.zero?
+                  unless pool.busy?
                     # address is not present in updated routing table and has no active connections
                     # it's now safe to terminate corresponding connection pool and forget about it
                     @address_to_pool.delete(address)
@@ -48,7 +47,8 @@ module Neo4j::Driver
           end
 
           def in_use_connections(address)
-            @netty_channel_tracker.in_use_channel_count(address)
+            @address_to_pool[address]&.size || 0
+            # @netty_channel_tracker.in_use_channel_count(address)
           end
 
           def idle_connections(address)

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

@@ -52,28 +52,30 @@ module Neo4j::Driver
         def close_async(commit = false, complete_with_null_if_not_open = true)
           @lock.synchronize do
             if complete_with_null_if_not_open && !open?
-              nil
+              Util::ResultHolder.successful(nil)
             elsif @state == State::COMMITTED
-              raise Neo4j::Driver::Exceptions::ClientException, commit ? CANT_COMMIT_COMMITTED_MSG : CANT_ROLLBACK_COMMITTED_MSG
+              Util::ResultHolder.failed(Neo4j::Driver::Exceptions::ClientException.new(
+                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
+              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
-                  raise Neo4j::Driver::Exceptions::ClientException, CANT_COMMIT_ROLLING_BACK_MSG
+                  Util::ResultHolder.failed(Neo4j::Driver::Exceptions::ClientException.new(CANT_COMMIT_ROLLING_BACK_MSG))
                 elsif @commit_pending
                   @commit_pending
                 else
-                  @commit_pending = true
+                  @commit_pending = Util::ResultHolder.new
                   nil
                 end
               else
                 if @commit_pending
-                  raise Neo4j::Driver::Exceptions::ClientException, CANT_ROLLBACK_COMMITTING_MSG
+                  Util::ResultHolder.failed(Neo4j::Driver::Exceptions::ClientException.new(CANT_ROLLBACK_COMMITTING_MSG))
                 elsif @rollback_pending
                   @rollback_pending
                 else
-                  @rollback_pending = true
+                  @rollback_pending = Util::ResultHolder.new
                   nil
                 end
               end
@@ -83,22 +85,18 @@ module Neo4j::Driver
               if commit
                 target_future = @commit_pending
                 target_action = lambda { |throwable|
-                  do_commit_async(throwable)
-                  handle_commit_or_rollback(throwable)
+                  do_commit_async(throwable).chain(&handle_commit_or_rollback(throwable))
                 }
               else
                 target_future = @rollback_pending
                 target_action = lambda { |throwable|
-                  do_rollback_async
-                  handle_commit_or_rollback(throwable)
+                  do_rollback_async.chain(&handle_commit_or_rollback(throwable))
                 }
               end
 
               @result_cursors.retrieve_not_consumed_error.then(&target_action)
-              handle_transaction_completion(commit, nil)
+                             .side { |_, error| handle_transaction_completion(commit, error) }.copy_to(target_future)
               target_future
-            rescue => throwable
-              handle_transaction_completion(commit, throwable)
             end
         end
 
@@ -148,7 +146,7 @@ module Neo4j::Driver
               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
+              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
@@ -175,23 +173,23 @@ module Neo4j::Driver
           end
 
           if exception
-            Util::Futures.failed_future(exception)
+            Util::ResultHolder.failed(exception)
           else
-            @protocol.commit_transaction(@connection, @bookmark_holder)
+            @protocol.commit_transaction(@connection).then(&@bookmark_holder.method(:bookmark=))
           end
         end
 
         def do_rollback_async
           if @lock.synchronize { @state } == State::TERMINATED
-            Util::Futures.completed_with_null
+            Util::ResultHolder.successful(nil)
           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)
+          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

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

@@ -2,45 +2,35 @@ 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?
+          writers.present?
         end
 
         def has_routers_and_readers?
-          @routers.present? && @readers.present?
+          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'])] })
+          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']
-          expiration_timestamp = now + ttl * 1000
-
-          if ttl < 0 || ttl >= MAX_TTL || expiration_timestamp < 0
-            expiration_timestamp = MAX_LONG
-          end
-
-          expiration_timestamp
+          now + (ttl.negative? ? 1000.years : ttl.seconds)
         end
 
-        def servers(role)
+        def self.servers(role)
           case role
           when 'READ'
             :readers

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

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

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

@@ -4,39 +4,32 @@ module Neo4j::Driver
       class ClusterRoutingTable
         MIN_ROUTERS = 1
 
-        attr_reader :database_name
-
-        def initialize(of_database, clock, routing_addresses)
+        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
+          @expiration_timestamp = Time.now
+          @routers = routing_addresses.to_set.freeze
+          @table_lock = Concurrent::ReentrantReadWriteLock.new
           @prefer_initial_router = true
-          @disused = {}
-          @readers = []
-          @writers = []
+          @disused = Set.new
+          @readers = Set.new
+          @writers = Set.new
         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)
+          @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)
-          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
+          Time.now - @table_lock.with_read_lock { @expiration_timestamp } >= extra_time
         end
 
         def update(cluster)
-          Util::LockUtil.execute_with_lock(@table_lock.write_lock) do
+          @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)
@@ -47,7 +40,7 @@ module Neo4j::Driver
         end
 
         def forget(address)
-          Util::LockUtil.execute_with_lock(@table_lock.write_lock) do
+          @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)
@@ -56,27 +49,27 @@ module Neo4j::Driver
         end
 
         def readers
-          Util::LockUtil.execute_with_lock(@table_lock.read_lock, -> () { @readers })
+          @table_lock.with_read_lock { @readers }
         end
 
         def writers
-          Util::LockUtil.execute_with_lock(@table_lock.read_lock, -> () { @writers })
+          @table_lock.with_read_lock { @writers }
         end
 
         def routers
-          Util::LockUtil.execute_with_lock(@table_lock.read_lock, -> () { @routers })
+          @table_lock.with_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)
+          @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)
@@ -85,53 +78,43 @@ module Neo4j::Driver
         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) } )
+          @table_lock.with_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 })
+          @table_lock.with_read_lock { @prefer_initial_router }
         end
 
         def expiration_timestamp
-          Util::LockUtil.execute_with_lock(@table_lock.read_lock, -> () { @expiration_timestamp })
+          @table_lock.with_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}'"
+          @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)
-          new_list = []
-
-          addresses.each do |address|
-            new_list << address unless address.eql?(address_to_skip)
-          end
-
-          new_list.freeze
+          (addresses - [address_to_skip]).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
+          addresses.map { |address| address == old_address ? new_address : address }.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
+        def new_with_reused_addresses(*addresses)
+          addresses.map(&:to_set).reduce(&:+).freeze
         end
 
         def to_bolt_server_address(address)
-          BoltServerAddress.class.eql?(address.class) ? address : BoltServerAddress.new(address.host, address.port)
+          if BoltServerAddress.class == address.class
+            address
+          else
+            BoltServerAddress.new(host: address.host, port: address.port)
+          end
         end
       end
     end

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

@@ -3,10 +3,7 @@ module Neo4j::Driver
     module Cluster
       class IdentityResolver
         IDENTITY_RESOLVER = new
-
-        def resolve(initial_router)
-          java.util.Collections.singleton(initial_router)
-        end
+        alias resolve Array
       end
     end
   end

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

@@ -28,10 +28,9 @@ module Neo4j::Driver
 
           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 nil
+              return
             end
 
             # choose start index for iteration in round-robin fashion
@@ -39,22 +38,23 @@ module Neo4j::Driver
             index = start_index
 
             least_connected_address = nil
-            least_active_connections = java.lang.Integer::MAX_VALUE
+            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 active_connections < least_active_connections
+              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 == size - 1) ? 0 : index += 1
+              index = (index + 1) % size
 
-              break if index != start_index
+              break if index == start_index
             end
 
             @log.debug("Selected #{address_type} with address: '#{least_connected_address}' and active connections: #{least_active_connections}")