neo4j-ruby-driver 4.4.0.alpha.4 → 4.4.0.alpha.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dceecd30fd6fa4473c3ec6bb640b6126bd7bb06eb5057d58e46064d8c434a929
-  data.tar.gz: 0e1a77da3ca678a1b4a201fa0d0211a771a009a77bb81b1a0c98e331b22c5471
+  metadata.gz: a035a8385e54c70c851003ce4131072610617d515f118d2d4b03f6ada71de3a7
+  data.tar.gz: bc8dfddb76165d4aea25d702e1d4bb1be5db3bb375d25f48fab39acb7f247c07
 SHA512:
-  metadata.gz: fdd3c4bbdd314fb7036ce6c7fedba8a49e26b194450dea535a7aa05f380d58a6ab04ea7edbba6cf664514c1585084ad0e17c40fb719a9794f127ee3623c169db
-  data.tar.gz: 673a7aa8a4f3192f7b9b15b91efaca7c05dfcb79779b39ed4f014989db06672f7c293fd3948e16fc515177cae84e428f5885b3f1d3b4c081f05e580afbd66b5d
+  metadata.gz: 17a1b5ada9f09120e7dda4316504d59fedf366696d27c26e87c5feeee381a876409a75eaa05cbc177af64415946af7ec8c1de7b4ed5e637ffc464a40c1fd4eea
+  data.tar.gz: aa41d20c4794dac6841aa1bf70cb0c3e8573a658e74d8aa4e475f45a2a0a9072056633a83f8744251014ab5a805b6ec368f4a75b036316c2179bc1bcc1f8f8fa

data/README.md

@@ -42,6 +42,7 @@ This gem includes 2 different implementations: java driver wrapper and pure ruby
 ## Testing
 
 To run the tests the following tools need to be installed:
+
     $ brew install python
     $ pip3 install --user git+https://github.com/klobuczek/boltkit@1.3#egg=boltkit
     $ neoctrl-install -e 4.4.5 servers

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/internal/async/inbound/inbound_message_dispatcher.rb

@@ -151,7 +151,7 @@ module Neo4j::Driver
               @auto_read_managing_handler.disable_auto_read_management
 
               # restore the default value of auto-read
-              @channel.config.set_auto_read(true)
+              @channel.auto_read = true
             end
 
             @auto_read_managing_handler = new_handler

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

@@ -33,11 +33,11 @@ module Neo4j::Driver
         end
 
         def enable_auto_read
-          set_auto_read(true) if open?
+          @channel.auto_read = true if open?
         end
 
         def disable_auto_read
-          set_auto_read(false) if open?
+          @channel.auto_read = false if open?
         end
 
         def flush
@@ -69,13 +69,12 @@ module Neo4j::Driver
 
         def release
           if @status.compare_and_set(Status::OPEN, Status::RELEASED)
-            @channel_pool.release(@channel)
+            handler = Handlers::ChannelReleasingResetResponseHandler.new(@channel, @channel_pool, @message_dispatcher, @log, @release)
+            write_reset_message_if_needed(handler, false)
+            # @metrics_listener.after_connection_released(Connection::ChannelAttributes.pool_id(@channel), @in_use_event)
+            # end
+            # @release_future
           end
-          # handler = Handlers::ChannelReleasingResetResponseHandler.new(@channel, @channel_pool, @message_dispatcher, @clock, @release)
-          # write_reset_message_if_needed(handler, false)
-          # @metrics_listener.after_connection_released(Connection::ChannelAttributes.pool_id(@channel), @in_use_event)
-          # end
-          # @release_future
         end
 
         def terminate_and_release(reason)
@@ -91,15 +90,13 @@ module Neo4j::Driver
         private
 
         def write_reset_message_if_needed(reset_handler, is_session_reset)
-          @channel.event_loop.execute do
-            if is_session_reset && !open?
-              reset_handler.on_success(java.util.Collections.empty_map)
-            else
-              # auto-read could've been disabled, re-enable it to automatically receive response for RESET
-              set_auto_read(true)
-              @message_dispatcher.enqueue(reset_handler)
-              @channel.write_and_flush(Messaging::Request::ResetMessage::RESET).add_listener(-> (_future) { register_connection_read_timeout(@channel) })
-            end
+          if is_session_reset && !open?
+            reset_handler.on_success
+          else
+            # auto-read could've been disabled, re-enable it to automatically receive response for RESET
+            @channel.auto_read = true
+            @message_dispatcher.enqueue(reset_handler)
+            @channel.write_and_flush(Messaging::Request::ResetMessage::RESET)#.add_listener(-> (_future) { register_connection_read_timeout(@channel) })
           end
         end
 
@@ -114,7 +111,7 @@ module Neo4j::Driver
           @message_dispatcher.enqueue(handler)
 
           if flush
-            @channel.write_and_flush(message)#.add_listener(-> (_future) { register_connection_read_timeout(@channel) })
+            @channel.write_and_flush(message) #.add_listener(-> (_future) { register_connection_read_timeout(@channel) })
           else
             @channel.write(message)
           end
@@ -135,10 +132,6 @@ module Neo4j::Driver
           end
         end
 
-        def set_auto_read(value)
-          @channel.config.set_auto_read(value)
-        end
-
         def verify_open(handler1, handler2)
           connection_status = @status.get
 

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/channel.rb

@@ -6,6 +6,7 @@ module Neo4j::Driver
           attr :stream
           attr_accessor :version, :protocol, :message_format, :message_dispatcher
           attr :attributes # should be attr
+          attr_accessor :auto_read
 
           def initialize(address, connector, logger)
             super()

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

@@ -20,6 +20,7 @@ module Neo4j::Driver
 
             begin
               channel = pool.acquire
+              @log.debug{"Channel #{channel.object_id} acquired"}
             rescue => error
               process_acquisition_error(pool, address, error)
             end
@@ -31,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)
@@ -47,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/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
+          (current_addresses + disused_addresses + new_addresses).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}")