neo4j-ruby-driver 1.7.6 → 4.4.0.alpha.1

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver::Internal
+  class SecuritySetting
+    include Scheme
+
+    attr_reader :encrypted, :trust_strategy, :customized
+
+    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
+        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)
+      end
+    end
+
+    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 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
+
+      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}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Neo4j::Driver
+  module Internal
+    class SessionFactoryImpl
+      attr_reader :connection_provider
+      delegate :verify_connectivity, :close, :supports_multi_db?, to: :connection_provider
+
+      def initialize(connection_provider, retry_logic, config)
+        @connection_provider = connection_provider
+        @leaked_sessions_logging_enabled = config[:leaked_session_logging]
+        @retry_logic = retry_logic
+        @logger = config[:logger]
+        @default_fetch_size = config[:fetch_size]
+      end
+
+      def new_instance(fetch_size: @default_fetch_size, default_access_mode: AccessMode::WRITE, **config)
+        bookmark_holder = DefaultBookmarkHolder.new(InternalBookmark.from(*config[:bookmarks]))
+        create_session(parse_database_name(config), default_access_mode, bookmark_holder, fetch_size, config[:impersonated_user])
+      end
+
+      private
+
+      def parse_database_name(config)
+        config[:database]&.then(&DatabaseNameUtil.method(:database)) || DatabaseNameUtil.default_database
+      end
+
+      def create_session(database_name, mode, bookmark_holder, fetch_size, impersonated_user)
+        (@leaked_sessions_logging_enabled ? org.neo4j.driver.internal.async.LeakLoggingNetworkSession : Async::NetworkSession)
+          .new(@connection_provider, @retry_logic, database_name, mode, bookmark_holder, impersonated_user, fetch_size, @logger)
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/spi/connection.rb

@@ -0,0 +1,19 @@
+module Neo4j::Driver
+  module Internal
+    module Spi
+      module Connection
+        def mode
+          raise java.lang.UnsupportedOperationException, "#{self.class} does not support access mode."
+        end
+
+        def database_name
+          raise java.lang.UnsupportedOperationException, "#{self.class} does not support database name."
+        end
+
+        def impersonated_user
+          raise java.lang.UnsupportedOperationException, "#{self.class} does not support impersonated user."
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/spi/connection_pool.rb

@@ -0,0 +1,9 @@
+module Neo4j::Driver
+  module Internal
+    module Spi
+      module ConnectionPool
+        CONNECTION_POOL_CLOSED_ERROR_MESSAGE = 'Pool closed'
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/spi/response_handler.rb

@@ -0,0 +1,23 @@
+module Neo4j::Driver
+  module Internal
+    module Spi
+      module ResponseHandler
+        # Tells whether this response handler is able to manage auto-read of the underlying connection using {@link Connection#enableAutoRead()} and
+        # {@link Connection#disableAutoRead()}.
+        # <p>
+        # Implementations can use auto-read management to apply network-level backpressure when receiving a stream of records.
+        # There should only be a single such handler active for a connection at one point in time. Otherwise, handlers can interfere and turn on/off auto-read
+        # racing with each other. {@link InboundMessageDispatcher} is responsible for tracking these handlers and disabling auto-read management to maintain just
+        # a single auto-read managing handler per connection.
+        def can_manage_auto_read?
+          false
+        end
+        
+        # If this response handler is able to manage auto-read of the underlying connection, then this method signals it to
+        # stop changing auto-read setting for the connection.
+        def disable_auto_read_management
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/summary/internal_database_info.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver::Internal::Summary
+  class InternalDatabaseInfo < Struct.new(:name)
+    DEFAULT_DATABASE_INFO = new
+  end
+end

data/ruby/neo4j/driver/internal/summary/internal_input_position.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver::Internal::Summary
+  # Creating a position from and offset, line number and a column number.
+  #
+  # @param offset the offset from the start of the string, starting from 0.
+  # @param line the line number, starting from 1.
+  # @param column the column number, starting from 1.
+  class InternalInputPosition < Struct.new(:offset, :line, :column)
+  end
+end

data/ruby/neo4j/driver/internal/summary/internal_notification.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver::Internal::Summary
+  class InternalNotification < Struct.new(:code, :title, :description, :severity, :position)
+
+    VALUE_TO_NOTIFICATION = lambda do |value|
+      severity = value[:severity] || 'N/A'
+
+      position = value[:position]&.then do |pos_value|
+        InternalInputPosition.new(*pos_value.values_at(:offset, :line, :column).map(&:to_i))
+      end
+
+      InternalNotification.new(*value.values_at(:code, :title, :description), severity, position)
+    end
+  end
+end

data/ruby/neo4j/driver/internal/summary/internal_plan.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver::Internal::Summary
+  # Only call #initialize when sub-classing, for constructing plans, use .plan instead
+  class InternalPlan < Struct.new(:operator_type, :arguments, :identifiers, :children)
+    # Since a plan with or without profiling looks almost the same, we just keep two impls. of this
+    # around to contain the small difference, and share the rest of the code for building plan trees.
+    # @param <T>
+
+    class Converter
+      def initialize(&plan_creator)
+        @plan_creator = plan_creator
+      end
+
+      def apply(plan)
+        operator_type = plan[:operatorType]
+
+        arguments_value = plan[:args]
+        arguments = arguments_value || {}
+
+        identifiers_value = plan[:identifiers]
+        identifiers = identifiers_value || []
+
+        children_value = plan[:children]
+        children = children_value || []
+
+        @plan_creator.call(operator_type, arguments, identifiers, children, plan)
+      end
+    end
+
+    EXPLAIN_PLAN = lambda { |operator_type, arguments, identifiers, children, _original_plan_value|
+      new(operator_type, arguments, identifiers, children) }
+
+    # Builds a regular plan without profiling information - eg. a plan that came as a result of an `EXPLAIN` query
+    EXPLAIN_PLAN_FROM_VALUE = Converter.new(&EXPLAIN_PLAN).method(:apply)
+
+    def self.plan(operator_type, arguments, identifiers, children)
+      EXPLAIN_PLAN.call(operator_type, arguments, identifiers, children, nil)
+    end
+  end
+end

data/ruby/neo4j/driver/internal/summary/internal_profiled_plan.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver::Internal::Summary
+  class InternalProfiledPlan < InternalPlan
+    attr_reader :db_hits, :records, :page_cache_hits, :page_cache_misses, :page_cache_hit_ratio, :time
+
+    PROFILED_PLAN = lambda { |operator_type, arguments, identifiers, children, original_plan_value|
+      new(
+        operator_type, arguments, identifiers, children, original_plan_value[:db_hits].to_i,
+        original_plan_value[:rows].to_i, original_plan_value[:page_cache_hits].to_i,
+        original_plan_value[:page_cache_misses].to_i, original_plan_value[:page_cache_hit_ratio].to_f,
+        original_plan_value[:time].to_i
+      ) }
+
+    # Builds a regular plan without profiling information - eg. a plan that came as a result of an `EXPLAIN` query
+    PROFILED_PLAN_FROM_VALUE = Converter.new(&PROFILED_PLAN).method(:apply)
+
+    def initialize(operator_type, arguments, identifiers, children, db_hits, records, page_cache_hits, page_cache_misses, page_cache_hit_ratio, time)
+      super(operator_type, arguments, identifiers, children)
+      @db_hits = db_hits
+      @records = records
+      @page_cache_hits = page_cache_hits
+      @page_cache_misses = page_cache_misses
+      @page_cache_hit_ratio = page_cache_hit_ratio
+      @time = time
+    end
+
+    def page_cache_stats?
+      page_cache_hits.positive? || page_cache_misses.positive? || page_cache_hit_ratio.positive?
+    end
+  end
+end

data/ruby/neo4j/driver/internal/summary/internal_result_summary.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver::Internal::Summary
+  class InternalResultSummary < Struct.new(:query, :server, :database, :query_type, :counters, :plan, :profile,
+                                           :notifications, :result_available_after, :result_consumed_after)
+    alias has_plan? plan
+    alias has_profile? profile
+
+    def initialize(*args)
+      super
+      self.plan = resolve_plan(plan, profile)
+    end
+
+    def counters
+      super || InternalSummaryCounters::EMPTY_STATS
+    end
+
+    def notifications
+      super || []
+    end
+
+    private
+
+    # Profiled plan is a superset of plan. This method returns profiled plan if plan is {@code null}.
+    #
+    # @param plan the given plan, possibly {@code null}.
+    # @param profiled_plan the given profiled plan, possibly {@code null}.
+    # @return available plan.
+    def resolve_plan(plan, profiled_plan)
+      plan || profiled_plan
+    end
+  end
+end

data/ruby/neo4j/driver/internal/summary/internal_server_info.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver::Internal::Summary
+  class InternalServerInfo < Struct.new(:agent, :address, :version, :protocol_version)
+  end
+end

data/ruby/neo4j/driver/internal/summary/internal_summary_counters.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver::Internal::Summary
+  class InternalSummaryCounters < Struct.new(:nodes_created, :nodes_deleted, :relationships_created,
+                                             :relationships_deleted, :properties_set, :labels_added, :labels_removed,
+                                             :indexes_added, :indexes_removed, :constraints_added, :constraints_removed,
+                                             :system_updates)
+    EMPTY_STATS = InternalSummaryCounters.new(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+
+    def contains_updates?
+      any?(&:positive?)
+    end
+
+    def contains_system_updates?
+      system_updates.positive?
+    end
+  end
+end

data/ruby/neo4j/driver/internal/svm/netty_substitutions.rb

@@ -0,0 +1,196 @@
+module Neo4j::Driver
+  module Internal
+    module Svm
+      # This substitution avoid having loggers added to the build
+      class Target_io_netty_util_internal_logging_InternalLoggerFactory
+        def self.new_default_factory(name)
+          org.neo4j.driver.internal.shaded.io.netty.util.internal.logging.JdkLoggerFactory::INSTANCE
+        end
+      end
+      # SSL
+      # This whole section is mostly about removing static analysis references to openssl/tcnative
+      class Target_io_netty_handler_ssl_JdkSslServerContext
+        def initialize(provider, trust_cert_collection, trust_manager_factory, key_cert_chain, key, key_password,
+                       key_manager_factory, ciphers, cipher_filter, apn, session_cache_size, session_timeout, client_auth,
+                       protocols, start_tls, key_store)
+        end
+      end
+
+      class Target_io_netty_handler_ssl_JdkSslClientContext
+        def initialize(ssl_context_provider, trust_cert_collection, trust_manager_factory, key_cert_chain, key, key_password,
+                       key_manager_factory, ciphers, cipher_filter, apn, protocols, session_cache_size, session_timeout,
+                       key_store_type)
+        end
+      end
+
+      class Target_io_netty_handler_ssl_SslHandler
+        JDK = nil
+        def for_engine
+          JDK
+        end
+      end
+
+      class Target_io_netty_handler_ssl_JdkAlpnApplicationProtocolNegotiator_AlpnWrapper
+        def wrap_ssl_engine(engine, alloc, application_negotiator, server)
+          Target_io_netty_handler_ssl_JdkAlpnSslEngine.new(engine, application_negotiator, server)
+        end
+      end
+
+      def Target_io_netty_handler_ssl_JdkAlpnApplicationProtocolNegotiator_AlpnWrapperJava8
+        def wrap_ssl_engine(engine, alloc, application_negotiator, server)
+          if Target_io_netty_handler_ssl_JettyAlpnSslEngine.available?
+           return server ? Target_io_netty_handler_ssl_JettyAlpnSslEngine.new_server_engine(engine, application_negotiator) : Target_io_netty_handler_ssl_JettyAlpnSslEngine.new_client_engine(engine, application_negotiator)
+          end
+
+          raise RuntimeError, "Unable to wrap SSLEngine of type #{engine.class.name}"
+        end
+      end
+
+      class Target_io_netty_handler_ssl_JettyAlpnSslEngine
+        def self.available?
+          false
+        end
+
+        def new_client_engine(engine, application_negotiator)
+          nil
+        end
+
+        def new_server_engine(engine, application_negotiator)
+          nil
+        end
+      end
+
+      class Target_io_netty_handler_ssl_JdkAlpnSslEngine
+        def initialize(engine, application_negotiator, server)
+        end
+      end
+
+      class Target_io_netty_handler_ssl_SslContext
+        def new_client_context_internal(provider, ssl_context_provider, trust_cert_collection, trust_manager_factory, key_cert_chain, key, key_password,
+                                        key_manager_factory, ciphers, cipher_filter, apn, session_cache_size, session_timeout, client_auth,
+                                        protocols, start_tls, enable_ocsp, key_store_type, ctx_options)
+
+          if enable_ocsp
+            raise ArgumentError, "OCSP is not supported with this SslProvider: #{provider}"
+          else
+            Target_io_netty_handler_ssl_JdkSslServerContext.new(ssl_context_provider, trust_cert_collection, trust_manager_factory, key_cert_chain, key, key_password,
+                                                                key_manager_factory, ciphers, cipher_filter, apn, session_cache_size, session_timeout, client_auth,
+                                                                protocols, start_tls, key_store_type)
+          end
+        end
+
+        def new_client_context_internal(provider, ssl_context_provider, trust_cert, trust_manager_factory, key_cert_chain,
+                                        key, key_password, key_manager_factory, ciphers, cipher_filter, apn, protocols,
+                                        session_cache_size, session_timeout, enable_ocsp, key_store_type, options)
+
+          if enable_ocsp
+            raise ArgumentError, "OCSP is not supported with this SslProvider: #{provider}"
+          else
+            Target_io_netty_handler_ssl_JdkSslClientContext.new(ssl_context_provider, trust_cert, trust_manager_factory, key_cert_chain, key, key_password,
+                                                                key_manager_factory, ciphers, cipher_filter, apn, protocols, session_cache_size, session_timeout, key_store_type)
+          end
+        end
+      end
+
+      class Target_io_netty_handler_ssl_JdkDefaultApplicationProtocolNegotiator
+        INSTANCE = :instance
+      end
+
+      class Target_io_netty_handler_ssl_JdkSslContext
+        def self.to_negotiator(config, server)
+          if config.nil?
+            return Target_io_netty_handler_ssl_JdkDefaultApplicationProtocolNegotiator::INSTANCE
+          end
+
+          case config.protocol
+          when NONE
+            Target_io_netty_handler_ssl_JdkDefaultApplicationProtocolNegotiator::INSTANCE
+          when ALPN
+            if server
+              # GRAAL RC9 bug: https://github.com/oracle/graal/issues/813
+              #                switch(config.selectorFailureBehavior()) {
+              #                case FATAL_ALERT:
+              #                 return new JdkAlpnApplicationProtocolNegotiator(true, config.supportedProtocols());
+              #                case NO_ADVERTISE:
+              #                 return new JdkAlpnApplicationProtocolNegotiator(false, config.supportedProtocols());
+              #                default:
+              #                  throw new UnsupportedOperationException(new StringBuilder("JDK provider does not support ")
+              #      .           append(config.selectorFailureBehavior()).append(" failure behavior").toString());
+              #               }
+              behavior = config.selector_failure_behavior
+              if behavior == org.neo4j.driver.internal.shaded.io.netty.handler.ssl.ApplicationProtocolConfig.SelectorFailureBehavior::FATAL_ALERT
+                return org.neo4j.driver.internal.shaded.io.netty.handler.ssl.JdkAlpnApplicationProtocolNegotiator.new(true, config.supported_protocols)
+              elsif org.neo4j.driver.internal.shaded.io.netty.handler.ssl.ApplicationProtocolConfig.SelectorFailureBehavior::NO_ADVERTISE
+                return org.neo4j.driver.internal.shaded.io.netty.handler.ssl.JdkAlpnApplicationProtocolNegotiator.new(false, config.supported_protocols)
+              else
+                raise UnsupportedOperationException, "JDK provider does not support #{config.selector_failure_behavior} failure behavior"
+              end
+            else
+              case config.selected_listener_failure_behavior
+              when ACCEPT
+                org.neo4j.driver.internal.shaded.io.netty.handler.ssl.JdkAlpnApplicationProtocolNegotiator.new(false, config.supported_protocols)
+              when FATAL_ALERT
+                return org.neo4j.driver.internal.shaded.io.netty.handler.ssl.JdkAlpnApplicationProtocolNegotiator.new(true, config.supported_protocols)
+              else
+                raise UnsupportedOperationException, "JDK provider does not support #{config.selected_listener_failure_behavior} failure behavior"
+              end
+            end
+          else
+            raise UnsupportedOperationException, "JDK provider does not support #{config.protocol} protocol"
+          end
+        end
+      end
+
+      # This one only prints exceptions otherwise we get a useless bogus
+      # exception message: https://github.com/eclipse-vertx/vert.x/issues/1657
+      class Target_io_netty_bootstrap_AbstractBootstrap
+        def initialize(channel)
+          @channel_factory = org.neo4j.driver.internal.shaded.io.netty.bootstrap.ChannelFactory.new
+        end
+
+        def config
+          nil
+        end
+
+        def init_and_register
+          begin
+            channel = @channel_factory.new_channel
+            new(channel)
+          rescue StandardError => e
+            # THE FIX IS HERE:
+            t.print_stack_trace
+            unless channel.nil?
+              # channel can be null if newChannel crashed (eg SocketException("too many open files"))
+              channel.unsafe.close_forcibly
+            end
+
+            # as the Channel is not registered yet we need to force the usage of the GlobalEventExecutor
+            org.neo4j.driver.internal.shaded.io.netty.channel.DefaultChannelPromise.new(channel, io.netty.util.concurrent.GlobalEventExecutor::INSTANCE).set_failure(e)
+          end
+
+          reg_future = config.group.register(channel)
+          if reg_future.cause
+            if channel.registered?
+              channel.close
+            else
+              channel.unsafe.close_forcibly
+            end
+          end
+
+          # If we are here and the promise is not failed, it's one of the following cases:
+          # 1) If we attempted registration from the event loop, the registration has been completed at this point.
+          #    i.e. It's safe to attempt bind() or connect() now because the channel has been registered.
+          # 2) If we attempted registration from the other thread, the registration request has been successfully
+          #    added to the event loop's task queue for later execution.
+          #    i.e. It's safe to attempt bind() or connect() now:
+          #         because bind() or connect() will be executed *after* the scheduled registration task is executed
+          #         because register(), bind(), and connect() are all bound to the same thread.
+          reg_future
+        end
+      end
+
+      class NettySubstitutions
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/svm/z_lib_substitutions.rb

@@ -0,0 +1,21 @@
+module Neo4j::Driver
+  module Internal
+    module Svm
+      # This substitution avoid having jcraft zlib added to the build
+      class Target_org_neo4j_driver_internal_shaded_io_netty_handler_codec_compression_ZlibCodecFactory
+        class << self
+          def new_zlib_encoder(wrapper, compression_level)
+            org.neo4j.driver.internal.shaded.io.netty.handler.codec.compression.JdkZlibEncoder.new(wrapper, compression_level)
+          end
+
+          def zlib_decoder(wrapper)
+            org.neo4j.driver.internal.shaded.io.netty.handler.codec.compression.jdk_zlib_decoder(wrapper)
+          end
+        end
+      end
+
+      class ZLibSubstitutions
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Neo4j::Driver
+  module Internal
+    module Util
+
+      # A tool used to save, load certs, etc.
+      class CertificateTool
+        BEGIN_CERT = "-----BEGIN CERTIFICATE-----"
+        END_CERT = "-----END CERTIFICATE-----"
+
+        # Save a certificate to a file in base 64 binary format with BEGIN and END strings
+        # @param certStr
+        # @param certFile
+        # @throws IOException
+        class << self
+          def save_x509_cert(cert_str, cert_file)
+            writer = java.io.BufferedWriter.new(java.io.FileWriter.new(cert_file))
+
+            writer.write(BEGIN_CERT)
+            writer.new_line
+
+            writer.write(cert_str)
+            writer.new_line
+
+            writer.write(END_CERT)
+            writer.new_line
+          end
+
+          # Save a certificate to a file. Remove all the content in the file if there is any before.
+
+          # @param cert
+          # @param certFile
+          # @throws GeneralSecurityException
+          # @throws IOException
+
+          # Load the certificates written in X.509 format in a file to a key store.
+
+          # @param certFile
+          # @param keyStore
+          # @throws GeneralSecurityException
+          # @throws IOException
+          def load_x509_cert(cert_file, key_store)
+            input_stream = java.io.BufferedInputStream.new(java.io.FileInputStream.new(cert_file))
+
+            cert_factory = java.security.cert.CertificateFactory.get_instance('X.509')
+            cert_count = 0 #The file might contain multiple certs
+
+            while input_stream.available > 0
+              begin
+                cert = cert_factory.generate_certificate(input_stream)
+                cert_count = cert_count + 1
+                # load_x509_cert(cert, 'neo4j.javadriver.trustedcert.', cert_count, key_store)
+              rescue java.security.cert.CertificateException => e
+
+                # This happens if there is whitespace at the end of the certificate - we load one cert, and then try and load a
+                # second cert, at which point we fail
+                return if !e.get_cause.nil? && e.get_cause.get_message == 'Empty input'
+                raise java.io.IOException.new("Failed to load certificate from `#{cert_file.get_absolute_path}`: #{cert_count} : #{e.get_message}", e)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Neo4j::Driver
+  module Internal
+    module Util
+      module Clock
+        module System
+          class << self
+            def millis()
+              gettime(:millisecond)
+            end
+
+            def time()
+              gettime(:float_second).seconds
+            end
+
+            def sleep(duration)
+              super(duration.in_seconds)
+            end
+
+            private
+
+            def gettime(unit)
+              Process.clock_gettime(Process::CLOCK_MONOTONIC, unit)
+            end
+          end
+        end
+      end
+    end
+  end
+end