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

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
-        UNINITIALIZED_RECORDS = []
         RECORD_BUFFER_LOW_WATERMARK = ENV['record_buffer_low_watermark']&.to_i || 300
         RECORD_BUFFER_HIGH_WATERMARK = ENV['record_buffer_high_watermark']&.to_i || 1000
 
@@ -14,7 +13,7 @@ module Neo4j::Driver
           @metadata_extractor = Internal::Validator.require_non_nil!(metadata_extractor)
           @connection = Internal::Validator.require_non_nil!(connection)
           @completion_listener = Internal::Validator.require_non_nil!(completion_listener)
-          @records = UNINITIALIZED_RECORDS
+          @records = ::Async::Queue.new
         end
 
         def can_manage_auto_read?
@@ -39,7 +38,7 @@ module Neo4j::Driver
 
           failed_record_future = fail_record_future(error)
 
-          if fail_record_future
+          if failed_record_future
             # error propagated through the record future
             complete_failure_future(nil)
           else
@@ -54,7 +53,7 @@ module Neo4j::Driver
           if @ignore_records
             complete_record_future(nil)
           else
-            record = InternalRecord.new(run_response_handler.query_keys, fields)
+            record = InternalRecord.new(@run_response_handler.query_keys, fields)
             enqueue_record(record)
             complete_record_future(record)
           end
@@ -65,36 +64,46 @@ module Neo4j::Driver
         end
 
         def peek_async
-          record = @records.first
+          while @records.empty? && !(@ignore_records || @finished)
+            @records.wait
+          end
+          @records.items.first
 
-          if record.nil?
-            return Util::Futures.failed_future(extract_failure) unless @failure.nil?
+          # if record.nil?
+          #   return Util::Futures.failed_future(extract_failure) unless @failure.nil?
 
-            return Util::Futures.completed_with_null if @ignore_records || @finished
+          #   return Util::Futures.completed_with_null if @ignore_records || @finished
 
-            @record_future = java.util.concurrent.CompletableFuture.new if @record_future.nil?
+          #   @record_future = java.util.concurrent.CompletableFuture.new if @record_future.nil?
 
-            @record_future
-          else
-            java.util.concurrent.CompletableFuture.completed_future(record)
-          end
+          #   @record_future
+          # else
+          #   # java.util.concurrent.CompletableFuture.completed_future(record)
+          #   record
+          # end
         end
 
         def next_async
-          peek_async.then_apply(-> (_ignore) { dequeue_record })
+          dequeue_record if peek_async
         end
 
         def consume_async
           @ignore_records = true
-          @records.clear
-
-          pull_all_failure_async.then_apply do |error|
-            unless error.nil?
-              raise Util::Futures.as_completion_exception, error
-            end
+          @records.items.clear
 
+          if pull_all_failure_async.nil?
             @summary
+          else
+            raise Util::Futures.as_completion_exception, pull_all_failure_async
           end
+
+          # pull_all_failure_async do |error|
+          #   unless error.nil?
+          #     raise Util::Futures.as_completion_exception, error
+          #   end
+
+          #   @summary
+          # end
         end
 
         def list_async(map_function)
@@ -115,7 +124,8 @@ module Neo4j::Driver
           if !@failure.nil?
             return java.util.concurrent.CompletableFuture.completed_future(extract_failure)
           elsif @finished
-            return Util::Futures.completed_with_null
+            return nil
+            # return Util::Futures.completed_with_null
           else
             if @failure_future.nil?
               # neither SUCCESS nor FAILURE message has arrived, register future to be notified when it arrives
@@ -139,7 +149,7 @@ module Neo4j::Driver
           # when failure is requested we have to buffer all remaining records and then return the error
           # do not disable auto-read in this case, otherwise records will not be consumed and trailing
           # SUCCESS or FAILURE message will not arrive as well, so callers will get stuck waiting for the error
-          if !should_buffer_all_records && records.size > RECORD_BUFFER_HIGH_WATERMARK
+          if !should_buffer_all_records && @records.size > RECORD_BUFFER_HIGH_WATERMARK
             # more than high watermark records are already queued, tell connection to stop auto-reading from network
             # this is needed to deal with slow consumers, we do not want to buffer all records in memory if they are
             # fetched from network faster than consumed
@@ -148,7 +158,7 @@ module Neo4j::Driver
         end
 
         def dequeue_record
-          record = @records.drop(1)
+          record = @records.dequeue
 
           if @records.size < RECORD_BUFFER_LOW_WATERMARK
             # less than low watermark records are now available in the buffer, tell connection to pre-fetch more
@@ -170,7 +180,7 @@ module Neo4j::Driver
             result << map_function.apply(record)
           end
 
-          @records.clear
+          @records.items.clear
           result
         end
 
@@ -212,7 +222,7 @@ module Neo4j::Driver
 
         def extract_result_summary(metadata)
           result_available_after = @run_response_handler.result_available_after
-          @metadataExtractor.extract_summary(@query, @connection, result_available_after, metadata)
+          @metadata_extractor.extract_summary(@query, @connection, result_available_after, metadata)
         end
 
         def enable_auto_read

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

@@ -4,7 +4,6 @@ module Neo4j::Driver
       module Pulln
         class AutoPullResponseHandler < BasicPullResponseHandler
           delegate :signal, to: :@records
-          UNINITIALIZED_RECORDS = ::Async::Queue.new
           LONG_MAX_VALUE = 2 ** 63 - 1
 
           def initialize(query, run_response_handler, connection, metadata_extractor, completion_listener, fetch_size)
@@ -20,7 +19,7 @@ module Neo4j::Driver
               @low_record_watermark = fetch_size * 0.3
             end
 
-            @records = UNINITIALIZED_RECORDS
+            @records = ::Async::Queue.new
             @auto_pull_enabled = true
 
             install_record_and_summary_consumers

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

@@ -9,7 +9,7 @@ module Neo4j::Driver
           @completion_future = completion_future
         end
 
-        def on_success(_metadata)
+        def on_success(_metadata = {})
           reset_completed(true)
         end
 

data/ruby/neo4j/driver/internal/impersonation_util.rb

@@ -14,8 +14,8 @@ module Neo4j::Driver
       private
 
       def self.supports_impersonation?(connection)
-        connection.server_version.greater_than_or_equal(Util::ServerVersion::V4_4_0) &&
-        connection.protocol.version.compare_to( Messaging::V44::BoltProtocolV44::VERSION ) >= 0
+        connection.server_version >= Util::ServerVersion::V4_4_0 &&
+          connection.protocol.version >= Messaging::V44::BoltProtocolV44::VERSION
       end
     end
   end

data/ruby/neo4j/driver/internal/internal_bookmark.rb

@@ -2,13 +2,13 @@ module Neo4j::Driver
   module Internal
     class InternalBookmark
       include Bookmark
-      EMPTY = new
       attr :values
       delegate :hash, :empty?, to: :values
 
       private def initialize(*values)
         @values = values.to_set
       end
+      EMPTY = new.freeze
 
       def ==(other)
         equal?(other) || self.class == other.class && values == other.values

data/ruby/neo4j/driver/internal/internal_database_name.rb

@@ -1,10 +1,8 @@
 module Neo4j::Driver
   module Internal
-    class InternalDatabaseName < Struct.new(:database_name)
-      alias description database_name
-
-      def initialize(database_name)
-        super(Validator.require_non_nil!(database_name))
+    class InternalDatabaseName < Struct.new(:database_name, :description)
+      def initialize(database_name: nil, description: database_name)
+        super(database_name, description)
       end
     end
   end

data/ruby/neo4j/driver/internal/internal_driver.rb

@@ -7,7 +7,7 @@ module Neo4j::Driver
       # delegate :verify_connectivity, to: :session_factory
       delegate :metrics, :metrics_enabled?, to: :metrics_provider
       auto_closable :session
-      sync :close, :supports_multi_db?, :verify_connectivity
+      sync :close, :supports_multi_db?, :verify_connectivity, :session
 
       def initialize(security_plan, session_factory, metrics_provider, logger)
         @closed = Concurrent::AtomicBoolean.new(false)

data/ruby/neo4j/driver/internal/messaging/bolt_protocol_version.rb

@@ -2,10 +2,12 @@ module Neo4j::Driver
   module Internal
     module Messaging
       class BoltProtocolVersion < Struct.new(:major_version, :minor_version)
+        include Comparable
+
         def self.from_raw_bytes(raw_version)
           major = raw_version & 0x000000FF
           minor = (raw_version >> 8) & 0x000000FF
-          new(major,minor)
+          new(major, minor)
         end
 
         def to_int

data/ruby/neo4j/driver/internal/messaging/encode/route_message_encoder.rb

@@ -8,8 +8,14 @@ module Neo4j::Driver
             Util::Preconditions.check_argument(message, Request::RouteMessage)
             packer.pack_struct_header(3, message.signature)
             packer.pack(message.routing_context)
-            packer.pack(message.bookmark.present? ? Values.value(message.bookmark.values) : Values.value(java.util.Collections.empty_list))
-            packer.pack(message.database_name)
+            packer.pack(message.bookmark&.values || [])
+            packer.pack(option(message))
+          end
+
+          private
+
+          def option(message)
+            message.database_name
           end
         end
       end

data/ruby/neo4j/driver/internal/messaging/encode/route_v44_message_encoder.rb

@@ -3,22 +3,17 @@ module Neo4j::Driver
     module Messaging
       module Encode
         # Encodes the ROUTE message to the stream
-        class RouteV44MessageEncoder
-          def encode(message, packer)
-            Util::Preconditions.check_argument(message, Request::RouteMessage)
-            packer.pack_struct_header(3, message.signature)
-            packer.pack(message.routing_context)
-            packer.pack(message.bookmark.present? ? Values.value(message.bookmark.values) : Values.value(java.util.Collections.empty_list))
+        class RouteV44MessageEncoder < RouteMessageEncoder
+          private
 
-            if !message.impersonated_user.nil? && message.database_name.nil?
-              params = java.util.Collections.singleton_map("imp_user", Values.value(message.impersonated_user))
-            elsif !message.database_name.nil?
-              params = java.util.Collections.singleton_map("db", Values.value(message.database_name))
+          def option(message)
+            if message.impersonated_user && !message.database_name
+              { imp_user: message.impersonated_user }
+            elsif message.database_name
+              { db: message.database_name }
             else
-              params = java.util.Collections.empty_map
+              {}
             end
-
-            packer.pack(params)
           end
         end
       end

data/ruby/neo4j/driver/internal/messaging/request/begin_message.rb

@@ -7,9 +7,8 @@ module Neo4j::Driver
 
           def initialize(bookmark, config, database_name, mode, impersonated_user)
             super(Request::TransactionMetadataBuilder.build_metadata(
-              tx_timeout: config[:timeout]&.then(&DurationNormalizer.method(:milliseconds)),
-              tx_metadata: config[:metadata], database_name: database_name, mode: mode, bookmark: bookmark,
-              impersonated_user: impersonated_user))
+              timeout: config[:timeout], tx_metadata: config[:metadata], database_name: database_name, mode: mode,
+              bookmark: bookmark, impersonated_user: impersonated_user))
           end
 
           def signature

data/ruby/neo4j/driver/internal/messaging/request/multi_database_util.rb

@@ -10,12 +10,12 @@ module Neo4j::Driver
               end
             end
 
-            def supports_multi_database(connection)
+            def supports_multi_database?(connection)
               connection.server_version >= Util::ServerVersion::V4_0_0 &&
                 connection.protocol.version >= V4::BoltProtocolV4::VERSION
             end
 
-            def supports_route_message(connection)
+            def supports_route_message?(connection)
               connection.protocol.version >= V43::BoltProtocolV43::VERSION
             end
           end

data/ruby/neo4j/driver/internal/messaging/request/route_message.rb

@@ -6,19 +6,14 @@ module Neo4j::Driver
         # instance can provide the wanted service.
         # <p>
         # This message is used to fetch this routing information.
+        #
+        # @param routingContext   The routing context used to define the routing table. Multi-datacenter deployments is one of its use cases.
+        # @param bookmark         The bookmark used when getting the routing table.
+        # @param databaseName     The name of the database to get the routing table for.
+        # @param impersonatedUser The name of the impersonated user to get the routing table for, should be {@code null} for non-impersonated requests
         class RouteMessage < Struct.new(:routing_context, :bookmark, :database_name, :impersonated_user)
           SIGNATURE = 0x66
 
-          # Constructor
-
-          # @param routingContext   The routing context used to define the routing table. Multi-datacenter deployments is one of its use cases.
-          # @param bookmark         The bookmark used when getting the routing table.
-          # @param databaseName     The name of the database to get the routing table for.
-          # @param impersonatedUser The name of the impersonated user to get the routing table for, should be {@code null} for non-impersonated requests
-          def initialize(routing_context, bookmark, database_name, impersonated_user)
-            super(routing_context.freeze, bookmark, database_name, impersonated_user)
-          end
-
           def signature
             SIGNATURE
           end

data/ruby/neo4j/driver/internal/messaging/request/run_with_metadata_message.rb

@@ -9,7 +9,7 @@ module Neo4j::Driver
           class << self
             def auto_commit_tx_run_message(query, config, database_name, mode, bookmark, impersonated_user)
               metadata = Request::TransactionMetadataBuilder.build_metadata(
-                tx_timeout: config[:timeout], tx_metadata: config[:metadata], database_name: database_name, mode: mode,
+                timeout: config[:timeout], tx_metadata: config[:metadata], database_name: database_name, mode: mode,
                 bookmark: bookmark, impersonated_user: impersonated_user)
               new(query.text, query.parameters, metadata)
             end
@@ -29,10 +29,12 @@ module Neo4j::Driver
             SIGNATURE
           end
 
-          def eql?(other)
-            super && query.eql?(other.query) && parameters.eql?(other.parameters)
+          def ==(other)
+            super && query == other.query && parameters == other.parameters
           end
 
+          alias eql? ==
+
           def hash
             [query, parameters, metadata].hash
           end

data/ruby/neo4j/driver/internal/messaging/request/transaction_metadata_builder.rb

@@ -6,10 +6,10 @@ module Neo4j::Driver
           MODE_READ_VALUE = 'r'
 
           class << self
-            def build_metadata(tx_timeout:, tx_metadata:, mode:, bookmark:, impersonated_user:,
+            def build_metadata(timeout:, tx_metadata:, mode:, bookmark:, impersonated_user:,
                                database_name: DatabaseNameUtil.default_database)
               { bookmarks: bookmark.presence,
-                tx_timeout: tx_timeout,
+                tx_timeout: timeout&.then(&DurationNormalizer.method(:milliseconds)),
                 tx_metadata: tx_metadata.presence,
                 mode: (MODE_READ_VALUE if mode == AccessMode::READ),
                 db: database_name&.database_name,

data/ruby/neo4j/driver/internal/messaging/v3/bolt_protocol_v3.rb

@@ -13,7 +13,7 @@ module Neo4j::Driver
 
           def initialize_channel(channel, user_agent, auth_token, routing_context)
             message = Request::HelloMessage.new(user_agent, auth_token,
-                                                (routing_context.to_map if routing_context.server_routing_enabled?))
+                                                (routing_context.to_h if routing_context.server_routing_enabled?))
             handler = Handlers::HelloResponseHandler.new(channel, VERSION)
 
             channel.message_dispatcher.enqueue(handler)

data/ruby/neo4j/driver/internal/messaging/v44/message_writer_v44.rb

@@ -10,7 +10,7 @@ module Neo4j::Driver
               Request::HelloMessage::SIGNATURE => Encode::HelloMessageEncoder.new,
               Request::GoodbyeMessage::SIGNATURE => Encode::GoodbyeMessageEncoder.new,
               Request::RunWithMetadataMessage::SIGNATURE => Encode::RunWithMetadataMessageEncoder.new,
-              Request::RouteMessage::SIGNATURE => Encode::RouteMessageEncoder.new,
+              Request::RouteMessage::SIGNATURE => Encode::RouteV44MessageEncoder.new,
               Request::DiscardMessage::SIGNATURE => Encode::DiscardMessageEncoder.new,
               Request::PullMessage::SIGNATURE => Encode::PullMessageEncoder.new,
               Request::BeginMessage::SIGNATURE => Encode::BeginMessageEncoder.new,

data/ruby/neo4j/driver/internal/read_only_bookmark_holder.rb

@@ -0,0 +1,13 @@
+module Neo4j::Driver
+  module Internal
+    class ReadOnlyBookmarkHolder
+      attr_reader :bookmark
+
+      def initialize(bookmark = InternalBookmark.empty)
+        @bookmark = bookmark
+      end
+
+      def bookmark=(_value) end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/resolved_bolt_server_address.rb

@@ -0,0 +1,35 @@
+module Neo4j::Driver
+  module Internal
+    class ResolvedBoltServerAddress < BoltServerAddress
+      MAX_HOST_ADDRESSES_IN_STRING_VALUE = 5
+
+      def initialize(host, port, *resolved_addresses_arr)
+        super(host: host, port: port)
+        if resolved_addresses_arr.empty?
+          raise ArgumentError,
+                'The resolvedAddressesArr must not be empty, check your DomainNameResolver is compliant with the interface contract'
+        end
+        @resolved_addresses = resolved_addresses_arr.to_set.freeze
+        @string_value = create_string_representation
+      end
+
+      def unicast_stream
+        @resolved_addresses
+          .map { |address| BoltServerAddress.new(host: host, connection_host: address.ip_address, port: port) }
+      end
+
+      def to_s
+        @string_value
+      end
+
+      private def attributes
+        super + [@resolved_addresses]
+      end
+
+      def create_string_representation
+        host_addresses = @resolved_addresses.take(MAX_HOST_ADDRESSES_IN_STRING_VALUE).map(&:ip_address).join(',')
+        "#{host}(#{host_addresses}#{',...' if @resolved_addresses.size > MAX_HOST_ADDRESSES_IN_STRING_VALUE}):#{port}"
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/security/security_plan_impl.rb

@@ -4,7 +4,7 @@ module Neo4j::Driver::Internal
                                         :revocation_strategy)
       class << self
         def for_all_certificates(requires_hostname_verification, revocation_strategy)
-          new(true, OpenSSL::SSL::SSLContext.new, requires_hostname_verification, revocation_strategy)
+          new(true, all_context(requires_hostname_verification), requires_hostname_verification, revocation_strategy)
         end
 
         def for_custom_ca_signed_certificates(cert_files, requires_hostname_verification, revocation_strategy)
@@ -23,19 +23,24 @@ module Neo4j::Driver::Internal
 
         private
 
+        def all_context(requires_hostname_verification)
+          ssl_context(verify_mode: OpenSSL::SSL::VERIFY_NONE, verify_hostname: requires_hostname_verification)
+        end
+
         def ca_signed_context(requires_hostname_verification)
-          OpenSSL::SSL::SSLContext.new.tap do |context|
-            context.verify_mode = OpenSSL::SSL::VERIFY_PEER
-            context.verify_hostname = requires_hostname_verification
-          end
+          ssl_context(verify_hostname: requires_hostname_verification)
         end
 
         def custom_ca_signed_context(cert_files, requires_hostname_verification)
-          ca_signed_context(requires_hostname_verification).tap do |context|
-            context.cert_store = OpenSSL::X509::Store.new.tap do |store|
+          ssl_context(
+            cert_store: OpenSSL::X509::Store.new.tap do |store|
               cert_files.each(&store.method(:add_file))
-            end
-          end
+            end,
+            verify_hostname: requires_hostname_verification)
+        end
+
+        def ssl_context(**params)
+          OpenSSL::SSL::SSLContext.new.tap { |context| context.set_params(params) }
         end
       end
     end

data/ruby/neo4j/driver/internal/util/error_util.rb

@@ -59,7 +59,7 @@ module Neo4j::Driver::Internal::Util
       end
 
       def add_suppressed(main_error, error)
-        main_error.add_suppressed(error) if main_error.is_a?(Exceptions::Neo4jException) && main_error != error
+        main_error.add_suppressed(error) if main_error.is_a?(Neo4j::Driver::Exceptions::Neo4jException) && main_error != error
       end
 
       def get_root_cause(error)

data/ruby/neo4j/driver/net/{server_address1.rb → server_address.rb}

@@ -1,8 +1,8 @@
 module Neo4j::Driver
   module Net
-    module ServerAddress1
+    module ServerAddress
       def self.of(host, port)
-        Internal::BoltServerAddress.new(host, port)
+        Internal::BoltServerAddress.new(host: host, port: port)
       end
     end
   end

data/ruby/neo4j/driver/query.rb

@@ -10,7 +10,7 @@ module Neo4j
     # @since 1.0
     class Query < Struct.new(:text, :parameters)
       def initialize(text, **parameters)
-        super(self.class.validated_query_text(text), Values.value!(parameters))
+        super(self.class.validated_query_text(text), Values.value(parameters))
       end
 
       # @param newText the new query text

data/ruby/neo4j/driver/transaction_config.rb

@@ -32,7 +32,11 @@ module Neo4j
       def initialize(timeout: nil, metadata: {})
         Internal::Util::Preconditions.check_argument(timeout.nil? || timeout.positive?, 'Transaction timeout should be positive')
         Internal::Validator.require_non_nil!(metadata)
-        merge(timeout: timeout, metadata: metadata)
+        merge!(timeout: timeout, metadata: metadata)
+      end
+
+      def self.empty
+        EMPTY
       end
 
       # Check if this configuration object contains any values.

data/ruby/neo4j/driver/values.rb

@@ -1,14 +1,14 @@
 module Neo4j
   module Driver
     module Values
-      def self.value!(value)
-        this_method = method(:value!)
+      def self.value(value)
+        this_method = method(:value)
         case value
         when nil, TrueClass, FalseClass, Integer, Float, String, Symbol, Bookmark, ActiveSupport::Duration,
           Types::Point, Types::Time, Time, Date
           value
         when Hash
-          value.transform_keys!(&this_method).transform_values!(&this_method)
+          value.transform_keys(&this_method).transform_values(&this_method)
         when Internal::InternalPath
           nonconvertible(value)
         when Enumerable

data/ruby/neo4j/driver/version.rb

@@ -2,6 +2,6 @@
 
 module Neo4j
   module Driver
-    VERSION = '4.4.0.alpha.4'
+    VERSION = '4.4.0.alpha.7'
   end
 end