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

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?(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,109 @@
+module Neo4j::Driver
+  module Internal
+    module Util
+      class MetadataExtractor
+        ABSENT_QUERY_ID = -1
+
+        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] || ABSENT_QUERY_ID
+        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

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

@@ -0,0 +1,60 @@
+module Neo4j::Driver
+  module Internal
+    module Util
+      class ServerVersion < Struct.new(:product, :major, :minor, :patch)
+        include Comparable
+        NEO4J_PRODUCT = 'Neo4j'
+        V4_4_0 = new(NEO4J_PRODUCT, 4, 4, 0)
+        V4_3_0 = new(NEO4J_PRODUCT, 4, 3, 0)
+        V4_2_0 = new(NEO4J_PRODUCT, 4, 2, 0)
+        V4_1_0 = new(NEO4J_PRODUCT, 4, 1, 0)
+        V4_0_0 = new(NEO4J_PRODUCT, 4, 0, 0)
+        V3_5_0 = new(NEO4J_PRODUCT, 3, 5, 0)
+        V3_4_0 = new(NEO4J_PRODUCT, 3, 4, 0)
+        V_IN_DEV = new(NEO4J_PRODUCT)
+        NEO4J_IN_DEV_VERSION_STRING = "#{NEO4J_PRODUCT}/dev"
+        PATTERN = Regexp.new '([^/]+)/(\\d+)\\.(\\d+)(?:\\.)?(\\d*)(\\.|-|\\+)?([0-9A-Za-z\-.]*)?'
+
+        def <=>(other)
+          unless product == other.product
+            raise ArgumentError, "Comparing different products #{product}  with #{other.product}"
+          end
+          values <=> other.values
+        end
+
+        def to_s
+          major || minor || patch ? "#{product}/#{major}.#{minor}.#{patch}" : NEO4J_IN_DEV_VERSION_STRING
+        end
+
+        def self.version(server)
+          PATTERN.match(server) do |matchdata|
+            product = matchdata[1]
+            major = matchdata[2].to_i
+            minor = matchdata[3].to_i
+            patch = matchdata[4].to_i
+            return new(product, major, minor, patch)
+          end
+          return V_IN_DEV if server.casecmp?(NEO4J_IN_DEV_VERSION_STRING)
+          raise ArgumentError, "Cannot parse #{server}"
+        end
+
+        def self.from_bolt_protocol_version(protocol_version)
+          case protocol_version
+          when Messaging::V4::BoltProtocolV4::VERSION
+            V4_0_0
+          when Messaging::V41::BoltProtocolV41::VERSION
+            V4_1_0
+          when Messaging::V42::BoltProtocolV42::VERSION
+            V4_2_0
+          when Messaging::V43::BoltProtocolV43::VERSION
+            V4_3_0
+          when Messaging::V44::BoltProtocolV44::VERSION
+            V4_4_0
+          else
+            V_IN_DEV
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/logging1.rb

@@ -0,0 +1,51 @@
+module Neo4j
+  module Driver
+    module Logging1
+      # Obtain a {@link Logger} instance by class, its name will be the fully qualified name of the class.
+
+      # @param clazz class whose name should be used as the {@link Logger} name.
+      # @return {@link Logger} instance
+      private
+
+      def log(clazz)
+        canonical_name = clazz.canonical_name
+        log(canonical_name.nil? ? clazz.name : canonical_name)
+      end
+
+      # Create logging implementation that uses SLF4J.
+
+      # @return new logging implementation.
+      # @throws IllegalStateException if SLF4J is not available.
+      def slf4j
+        unavailability_error = Internal::Logging::Slf4jLogging.check_availability
+
+        raise unavailability_error unless unavailability_error.nil?
+
+        Slf4jLogging.new
+      end
+
+      # Create logging implementation that uses {@link java.util.logging}.
+
+      # @param level the log level.
+      # @return new logging implementation.
+      def java_util_logging(level)
+        Internal::Logging::JULogging.new(level)
+      end
+
+      # Create logging implementation that uses {@link java.util.logging} to log to {@code System.err}.
+
+      # @param level the log level.
+      # @return new logging implementation.
+      def console(level)
+        Internal::Logging::ConsoleLogging.new(level)
+      end
+
+      # Create logging implementation that discards all messages and logs nothing.
+
+      # @return new logging implementation.
+      def none
+        Internal::Logging::DevNullLogging::DEV_NULL_LOGGING
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/net/server_address1.rb

@@ -0,0 +1,9 @@
+module Neo4j::Driver
+  module Net
+    module ServerAddress1
+      def self.of(host, port)
+        Internal::BoltServerAddress.new(host, port)
+      end
+    end
+  end
+end