neo4j-ruby-driver 1.7.4 → 4.4.0

data/ruby/neo4j/driver/internal/handlers/session_pull_response_completion_listener.rb

@@ -0,0 +1,34 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      class SessionPullResponseCompletionListener
+        def initialize(connection, bookmark_holder)
+          @connection = connection
+          @bookmark_holder = bookmark_holder
+        end
+
+        def after_success(metadata)
+          release_connection
+          @bookmark_holder.bookmark = Util::MetadataExtractor.extract_bookmarks(metadata)
+        end
+
+        def after_failure(error)
+          case error
+          when Exceptions::AuthorizationExpiredException
+            @connection.terminate_and_release(Exceptions::AuthorizationExpiredException::DESCRIPTION)
+          when Exceptions::ConnectionReadTimeoutException
+            @connection.terminate_and_release(error.message)
+          else
+            release_connection
+          end
+        end
+
+        private
+
+        def release_connection
+          @connection.release
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/handlers/transaction_pull_response_completion_listener.rb

@@ -0,0 +1,20 @@
+module Neo4j::Driver
+  module Internal
+    module Handlers
+      class TransactionPullResponseCompletionListener
+        def initialize(tx)
+          @tx = Validator.require_non_nil!(tx)
+        end
+
+        def after_success(_metadata) end
+
+        def after_failure(error)
+          # always mark transaction as terminated because every error is "acknowledged" with a RESET message
+          # so database forgets about the transaction after the first error
+          # such transaction should not attempt to commit and can be considered as rolled back
+          @tx.mark_terminated(error)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Neo4j::Driver
+  module Internal
+    class ImpersonationUtil
+      IMPERSONATION_UNSUPPORTED_ERROR_MESSAGE = 'Detected connection that does not support impersonation, please make sure to have all servers running 4.4 version or above and communicating over Bolt version 4.4 or above when using impersonation feature'
+
+      def self.ensure_impersonation_support(connection, impersonated_user)
+        if !impersonated_user.nil? && !supports_impersonation?(connection)
+          raise Neo4j::Driver::Exceptions::ClientException, IMPERSONATION_UNSUPPORTED_ERROR_MESSAGE
+        end
+
+        connection
+      end
+
+      private
+
+      def self.supports_impersonation?(connection)
+        connection.server_version >= Util::ServerVersion::V4_4_0 &&
+          connection.protocol.version >= Messaging::V44::BoltProtocolV44::VERSION
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Neo4j::Driver
+  module Internal
+    class InternalBookmark
+      include Bookmark
+      attr :values
+      delegate :hash, :empty?, to: :values
+
+      private def initialize(*values)
+        @values = values.to_set
+      end
+      EMPTY = new.freeze
+
+      def ==(other)
+        equal?(other) || self.class == other.class && values == other.values
+      end
+
+      alias eql? ==
+
+      def to_s
+        "Bookmark{values=#{values}}"
+      end
+
+      class << self
+        def empty
+          EMPTY
+        end
+
+        def from(*bookmarks)
+          new(*bookmarks.reduce(Set.new) { |set, bookmark| set + bookmark.values })
+        end
+
+        alias parse new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Neo4j::Driver
+  module Internal
+    class InternalDatabaseName < Struct.new(:database_name, :description)
+      def initialize(database_name: nil, description: database_name)
+        super(database_name, description)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Neo4j::Driver
+  module Internal
+    class InternalDriver
+      extend AutoClosable
+      extend Synchronizable
+      attr_reader :session_factory, :metrics_provider
+      # delegate :verify_connectivity, to: :session_factory
+      delegate :metrics, :metrics_enabled?, to: :metrics_provider
+      auto_closable :session
+      sync :close, :supports_multi_db?, :verify_connectivity, :session
+
+      def initialize(security_plan, session_factory, metrics_provider, logger)
+        @closed = Concurrent::AtomicBoolean.new(false)
+        @security_plan = security_plan
+        @session_factory = session_factory
+        @metrics_provider = metrics_provider
+        @log = logger
+      end
+
+      def session(**session_config)
+        InternalSession.new(new_session(**session_config))
+      end
+
+      def async_session(**session_config)
+        InternalAsyncSession.new(new_session(**session_config))
+      end
+
+      def encrypted?
+        assert_open!
+        @security_plan.requires_encryption?
+      end
+
+      def close
+        close_async
+      end
+
+      def close_async
+        return nil unless @closed.make_true
+        @log.info { "Closing driver instance #{object_id}" }
+        session_factory.close
+      end
+
+      def verify_connectivity_async
+        session_factory.verify_connectivity
+      end
+
+      def supports_multi_db?
+        supports_multi_db_async?
+      end
+
+      def supports_multi_db_async?
+        session_factory.supports_multi_db?
+      end
+
+      def verify_connectivity
+        verify_connectivity_async
+      end
+
+      def new_session(**config)
+        assert_open!
+        session_factory.new_instance(**config.compact)
+      ensure
+        # session does not immediately acquire connection, it is fine to just throw
+        assert_open!
+      end
+
+      private
+
+      def assert_open!
+        raise Exceptions::IllegalStateException, 'This driver instance has already been closed' if @closed.true?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Neo4j::Driver
+  module Internal
+    class InternalEntity
+      attr_reader :id, :properties
+      delegate :hash, to: :id
+      delegate :[], :size, :key?, :keys, :values, :to_h, to: :properties
+
+      def initialize(id, properties)
+        @id = id
+        @properties = properties
+      end
+
+      def ==(other)
+        equal?(other) || self.class == other.class && id == other.id
+      end
+
+      alias eql? ==
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Neo4j::Driver
+  module Internal
+    # {@link Node} implementation that directly contains labels and properties.
+    class InternalNode < InternalEntity
+      attr_reader :labels
+
+      def initialize(id, *labels, **properties)
+        super(id, properties)
+        @labels = labels
+      end
+
+      def label?(label)
+        labels.include?(label)
+      end
+
+      def to_s
+        "node<#{id}>"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Neo4j::Driver
+  module Internal
+    class InternalPair < Struct.new(:key, :value)
+      def self.of(key, value)
+        new(key, value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Neo4j::Driver
+  module Internal
+    class InternalPath < Array
+      attr_reader :nodes, :relationships
+
+      class Segment < Struct.new(:start_node, :relationship, :end_node)
+        def to_s
+          sprintf(relationship.start_node_id == start_node.id ? '(%s)-[%s:%s]->(%s)' : '(%s)<-[%s:%s]-(%s)',
+                  start_node.id, relationship.id, relationship.type, end_node.id)
+        end
+      end
+
+      delegate :length, to: :relationships
+      delegate :include?, to: :entities
+
+      def initialize(nodes, relationships)
+        super()
+        @nodes = nodes
+        @relationships = relationships
+      end
+
+      def to_s
+        'path' + super
+      end
+
+      def start_node
+        @nodes.first
+      end
+
+      def end_node
+        @nodes.last
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Neo4j::Driver
+  module Internal
+    class InternalPoint2D < Struct.new(:srid, :x, :y)
+      def z
+        Float::NAN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module Neo4j::Driver
+  module Internal
+    class InternalPoint3D < Struct.new(:srid, :x, :y, :z)
+    end
+  end
+end

data/{ffi → ruby}/neo4j/driver/internal/internal_record.rb

@@ -5,7 +5,8 @@ module Neo4j
     module Internal
       class InternalRecord
         attr_reader :keys, :values
-        delegate :first, to: :values
+        delegate :first, :size,to: :values
+        delegate :key?, to: :keys
 
         def initialize(keys, values)
           @keys = keys

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver
+  module Internal
+    class InternalRelationship < InternalEntity
+      attr_accessor :start_node_id, :end_node_id
+      attr_reader :type
+
+      def initialize(id, start_node_id, end_node_id, type, **properties)
+        super(id, properties)
+        @start_node_id = start_node_id
+        @end_node_id = end_node_id
+        @type = type.to_sym
+      end
+
+      def start_and_end_node_ids=(start_node_id, end_node_id)
+        @start_node_id = start_node_id
+        @end_node_id = end_node_id
+      end
+
+      def to_s
+        "relationship<#{id}>"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Neo4j::Driver
+  module Internal
+    class InternalResult
+      extend Synchronizable
+      include Enumerable
+      sync :keys, :has_next?, :next, :single, :peek, :consume
+      delegate :keys, to: :@cursor
+
+      def initialize(connection, cursor)
+        @connection = connection
+        @cursor = cursor
+      end
+
+      def has_next?
+        @cursor.peek_async.result!
+      end
+
+      def next
+        @cursor.next_async.result! || raise(Exceptions::NoSuchRecordException.no_more)
+      end
+
+      def single
+        @cursor.single_async.result!
+      end
+
+      def peek
+        @cursor.peek_async.result! or raise Exceptions::NoSuchRecordException.no_peek_past
+      end
+
+      def each
+        yield self.next while has_next?
+      end
+
+      def consume
+        @cursor.consume_async.result!
+      end
+
+      def remove
+        raise ClientException, 'Removing records from a result is not supported.'
+      end
+
+      private
+
+      def terminate_connection_on_thread_interrupt
+        @connection.terminate_and_release('Thread interrupted while waiting for result to arrive')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module Neo4j::Driver
+  module Internal
+    class InternalSession
+      extend AutoClosable
+      extend Synchronizable
+      # include Ext::RunOverride
+      delegate :open?, :last_bookmark, to: :@session
+      auto_closable :begin_transaction
+      sync :close, :begin_transaction, :run, :transaction
+
+      def initialize(session)
+        @session = session
+      end
+
+      def run(query, parameters = {}, config = {})
+        parameters ||= {}
+        Validator.require_hash_parameters!(parameters)
+        cursor = @session.run_async(Query.new(query, **parameters), **TransactionConfig.new(**config.compact)) do
+          terminate_connection_on_thread_interrupt('Thread interrupted while running query in session')
+        end.result!
+
+        # query executed, it is safe to obtain a connection in a blocking way
+        connection = @session.connection_async
+        InternalResult.new(connection, cursor)
+      end
+
+      def close
+        @session.close_async do
+          terminate_connection_on_thread_interrupt("Thread interrupted while closing the session")
+        end
+      end
+
+      def begin_transaction(**config)
+        tx = @session.begin_transaction_async(**config) do
+          terminate_connection_on_thread_interrupt("Thread interrupted while starting a transaction")
+        end
+        InternalTransaction.new(tx)
+      end
+
+      def read_transaction(**config, &block)
+        transaction(AccessMode::READ, **config, &block)
+      end
+
+      def write_transaction(**config, &block)
+        transaction(AccessMode::WRITE, **config, &block)
+      end
+
+      private
+
+      def transaction(mode, **config)
+        # use different code path compared to async so that work is executed in the caller thread
+        # caller thread will also be the one who sleeps between retries;
+        # it is unsafe to execute retries in the event loop threads because this can cause a deadlock
+        # event loop thread will bock and wait for itself to read some data
+        @session.retry_logic.retry do
+          tx = private_begin_transaction(mode, **config)
+          result = yield tx
+          tx.commit if tx.open? # if a user has not explicitly committed or rolled back the transaction
+          result
+        ensure
+          tx&.close
+        end
+      end
+
+      def private_begin_transaction(mode, **config)
+        tx = @session.begin_transaction_async(mode, **config) do
+          terminate_connection_on_thread_interrupt("Thread interrupted while starting a transaction")
+        end
+        InternalTransaction.new(tx)
+      end
+
+      def terminate_connection_on_thread_interrupt(reason)
+        connection = @session.connection_async
+      rescue
+        nil # ignore errors because handing interruptions is best effort
+      ensure
+        connection&.terminate_and_release(reason)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Neo4j::Driver
+  module Internal
+    class InternalTransaction
+      extend Synchronizable
+      sync :commit, :rollback, :close, :run
+      delegate :open?, to: :@tx
+
+      def initialize(tx)
+        @tx = tx
+      end
+
+      def commit
+        @tx.commit_async.result!
+        # org.neo4j.driver.internal.util.Futures.blockingGet(@tx.commit_async) do
+        #   terminate_connection_on_thread_interrupt('Thread interrupted while committing the transaction')
+        # end
+      end
+
+      def rollback
+        @tx.rollback_async.result!
+        # org.neo4j.driver.internal.util.Futures.blockingGet(@tx.rollback_async) do
+        #   terminate_connection_on_thread_interrupt('Thread interrupted while rolling back the transaction')
+        # end
+      end
+
+      def close
+        @tx.close_async.result!
+        # org.neo4j.driver.internal.util.Futures.blockingGet(@tx.close_async) do
+        #     terminate_connection_on_thread_interrupt('Thread interrupted while closing the transaction')
+        #   end
+      end
+
+      def run(query, **parameters)
+        cursor = @tx.run_async(Query.new(query, **parameters)).result!
+        # cursor = org.neo4j.driver.internal.util.Futures.blockingGet(@tx.run_async(to_statement(query, parameters))) do
+        #   terminate_connection_on_thread_interrupt('Thread interrupted while running query in transaction')
+        # end
+        InternalResult.new(@tx.connection, cursor)
+      end
+
+      private
+
+      def terminate_connection_on_thread_interrupt(reason)
+        @tx.connection.terminate_and_release(reason)
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/logging/channel_activity_logger.rb

@@ -0,0 +1,29 @@
+module Neo4j::Driver
+  module Internal
+    module Logging
+      class ChannelActivityLogger < ReformattedLogger
+        def initialize(channel, logger, owner)
+          super(logger)
+          @channel = channel
+          @local_channel_id = channel&.object_id&.to_s
+          @owner = owner
+        end
+
+        private
+
+        def format_message(severity, datetime, progname, msg)
+          super(severity, datetime, @owner || progname,
+                @channel && "[0x#{@local_channel_id}] [#{server_address}] [#{db_connection_id}] #{msg}" || msg)
+        end
+
+        def db_connection_id
+          @db_connection_id ||= Async::Connection::ChannelAttributes.connection_id(@channel)
+        end
+
+        def server_address
+          @server_address ||= Async::Connection::ChannelAttributes.server_address(@channel)&.to_s
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/logging/channel_error_logger.rb

@@ -0,0 +1,17 @@
+module Neo4j::Driver
+  module Internal
+    module Logging
+      class ChannelErrorLogger < ChannelActivityLogger
+        DEBUG_MESSAGE_FORMAT = "%s (%s)"
+
+        def initialize(channel, logger)
+          super(channel, logger, self.class)
+        end
+
+        def debug(message, error)
+          super(DEBUG_MESSAGE_FORMAT % [message, error.class])
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/logging/prefixed_logger.rb

@@ -0,0 +1,19 @@
+module Neo4j::Driver
+  module Internal
+    module Logging
+      class PrefixedLogger < ReformattedLogger
+        def initialize(message_prefix = nil, delegate)
+          super(delegate)
+          @message_prefix = message_prefix
+        end
+
+        private
+
+        def format_message(severity, datetime, progname, msg)
+          return super unless @message_prefix
+          super(severity, datetime, progname, "#{@message_prefix} #{msg}")
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/logging/reformatted_logger.rb

@@ -0,0 +1,17 @@
+module Neo4j::Driver
+  module Internal
+    module Logging
+      class ReformattedLogger
+        delegate_missing_to :@delegate
+
+        def initialize(delegate)
+          @delegate = Validator.require_non_nil!(delegate)
+        end
+
+        def trace(*arg)
+          debug(*arg)
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/abstract_message_writer.rb

@@ -0,0 +1,23 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      class AbstractMessageWriter
+        def initialize(packer)
+          @packer = Internal::Validator.require_non_nil!(packer)
+          @encoders_by_message_signature = Internal::Validator.require_non_nil!(build_encoders).transform_values(&:new)
+        end
+
+        def write(msg)
+          signature = msg.class::SIGNATURE
+          encoder = @encoders_by_message_signature[signature]
+
+          if encoder.nil?
+            raise IOError, "No encoder found for message #{msg} with signature #{signature}"
+          end
+
+          encoder.encode(msg, @packer)
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/bolt_protocol.rb

@@ -0,0 +1,30 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module BoltProtocol
+        def self.for_channel(channel)
+          for_version(channel.attributes[:protocol_version])
+        end
+
+        def self.for_version(version)
+          case version
+          when V3::BoltProtocolV3::VERSION
+            V3::BoltProtocolV3::INSTANCE
+          when V4::BoltProtocolV4::VERSION
+            V4::BoltProtocolV4::INSTANCE
+          when V41::BoltProtocolV41::VERSION
+            V41::BoltProtocolV41::INSTANCE
+          when V42::BoltProtocolV42::VERSION
+            V42::BoltProtocolV42::INSTANCE
+          when V43::BoltProtocolV43::VERSION
+            V43::BoltProtocolV43::INSTANCE
+          when V44::BoltProtocolV44::VERSION
+            V44::BoltProtocolV44::INSTANCE
+          else
+            raise Exceptions::ClientException, "Unknown protocol version: #{version}"
+          end
+        end
+      end
+    end
+  end
+end