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

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

@@ -0,0 +1,78 @@
+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
+
+      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 rx_session(**session_config)
+        InternalRxSession.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,22 @@
+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 eql?(other)
+        id.eql?(other.id)
+      end
+
+      def ==(other)
+        id == other.id
+      end
+    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,60 @@
+module Neo4j::Driver
+  module Internal
+    class InternalResult
+      extend Synchronizable
+      include Enumerable
+      sync :keys, :has_next?, :next, :single, :peek, :consume
+
+      def initialize(connection, cursor)
+        @connection = connection
+        @cursor = cursor
+      end
+
+      def keys
+        @keys ||=
+          begin
+            @cursor.peek_async
+            @cursor.keys
+          end
+      end
+
+      def has_next?
+        @cursor.peek_async
+      end
+
+      def next
+        @cursor.next_async || raise(Exceptions::NoSuchRecordException.no_more)
+      end
+
+      def single
+        @cursor.single_async
+      end
+
+      def peek
+        @cursor.peek_async or raise Exceptions::NoSuchRecordException.no_peek_past
+      end
+
+      def each
+        yield self.next while has_next?
+      end
+
+      def consume
+        @cursor.consume_async
+      end
+
+      def remove
+        raise ClientException, 'Removing records from a result is not supported.'
+      end
+
+      private
+
+      def blocking_get(stage)
+        Util::Futures.blocking_get(stage, &method(:terminate_connection_on_thread_interrupt))
+      end
+
+      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
+
+        # 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
+        # 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
+        # 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
+        # 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))
+        # 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)
+        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

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

@@ -0,0 +1,46 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      class BoltProtocolVersion < Struct.new(:major_version, :minor_version)
+        def self.from_raw_bytes(raw_version)
+          major = raw_version & 0x000000FF
+          minor = (raw_version >> 8) & 0x000000FF
+          new(major,minor)
+        end
+
+        def to_int
+          shifted_minor = minor_version << 8
+          shifted_minor | major_version
+        end
+
+        def to_int_range(min_version)
+          if major_version != min_version.major_version
+            raise ArgumentError, 'Versions should be from the same major version'
+          elsif minor_version < min_version.minor_version
+            raise ArgumentError, 'Max version should be newer than min version'
+          end
+
+          range = minor_version - min_version.minor_version
+          shifted_range = range << 16
+          shifted_range | to_int
+        end
+
+        # @return the version in format X.Y where X is the major version and Y is the minor version
+        def to_s
+          values.join('.')
+        end
+
+        def <=>(other)
+          result = major_version <=> other.major_version
+          result == 0 ? minor_version <=> other.minor_version : result
+        end
+
+        def self.http?(protocol_version)
+          # server would respond with `HTTP..` We read 4 bytes to figure out the version. The first two are not used
+          # and therefore parse the `P` (80) for major and `T` (84) for minor.
+          protocol_version.major_version == 80 && protocol_version.minor_version == 84
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/common/common_message_reader.rb

@@ -0,0 +1,51 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Common
+        class CommonMessageReader
+          def initialize(input)
+            @unpacker = input
+          end
+
+          def read(handler)
+            @unpacker.unpack_struct_header
+            type = @unpacker.unpack_struct_signature
+
+            case type
+            when Response::SuccessMessage::SIGNATURE
+              unpack_success_message(handler)
+            when Response::FailureMessage::SIGNATURE
+              unpack_failure_message(handler)
+            when Response::IgnoredMessage::SIGNATURE
+              unpack_ignored_message(handler)
+            when Response::RecordMessage::SIGNATURE
+              unpack_record_message(handler)
+            else
+              raise IOError, "Unknown message type: #{type}"
+            end
+          end
+
+          private
+
+          def unpack_success_message(output)
+            map = @unpacker.unpack
+            output.handle_success_message(map)
+          end
+
+          def unpack_failure_message(output)
+            output.handle_failure_message(**@unpacker.unpack)
+          end
+
+          def unpack_ignored_message(output)
+            output.handle_ignored_message
+          end
+
+          def unpack_record_message(output)
+            fields = @unpacker.unpack
+            output.handle_record_message(fields)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/common/common_value.rb

@@ -0,0 +1,31 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Common
+        module CommonValue
+          include Packstream::PackStream::Common
+          DATE = 'D'
+          DATE_STRUCT_SIZE = 1
+          TIME = 'T'
+          TIME_STRUCT_SIZE = 2
+          LOCAL_TIME = 't'
+          LOCAL_TIME_STRUCT_SIZE = 1
+          LOCAL_DATE_TIME = 'd'
+          LOCAL_DATE_TIME_STRUCT_SIZE = 2
+          DATE_TIME_WITH_ZONE_OFFSET = 'F'
+          DATE_TIME_WITH_ZONE_ID = 'f'
+          DATE_TIME_STRUCT_SIZE = 3
+          DURATION = 'E'
+          DURATION_TIME_STRUCT_SIZE = 4
+          POINT_2D_STRUCT_TYPE = 'X'
+          POINT_2D_STRUCT_SIZE = 3
+          POINT_3D_STRUCT_TYPE = 'Y'
+          POINT_3D_STRUCT_SIZE = 4
+
+          EPOCH = Date.parse('1970-01-01')
+          NANO_FACTOR = 1_000_000_000
+        end
+      end
+    end
+  end
+end