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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 698039b3b9cd2cf99a79e5a96f23ad4be85aabe2dbf85274b01ec8bf05301658
-  data.tar.gz: cf29ed98589d4e6aac9469d67d3e069696091612d9a0fd8eef2e3993f2ef9a4f
+  metadata.gz: 92d999b42ad79f180328388f8b50e610e35190b2efc0b5ad9f799773a3d5d006
+  data.tar.gz: 759f1058c5dcf0c12d970dec2793bd2f6a5600aecfcdeb43f63b19630f038fb2
 SHA512:
-  metadata.gz: 3f2beecb1b73d3394f3ea6259c4664b7aa0400472edba1aafdc02a0b5932cd90e1e5ff2bf8319e6931c341b9e74a0037d4727ceffc4e29138f188fa373aee4b0
-  data.tar.gz: 673f97b1c0eed87beea9f0c1538eb96fe34ff92fdd9b49ef82c9dc9e54b49b0197c98e578ea399023b3b1579774e474d3019527c67ed7a62b5251fdeff078f23
+  metadata.gz: 50d2744664faa1596e8fe964db0b083e216f58b001a4d3d7d70218752814a164d4e83ea71f5d4b4b2330432aa58d74b12875ea182bb8f99aad701a831032cc73
+  data.tar.gz: 5d8f9e3e8eb358d7aa494d7be74d3ee49507ff2496f346d0b5ab9defea5c92a6017e147ae51b0e128728a667ef924cdf8b7e13f69ff398a1f6f6606d24cddeef

data/README.md

@@ -56,12 +56,23 @@ $ bin/setup
 $ rspec spec
 ```
 
-In case of heap space memory error (`org.neo4j.driver.exceptions.DatabaseException: Java heap space`), you should limit the dbms memory, for example:
+Known errors:
+
+1. In case of heap space memory error (`org.neo4j.driver.exceptions.DatabaseException: Java heap space`), you should limit the dbms memory, for example:
 
 ```console
 $ neoctrl-configure servers/neo4j-enterprise-4.4.5 dbms.memory.pagecache.size=600m dbms.memory.heap.max_size=600m dbms.memory.heap.initial_size=600m dbms.directories.import= dbms.connectors.default_listen_address=::
 ```
 
+2. When using command `pip3 install --user git+https://github.com/klobuczek/boltkit@1.3#egg=boltkit`, if you have m1 mac chip, you may get error when pip3 tries to install `cryptography`. Steps to take in that case (reference https://stackoverflow.com/a/70074869/2559490)
+
+```console
+$ pip uninstall cffi
+$ python -m pip install --upgrade pip
+$ pip install cffi
+$ pip install cryptography
+```
+
 ## Contributing
 
 Suggestions, improvements, bug reports and pull requests are welcome on GitHub at https://github.com/neo4jrb/neo4j-ruby-driver.

data/ruby/neo4j/driver/config.rb

@@ -10,7 +10,7 @@ module Neo4j
 
         attr_reader :strategy, :cert_files, :revocation_strategy
 
-        #
+        # Sample config:
         # {
         #   trust_strategy: {
         #     strategy: :trust_custom_certificates,
@@ -62,12 +62,12 @@ module Neo4j
         max_transaction_retry_time: Internal::Retry::ExponentialBackoffRetryLogic::DEFAULT_MAX_RETRY_TIME,
         metrics_enabled: false,
         # resolver: nil # :set_address_resolver
-        trust_strategy: TrustStrategy.trust_all_certificates,
+        trust_strategy: { strategy: :trust_all_certificates }
       }.freeze
 
       def initialize(**config)
         merge!(DEFAULTS).merge!(config.compact)
-        init_security_and_trust_config(config)
+        init_security_and_trust_config
       end
 
       def routing_settings
@@ -77,13 +77,11 @@ module Neo4j
 
       private
 
-      def init_security_and_trust_config(config)
-        trust_strategy = config.key?(:trust_strategy) ? TrustStrategy.new(**config) : DEFAULTS[:trust_strategy]
-        encryption = config.key?(:encryption) ? config[:encryption] : DEFAULTS[:encryption]
-        customized = %i[encryption trust_strategy].any?(&config.method(:key?))
-        merge!(
-          security_settings: Neo4j::Driver::Internal::SecuritySetting.new(encryption, trust_strategy, customized),
-          trust_strategy: trust_strategy
+      def init_security_and_trust_config
+        relevant = %i[encryption trust_strategy]
+        customized = slice(*relevant) == DEFAULTS.slice(*relevant)
+        merge!(security_settings: Neo4j::Driver::Internal::SecuritySetting.new(
+          fetch(:encryption), TrustStrategy.new(**fetch(:trust_strategy)), customized),
         )
       end
     end

data/ruby/neo4j/driver/graph_database.rb

@@ -8,66 +8,6 @@ module Neo4j::Driver
       auto_closable :driver, :routing_driver
       sync :driver
 
-      GOGOBOLT = ["6060B017"].pack('H*')
-
-      def handshake_concurrent(*versions)
-        remote_port = 7687
-        remote_addr = 'localhost'
-        selector = NIO::Selector.new
-        socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
-        begin
-          socket.connect_nonblock Socket.sockaddr_in(remote_port, remote_addr)
-        rescue Errno::EINPROGRESS
-          # Ruby's a-tryin' to connect us, we swear!
-          selector.register(socket, :w)
-        end
-        selector.select do |monitor|
-          case monitor.io
-          when Socket
-            if monitor.writable?
-              begin
-                socket.connect_nonblock Socket.sockaddr_in(remote_port, remote_addr)
-              rescue Errno::EISCONN
-                # SUCCESS! Since Ruby is crazy we discover we're successful via an exception
-              end
-            end
-          end
-        end
-        socket.write_nonblock(GOGOBOLT)
-        socket.write_nonblock(bolt_versions(*versions))
-
-        @data = nil
-        begin
-          @data = socket.read_nonblock(16384)
-        rescue IO::WaitReadable
-          monitor = selector.register(socket, :r)
-          monitor.value = proc do
-            @data = socket.read_nonblock(16384)
-          end
-        end
-        Concurrent::Promises.future do
-          selector.select do |monitor|
-            monitor.value.call
-          end
-          ruby_version(@data)
-        end
-      end
-
-      class Connection < Async::Pool::Resource
-        attr :version, true
-        attr :io
-
-        def initialize
-          super
-          @io = Async::IO::Endpoint.tcp('localhost', 7687).connect
-        end
-
-        def close
-          super
-          @io.close
-        end
-      end
-
       def driver(uri, auth_token = nil, **config)
         internal_driver(uri, auth_token, config, Internal::DriverFactory.new)
       end

data/ruby/neo4j/driver/internal/async/connection/channel_connector_impl.rb

@@ -16,9 +16,15 @@ module Neo4j::Driver
           end
 
           def connect(address)
-            socket_host = (@domain_name_resolver.call(address.connection_host).first.ip_address rescue nil) || bracketless(address.connection_host)
+            socket_host = (@domain_name_resolver.call(address.connection_host).first.ip_address rescue nil) ||
+              bracketless(address.connection_host)
 
-            channel_connected = ::Async::IO::Endpoint.tcp(socket_host, address.port).connect
+            endpoint = ::Async::IO::Endpoint.tcp(socket_host, address.port)
+            if @security_plan.requires_encryption?
+              endpoint = ::Async::IO::SSLEndpoint.new(endpoint, ssl_context: @security_plan.ssl_context,
+                                                    hostname: address.host)
+            end
+            channel_connected = endpoint.connect
 
             # install_channel_connected_listeners(address, channel_connected, handshake_completed)
             # install_handshake_completed_listeners(handshake_completed, connection_initialized)

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/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/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

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

@@ -26,7 +26,7 @@ module Neo4j::Driver
             @routing_tables.ensure_routing_table(context).then_flat do |handler|
               acquire(context.mode, handler.routing_table).then do |connection|
                 Async::Connection::RoutingConnection.new(connection,
-                                                         Util::Futures.join_now_or_else_throw(context.database_name_future, Async::ConnectionContext::PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER),
+                                                         Util::Futures.join_now_or_else_throw(context.database_name, Async::ConnectionContext::PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER),
                                                          context.mode, context.impersonated_user, handler)
               end
             end

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

@@ -4,7 +4,7 @@ module Neo4j::Driver
       class RoutingTableRegistryImpl
         def initialize(connection_pool, rediscovery, clock, logger, routing_table_purge_delay_ms)
           @factory = RoutingTableHandlerFactory.new(connection_pool, rediscovery, clock, logger, routing_table_purge_delay_ms)
-          @routing_table_handlers = {}
+          @routing_table_handlers = Concurrent::Hash.new
           @principal_to_database_name_stage = {}
           @clock = clock
           @connection_pool = connection_pool

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

@@ -26,7 +26,7 @@ module Neo4j::Driver
         end
 
         def each_async(&action)
-          internal_for_each_async(result_future, &action)
+          internal_for_each_async(&action)
           consume_async
         end
 
@@ -42,33 +42,25 @@ module Neo4j::Driver
 
         def pull_all_failure_async
           # runError has priority over other errors and is expected to have been reported to user by now
-          @pull_all_handler.pull_all_failure_async.then { |error| @run_error ? nil : error }
+          @pull_all_handler.pull_all_failure_async.then { |error| run_error ? nil : error }
         end
 
-        private def internal_for_each_async(result_future, &action)
-          record_future = next_async
-
-          # use async completion listener because of recursion, otherwise it is possible for
-          # the caller thread to get StackOverflowError when result is large and buffered
-          record_future.on_complete do |_fulfilled, record, error|
-            if error
-              result_future.reject(error)
-            elsif record
-              begin
-                yield record
-              rescue => action_error
-                result_future.reject(action_error)
-                return
-              end
-              internal_for_each_async(result_future, &action)
-            else
-              result_future.fulfill(nil)
+        private def internal_for_each_async
+          while record = next_async
+            begin
+              yield record
+            rescue
+              nil
             end
           end
         end
 
         def map_successful_run_completion_async
-          @run_error || self
+          run_error || self
+        end
+
+        def run_error
+          @run_handler.error
         end
       end
     end

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

@@ -3,11 +3,10 @@ module Neo4j::Driver
     module Cursor
       # Used by Bolt V1, V2, V3
       class AsyncResultCursorOnlyFactory
-        def initialize(connection, run_message, run_handler, run_future, pull_handler)
+        def initialize(connection, run_message, run_handler, pull_handler)
           @connection = Internal::Validator.require_non_nil!(connection)
           @run_message = Internal::Validator.require_non_nil!(run_message)
           @run_handler = Internal::Validator.require_non_nil!(run_handler)
-          @run_future = Internal::Validator.require_non_nil!(run_future)
 
           @pull_all_handler = Internal::Validator.require_non_nil!(pull_handler)
         end
@@ -17,7 +16,7 @@ module Neo4j::Driver
           @connection.write(@run_message, @run_handler) # queues the run message, will be flushed with pull message together
           @pull_all_handler.pre_populate_records
 
-          @run_future.handle { |_ignored, error| DisposableAsyncResultCursor.new(AsyncResultCursorImpl.new(error, @run_handler, @pull_all_handler)) }
+          DisposableAsyncResultCursor.new(AsyncResultCursorImpl.new(@run_handler, @pull_all_handler))
         end
 
         def rx_result

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

@@ -67,36 +67,35 @@ module Neo4j::Driver::Internal
 
     def create_driver(uri, security_plan, address, connection_pool, eventExecutorGroup, routing_settings, retryLogic, metricsProvider, config)
       if routing_scheme?(uri.scheme.downcase)
-        createRoutingDriver(security_plan, address, connection_pool, eventExecutorGroup, routing_settings, retryLogic, metricsProvider, config)
+        create_routing_driver(security_plan, address, connection_pool, eventExecutorGroup, routing_settings, retryLogic, metricsProvider, config)
       else
         assert_no_routing_context(uri, routing_settings)
-        createDirectDriver(security_plan, address, connection_pool, retryLogic, metricsProvider, config)
+        create_direct_driver(security_plan, address, connection_pool, retryLogic, metricsProvider, config)
       end
     rescue => driver_error
       # we need to close the connection pool if driver creation threw exception
-      closeConnectionPoolAndSuppressError(connection_pool, driver_error)
-      raise driver_error
+      close_connection_pool_and_suppress_error(connection_pool, driver_error)
+      raise
     end
 
-    def createDirectDriver(securityPlan, address, connection_pool, retryLogic, metricsProvider, config)
+    def create_direct_driver(securityPlan, address, connection_pool, retryLogic, metricsProvider, config)
       connection_provider = DirectConnectionProvider.new(address, connection_pool)
       driver(:Direct, securityPlan, address, connection_provider, retryLogic, metricsProvider, config)
     end
 
-    def createRoutingDriver(securityPlan, address, connection_pool, eventExecutorGroup, routingSettings, retryLogic, metricsProvider, config)
-      connection_provider = createLoadBalancer(address, connection_pool, eventExecutorGroup, config, routingSettings)
+    def create_routing_driver(securityPlan, address, connection_pool, eventExecutorGroup, routingSettings, retryLogic, metricsProvider, config)
+      connection_provider = create_load_balancer(address, connection_pool, eventExecutorGroup, config, routingSettings)
       driver(:Routing, securityPlan, address, connection_provider, retryLogic, metricsProvider, config)
     end
 
     def driver(type, security_plan, address, connection_provider, retry_logic, metrics_provider, config)
       session_factory = SessionFactoryImpl.new(connection_provider, retry_logic, config)
       InternalDriver.new(security_plan, session_factory, metrics_provider, config[:logger]).tap do |driver|
-        log = config[:logger]
-        log.info { "#{type} driver instance #{driver.object_id} created for server address #{address}" }
+        config[:logger]&.info { "#{type} driver instance #{driver.object_id} created for server address #{address}" }
       end
     end
 
-    def createLoadBalancer(address, connection_pool, eventExecutorGroup, config, routingSettings)
+    def create_load_balancer(address, connection_pool, eventExecutorGroup, config, routingSettings)
       load_balancing_strategy = Cluster::Loadbalancing::LeastConnectedLoadBalancingStrategy.new(connection_pool, config[:logger])
       resolver = create_resolver(config)
       Cluster::Loadbalancing::LoadBalancer.new(
@@ -110,7 +109,7 @@ module Neo4j::Driver::Internal
 
     protected
 
-    def closeConnectionPoolAndSuppressError(connection_pool, main_error)
+    def close_connection_pool_and_suppress_error(connection_pool, main_error)
       connection_pool.close
     rescue => close_error
       Util::ErrorUtil.add_suppressed(main_error, close_error)

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

@@ -2,26 +2,27 @@ module Neo4j::Driver
   module Internal
     module Handlers
       class ChannelReleasingResetResponseHandler < ResetResponseHandler
-        def initialize(channel, pool, message_dispatcher, clock, release_future)
+        def initialize(channel, pool, message_dispatcher, log, release_future)
           super(message_dispatcher, release_future)
           @channel = channel
           @pool = pool
-          @clock = clock
+          @log = log
         end
 
-        def reset_completed(completion_future, success)
+        def reset_completed(success)
           if success
             # update the last-used timestamp before returning the channel back to the pool
-            Async::Connection::ChannelAttributes.set_last_used_timestamp(@channel, @clock.millis)
-            closure_stage = Util::Futures.completed_with_null
+            # Async::Connection::ChannelAttributes.set_last_used_timestamp(@channel, @clock.millis)
+            # closure_stage = Util::Futures.completed_with_null
           else
             # close the channel before returning it back to the pool if RESET failed
-            closure_stage = Util::Futures.as_completion_stage(@channel.close)
-          end
-
-          closure_stage.exceptionally(-> (_throwable) { nil }).then_compose(-> (_ignored) { @pool.release(@channel) }).when_complete do |_, _error|
-            completion_future.complete(nil)
+            @channel.close
           end
+        rescue
+          nil
+        ensure
+          @pool.release(@channel)
+          @log.debug { "Channel #{@channel.object_id} released." }
         end
       end
     end

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

@@ -9,11 +9,11 @@ module Neo4j::Driver
         RECORD_BUFFER_HIGH_WATERMARK = ENV['record_buffer_high_watermark']&.to_i || 1000
 
         def initialize(query, run_response_handler, connection, metadata_extractor, completion_listener)
-          @query = Util::Validator.require_non_nil!(query)
-          @run_response_handler = Util::Validator.require_non_nil!(run_response_handler)
-          @metadata_extractor = Util::Validator.require_non_nil!(metadata_extractor)
-          @connection = Util::Validator.require_non_nil!(connection)
-          @completion_listener = Util::Validator.require_non_nil!(completion_listener)
+          @query = Internal::Validator.require_non_nil!(query)
+          @run_response_handler = Internal::Validator.require_non_nil!(run_response_handler)
+          @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
         end
 
@@ -212,7 +212,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
@@ -79,8 +78,8 @@ module Neo4j::Driver
             @summary
           end
 
-          def list_async(map_function)
-            pull_all_async.then_apply(-> (summary) { records_as_list(map_function) })
+          def list_async(&map_function)
+            pull_all_async.then_apply(-> (summary) { records_as_list(&map_function) })
           end
 
           def pull_all_failure_async
@@ -167,6 +166,10 @@ module Neo4j::Driver
           def completed_with_value_if_no_failure(value)
             @failure ? extract_failure : value
           end
+
+          # def request(size)
+          #   @auto_pull_enabled ? Async { super } : super
+          # end
         end
       end
     end

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/handlers/run_response_handler.rb

@@ -3,7 +3,7 @@ module Neo4j::Driver
     module Handlers
       class RunResponseHandler
         include Spi::ResponseHandler
-        attr_reader :query_keys, :result_available_after, :query_id
+        attr :query_keys, :result_available_after, :query_id, :error
 
         def initialize(metadata_extractor, connection, tx)
           @query_keys = []
@@ -26,6 +26,7 @@ module Neo4j::Driver
           elsif error.is_a?(Exceptions::ConnectionReadTimeoutException)
             connection.terminate_and_release(error.message)
           end
+          @error = error
         end
 
         def on_record(_fields)

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

@@ -10,14 +10,12 @@ module Neo4j::Driver
         @values = values.to_set
       end
 
-      def eql?(other)
-        values.eql?(other.values)
-      end
-
       def ==(other)
-        values == other.values
+        equal?(other) || self.class == other.class && values == other.values
       end
 
+      alias eql? ==
+
       def to_s
         "Bookmark{values=#{values}}"
       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/internal_entity.rb

@@ -10,13 +10,11 @@ module Neo4j::Driver
         @properties = properties
       end
 
-      def eql?(other)
-        id.eql?(other.id)
-      end
-
       def ==(other)
-        id == other.id
+        equal?(other) || self.class == other.class && id == other.id
       end
+
+      alias eql? ==
     end
   end
 end

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

@@ -58,11 +58,10 @@ module Neo4j::Driver
           end
 
           def build_result_cursor_factory(connection, query, bookmark_holder, tx, run_message, ignored)
-            run_future = java.util.concurrent.CompletableFuture.new
-            run_handler = Handlers::RunResponseHandler.new(run_future, METADATA_EXTRACTOR, connection, tx)
+            run_handler = Handlers::RunResponseHandler.new(METADATA_EXTRACTOR, connection, tx)
             pull_handler = Handlers::PullHandlers.new_bolt_v3_pull_all_handler(query, run_handler, connection, bookmark_holder, tx)
 
-            Cursor::AsyncResultCursorOnlyFactory.new(connection, run_message, run_handler, run_future, pull_handler)
+            Cursor::AsyncResultCursorOnlyFactory.new(connection, run_message, run_handler, pull_handler)
           end
 
           def verify_database_name_before_transaction(database_name)

data/ruby/neo4j/driver/internal/packstream/pack_stream.rb

@@ -171,7 +171,7 @@ module Neo4j::Driver
             elsif size < PLUS_2_TO_THE_8
               write_byte(STRING_8).write_byte(size)
             elsif size < PLUS_2_TO_THE_16
-              write_byte(BYTES_16).write_short(size)
+              write_byte(STRING_16).write_short(size)
             else
               write_byte(STRING_32).write_int(size)
             end

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

@@ -1,22 +1,20 @@
 module Neo4j::Driver::Internal
   module Security
-    class SecurityPlanImpl < Struct.new(:requires_encryption, :ssl_context, :requires_hostname_verification,
+    class SecurityPlanImpl < Struct.new(:requires_encryption?, :ssl_context, :requires_hostname_verification?,
                                         :revocation_strategy)
       class << self
         def for_all_certificates(requires_hostname_verification, revocation_strategy)
-          ssl_context = javax.net.ssl.SSLContext.get_instance('TLS')
-          ssl_context.init(javax.net.ssl.KeyManager[0].new, [TrustAllTrustManager.new].to_java(javax.net.ssl.KeyManager), nil)
-          new(true, ssl_context, requires_hostname_verification, revocation_strategy)
+          new(true, OpenSSL::SSL::SSLContext.new, requires_hostname_verification, revocation_strategy)
         end
 
-        def for_custom_ca_signed_certificate(cert_file, requires_hostname_verification, revocation_strategy)
-          ssl_context = config_ssl_context(cert_file, revocation_strategy)
-          new(true, ssl_context, requires_hostname_verification, revocation_strategy)
+        def for_custom_ca_signed_certificates(cert_files, requires_hostname_verification, revocation_strategy)
+          new(true, custom_ca_signed_context(cert_files, requires_hostname_verification),
+              requires_hostname_verification, revocation_strategy)
         end
 
-        def for_system_ca_signed_certificate(requires_hostname_verification, revocation_strategy)
-          ssl_context = config_ssl_context(nil, revocation_strategy)
-          new(true, ssl_context, requires_hostname_verification, revocation_strategy)
+        def for_system_ca_signed_certificates(requires_hostname_verification, revocation_strategy)
+          new(true, ca_signed_context(requires_hostname_verification), requires_hostname_verification,
+              revocation_strategy)
         end
 
         def insecure
@@ -25,68 +23,21 @@ module Neo4j::Driver::Internal
 
         private
 
-        def configure_ssl_context(custom_cert_file, revocation_strategy)
-          trusted_key_store = java.security.KeyStore.get_instance(java.security.KeyStore.get_default_type)
-          trusted_key_store.load(nil, nil)
-
-          if !custom_cert_file.nil?
-            Util::CertificateTool.loadX509_cert(custom_cert_file, trusted_key_store)
-          else
-            load_system_certificates(trusted_key_store)
-          end
-
-          pkix_builder_parameters = java.security.cert.PKIXBuilderParameters.new(trusted_key_store, java.security.cert.X509CertSelector.new)
-          pkix_builder_parameters.set_revocation_enabled(RevocationStrategy.requires_revocation_checking?(revocation_strategy))
-
-          if RevocationStrategy.requires_revocation_checking?(revocation_strategy)
-            java.lang.System.set_property('jdk.tls.client.enableStatusRequestExtension', true)
-            if revocation_strategy == RevocationStrategy::VERIFY_IF_PRESENT
-              java.security.Security.set_property('ocsp.enable', true)
-            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 = javax.net.ssl.SSLContext.get_instance('TLS')
-
-          trust_manager_factory = javax.net.ssl.TrustManager.get_instance(javax.net.ssl.TrustManagerFactory.get_default_algorithm)
-          trust_manager_factory.init(javax.net.ssl.CertPathTrustManagerParameters.new(pkix_builder_parameters))
-          ssl_context.init(javax.net.ssl.KeyManager[0].new, trust_manager_factory.get_trust_managers, nil)
-          ssl_context
         end
 
-        def load_system_certificates(trusted_key_store)
-          temp_factory = javax.net.ssl.TrustManagerFactory.get_instance(javax.net.ssl.TrustManagerFactory.get_default_algorithm)
-          temp_factory.init(nil)
-
-          x509_trust_manager = nil
-          temp_factory.get_trust_managers.each do |trust_manager|
-            if trust_manager.is_a?(javax.net.ssl.X509TrustManager)
-              x509_trust_manager = javax.net.ssl.X509TrustManager.java_class.cast(trust_manager)
-              break
+        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|
+              cert_files.each(&store.method(:add_file))
             end
           end
-
-          if x509_trust_manager.nil?
-            raise Neo4j::Driver::Exceptions::CertificateException, 'No system certificates found'
-          else
-            Util::CertificateTool.load_x509_cert(x509_trust_manager.get_accepted_issuer, trusted_key_store)
-          end
         end
       end
-
-      class TrustAllTrustManager
-        def check_client_trusted(chain, auth_type)
-          raise Neo4j::Driver::Exceptions::CertificateException, 'All client connections to this client are forbidden.'
-        end
-
-        def check_server_trusted(chain, auth_type)
-        end
-
-        def get_accepted_issuers
-          java.security.cert.X509Certificate[0].new
-        end
-      end
-
-      private_constant :TrustAllTrustManager
     end
   end
 end

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

@@ -1,72 +1,65 @@
 # frozen_string_literal: true
 
-module Neo4j::Driver::Internal
-  class SecuritySetting
-    include Scheme
+module Neo4j::Driver
+  module Internal
+    class SecuritySetting
+      include Scheme
 
-    attr_reader :encrypted, :trust_strategy, :customized
+      attr_reader :encrypted, :trust_strategy, :customized
 
-    def initialize(encrypted, trust_strategy, customized)
-      @encrypted = encrypted
-      @trust_strategy = trust_strategy
-      @customized = customized
-    end
+      def initialize(encrypted, trust_strategy, customized)
+        @encrypted = encrypted
+        @trust_strategy = trust_strategy
+        @customized = customized
+      end
 
-    def create_security_plan(uri_scheme)
-      validate_scheme!(uri_scheme)
-      begin
+      def create_security_plan(uri_scheme)
+        validate_scheme!(uri_scheme)
         if security_scheme?(uri_scheme)
           assert_security_settings_not_user_configured(uri_scheme)
           create_security_plan_from_scheme(uri_scheme)
         else
           create_security_plan_impl(encrypted, trust_strategy)
         end
-      # rescue java.security.GeneralSecurityException, IOError
       rescue IOError
         raise Neo4j::Driver::Exceptions::ClientException, 'Unable to establish SSL parameters'
       end
-    end
 
-    def create_security_plan_from_scheme(uri_scheme)
-      if high_trust_scheme?(uri_scheme)
-        org.neo4j.driver.internal.security.SecurityPlanImpl.forSystemCASignedCertificates(
-          true, org.neo4j.driver.internal.RevocationStrategy::NO_CHECKS
-        )
-      else
-        org.neo4j.driver.internal.security.SecurityPlanImpl.forAllCertificates(false, org.neo4j.driver.internal.RevocationStrategy::NO_CHECKS)
+      def create_security_plan_from_scheme(uri_scheme)
+        if high_trust_scheme?(uri_scheme)
+          Security::SecurityPlanImpl.for_system_ca_signed_certificates(true, RevocationStrategy::NO_CHECKS)
+        else
+          Security::SecurityPlanImpl.for_all_certificates(false, RevocationStrategy::NO_CHECKS)
+        end
       end
-    end
 
-    private
+      private
 
-    def assert_security_settings_not_user_configured(uri_scheme)
-      return unless customized
-
-      raise Neo4j::Driver::Exceptions::ClientException,
-            "Scheme #{uri_scheme} is not configurable with manual encryption and trust settings"
-    end
+      def assert_security_settings_not_user_configured(uri_scheme)
+        if customized
+          raise Neo4j::Driver::Exceptions::ClientException,
+                "Scheme #{uri_scheme} is not configurable with manual encryption and trust settings"
+        end
+      end
 
-    def create_security_plan_impl(encrypted, trust_strategy)
-      return Security::SecurityPlanImpl.insecure unless encrypted
+      def create_security_plan_impl(encrypted, trust_strategy)
+        return Security::SecurityPlanImpl.insecure unless encrypted
 
-      hostname_verification_enabled = trust_strategy.hostname_verification_enabled?
-      revocation_strategy = trust_strategy.revocation_strategy
+        hostname_verification_enabled = trust_strategy.hostname_verification_enabled?
+        revocation_strategy = trust_strategy.revocation_strategy
 
-      case trust_strategy.strategy
-      when Config::TrustStrategy::TRUST_CUSTOM_CA_SIGNED_CERTIFICATES
-        return Security::SecurityPlanImpl.forCustomCASignedCertificates(
-          trust_strategy.cert_file_to_java, hostname_verification_enabled, revocation_strategy
-        )
-      when Config::TrustStrategy::TRUST_SYSTEM_CA_SIGNED_CERTIFICATES
-        return Security::SecurityPlanImpl.forSystemCASignedCertificates(
-          hostname_verification_enabled, revocation_strategy
-        )
-      when Config::TrustStrategy::TRUST_ALL_CERTIFICATES
-        return Security::SecurityPlanImpl.forAllCertificates(
-          hostname_verification_enabled, revocation_strategy
-        )
-      else
-        raise ClientException, "Unknown TLS authentication strategy: #{trust_strategy.strategy}"
+        case trust_strategy.strategy
+        when Config::TrustStrategy::TRUST_CUSTOM_CA_SIGNED_CERTIFICATES
+          Security::SecurityPlanImpl.for_custom_ca_signed_certificates(
+            trust_strategy.cert_files, hostname_verification_enabled, revocation_strategy)
+        when Config::TrustStrategy::TRUST_SYSTEM_CA_SIGNED_CERTIFICATES
+          Security::SecurityPlanImpl
+            .for_system_ca_signed_certificates(hostname_verification_enabled, revocation_strategy)
+        when Config::TrustStrategy::TRUST_ALL_CERTIFICATES
+          Security::SecurityPlanImpl.for_all_certificates(hostname_verification_enabled, revocation_strategy)
+        else
+          raise ClientException, "Unknown TLS authentication strategy: #{trust_strategy.strategy}"
+        end
       end
     end
   end

data/ruby/neo4j/driver/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j-ruby-driver
 version: !ruby/object:Gem::Version
-  version: 4.4.0.alpha.2
+  version: 4.4.0.alpha.5
 platform: ruby
 authors:
 - Heinrich Klobuczek
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-14 00:00:00.000000000 Z
+date: 2022-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -136,20 +136,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: parallel
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement