tarantool-client 0.1.0

data/lib/tarantool/client/protocol/extensions/interval.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Extensions
+        # MP_EXT interval: uint8 count, then (uint8 field id, msgpack int) pairs for non-zero values.
+        # @api private
+        module Interval
+          FIELD_NAMES = %i[year month week day hour min sec nsec adjust].freeze
+          FIELDS = FIELD_NAMES.each_with_index.to_h { |name, id| [id, name] }.freeze
+          ADJUSTS = { excess: 0, none: 1, last: 2 }.freeze
+
+          module_function
+
+          def pack(interval)
+            pairs = codes(interval).each_with_index.reject { |code, _id| code.zero? }
+
+            pairs.reduce([pairs.size].pack('C')) do |payload, (code, id)|
+              payload + [id].pack('C') + MessagePack.pack(code)
+            end
+          end
+
+          # Count and field ids are uint8 below 0x80, which are byte-identical to positive fixints,
+          # so the whole payload reads as a msgpack stream.
+          def unpack(payload)
+            count, *pairs = MessagePack::Unpacker.new.feed(payload).each.to_a
+            raise ArgumentError, 'malformed interval: field count mismatch' unless pairs.size == count * 2
+
+            attributes = pairs.each_slice(2).to_h { |id, value| [FIELDS.fetch(id), value] }
+            attributes[:adjust] = decode_adjust(attributes.fetch(:adjust, 0))
+
+            Client::Interval.new(**attributes)
+          end
+
+          def codes(interval)
+            values = interval.to_h.merge(adjust: encode_adjust(interval.adjust))
+
+            FIELD_NAMES.map { |name| values.fetch(name) }
+          end
+
+          def encode_adjust(adjust)
+            ADJUSTS.fetch(adjust) { raise ArgumentError, "unknown interval adjust: #{adjust.inspect}" }
+          end
+
+          def decode_adjust(code)
+            ADJUSTS.key(code) || raise(ArgumentError, "malformed interval: adjust #{code}")
+          end
+
+          private_class_method :codes, :encode_adjust, :decode_adjust
+
+          Extensions.register(
+            Constants::MP_INTERVAL, Client::Interval, packer: method(:pack), unpacker: method(:unpack)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/extensions/uuid.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Extensions
+        # MP_EXT uuid: 16 raw bytes in RFC 4122 order.
+        # @api private
+        module Uuid
+          SIZE = 16
+
+          module_function
+
+          def pack(uuid)
+            [uuid.value.delete('-')].pack('H*')
+          end
+
+          def unpack(payload)
+            raise ArgumentError, "malformed uuid: #{payload.bytesize} bytes" unless payload.bytesize == SIZE
+
+            Client::UUID.new(payload.unpack('H8H4H4H4H12').join('-'))
+          end
+
+          Extensions.register(Constants::MP_UUID, Client::UUID, packer: method(:pack), unpacker: method(:unpack))
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/extensions.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      # MP_EXT types the codec knows; every file under extensions/ registers itself here.
+      # @api private
+      module Extensions
+        Entry = Data.define(:type, :klass, :options)
+
+        @entries = []
+
+        class << self
+          include Enumerable
+
+          def register(type, klass, **options)
+            @entries << Entry.new(type:, klass:, options:)
+          end
+
+          def each(&)
+            @entries.each(&)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/greeting.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      # Greeting sent by the server on connect: a 64-byte banner and a 64-byte base64 salt line.
+      # @api private
+      Greeting = Data.define(:version, :salt) do
+        self::BANNER_VERSION = /\ATarantool (\S+)/
+
+        def self.parse(bytes)
+          banner = bytes.byteslice(0, 64)
+          version = banner[Greeting::BANNER_VERSION, 1]
+          raise ProtocolError, "unexpected greeting: #{banner.strip.inspect}" unless version
+
+          new(version:, salt: bytes.byteslice(64, 64).strip.unpack1('m'))
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/auth.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Requests
+        # IPROTO_AUTH: authenticate the session.
+        # @api private
+        Auth = Data.define(:user, :mechanism, :scramble) do
+          def type = Constants::AUTH
+
+          # Tarantool expects the scramble as MP_STR; binary Ruby strings would be packed as MP_BIN.
+          def body
+            {
+              Constants::USER_NAME => user,
+              Constants::TUPLE => [mechanism, scramble.dup.force_encoding(Encoding::UTF_8)]
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/begin.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Requests
+        # IPROTO_BEGIN: open a transaction in a stream. The server rolls it back once the timeout (seconds) expires.
+        # @api private
+        Begin = Data.define(:isolation, :timeout) do
+          def initialize(isolation:, **)
+            unless Constants::ISOLATION_LEVELS.key?(isolation)
+              raise ArgumentError, "unknown isolation level: #{isolation.inspect}"
+            end
+
+            super
+          end
+
+          def type = Constants::BEGIN_TRANSACTION
+
+          # The server accepts only a MessagePack double for the timeout and rejects an integer.
+          def body
+            level = Constants::ISOLATION_LEVELS.fetch(isolation)
+
+            { Constants::TXN_ISOLATION => level, Constants::TIMEOUT => timeout&.to_f }.compact
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/call.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Requests
+        # IPROTO_CALL: invoke a stored or global Lua function.
+        # @api private
+        Call = Data.define(:function_name, :arguments) do
+          def type = Constants::CALL
+          def body = { Constants::FUNCTION_NAME => function_name, Constants::TUPLE => arguments }
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/commit.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Requests
+        # IPROTO_COMMIT: commit the stream's transaction.
+        # @api private
+        Commit = Data.define do
+          def type = Constants::COMMIT
+          def body = {}
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/delete.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Requests
+        # IPROTO_DELETE: remove the tuple found by key.
+        # @api private
+        Delete = Data.define(:space_id, :index_id, :key) do
+          def type = Constants::DELETE
+
+          def body
+            { Constants::SPACE_ID => space_id, Constants::INDEX_ID => index_id, Constants::KEY => key }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/eval.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Requests
+        # IPROTO_EVAL: run a Lua chunk; arguments are available as `...`.
+        # @api private
+        Eval = Data.define(:expression, :arguments) do
+          def type = Constants::EVAL
+          def body = { Constants::EXPR => expression, Constants::TUPLE => arguments }
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/execute.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Requests
+        # IPROTO_EXECUTE: run SQL given as text or as a prepared statement id.
+        # @api private
+        Execute = Data.define(:statement, :bindings) do
+          def type = Constants::EXECUTE
+
+          def body
+            key = statement.is_a?(Integer) ? Constants::STMT_ID : Constants::SQL_TEXT
+
+            { key => statement, Constants::SQL_BIND => bindings }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/id.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Requests
+        # IPROTO_ID: exchange protocol version and feature lists.
+        # @api private
+        Id = Data.define(:version, :features) do
+          def type = Constants::ID
+          def body = { Constants::VERSION => version, Constants::FEATURES => features }
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/insert.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Requests
+        # IPROTO_INSERT: fails on duplicate primary key.
+        # @api private
+        Insert = Data.define(:space_id, :tuple) do
+          def type = Constants::INSERT
+          def body = { Constants::SPACE_ID => space_id, Constants::TUPLE => tuple }
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/ping.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      # @api private
+      module Requests
+        # IPROTO_PING: liveness check.
+        # @api private
+        Ping = Data.define do
+          def type = Constants::PING
+          def body = {}
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/prepare.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Requests
+        # IPROTO_PREPARE: prepare SQL text, or deallocate a prepared statement given its id.
+        # @api private
+        Prepare = Data.define(:statement) do
+          def type = Constants::PREPARE
+          def body = { (statement.is_a?(Integer) ? Constants::STMT_ID : Constants::SQL_TEXT) => statement }
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/replace.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Requests
+        # IPROTO_REPLACE: insert or overwrite by primary key.
+        # @api private
+        Replace = Data.define(:space_id, :tuple) do
+          def type = Constants::REPLACE
+          def body = { Constants::SPACE_ID => space_id, Constants::TUPLE => tuple }
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/rollback.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Requests
+        # IPROTO_ROLLBACK: roll back the stream's transaction.
+        # @api private
+        Rollback = Data.define do
+          def type = Constants::ROLLBACK
+          def body = {}
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/select.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Requests
+        # IPROTO_SELECT: index lookup or scan. `after` continues past a tuple (keyset pagination, 2.11+).
+        # @api private
+        Select = Data.define(:space_id, :index_id, :key, :limit, :offset, :iterator, :after) do
+          def initialize(iterator:, after: nil, **)
+            raise ArgumentError, "unknown iterator: #{iterator.inspect}" unless Constants::ITERATORS.key?(iterator)
+
+            super
+          end
+
+          def type = Constants::SELECT
+
+          def body
+            {
+              Constants::SPACE_ID => space_id,
+              Constants::INDEX_ID => index_id,
+              Constants::LIMIT => limit,
+              Constants::OFFSET => offset,
+              Constants::ITERATOR => Constants::ITERATORS.fetch(iterator),
+              Constants::KEY => key
+            }.tap { |body| body[Constants::AFTER_TUPLE] = after unless after.nil? }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/unwatch.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Requests
+        # IPROTO_UNWATCH: drop the subscription to a key. No reply.
+        # @api private
+        Unwatch = Data.define(:key) do
+          def type = Constants::UNWATCH
+          def body = { Constants::EVENT_KEY => key }
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/update.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Requests
+        # IPROTO_UPDATE: field operations on the tuple found by key.
+        # @api private
+        Update = Data.define(:space_id, :index_id, :key, :operations) do
+          def type = Constants::UPDATE
+
+          def body
+            {
+              Constants::SPACE_ID => space_id,
+              Constants::INDEX_ID => index_id,
+              Constants::KEY => key,
+              Constants::TUPLE => operations
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/upsert.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Requests
+        # IPROTO_UPSERT: insert the tuple or apply operations to the existing one.
+        # @api private
+        Upsert = Data.define(:space_id, :tuple, :operations) do
+          def type = Constants::UPSERT
+
+          def body
+            { Constants::SPACE_ID => space_id, Constants::TUPLE => tuple, Constants::OPS => operations }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/requests/watch.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      module Requests
+        # IPROTO_WATCH: subscribe to a key, or acknowledge the last event for it. No reply.
+        # @api private
+        Watch = Data.define(:key) do
+          def type = Constants::WATCH
+          def body = { Constants::EVENT_KEY => key }
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/protocol/response.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    module Protocol
+      # Decoded IPROTO response frame.
+      # @api private
+      class Response
+        attr_reader :header, :body
+
+        def initialize(header, body)
+          @header = header
+          @body = body
+        end
+
+        def type = header.fetch(Constants::REQUEST_TYPE)
+        def sync = header[Constants::SYNC]
+        def schema_version = header[Constants::SCHEMA_VERSION]
+        def data = body[Constants::DATA]
+        def error? = type.anybits?(Constants::TYPE_ERROR)
+        def push? = type == Constants::CHUNK
+        def event? = type == Constants::EVENT
+        def event_key = body[Constants::EVENT_KEY]
+        def event_data = body[Constants::EVENT_DATA]
+        def error_code = type & ~Constants::TYPE_ERROR
+        def error_message = body[Constants::ERROR_24]
+
+        def error_stack
+          body.fetch(Constants::ERROR, {}).fetch(Constants::ERROR_STACK, []).map do |entry|
+            entry.transform_keys(Constants::ERROR_FIELDS)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/schema.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    # Space and index name -> id lookup and space formats loaded from the _vspace and _vindex system views over one
+    # connection. Its ids are valid only for the instance behind that connection.
+    # @api private
+    class Schema
+      attr_reader :version, :connection
+
+      def self.fetch(connection, timeout:)
+        deadline = Transport::Deadline.after(timeout)
+        spaces, indexes = [Protocol::Constants::VSPACE_ID, Protocol::Constants::VINDEX_ID].map do |space_id|
+          connection.perform(select_all(space_id), timeout: Transport::Deadline.remaining(deadline))
+        end
+
+        new(version: spaces.schema_version, spaces: spaces.data, indexes: indexes.data, connection:)
+      end
+
+      def self.select_all(space_id)
+        Protocol::Requests::Select.new(
+          space_id:, index_id: 0, key: [], limit: Protocol::Constants::MAX_LIMIT, offset: 0, iterator: :all
+        )
+      end
+      private_class_method :select_all
+
+      def initialize(version:, spaces:, indexes:, connection: nil)
+        @version = version
+        @connection = connection
+        @space_ids = spaces.to_h { |space| [space[2], space[0]] }
+        @index_ids = indexes.to_h { |index| [[index[0], index[2]], index[1]] }
+        @space_infos = build_space_infos(spaces, indexes)
+      end
+
+      def resolve(space, index)
+        space_id = space_id(space)
+
+        [space_id, index_id(space_id, index)]
+      end
+
+      def space_info(space)
+        @space_infos.fetch(space_id(space)) { raise SchemaError, "space '#{space}' not found" }
+      end
+
+      private
+
+      def build_space_infos(spaces, indexes)
+        indexes_by_space = indexes.group_by(&:first)
+        infos = spaces.map { |space| SpaceInfo.from_tuples(space, indexes_by_space.fetch(space.first, [])) }
+
+        infos.to_h { |info| [info.id, info] }
+      end
+
+      def space_id(space)
+        return space if space.is_a?(Integer)
+
+        @space_ids.fetch(space.to_s) { raise SchemaError, "space '#{space}' not found" }
+      end
+
+      def index_id(space_id, index)
+        return index if index.is_a?(Integer)
+
+        @index_ids.fetch([space_id, index.to_s]) do
+          raise SchemaError, "index '#{index}' not found in space #{space_id}"
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/client/schema_cache.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Tarantool
+  class Client
+    # Latest known schema, installed by #replace for each new connection. Concurrent reloads of the same
+    # stale schema collapse into one fetch.
+    # @api private
+    class SchemaCache
+      attr_reader :schema
+
+      def initialize
+        @lock = Transport::TimedLock.new
+        @assign = Mutex.new
+      end
+
+      # Fetches over the stale schema's own connection. A reconnect may replace the schema meanwhile, and
+      # its schema wins: the fetched one is kept only while the stale one is still current.
+      def reload(stale, timeout:)
+        deadline = Transport::Deadline.after(timeout)
+
+        @lock.synchronize(deadline) do
+          return @schema unless @schema.equal?(stale)
+
+          fresh = Schema.fetch(stale.connection, timeout: Transport::Deadline.remaining(deadline))
+          @assign.synchronize { @schema = fresh if @schema.equal?(stale) }
+          @schema
+        end
+      end
+
+      # Skips the TimedLock: a reload holding it may hang on a lost connection until its timeout, and a new
+      # connection's schema must not wait for that.
+      def replace(schema)
+        @assign.synchronize { @schema = schema }
+      end
+
+      # An unknown name may have been created after the last load, so it costs one reload.
+      def resolve(space, index, deadline, schema = @schema)
+        with_reload(schema, deadline) { |current| [current, current.resolve(space, index)] }
+      end
+
+      def space_info(space, deadline)
+        with_reload(@schema, deadline) { |current| current.space_info(space) }
+      end
+
+      private
+
+      def with_reload(schema, deadline)
+        yield schema
+      rescue SchemaError
+        yield reload(schema, timeout: Transport::Deadline.remaining(deadline))
+      end
+    end
+  end
+end