neo4j-ruby-driver 5.7.0.alpha.4 → 6.0.3.alpha.0-java

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

@@ -1,196 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

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

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j::Driver::Internal::Util
-  class ErrorUtil
-    DEFAULT_CONN_TERMINATED_REASON = 'Please ensure that your database is listening on the correct host and port and '\
-      'that you have compatible encryption settings both on Neo4j server and driver. '\
-      'Note that the default encryption setting has changed in Neo4j 4.0.'.freeze
-
-    SEC_EXCEPTION_CODE_MAPPING = {
-      'Neo.ClientError.Security.Unauthorized' => Neo4j::Driver::Exceptions::AuthenticationException,
-      'Neo.ClientError.Security.AuthorizationExpired' => Neo4j::Driver::Exceptions::AuthorizationExpiredException,
-      'Neo.ClientError.Security.TokenExpired' => Neo4j::Driver::Exceptions::TokenExpiredException
-    }.freeze
-
-    class << self
-      def new_connection_terminated_error(reason)
-        reason ||= DEFAULT_CONN_TERMINATED_REASON
-        Neo4j::Driver::Exceptions::ServiceUnavailableException.new("Connection to the database terminated. #{reason}")
-      end
-
-      def new_result_consumed_error
-        Neo4j::Driver::Exceptions::ResultConsumedException.new(
-          'Cannot access records on this result any more as the result has already been consumed '\
-          'or the query runner where the result is created has already been closed.'
-        )
-      end
-
-      def new_neo4j_error(code, message)
-        case extract_error_class(code)
-        when 'ClientError'
-          if extract_error_sub_class(code) == 'Security'
-            SEC_EXCEPTION_CODE_MAPPING[code] || Neo4j::Driver::Exceptions::SecurityException
-          else
-            code == 'Neo.ClientError.Database.DatabaseNotFound' ? Neo4j::Driver::Exceptions::FatalDiscoveryException : Neo4j::Driver::Exceptions::ClientException
-          end
-        when 'TransientError'
-          Neo4j::Driver::Exceptions::TransientException
-        else
-          Neo4j::Driver::Exceptions::DatabaseException
-        end.new(code, message)
-      end
-
-      def fatal?(error)
-        !error.is_a?(Neo4j::Driver::Exceptions::Neo4jException) ||
-          protocol_violation_error?(error.code) ||
-          !client_or_transient_error?(error.code)
-      end
-
-      def rethrow_async_exception(exception)
-        error = exception.cause
-        internal_cause = InternalExceptionCause.new(nil, error.backtrace)
-        error.add_suppressed(internal_cause)
-
-        # do not include Thread.current and this method in the stacktrace
-        current_stack_trace = Thread.current.backtrace.drop(2)
-        error.set_backtrace(current_stack_trace)
-
-        org.neo4j.driver.internal.shaded.io.netty.util.internal.PlatformDependent.throw_exception(error)
-      end
-
-      def add_suppressed(main_error, error)
-        main_error.add_suppressed(error) if main_error.is_a?(Neo4j::Driver::Exceptions::Neo4jException) && main_error != error
-      end
-
-      def get_root_cause(error)
-        java.util.Objects.require_non_null(error)
-
-        error.cause ? get_root_cause(error.cause) : error
-      end
-
-      # Exception which is merely a holder of an async stacktrace, which is not the primary stacktrace users are interested in.
-      # Used for blocking API calls that block on async API calls.
-      class InternalExceptionCause < RuntimeError
-        def initialize(message, backtrace)
-          super(message)
-          set_backtrace(backtrace)
-        end
-      end
-
-      private
-
-      def extract_error_class(code)
-        extract_class_from_code(code, 2)
-      end
-
-      def extract_error_sub_class(code)
-        extract_class_from_code(code, 3)
-      end
-
-      def extract_class_from_code(code, parts_counts)
-        parts = code.split('.')
-        parts.length < parts_counts ? '' : parts[parts_counts - 1]
-      end
-
-      def protocol_violation_error?(error_code)
-        error_code&.start_with?('Neo.ClientError.Request')
-      end
-
-      def client_or_transient_error?(error_code)
-        error_code && %w[ClientError TransientError].any?(&error_code.method(:include?))
-      end
-    end
-  end
-end

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

@@ -1,123 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Util
-      # Utility class for extracting data.
-      class Extract
-        def initialize
-          raise java.lang.UnsupportedOperationException
-        end
-
-        class << self
-          def list(data, map_function)
-            size = data.length
-
-            case size
-            when 0
-              java.util.Collections.empty_list
-            when 1
-              java.util.Collections.singleton_list(map_function.apply(data.first))
-            else
-              result = []
-              data.each do |value|
-                result << map_function.apply(value)
-              end
-
-              result.freeze
-            end
-          end
-
-          def map(record, map_function)
-            size = record.length
-
-            case size
-            when 0
-              java.util.Collections.empty_map
-            when 1
-              java.util.Collections.singleton_map[record.keys.first] = map_function.apply(record.first)
-            else
-              map = {}
-              keys = record.keys
-              size.times do |i|
-                map[keys[i]] = map_function.apply(record[i])
-              end
-
-              map.freeze
-            end
-          end
-
-          def properties(map, map_function)
-            size = map.length
-
-            case size
-            when 0
-              java.util.Collections.empty_list
-            when 1
-              key = map.keys.first
-              value = map[key]
-              java.util.Collections.singleton_list(InternalPair.of(key, map_function.apply(value)))
-            else
-              list = []
-              keys = record.keys
-              map.keys.each do |map_key|
-                map_value = map[map_key]
-                list << InternalPair.of(map_key, map_function.apply(map_value))
-              end
-
-              list.freeze
-            end
-          end
-
-          def fields(map, map_function)
-            size = map.keys.length
-
-            case size
-            when 0
-              java.util.Collections.empty_list
-            when 1
-              key = map.keys.first
-              value = map[key]
-              java.util.Collections.singleton_list(InternalPair.of(key, map_function.apply(value)))
-            else
-              list = []
-              keys = record.keys
-              size.times do |i|
-                key = keys[i]
-                value = map[key]
-                list << InternalPair.of(key, map_function.apply(value))
-              end
-
-              list.freeze
-            end
-          end
-
-          def map_of_values(map)
-            return java.util.Collections.empty_map if map.nil? || map.empty?
-
-            result = {}
-
-            map.entry_set.each do |key, value|
-              assert_parameter(value)
-              result[key] = value
-            end
-
-            result
-          end
-
-          def assert_parameter(value)
-            if value.is_a? Types::Node
-              raise Exceptions::ClientException, "Nodes can't be used as parameters."
-            end
-
-            if value.is_a? Types::Relationship
-              raise Exceptions::ClientException, "Relationships can't be used as parameters."
-            end
-
-            if value.is_a? Types::Path
-              raise Exceptions::ClientException, "Paths can't be used as parameters."
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Util
-      class Format
-        def initialize
-          raise java.lang.UnsupportedOperationException
-        end
-
-        # formats map using ':' as key-value separator instead of default '='
-        class << self
-          def format_pairs(entries)
-            case entries.size
-            when 0
-              '{}'
-            when 1
-              "#{key_value_string(entries.first)}"
-            else
-              builder = ""
-              builder << "{"
-              builder << key_value_string(entries.first)
-
-              entries.each do |entry|
-                builder << ","
-                builder << " "
-                builder << key_value_string(entry)
-              end
-
-              builder << "}"
-            end
-          end
-
-          private def key_value_string(entry)
-            "#{entry.keys.first}:#{entry.values.first}"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j::Driver
-  module Internal
-    module Util
-      class Futures
-        # TO DO: complete this class, this was partially migrated
-
-        private
-
-        COMPLETED_WITH_NULL = Concurrent::Promises.fulfilled_future(nil)
-
-        public
-
-        class << self
-          def completed_with_null
-            COMPLETED_WITH_NULL
-          end
-
-          def completed_with_null_if_no_error(future, error)
-            error ? future.reject(error) : future.fulfill(nil)
-          end
-
-          def failed_future(error)
-            Concurrent::Promises.rejected_future(error)
-          end
-
-          def blocking_get(stage)
-            Async::Connection::EventLoopGroupFactory.assert_not_in_event_loop_thread
-
-            interrupted = false
-            begin
-              loop do
-                break stage.value!
-              rescue Interrupt => e
-                # this thread was interrupted while waiting
-                # computation denoted by the future might still be running
-                interrupted = true
-
-                # run the interrupt handler and ignore if it throws
-                # need to wait for IO thread to actually finish, can't simply re-rethrow
-                yield rescue nil
-                # rescue java.util.concurrent.ExecutionException => e
-                #   ErrorUtil.rethrow_async_exception(e)
-              end
-            ensure
-              Thread.current.interrupt if interrupted
-            end
-          end
-
-          def get_now(stage)
-            stage.resolved? ? stage.value! : nil
-          end
-
-          def join_now_or_else_throw(future)
-            if future.resolved?
-              future.value!
-            else
-              raise yield
-            end
-          end
-
-          def combine_errors(error1, error2)
-            ErrorUtil.add_suppressed(error1, error2) if error1 && error2
-            error1 || error2
-          end
-
-          def on_error_continue(future, error_recorder)
-            Validator.require_non_nil!(future)
-
-            future
-              .then { |value| CompletionResult.new(value, nil) }
-              .rescue do |error|
-              Futures.combine_errors(error_recorder, error)
-              CompletionResult.new(nil, error)
-            end.then_flat do |result|
-              if result.value.nil?
-                yield result.error
-              else
-                Concurrent::Promises.fulfilled_future(result.value)
-              end
-            end
-          end
-
-          def future_completing_consumer(future, fulfilled, value, throwable)
-            fulfilled ? future.fulfill(value) : future.reject(throwable)
-          end
-
-          private
-
-          CompletionResult = Struct.new(:value, :error)
-
-          def no_op_interrupt_handler
-          end
-        end
-      end
-    end
-  end
-end