neo4j-ruby-driver 1.7.4 → 4.4.0

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

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+module Neo4j::Driver
+  module Internal
+    module Util
+      class Iterables
+        EMPTY_QUEUE = Queue.new
+
+        class << self
+          def single(it)
+            if it.empty?
+              raise ArgumentError, 'Given iterable is empty'
+            end
+
+            result = it.first
+
+            if it.size > 1
+              raise ArgumentError, "Given iterable contains more than one element: #{it}"
+            end
+
+            result
+          end
+
+          def map(alternating_key_value)
+            out = {}
+
+            (0...alternating_key_value.length).step(2) do |i|
+              out[i] = out[i+1]
+            end
+
+            out
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Neo4j::Driver
+  module Internal
+    module Util
+      class LockUtil
+        class << self
+          def execute_with_lock(lock)
+            lock.lock
+            begin
+              yield
+            ensure
+              lock.unlock
+            end
+          end
+
+          def execute_with_lock_async(lock)
+            lock.lock
+            Concurrent::Promises.fulfilled_future(lock).then_flat { yield }.on_fulfillment! { lock.unlock }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+module Neo4j::Driver
+  module Internal
+    module Util
+      class MetadataExtractor
+        def initialize(result_available_after_metadata_key, result_consumed_after_metadata_key)
+          @result_available_after_metadata_key = result_available_after_metadata_key
+          @result_consumed_after_metadata_key = result_consumed_after_metadata_key
+        end
+
+        def extract_query_keys(metadata)
+          metadata[:fields]&.map(&:to_sym) || []
+        end
+
+        def extract_query_id(metadata)
+          metadata[:qid]
+        end
+
+        def extract_result_available_after(metadata)
+          metadata[@result_available_after_metadata_key]
+        end
+
+        def extract_summary(query, connection, result_available_after, metadata)
+          server_info = Summary::InternalServerInfo.new(connection.server_agent, connection.server_address, connection.server_version, connection.protocol.version)
+          db_info = self.class.extract_database_info(metadata)
+          Summary::InternalResultSummary.new(
+            query, server_info, db_info, self.class.extract_query_type(metadata), self.class.extract_counters(metadata),
+            self.class.extract_plan(metadata), self.class.extract_profiled_plan(metadata),
+            self.class.extract_notifications(metadata), result_available_after,
+            self.class.extract_result_consumed_after(metadata, @result_consumed_after_metadata_key))
+        end
+
+        class << self
+          def extract_database_info(metadata)
+            metadata[:db]&.then(&Summary::InternalDatabaseInfo.method(:new)) ||
+              Summary::InternalDatabaseInfo::DEFAULT_DATABASE_INFO
+          end
+
+          def extract_bookmarks(metadata)
+            bookmark_value = metadata[:bookmark]
+
+            return InternalBookmark.parse(bookmark_value) if bookmark_value&.is_a? String
+
+            InternalBookmark.empty
+          end
+
+          def extract_neo4j_server_version(metadata)
+            server_value = extract_server(metadata)
+            server = Util::ServerVersion.version(server_value)
+            return server if Util::ServerVersion::NEO4J_PRODUCT.casecmp?(server.product)
+            raise Neo4j::Driver::Exceptions::UntrustedServerException, "Server does not identify as a genuine Neo4j instance: #{server.product}"
+          end
+
+          def extract_server(metadata)
+            metadata[:server].tap do |version_value|
+              unless version_value
+                raise Neo4j::Driver::Exceptions::UntrustedServerException, 'Server provides no product identifier'
+              end
+            end
+          end
+
+          def extract_query_type(metadata)
+            metadata[:type]
+          end
+
+          def extract_counters(metadata)
+            counters_value = metadata[:stats]
+            counters_value &&
+              Summary::InternalSummaryCounters.new(
+                *%i[
+                nodes-created
+                nodes-deleted
+                relationships-created
+                relationships-deleted
+                properties-set
+                labels-added
+                labels-removed
+                indexes-added
+                indexes-removed
+                constraints-added
+                constraints-removed
+                system-updates
+            ].map { |key| counters_value[key].to_i }
+              )
+          end
+
+          def extract_plan(metadata)
+            metadata[:plan]&.then(&Summary::InternalPlan::EXPLAIN_PLAN_FROM_VALUE)
+          end
+
+          def extract_profiled_plan(metadata)
+            metadata[:profile]&.then(&Summary::InternalProfiledPlan::PROFILED_PLAN_FROM_VALUE)
+          end
+
+          def extract_notifications(metadata)
+            metadata[:notifications]&.then do |notifications|
+              notifications.map(&Summary::InternalNotification::VALUE_TO_NOTIFICATION)
+            end
+          end
+
+          def extract_result_consumed_after(metadata, key)
+            metadata[key]&.to_i
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Neo4j::Driver::Internal
+  module Util
+    class Mutex < Mutex
+      def synchronize
+        owned? ? yield : super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Neo4j::Driver
+  module Internal
+    module Util
+      class Preconditions
+        # Assert that given expression is true.
+
+        # @param expression the value to check.
+        # @param message the message.
+        # @throws IllegalArgumentException if given value is {@code false}.
+        def self.check_argument(expression, message)
+          raise ArgumentError, message unless expression
+        end
+      end
+    end
+  end
+end