neo4j-ruby-driver 1.7.4 → 4.4.0

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

@@ -0,0 +1,48 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      class BoltProtocolVersion < Struct.new(:major_version, :minor_version)
+        include Comparable
+
+        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

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

@@ -0,0 +1,101 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Common
+        module CommonValuePacker
+          include CommonValue
+
+          def pack(value)
+            case value
+            when ActiveSupport::Duration
+              pack_duration(value)
+            when Types::Point
+              pack_point(value)
+            when Types::OffsetTime
+              pack_time(value)
+            when Types::LocalTime
+              pack_local_time(value)
+            when Types::LocalDateTime
+              pack_local_date_time(value)
+            when ActiveSupport::TimeWithZone
+              pack_date_time_with_zone_id(value)
+            when Time, DateTime
+              pack_date_time_with_zone_offset(value)
+            when Date
+              pack_date(value)
+            else
+              super
+            end
+          end
+
+          private
+
+          def pack_date(local_date)
+            pack_struct_header(DATE_STRUCT_SIZE, DATE)
+            pack_integer((local_date - EPOCH).to_i)
+          end
+
+          def pack_time(offset_time)
+            pack_struct_header(TIME_STRUCT_SIZE, TIME)
+            pack_nano_of_day(offset_time)
+            pack_utc_offset(offset_time)
+          end
+
+          def pack_utc_offset(time)
+            pack_integer(time.utc_offset)
+          end
+
+          def pack_nano_of_day(local_time)
+            pack_integer(((local_time.hour * 60 + local_time.min) * 60 + local_time.sec) * NANO_FACTOR + local_time.nsec)
+          end
+
+          def pack_local_time(local_time)
+            pack_struct_header(LOCAL_TIME_STRUCT_SIZE, LOCAL_TIME)
+            pack_nano_of_day(local_time)
+          end
+
+          def pack_local_date_time(local_date_time)
+            pack_struct_header(LOCAL_DATE_TIME_STRUCT_SIZE, LOCAL_DATE_TIME)
+            pack_integer(local_date_time.to_i)
+            pack_integer(local_date_time.nsec)
+          end
+
+          def pack_date_time_with_zone_id(time)
+            pack_struct_header(DATE_TIME_STRUCT_SIZE, DATE_TIME_WITH_ZONE_ID)
+            pack_date_time(time)
+            pack_string(time.time_zone.tzinfo.identifier)
+          end
+
+          def pack_date_time(time)
+            pack_integer(time.to_i + time.utc_offset)
+            pack_integer(time.nsec)
+          end
+
+          def pack_date_time_with_zone_offset(time)
+            pack_struct_header(DATE_TIME_STRUCT_SIZE, DATE_TIME_WITH_ZONE_OFFSET)
+            pack_date_time(time)
+            pack_utc_offset(time)
+          end
+
+          def pack_duration(duration)
+            pack_struct_header(DURATION_TIME_STRUCT_SIZE, DURATION)
+            DurationNormalizer.normalize(duration).each(&method(:pack_integer))
+          end
+
+          def pack_point(point)
+            case point.coordinates.size
+            when 2
+              pack_struct_header(POINT_2D_STRUCT_SIZE, POINT_2D_STRUCT_TYPE)
+            when 3
+              pack_struct_header(POINT_3D_STRUCT_SIZE, POINT_3D_STRUCT_TYPE)
+            else
+              raise IOError, "Unknown type: type: #{point.class}, value: #{point.to_s}"
+            end
+            pack_integer(point.srid.to_i)
+            point.coordinates.each(&method(:pack_float))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,234 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Common
+        module CommonValueUnpacker
+          include CommonValue
+          NODE = 'N'
+          RELATIONSHIP = 'R'
+          UNBOUND_RELATIONSHIP = 'r'
+          PATH = 'P'
+          NODE_FIELDS = 3
+
+          def unpack_map(size)
+            size.times.to_h { [unpack.to_sym, unpack] }
+          end
+
+          def unpack_array(size)
+            size.times.map { unpack }
+          end
+
+          def unpack
+            marker_byte = read_byte
+            marker_high_nibble = marker_byte & 0xF0
+            marker_low_nibble = marker_byte & 0x0F
+
+            case marker_high_nibble
+            when TINY_STRING
+              return unpack_string(marker_low_nibble)
+            when TINY_LIST
+              return unpack_array(marker_low_nibble)
+            when TINY_MAP
+              return unpack_map(marker_low_nibble)
+            when TINY_STRUCT
+              return unpack_struct(marker_low_nibble, read_char)
+            end
+
+            case marker_byte & 0xFF # we read a signed byte but markers are unsigned
+            when NULL
+              nil
+            when TRUE
+              true
+            when FALSE
+              false
+            when FLOAT_64
+              unpack_double
+            when BYTES_8
+              unpack_bytes(read_ubyte)
+            when BYTES_16
+              unpack_bytes(read_ushort)
+            when BYTES_32
+              unpack_bytes(read_uint)
+            when STRING_8
+              unpack_string(read_ubyte)
+            when STRING_16
+              unpack_string(read_ushort)
+            when STRING_32
+              unpack_string(read_uint)
+            when LIST_8
+              unpack_array(read_ubyte)
+            when LIST_16
+              unpack_array(read_ushort)
+            when LIST_32
+              unpack_array(read_uint)
+            when MAP_8
+              unpack_map(read_ubyte)
+            when MAP_16
+              unpack_map(read_ushort)
+            when STRUCT_8
+              unpack_struct(read_ubyte, read_char)
+            when STRUCT_16
+              unpack_struct(read_ushort, read_char)
+            else
+              unpack_long(marker_byte)
+            end
+          end
+
+          def unpack_struct(size, type)
+            case type
+            when DATE
+              ensure_correct_struct_size(:DATE, DATE_STRUCT_SIZE, size)
+              unpack_date
+            when TIME
+              ensure_correct_struct_size(:TIME, TIME_STRUCT_SIZE, size)
+              unpack_time
+            when LOCAL_TIME
+              ensure_correct_struct_size(:LOCAL_TIME, LOCAL_TIME_STRUCT_SIZE, size)
+              unpack_local_time
+            when LOCAL_DATE_TIME
+              ensure_correct_struct_size(:LOCAL_DATE_TIME, LOCAL_DATE_TIME_STRUCT_SIZE, size)
+              unpack_local_date_time
+            when DATE_TIME_WITH_ZONE_OFFSET
+              ensure_correct_struct_size(:DATE_TIME_WITH_ZONE_OFFSET, DATE_TIME_STRUCT_SIZE, size)
+              unpack_date_time_with_zone_offset
+            when DATE_TIME_WITH_ZONE_ID
+              ensure_correct_struct_size(:DATE_TIME_WITH_ZONE_ID, DATE_TIME_STRUCT_SIZE, size)
+              unpack_date_time_with_zone_id
+            when DURATION
+              ensure_correct_struct_size(:DURATION, DURATION_TIME_STRUCT_SIZE, size)
+              unpack_duration
+            when POINT_2D_STRUCT_TYPE
+              ensure_correct_struct_size(:POINT, POINT_2D_STRUCT_SIZE, size)
+              unpack_point2_d
+            when POINT_3D_STRUCT_TYPE
+              ensure_correct_struct_size(:POINT, POINT_3D_STRUCT_SIZE, size)
+              unpack_point3_d
+            when NODE
+              ensure_correct_struct_size(:NODE, NODE_FIELDS, size)
+              adapted = unpack_node
+            when RELATIONSHIP
+              ensure_correct_struct_size(:RELATIONSHIP, 5, size)
+              unpack_relationship
+            when UNBOUND_RELATIONSHIP
+              ensure_correct_struct_size(:RELATIONSHIP, 3, size)
+              unpack_unbound_relationship
+            when PATH
+              ensure_correct_struct_size(:PATH, 3, size)
+              unpack_path
+            else
+              raise IOError, "Unknown struct type: #{type}"
+            end
+          end
+
+          private
+
+          def unpack_relationship
+            InternalRelationship.new(*4.times.map { unpack }, **unpack)
+          end
+
+          def unpack_unbound_relationship
+            InternalRelationship.new(unpack, nil, nil, unpack, **unpack)
+          end
+
+          def unpack_node
+            InternalNode.new(unpack, *unpack.map(&:to_sym), **unpack)
+          end
+
+          def unpack_path
+            uniq_nodes = unpack
+            uniq_rels = unpack
+            sequence = unpack
+            prev_node = uniq_nodes.first
+            nodes = [prev_node] # Start node is always 0, and isn't encoded in the sequence
+            rels = []
+            path = Types::Path.new(nodes, rels)
+            sequence.in_groups_of(2) do |rel_idx, node_idx|
+              node = uniq_nodes[node_idx]
+              nodes << node
+              rel = uniq_rels[rel_idx.abs - 1] # -1 because rel idx are 1-indexed
+              update(rel, prev_node, node, rel_idx.negative?)
+              rels << rel
+              path << Types::Path::Segment.new(prev_node, rel, node)
+              prev_node = node
+            end
+            path
+          end
+
+          def update(rel, prev_node, node, inversed)
+            # Negative rel index means this rel was traversed "inversed" from its direction
+            prev_node, node = node, prev_node if inversed
+            rel.start_node_id = prev_node.id
+            rel.end_node_id = node.id
+          end
+
+          def ensure_correct_struct_size(type_constructor, expected, actual)
+            if expected != actual
+              struct_name = type_constructor.to_s
+              raise Neo4j::Driver::Exceptions::ClientException, "Invalid message received, serialized #{struct_name} structures should have #{expected} fields, received #{struct_name} structure has #{actual} fields."
+            end
+          end
+
+          private
+
+          def ensure_correct_struct_signature(struct_name, expected, actual)
+            if expected != actual
+              struct_name = type_constructor.to_s
+              raise Neo4j::Driver::Exceptions::ClientException, "Invalid message received, expected a `#{struct_name}`, signature 0x#{expected.to_i.to_s(16)}. Received signature was 0x#{actual.to_i.to_s(16)}."
+            end
+          end
+
+          def unpack_date
+            EPOCH + unpack
+          end
+
+          def time(nano_of_day_local, offset_seconds = nil)
+            min, sec = Rational(nano_of_day_local, NANO_FACTOR).divmod(60)
+            Time.new(0, 1, 1, *min.divmod(60), sec, offset_seconds)
+          end
+
+          def unpack_time
+            Types::OffsetTime.new(time(unpack, unpack))
+          end
+
+          def unpack_local_time
+            Types::LocalTime.new(time(unpack))
+          end
+
+          def unpack_local_date_time
+            Types::LocalDateTime.new(Time.at(unpack, unpack, :nsec).utc)
+          end
+
+          def unpack_date_time_with_zone_offset
+            # Time.at(unpack, unpack, :nsec, in: unpack)
+            sec = unpack
+            nsec = unpack
+            offset = unpack
+            time = Time.at(sec, nsec, :nsec).utc
+            Time.new(time.year, time.month, time.mday, time.hour, time.min, time.sec + Rational(nsec, 1_000_000_000),
+                     offset)
+          end
+
+          def unpack_date_time_with_zone_id
+            time = Time.at(unpack, unpack, :nsec).in_time_zone(TZInfo::Timezone.get(unpack))
+            time - time.utc_offset
+          end
+
+          def unpack_duration
+            ActiveSupport::Duration.months(unpack) +
+              ActiveSupport::Duration.days(unpack) +
+              ActiveSupport::Duration.seconds(unpack) +
+              ActiveSupport::Duration.seconds(unpack * BigDecimal('1e-9'))
+          end
+
+          def unpack_point2_d
+            Types::Point.new(srid: unpack, x: unpack, y: unpack)
+          end
+
+          def unpack_point3_d
+            Types::Point.new(srid: unpack, x: unpack, y: unpack, z: unpack)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/encode/begin_message_encoder.rb

@@ -0,0 +1,15 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class BeginMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::BeginMessage)
+            packer.pack_struct_header(1, message.signature)
+            packer.pack(message.metadata)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/encode/commit_message_encoder.rb

@@ -0,0 +1,14 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class CommitMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::CommitMessage)
+            packer.pack_struct_header(0, Request::CommitMessage::SIGNATURE)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/encode/discard_all_message_encoder.rb

@@ -0,0 +1,14 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class DiscardAllMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::DiscardAllMessage)
+            packer.pack_struct_header(0, Request::DiscardAllMessage::SIGNATURE)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/encode/discard_message_encoder.rb

@@ -0,0 +1,15 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class DiscardMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::DiscardMessage)
+            packer.pack_struct_header(1, Request::DiscardMessage::SIGNATURE)
+            packer.pack(message.metadata)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/encode/goodbye_message_encoder.rb

@@ -0,0 +1,14 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class GoodbyeMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::GoodbyeMessage)
+            packer.pack_struct_header(0, Request::GoodbyeMessage::SIGNATURE)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/encode/hello_message_encoder.rb

@@ -0,0 +1,15 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class HelloMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::HelloMessage)
+            packer.pack_struct_header(1, message.class::SIGNATURE)
+            packer.pack(message.metadata)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/encode/init_message_encoder.rb

@@ -0,0 +1,16 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class InitMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::InitMessage)
+            packer.pack_struct_header(2, message.signature)
+            packer.pack(message.user_agent)
+            packer.pack(message.auth_token)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/encode/pull_all_message_encoder.rb

@@ -0,0 +1,14 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class PullAllMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::PullAllMessage)
+            packer.pack_struct_header(0, Request::PullAllMessage::SIGNATURE)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/encode/pull_message_encoder.rb

@@ -0,0 +1,15 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class PullMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::PullMessage)
+            packer.pack_struct_header(1, Request::PullMessage::SIGNATURE)
+            packer.pack(message.metadata)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/encode/reset_message_encoder.rb

@@ -0,0 +1,14 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class ResetMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::ResetMessage)
+            packer.pack_struct_header(0, Request::ResetMessage::SIGNATURE)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/encode/rollback_message_encoder.rb

@@ -0,0 +1,14 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        class RollbackMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::RollbackMessage)
+            packer.pack_struct_header(0, Request::RollbackMessage::SIGNATURE)
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/encode/route_message_encoder.rb

@@ -0,0 +1,24 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        # Encodes the ROUTE message to the stream
+        class RouteMessageEncoder
+          def encode(message, packer)
+            Util::Preconditions.check_argument(message, Request::RouteMessage)
+            packer.pack_struct_header(3, message.signature)
+            packer.pack(message.routing_context)
+            packer.pack(message.bookmark&.values || [])
+            packer.pack(option(message))
+          end
+
+          private
+
+          def option(message)
+            message.database_name
+          end
+        end
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/internal/messaging/encode/route_v44_message_encoder.rb

@@ -0,0 +1,22 @@
+module Neo4j::Driver
+  module Internal
+    module Messaging
+      module Encode
+        # Encodes the ROUTE message to the stream
+        class RouteV44MessageEncoder < RouteMessageEncoder
+          private
+
+          def option(message)
+            if message.impersonated_user && !message.database_name
+              { imp_user: message.impersonated_user }
+            elsif message.database_name
+              { db: message.database_name }
+            else
+              {}
+            end
+          end
+        end
+      end
+    end
+  end
+end