neo4j-ruby-driver 4.4.0.alpha.9 → 4.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41dc794832386239a05ddcc44bb1937da85f8d1b3d0be4977ab3b53157ab5ac0
-  data.tar.gz: e085f6bfce9255985ead9e0aab6bd70a8495f9b62bbfa16fbe38efaac1508032
+  metadata.gz: aad2e30fa3fa23dc95e7db9f27847b1c5382c23600c019d93a7625fc5a66d085
+  data.tar.gz: 534c14f354f92df7a85b153e1451951ded71863fbbb10c61a50a280a8bf3bea7
 SHA512:
-  metadata.gz: d3eeaeaeb2a4f8d19ffacdec93f2fb64ff5c8a65ab27bf6593d4ae3ce2c08e092b97662bd6ab58f4cc59a5bb4d2215e1c8fe80c916c05eda9e9b9454b72411a5
-  data.tar.gz: 0a86332ba42e153c1f21964fbca5a0cdba75bf5b3cea574ce40db4a1a54f090dd43d1b1f6096acb51e04ac7d6cdddaf03a3f84dad6fb4582de911d11f22824b5
+  metadata.gz: 909be9c6542e378161b3e9b9c62ad9e45ef08c54f7410b4ea5a2ba3f15267fd445995757f74210aadcaa10f94475f839cddeb2294c23d44a9925e044e23cc162
+  data.tar.gz: 4d22446e5a24c6f7f99072202bfc4dbab1e222b535c64b1c716a31f4993f9fe0da07c8d5dfbd3f68d793fc1b11f6782f4a6062e3171f41b7b26a8c7260b0966a

data/ruby/neo4j/driver/graph_database.rb

@@ -66,7 +66,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

@@ -1,14 +1,13 @@
 module Neo4j::Driver
   module Internal
     module Async
-      class NetworkConnection < ::Async::Pool::Resource
+      class NetworkConnection
         include Spi::Connection
         delegate :protocol, to: :@channel
 
         attr_reader :server_agent, :server_address, :server_version
 
-        def initialize(channel, channel_pool, logger)
-          super()
+        def initialize(channel, channel_pool, logger, &on_pool_shutdown)
           @log = logger
           @channel = channel
           @message_dispatcher = channel.attributes[:message_dispatcher]
@@ -17,17 +16,13 @@ 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
           @status = Concurrent::AtomicReference.new(Status::OPEN)
         end
 
-        # def close
-        #   super
-        #   @io.close
-        # end
-
         def open?
           @status.get == Status::OPEN
         end
@@ -95,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
@@ -109,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

@@ -2,14 +2,13 @@ module Neo4j::Driver
   module Internal
     module Async
       module Pool
-        class Channel < ::Async::Pool::Resource
+        class Channel
           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()
             @attributes = Connection::ChannelAttributes.new
             @stream = Connection::Stream.new(connector.connect(address))
             @stream.write(Connection::BoltProtocolUtil.handshake_buf)
@@ -25,7 +24,6 @@ module Neo4j::Driver
           end
 
           def close
-            super unless closed? # Should this be conditional?
             @stream.close
           end
 

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

@@ -0,0 +1,31 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      module Pool
+        class ChannelPool < ConnectionPool
+          def initialize(limit: nil, acquisition_timeout: nil, &block)
+            super(size: limit, timeout: acquisition_timeout, &block)
+            @available = TimedStack.new(@size, &block)
+          end
+
+          def acquire(options = {})
+            @available.pop(options[:timeout] || @timeout)
+          end
+
+          def release(resource)
+            @available.push(resource)
+            nil
+          end
+
+          def close
+            @available.shutdown(&:close)
+          end
+
+          def busy?
+            @available.any_resource_busy?
+          end
+        end
+      end
+    end
+  end
+end

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)
@@ -77,11 +83,11 @@ module Neo4j::Driver
           private
 
           def process_acquisition_error(pool, server_address, error)
-            if error.is_a?(::Async::TimeoutError)
+            if error.is_a?(ConnectionPool::TimeoutError)
               # 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.wrap(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/async/pool/timed_stack.rb

@@ -0,0 +1,15 @@
+module Neo4j::Driver
+  module Internal
+    module Async
+      module Pool
+        class TimedStack < ConnectionPool::TimedStack
+          def any_resource_busy?
+            @mutex.synchronize do
+              @created > @que.length
+            end
+          end
+        end
+      end
+    end
+  end
+end

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.alpha.9'
+    VERSION = '4.4.0'
   end
 end

data/ruby/neo4j/driver.rb

@@ -5,9 +5,8 @@ require 'active_support/core_ext/hash/keys'
 require 'active_support/logger'
 require 'async/io'
 require 'async/io/stream'
-require 'async/pool'
-require 'async/pool/resource'
 require 'async/queue'
+require 'connection_pool'
 require 'bigdecimal'
 require 'date'
 require 'loader'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j-ruby-driver
 version: !ruby/object:Gem::Version
-  version: 4.4.0.alpha.9
+  version: 4.4.0
 platform: ruby
 authors:
 - Heinrich Klobuczek
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-24 00:00:00.000000000 Z
+date: 2022-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: async-pool
+  name: connection_pool
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -287,13 +287,14 @@ 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
 - ruby/neo4j/driver/internal/async/pool/pool_settings.rb
+- ruby/neo4j/driver/internal/async/pool/timed_stack.rb
 - ruby/neo4j/driver/internal/async/result_cursors_holder.rb
 - ruby/neo4j/driver/internal/async/unmanaged_transaction.rb
 - ruby/neo4j/driver/internal/bookmark_holder.rb
@@ -495,9 +496,9 @@ 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
 signing_key:

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

@@ -1,25 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Async
-      module Pool
-        class Controller < ::Async::Pool::Controller
-          def initialize(constructor, limit: nil, concurrency: nil, acquisition_timeout: nil)
-            super(constructor, limit: limit, concurrency: concurrency)
-            @acquisition_timeout = acquisition_timeout
-          end
-
-          def wait_for_resource
-            case @acquisition_timeout
-            when nil
-              super
-            when 0
-              available_resource or raise ::Async::TimeoutError
-            else
-              ::Async::Task.current.with_timeout(@acquisition_timeout) { super }
-            end
-          end
-        end
-      end
-    end
-  end
-end