neo4j-ruby-driver 4.4.0.beta.1 → 4.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c795045f581183398e15ba5c44c1f89b10ea234a9a6dc1e46fecd8c02b857bb3
-  data.tar.gz: 1859daea7265d9409d001e748048ab97837fe26895d80fe4e24773b1b51ed49d
+  metadata.gz: 6fd1245f505176d11efea03e96cc022216e0e93f93581aaf6b55d6397097cf2d
+  data.tar.gz: 7a7394025131851020cfda11949bed86860be9fb599b22efe458e8d79bcbffc2
 SHA512:
-  metadata.gz: 5f72367997a92a64e8a75ef08bfca59d0acffaac7589e594b69d8fead9173dc3339d6b3dc26ad63ae1f2f0f7cde0a9f172908e9112b92b3496c209ef8c99e01d
-  data.tar.gz: 7bee1a6da116192d42ad2d9b86091d787211af683278c9cfe136f3c8ebf3d1d8c807834b44d5162a308b47b5208ee8e0b40302961a5dfb83c16a7180353d617e
+  metadata.gz: b77c6e15952c126b67a67fc953c9da825fb8aee8399c8929eb8bc45d43542b0f88ef2d019de39877409c9c5fb73e3d04972ad79dcbda9f8b64a62f47120e6a34
+  data.tar.gz: d1a0538ad1ec75804854efaf5d0cd951573f25fb1b976adf0fe606826d87e8141f30453cd77eec1b390201f3d80515d0094840855121f43766e11db5d0d1108e

data/ruby/neo4j/driver/graph_database.rb

@@ -4,9 +4,7 @@ module Neo4j::Driver
   class GraphDatabase
     class << self
       extend AutoClosable
-      extend Synchronizable
       auto_closable :driver, :routing_driver
-      sync :driver
 
       def driver(uri, auth_token = nil, **config)
         internal_driver(uri, auth_token, config, Internal::DriverFactory.new)
@@ -66,7 +64,7 @@ module Neo4j::Driver
 
       def close_driver(driver, uri, log)
         driver.close
-      rescue StandardError => close_error
+      rescue => close_error
         log.warn { "Unable to close driver towards URI: #{uri}\n#{close_error}" }
       end
 

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

@@ -7,7 +7,7 @@ module Neo4j::Driver
 
         attr_reader :server_agent, :server_address, :server_version
 
-        def initialize(channel, channel_pool, logger)
+        def initialize(channel, channel_pool, logger, &on_pool_shutdown)
           @log = logger
           @channel = channel
           @message_dispatcher = channel.attributes[:message_dispatcher]
@@ -16,6 +16,7 @@ module Neo4j::Driver
           @server_version = channel.attributes[:server_version]
           @protocol = Messaging::BoltProtocol.for_channel(channel)
           @channel_pool = channel_pool
+          @on_pool_shutdow = on_pool_shutdown
           # @release_future = java.util.concurrent.CompletableFuture.new
           # @clock = clock
           # @connection_read_timeout = Connection::ChannelAttributes.connection_read_timeout(channel) || nil
@@ -89,10 +90,25 @@ module Neo4j::Driver
             # 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) })
+            write_to_channel(Messaging::Request::ResetMessage::RESET, true)
           end
         end
 
+        def write_to_channel(message, flush = false)
+          if flush
+            @channel.write_and_flush(message) #.add_listener(-> (_future) { register_connection_read_timeout(@channel) })
+          else
+            @channel.write(message)
+          end
+        rescue EOFError, Errno::ECONNRESET, Errno::EPIPE => e
+          terminate_and_release(e.message)
+          @log.debug("Shutting down connection pool towards #{@server_address} due to error: #{e.message}")
+          @channel_pool.shutdown(&:close)
+          @on_pool_shutdow.call
+          # should remove routing table entry as well
+          raise Exceptions::SessionExpiredException, e.message
+        end
+
         def flush_in_event_loop
           @channel.event_loop.execute do
             @channel.flush
@@ -103,11 +119,7 @@ module Neo4j::Driver
         def write_message_in_event_loop(message, handler, flush)
           @message_dispatcher.enqueue(handler)
 
-          if flush
-            @channel.write_and_flush(message) #.add_listener(-> (_future) { register_connection_read_timeout(@channel) })
-          else
-            @channel.write(message)
-          end
+          write_to_channel(message, flush)
         end
 
         def write_messages_in_event_loop(message1, handler1, message2, handler2, flush)

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

@@ -10,7 +10,7 @@ module Neo4j::Driver
 
           def initialize(address, connector, logger)
             @attributes = Connection::ChannelAttributes.new
-            @stream = Connection::Stream.new(connector.connect(address))
+            @stream = Connection::Stream.new(connect_to_io_socket(connector, address))
             @stream.write(Connection::BoltProtocolUtil.handshake_buf)
             @stream.flush
             Connection::HandshakeHandler.new(logger).decode(self)
@@ -39,6 +39,10 @@ module Neo4j::Driver
 
           private
 
+          def connect_to_io_socket(connector, address)
+            Sync { connector.connect(address) }
+          end
+
           def bracketless(host)
             host.delete_prefix('[').delete_suffix(']')
           end

data/ruby/neo4j/driver/internal/async/pool/{controller.rb → channel_pool.rb}

@@ -2,7 +2,7 @@ module Neo4j::Driver
   module Internal
     module Async
       module Pool
-        class Controller < ConnectionPool
+        class ChannelPool < ConnectionPool
           def initialize(limit: nil, acquisition_timeout: nil, &block)
             super(size: limit, timeout: acquisition_timeout, &block)
             @available = TimedStack.new(@size, &block)

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

@@ -20,12 +20,12 @@ module Neo4j::Driver
 
             begin
               channel = pool.acquire
-              @log.debug{"Channel #{channel.object_id} acquired"}
+              @log.debug { "Channel #{channel.object_id} acquired" }
             rescue => error
               process_acquisition_error(pool, address, error)
             end
             assert_not_closed(address, channel, pool)
-            NetworkConnection.new(channel, pool, @log)
+            NetworkConnection.new(channel, pool, @log) { remove(pool) }
           end
 
           def retain_all(addresses_to_retain)
@@ -46,6 +46,12 @@ module Neo4j::Driver
             end
           end
 
+          def remove(pool)
+            @address_to_pool_lock.with_write_lock do
+              @address_to_pool.each { |address, value| @address_to_pool.delete(address) if value == pool }
+            end
+          end
+
           def in_use_connections(address)
             @address_to_pool[address]&.size || 0
             # @netty_channel_tracker.in_use_channel_count(address)
@@ -81,7 +87,7 @@ module Neo4j::Driver
               # NettyChannelPool returns future failed with TimeoutException if acquire operation takes more than
               # configured time, translate this exception to a prettier one and re-throw
               raise Neo4j::Driver::Exceptions::ClientException.new("Unable to acquire connection from the pool within configured maximum time of #{@settings.connection_acquisition_timeout.inspect}")
-            # elsif pool.closed?
+              # elsif pool.closed?
               # There is a race condition where a thread tries to acquire a connection while the pool is closed by another concurrent thread.
               # Treat as failed to obtain connection for a direct driver. For a routing driver, this error should be retried.
               # raise Neo4j::Driver::Exceptions::ServiceUnavailableException, "Connection pool for server #{server_address} is closed while acquiring a connection."
@@ -109,7 +115,7 @@ module Neo4j::Driver
           end
 
           def new_pool(address)
-            Controller.new(limit: @settings.max_connection_pool_size, acquisition_timeout: @settings.connection_acquisition_timeout) { Channel.new(address, @connector, @log) }
+            ChannelPool.new(limit: @settings.max_connection_pool_size, acquisition_timeout: @settings.connection_acquisition_timeout) { Channel.new(address, @connector, @log) }
           end
 
           def get_or_create_pool(address)

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

@@ -41,13 +41,15 @@ module Neo4j::Driver
           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.lazy.map do |address|
-              private_suports_multi_db?(address)
+            addresses.each do |address|
+              return private_suports_multi_db?(address)
             rescue Exceptions::SecurityException
               raise
             rescue => error
               Util::Futures.combine_errors(base_error, error)
-            end.find { |result| !result.nil? } or raise base_error
+            end
+
+            raise base_error
           end
 
           private

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

@@ -12,19 +12,19 @@ module Neo4j::Driver
 
         def get_cluster_composition(connection, database_name, bookmark, impersonated_user)
           runner = if Messaging::Request::MultiDatabaseUtil.supports_route_message?(connection)
-                    @route_message_routing_procedure_runner
-                  elsif Messaging::Request::MultiDatabaseUtil.supports_multi_database?(connection)
-                    @multi_database_routing_procedure_runner
-                  else
-                    @single_database_routing_procedure_runner
-                  end
+                     @route_message_routing_procedure_runner
+                   elsif Messaging::Request::MultiDatabaseUtil.supports_multi_database?(connection)
+                     @multi_database_routing_procedure_runner
+                   else
+                     @single_database_routing_procedure_runner
+                   end
 
           process_routing_response(runner.run(connection, database_name, bookmark, impersonated_user))
         end
 
         def process_routing_response(response)
           unless response.success?
-            raise response.error.class, "Failed to run '#{invoked_procedure_string(response)}' on server. Please make sure that there is a Neo4j server or cluster up running."
+            raise response.error, "Failed to run '#{invoked_procedure_string(response)}' on server. Please make sure that there is a Neo4j server or cluster up running."
           end
 
           records = response.records
@@ -36,7 +36,7 @@ module Neo4j::Driver
 
           # failed to parse the record
           begin
-            cluster = ClusterComposition.parse( records[0], Time.now)
+            cluster = ClusterComposition.parse(records[0], Time.now)
           rescue Exceptions::Value::ValueException => e
             raise Exceptions::ProtocolException, "#{PROTOCOL_ERROR_MESSAGE % invoked_procedure_string(response)} unparsable record received. #{e}"
           end

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

@@ -17,8 +17,8 @@ module Neo4j::Driver
           procedure = procedure_query(connection.server_version, database_name)
           bookmark_holder = bookmark_holder(bookmark)
           begin
-            records = run_procedure(delegate, procedure, bookmark_holder)
-            RoutingProcedureResponse.new(procedure, records: records)
+            result = run_procedure(delegate, procedure, bookmark_holder)
+            RoutingProcedureResponse.new(procedure, **result.error ? { error: result.error } : { records: result.result! })
           rescue => error
             handle_error(procedure, error)
           ensure
@@ -48,7 +48,7 @@ module Neo4j::Driver
           connection.protocol
                     .run_in_auto_commit_transaction(connection, procedure, bookmark_holder, TransactionConfig.empty,
                                                     Handlers::Pulln::FetchSizeUtil::UNLIMITED_FETCH_SIZE)
-                    .async_result.then(&:to_a)
+                    .async_result.list_async
         end
 
         def release_connection(connection)

data/ruby/neo4j/driver/internal/cursor/async_result_cursor_impl.rb

@@ -2,7 +2,6 @@ module Neo4j::Driver
   module Internal
     module Cursor
       class AsyncResultCursorImpl
-        include Enumerable
         delegate :consume_async, :next_async, :peek_async, to: :@pull_all_handler
 
         def initialize(run_handler, pull_all_handler)
@@ -29,13 +28,7 @@ module Neo4j::Driver
           end
         end
 
-        def each(&action)
-          result_holder = Util::ResultHolder.new
-          internal_for_each_async(result_holder, &action)
-          result_holder.then { consume_async }
-        end
-
-        def to_async(&map_function)
+        def list_async(&map_function)
           @pull_all_handler.list_async(&block_given? ? map_function : :itself)
         end
 
@@ -49,23 +42,6 @@ module Neo4j::Driver
           @pull_all_handler.pull_all_failure_async.then { |error| run_error ? nil : error }
         end
 
-        private def internal_for_each_async(result_holder, &action)
-          next_async.chain do |record, error|
-            if error
-              result_holder.fail(error)
-            elsif record
-              begin
-                yield record
-              rescue => action_error
-                result_holder.fail(action_error)
-              end
-              internal_for_each_async(result_holder, &action)
-            else
-              result_holder.succeed(nil)
-            end
-          end
-        end
-
         def map_successful_run_completion_async
           run_error&.then(&Util::ResultHolder.method(:failed)) || Util::ResultHolder.successful(self)
         end

data/ruby/neo4j/driver/internal/cursor/disposable_async_result_cursor.rb

@@ -34,6 +34,11 @@ module Neo4j::Driver
           @delegate.each(&action)
         end
 
+        def list_async(&block)
+          assert_not_disposed
+          @delegate.list_async(&block)
+        end
+
         def discard_all_failure_async
           @disposed = true
           @delegate.discard_all_failure_async

data/ruby/neo4j/driver/internal/handlers/legacy_pull_all_response_handler.rb

@@ -4,7 +4,6 @@ module Neo4j::Driver
       # This is the Pull All response handler that handles pull all messages in Bolt v3 and previous protocol versions.
       class LegacyPullAllResponseHandler
         include Spi::ResponseHandler
-        include Enumerable
         RECORD_BUFFER_LOW_WATERMARK = ENV['record_buffer_low_watermark']&.to_i || 300
         RECORD_BUFFER_HIGH_WATERMARK = ENV['record_buffer_high_watermark']&.to_i || 1000
 
@@ -83,12 +82,15 @@ module Neo4j::Driver
             Util::ResultHolder.successful(@summary)
         end
 
-        def each
-          pull_all_failure_async.then do
+        def list_async(&block)
+          pull_all_failure_async.then do |error|
+            raise error if error
             unless @finished
               raise Exceptions::IllegalStateException, "Can't get records as list because SUCCESS or FAILURE did not arrive"
             end
-            @records.each { |record| yield record }
+            @records.items.map(&block)
+          ensure
+            @records.items.clear
           end
         end
 

data/ruby/neo4j/driver/internal/handlers/pulln/auto_pull_response_handler.rb

@@ -3,7 +3,6 @@ module Neo4j::Driver
     module Handlers
       module Pulln
         class AutoPullResponseHandler < BasicPullResponseHandler
-          include Enumerable
           delegate :signal, to: :@records
           LONG_MAX_VALUE = 2 ** 63 - 1
 
@@ -79,12 +78,14 @@ module Neo4j::Driver
             completed_with_value_if_no_failure(@summary)
           end
 
-          def each
+          def list_async(&block)
             pull_all_async.then do
               unless done?
                 raise Exceptions::IllegalStateException, "Can't get records as list because SUCCESS or FAILURE did not arrive"
               end
-              @records.each { |record| yield record }
+              @records.items.map(&block)
+            ensure
+              @records.items.clear
             end
           end
 

data/ruby/neo4j/driver/version.rb

@@ -2,6 +2,6 @@
 
 module Neo4j
   module Driver
-    VERSION = '4.4.0.beta.1'
+    VERSION = '4.4.1'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j-ruby-driver
 version: !ruby/object:Gem::Version
-  version: 4.4.0.beta.1
+  version: 4.4.1
 platform: ruby
 authors:
 - Heinrich Klobuczek
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-25 00:00:00.000000000 Z
+date: 2023-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -287,9 +287,9 @@ files:
 - ruby/neo4j/driver/internal/async/outbound/chunk_aware_byte_buf_output.rb
 - ruby/neo4j/driver/internal/async/outbound/outbound_message_handler.rb
 - ruby/neo4j/driver/internal/async/pool/channel.rb
+- ruby/neo4j/driver/internal/async/pool/channel_pool.rb
 - ruby/neo4j/driver/internal/async/pool/channel_tracker.rb
 - ruby/neo4j/driver/internal/async/pool/connection_pool_impl.rb
-- ruby/neo4j/driver/internal/async/pool/controller.rb
 - ruby/neo4j/driver/internal/async/pool/netty_channel_health_checker.rb
 - ruby/neo4j/driver/internal/async/pool/netty_channel_pool.rb
 - ruby/neo4j/driver/internal/async/pool/network_connection_factory.rb
@@ -496,11 +496,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: ''