neo4j-ruby-driver 1.7.4 → 4.4.0

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

@@ -0,0 +1,32 @@
+module Neo4j::Driver::Internal::Scheme
+  BOLT_URI_SCHEME = 'bolt'
+  BOLT_HIGH_TRUST_URI_SCHEME = 'bolt+s'
+  BOLT_LOW_TRUST_URI_SCHEME = 'bolt+ssc'
+  NEO4J_URI_SCHEME = 'neo4j'
+  NEO4J_HIGH_TRUST_URI_SCHEME = 'neo4j+s'
+  NEO4J_LOW_TRUST_URI_SCHEME = 'neo4j+ssc'
+
+  def validate_scheme!(scheme)
+    unless [BOLT_URI_SCHEME, BOLT_LOW_TRUST_URI_SCHEME, BOLT_HIGH_TRUST_URI_SCHEME, NEO4J_URI_SCHEME,
+            NEO4J_LOW_TRUST_URI_SCHEME, NEO4J_HIGH_TRUST_URI_SCHEME].include?(scheme)
+      raise ArgumentError, scheme ? "Invalid address format #{scheme}" : 'Scheme must not be null'
+    end
+  end
+
+  def high_trust_scheme?(scheme)
+    [BOLT_HIGH_TRUST_URI_SCHEME, NEO4J_HIGH_TRUST_URI_SCHEME].include?(scheme)
+  end
+
+  def low_trust_scheme?(scheme)
+    [BOLT_LOW_TRUST_URI_SCHEME, NEO4J_LOW_TRUST_URI_SCHEME].include?(scheme)
+  end
+
+  def security_scheme?(scheme)
+    [BOLT_LOW_TRUST_URI_SCHEME, NEO4J_LOW_TRUST_URI_SCHEME, BOLT_HIGH_TRUST_URI_SCHEME, NEO4J_HIGH_TRUST_URI_SCHEME]
+      .include?(scheme)
+  end
+
+  def routing_scheme?(scheme)
+    [NEO4J_LOW_TRUST_URI_SCHEME, NEO4J_HIGH_TRUST_URI_SCHEME, NEO4J_URI_SCHEME].include?(scheme)
+  end
+end

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

@@ -0,0 +1,15 @@
+module Neo4j::Driver
+  module Internal
+    module Security
+      # A simple common token for authentication schemes that easily convert to
+      # an auth token map
+      class InternalAuthToken < Hash
+        SCHEME_KEY = :scheme
+        PRINCIPAL_KEY = :principal
+        CREDENTIALS_KEY = :credentials
+        REALM_KEY = :realm
+        PARAMETERS_KEY = :parameters
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Neo4j::Driver::Internal
+  module Security
+    class SecurityPlanImpl < Struct.new(:requires_encryption?, :ssl_context, :requires_hostname_verification?,
+                                        :revocation_strategy)
+      class << self
+        def for_all_certificates(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)
+          new(true, custom_ca_signed_context(cert_files, requires_hostname_verification),
+              requires_hostname_verification, revocation_strategy)
+        end
+
+        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
+          new(false, nil, false, RevocationStrategy::NO_CHECKS)
+        end
+
+        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)
+          ssl_context(verify_hostname: requires_hostname_verification)
+        end
+
+        def custom_ca_signed_context(cert_files, requires_hostname_verification)
+          ssl_context(
+            cert_store: OpenSSL::X509::Store.new.tap do |store|
+              cert_files.each(&store.method(:add_file))
+            end,
+            verify_hostname: requires_hostname_verification)
+        end
+
+        def ssl_context(**params)
+          OpenSSL::SSL::SSLContext.new.tap { |context| context.set_params(params) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver
+  module 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)
+        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 IOError
+        raise Neo4j::Driver::Exceptions::ClientException, 'Unable to establish SSL parameters'
+      end
+
+      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
+
+      private
+
+      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
+
+        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
+          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
+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