grpc-dc 0.37.1

data/lib/grpcdc/dynamic.rb

@@ -0,0 +1,677 @@
+# @generated by grpc-dc codegen. DO NOT EDIT.
+# SPDX-License-Identifier: Apache-2.0
+# Dynamic, descriptor-driven client and server.
+#
+# Parses a FileDescriptorSet (as produced by
+# `protoc --descriptor_set_out`) at runtime and builds clients
+# and servers whose messages are generic field maps — no
+# generated stubs required. This is the runtime-generation
+# counterpart of the protoc-plugin surfaces: schemas arrive as
+# data (descriptor.proto), not as code.
+#
+# Generic values by field type: varint family -> Integer,
+# string -> String, bytes/message -> String / GenericMessage,
+# fixed/float -> Integer / Float, bool -> true/false. Repeated
+# fields are arrays in field-number order.
+
+require_relative "codec"
+require_relative "server"
+require_relative "wire_gen"
+
+module Grpcdc
+  # FieldDescriptorProto.Type values (descriptor.proto).
+  TYPE_DOUBLE = 1
+  TYPE_FLOAT = 2
+  TYPE_INT64 = 3
+  TYPE_UINT64 = 4
+  TYPE_INT32 = 5
+  TYPE_FIXED64 = 6
+  TYPE_FIXED32 = 7
+  TYPE_BOOL = 8
+  TYPE_STRING = 9
+  TYPE_GROUP = 10
+  TYPE_MESSAGE = 11
+  TYPE_BYTES = 12
+  TYPE_UINT32 = 13
+  TYPE_ENUM = 14
+  TYPE_SFIXED32 = 15
+  TYPE_SFIXED64 = 16
+  TYPE_SINT32 = 17
+  TYPE_SINT64 = 18
+
+  VARINT_TYPES = [TYPE_INT64, TYPE_UINT64, TYPE_INT32, TYPE_BOOL,
+                  TYPE_UINT32, TYPE_ENUM, TYPE_SINT32, TYPE_SINT64].freeze
+  LEN_TYPES = [TYPE_STRING, TYPE_BYTES, TYPE_MESSAGE, TYPE_GROUP].freeze
+
+  WIRE_TYPE = {}.tap do |table|
+    VARINT_TYPES.each { |t| table[t] = 0 }
+    [TYPE_FIXED64, TYPE_SFIXED64, TYPE_DOUBLE].each { |t| table[t] = 1 }
+    LEN_TYPES.each { |t| table[t] = 2 }
+    [TYPE_FIXED32, TYPE_SFIXED32, TYPE_FLOAT].each { |t| table[t] = 5 }
+  end.freeze
+
+  LABEL_REPEATED = 3
+
+  # Minimal protobuf reader over a binary String.
+  class PbReader
+    attr_reader :last_chunk
+
+    def initialize(data)
+      @buf = data.b
+      @pos = 0
+      @last_chunk = nil
+    end
+
+    def varint
+      result = 0
+      shift = 0
+      loop do
+        raise ArgumentError, "truncated varint" if @pos >= @buf.bytesize
+
+        b = @buf.getbyte(@pos)
+        @pos += 1
+        result |= (b & 0x7F) << shift
+        return result if (b & 0x80).zero?
+
+        shift += 7
+        raise ArgumentError, "varint too long" if shift >= 70
+      end
+    end
+
+    def bytes_field
+      n = varint
+      raise ArgumentError, "truncated bytes field" if @pos + n > @buf.bytesize
+
+      out = @buf.byteslice(@pos, n)
+      @pos += n
+      out
+    end
+
+    # Yield [number, wire_type, value] until end of buffer.
+    # Sets last_chunk to the raw bytes of the yielded field
+    # (captured before the yield, so consumers may read it while
+    # processing this field).
+    def each_field
+      return enum_for(:each_field) unless block_given?
+
+      while @pos < @buf.bytesize
+        start = @pos
+        tag = varint
+        number = tag >> 3
+        wire = tag & 7
+        value =
+          case wire
+          when 0 then varint
+          when 2 then bytes_field
+          when 1
+            raise ArgumentError, "truncated fixed64" if @pos + 8 > @buf.bytesize
+
+            v = @buf.byteslice(@pos, 8)
+            @pos += 8
+            v
+          when 5
+            raise ArgumentError, "truncated fixed32" if @pos + 4 > @buf.bytesize
+
+            v = @buf.byteslice(@pos, 4)
+            @pos += 4
+            v
+          else
+            raise ArgumentError, "unsupported wire type #{wire}"
+          end
+        @last_chunk = @buf.byteslice(start...@pos)
+        yield number, wire, value
+      end
+    end
+  end
+
+  class FieldModel
+    attr_reader :number, :name, :type, :type_name
+
+    def initialize(number, name, field_type, label, type_name)
+      @number = number
+      @name = name
+      @type = field_type
+      @repeated = label == LABEL_REPEATED
+      @type_name = type_name # for TYPE_MESSAGE, e.g. ".echo.EchoRequest"
+    end
+
+    def repeated?
+      @repeated
+    end
+  end
+
+  class MessageModel
+    attr_reader :full_name, :fields, :by_name
+
+    def initialize(full_name, fields)
+      @full_name = full_name
+      @fields = fields # number -> FieldModel
+      @by_name = {}
+      fields.each_value { |f| @by_name[f.name] = f }
+    end
+
+    def refresh_by_name
+      @by_name = {}
+      @fields.each_value { |f| @by_name[f.name] = f }
+    end
+  end
+
+  class MethodModel
+    attr_reader :name, :path, :kind, :input, :output
+
+    def initialize(name, path, kind, input_model, output_model)
+      @name = name
+      @path = path
+      @kind = kind
+      @input = input_model
+      @output = output_model
+    end
+  end
+
+  class ServiceModel
+    attr_reader :full_name, :methods
+
+    def initialize(full_name, methods)
+      @full_name = full_name
+      @methods = methods # name -> MethodModel
+    end
+  end
+
+  # Parsed descriptor set: messages and services by full name.
+  class FileModel
+    attr_reader :messages, :services
+
+    def initialize
+      @messages = {} # ".echo.EchoRequest" -> MessageModel
+      @services = {} # "echo.Echo" -> ServiceModel
+    end
+
+    def message(full_name)
+      @messages.fetch(full_name)
+    end
+
+    def service(full_name)
+      @services.fetch(full_name)
+    end
+  end
+
+  # A message as field number -> list of values (descriptor order).
+  #
+  # Fields not in the model are retained as raw encoded chunks in
+  # `unknown` (protobuf unknown-field retention): a decode ->
+  # encode round trip re-emits them after the known fields, so
+  # intermediate hops do not strip newer fields.
+  class GenericMessage
+    attr_accessor :model
+    attr_reader :values, :unknown
+
+    def initialize(model = nil)
+      @model = model
+      @values = {}
+      @unknown = []
+    end
+
+    def set(number, value)
+      @values[number] = [value]
+      self
+    end
+
+    def add(number, value)
+      (@values[number] ||= []) << value
+      self
+    end
+
+    def get_all(number)
+      (@values[number] || []).dup
+    end
+
+    def get(number, default = nil)
+      items = @values[number]
+      items && !items.empty? ? items[0] : default
+    end
+
+    def get_string(number, default = "")
+      value = get(number)
+      value.is_a?(String) ? value : default
+    end
+
+    def get_int(number, default = 0)
+      value = get(number)
+      value.is_a?(Integer) ? value : default
+    end
+
+    def ==(other)
+      other.is_a?(GenericMessage) && @values == other.values
+    end
+
+    def inspect
+      "GenericMessage(#{@values.inspect})"
+    end
+  end
+
+  class << self
+    def encode_varint(value)
+      out = String.new(encoding: Encoding::BINARY)
+      v = value & 0xFFFFFFFFFFFFFFFF
+      while v > 0x7F
+        out << ((v & 0x7F) | 0x80)
+        v >>= 7
+      end
+      out << v
+      out
+    end
+
+    def encode_generic(model, message, file_model)
+      out = String.new(encoding: Encoding::BINARY)
+      message.values.keys.sort.each do |number|
+        field = model.fields[number]
+        if field.nil?
+          raise StatusError.new(CODE_INVALID_ARGUMENT, "unknown field #{number} for #{model.full_name}")
+        end
+
+        values = message.values[number]
+        if field.repeated?
+          values.each { |value| out << encode_value(field, value, file_model) }
+        elsif !values.empty?
+          out << encode_value(field, values[0], file_model)
+        end
+      end
+      (message.unknown || []).each { |chunk| out << chunk }
+      out
+    end
+
+    def decode_generic(model, data, file_model)
+      message = GenericMessage.new(model)
+      reader = PbReader.new(data)
+      reader.each_field do |number, wire, raw|
+        field = model.fields[number]
+        if field.nil?
+          # Unknown field: retain the raw encoded chunk verbatim.
+          message.unknown << reader.last_chunk
+          next
+        end
+        (message.values[number] ||= []) << decode_value(field, wire, raw, file_model)
+      end
+      message
+    end
+
+    # Parse FileDescriptorSet bytes into a FileModel.
+    def parse_descriptor_set(data)
+      file_model = FileModel.new
+      pending_services = []
+      PbReader.new(data).each_field do |number, _wire, file_bytes|
+        next unless number == 1
+
+        package = ""
+        service_types = []
+        fields_of_file = PbReader.new(file_bytes).each_field.to_a
+        fields_of_file.each do |fnum, _w, fval|
+          package = fval.dup.force_encoding(Encoding::UTF_8) if fnum == 2
+        end
+        fields_of_file.each do |fnum, _w, fval|
+          case fnum
+          when 4 then parse_message(package, fval, file_model)
+          when 6 then service_types << [package, fval]
+          end
+        end
+        pending_services.concat(service_types)
+      end
+      pending_services.each { |package, bytes| parse_service(package, bytes, file_model) }
+      file_model
+    end
+
+    # Register a runtime-built service on a Grpcdc::Server.
+    #
+    # handler is an object with methods by kind:
+    #   unary(ctx, method, request) -> GenericMessage
+    #   server_stream(ctx, method, request, send) -> nil
+    #   client_stream(ctx, method, request_enum) -> GenericMessage
+    #   bidi(ctx, method, request_enum, send) -> nil
+    # where send is a callable taking a GenericMessage and
+    # request_enum yields GenericMessages until half-close.
+    def register_dynamic_service(server, file_model, service_name, handler)
+      service = file_model.services.fetch(service_name)
+      methods = service.methods.values.map do |method|
+        Method.new(method.name, method.path, method.kind, make_handler(handler, method, file_model))
+      end
+      server.register_service(ServiceDesc.new(service.full_name, methods))
+    end
+
+    private
+
+    def to_signed(value, bits)
+      value &= (1 << bits) - 1
+      value >= (1 << (bits - 1)) ? value - (1 << bits) : value
+    end
+
+    def zigzag_decode(value)
+      (value >> 1) ^ -(value & 1)
+    end
+
+    def zigzag_encode(value)
+      ((value << 1) ^ (value >> 63)) & 0xFFFFFFFFFFFFFFFF
+    end
+
+    def encode_value(field, value, file_model)
+      wire = WIRE_TYPE.fetch(field.type)
+      out = encode_varint((field.number << 3) | wire)
+      case wire
+      when 0
+        if [TYPE_SINT32, TYPE_SINT64].include?(field.type)
+          bits = field.type == TYPE_SINT32 ? 32 : 64
+          out << encode_varint(zigzag_encode(value) & ((1 << bits) - 1))
+        elsif field.type == TYPE_BOOL
+          out << encode_varint(value ? 1 : 0)
+        else
+          out << encode_varint(value & 0xFFFFFFFFFFFFFFFF)
+        end
+      when 1
+        out << if field.type == TYPE_DOUBLE
+                 [value].pack("E")
+               elsif field.type == TYPE_SFIXED64
+                 [value].pack("q<")
+               else
+                 [value & 0xFFFFFFFFFFFFFFFF].pack("Q<")
+               end
+      when 5
+        out << if field.type == TYPE_FLOAT
+                 [value].pack("e")
+               elsif field.type == TYPE_SFIXED32
+                 [value].pack("l<")
+               else
+                 [value & 0xFFFFFFFF].pack("V")
+               end
+      else
+        data =
+          case field.type
+          when TYPE_STRING then value.encode(Encoding::UTF_8).b
+          when TYPE_MESSAGE then encode_generic(file_model.messages.fetch(field.type_name), value, file_model)
+          else value.b
+          end
+        out << encode_varint(data.bytesize)
+        out << data
+      end
+      out
+    end
+
+    def decode_value(field, wire, raw, file_model)
+      case wire
+      when 0
+        case field.type
+        when TYPE_BOOL then raw != 0
+        when TYPE_SINT32, TYPE_SINT64 then zigzag_decode(raw)
+        when TYPE_INT32, TYPE_ENUM then to_signed(raw, 32)
+        when TYPE_INT64 then to_signed(raw, 64)
+        else raw
+        end
+      when 1
+        case field.type
+        when TYPE_DOUBLE then raw.unpack1("E")
+        when TYPE_SFIXED64 then raw.unpack1("q<")
+        else raw.unpack1("Q<")
+        end
+      when 5
+        case field.type
+        when TYPE_FLOAT then raw.unpack1("e")
+        when TYPE_SFIXED32 then raw.unpack1("l<")
+        else raw.unpack1("V")
+        end
+      else
+        # length-delimited
+        case field.type
+        when TYPE_STRING then raw.dup.force_encoding(Encoding::UTF_8)
+        when TYPE_MESSAGE then decode_generic(file_model.messages.fetch(field.type_name), raw, file_model)
+        else raw.b
+        end
+      end
+    end
+
+    def parse_message(package, data, file_model)
+      name = ""
+      raw_fields = []
+      nested = []
+      PbReader.new(data).each_field do |fnum, _w, fval|
+        case fnum
+        when 1 then name = fval.dup.force_encoding(Encoding::UTF_8)
+        when 2 then raw_fields << fval
+        when 3 then nested << fval
+        end
+      end
+      full_name = package.empty? ? name : "#{package}.#{name}"
+      fields = {}
+      model = MessageModel.new(full_name, fields)
+      file_model.messages["." + full_name] = model
+      nested.each { |bytes| parse_nested(package, name, bytes, file_model) }
+      raw_fields.each do |field_bytes|
+        field = parse_field(field_bytes)
+        fields[field.number] = field
+      end
+      model.refresh_by_name
+      model
+    end
+
+    def parse_nested(package, outer, data, file_model)
+      name = ""
+      raw_fields = []
+      PbReader.new(data).each_field do |fnum, _w, fval|
+        case fnum
+        when 1 then name = fval.dup.force_encoding(Encoding::UTF_8)
+        when 2 then raw_fields << fval
+        end
+      end
+      full_name = package.empty? ? "#{outer}.#{name}" : "#{package}.#{outer}.#{name}"
+      fields = {}
+      model = MessageModel.new(full_name, fields)
+      file_model.messages["." + full_name] = model
+      raw_fields.each do |field_bytes|
+        field = parse_field(field_bytes)
+        fields[field.number] = field
+      end
+      model.refresh_by_name
+      model
+    end
+
+    def parse_field(data)
+      name = ""
+      number = 0
+      label = 1
+      field_type = 0
+      type_name = ""
+      PbReader.new(data).each_field do |fnum, _w, fval|
+        case fnum
+        when 1 then name = fval.dup.force_encoding(Encoding::UTF_8)
+        when 3 then number = fval
+        when 4 then label = fval
+        when 5 then field_type = fval
+        when 6 then type_name = fval.dup.force_encoding(Encoding::UTF_8)
+        end
+      end
+      FieldModel.new(number, name, field_type, label, type_name)
+    end
+
+    def kind_of(client_streaming, server_streaming)
+      if client_streaming && server_streaming
+        KIND_BIDI
+      elsif server_streaming
+        KIND_SERVER_STREAMING
+      elsif client_streaming
+        KIND_CLIENT_STREAMING
+      else
+        KIND_UNARY
+      end
+    end
+
+    def parse_service(package, data, file_model)
+      name = ""
+      raw_methods = []
+      PbReader.new(data).each_field do |fnum, _w, fval|
+        case fnum
+        when 1 then name = fval.dup.force_encoding(Encoding::UTF_8)
+        when 2 then raw_methods << fval
+        end
+      end
+      full_name = package.empty? ? name : "#{package}.#{name}"
+      methods = {}
+      raw_methods.each do |method_bytes|
+        mname = ""
+        input_type = ""
+        output_type = ""
+        client_streaming = false
+        server_streaming = false
+        PbReader.new(method_bytes).each_field do |fnum, _w, fval|
+          case fnum
+          when 1 then mname = fval.dup.force_encoding(Encoding::UTF_8)
+          when 2 then input_type = fval.dup.force_encoding(Encoding::UTF_8)
+          when 3 then output_type = fval.dup.force_encoding(Encoding::UTF_8)
+          when 5 then client_streaming = fval != 0
+          when 6 then server_streaming = fval != 0
+          end
+        end
+        methods[mname] = MethodModel.new(
+          mname, "/#{full_name}/#{mname}", kind_of(client_streaming, server_streaming),
+          file_model.messages.fetch(input_type), file_model.messages.fetch(output_type)
+        )
+      end
+      service = ServiceModel.new(full_name, methods)
+      file_model.services[full_name] = service
+      service
+    end
+
+    def make_handler(handler, method, file_model)
+      lambda do |ctx, reqs, sink|
+        send = lambda do |generic|
+          sink.send(encode_generic(method.output, generic, file_model))
+        end
+        request_enum = Enumerator.new do |yielder|
+          loop do
+            begin
+              payload = reqs.recv_raw
+            rescue EOFError
+              break
+            end
+            yielder << decode_generic(method.input, payload, file_model)
+          end
+        end
+        case method.kind
+        when KIND_UNARY
+          send.call(handler.unary(ctx, method, request_enum.next))
+        when KIND_SERVER_STREAMING
+          handler.server_stream(ctx, method, request_enum.next, send)
+        when KIND_CLIENT_STREAMING
+          send.call(handler.client_stream(ctx, method, request_enum))
+        else
+          handler.bidi(ctx, method, request_enum, send)
+        end
+      end
+    end
+  end
+
+  # Adapts a (MessageModel, GenericMessage) pair to the Channel
+  # marshal/unmarshal contract.
+  class BoundMessage
+    attr_reader :model, :file_model
+    attr_accessor :generic
+
+    def initialize(model, generic, file_model)
+      @model = model
+      @generic = generic || GenericMessage.new(model)
+      @file_model = file_model
+    end
+
+    def marshal_dc
+      Grpcdc.encode_generic(@model, @generic, @file_model)
+    end
+
+    def unmarshal_dc(data)
+      @generic = Grpcdc.decode_generic(@model, data, @file_model)
+      self
+    end
+  end
+
+  class DynamicRecvStream
+    include Enumerable
+
+    def initialize(stream, model, file_model)
+      @stream = stream
+      @model = model
+      @file_model = file_model
+    end
+
+    def recv
+      @stream.recv(BoundMessage.new(@model, nil, @file_model)).generic
+    end
+
+    # Abandon the call early: RST unless it already terminated.
+    def cancel
+      @stream.cancel
+    end
+
+    def close
+      @stream.cancel
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      begin
+        loop do
+          begin
+            yield recv
+          rescue EOFError
+            return
+          end
+        end
+      ensure
+        # Breaking out of the block abandons the call: RST so
+        # the server stops producing (no-op once terminated).
+        close
+      end
+    end
+  end
+
+  # Runtime-built client: methods resolve from the FileModel.
+  class DynamicClient
+    def initialize(channel, file_model)
+      @channel = channel
+      @model = file_model
+    end
+
+    def unary(service_name, method_name, request, metadata = nil, timeout: nil)
+      method = resolve(service_name, method_name)
+      resp = BoundMessage.new(method.output, nil, @model)
+      @channel.unary(method.path, BoundMessage.new(method.input, request, @model), resp, metadata, timeout: timeout)
+      resp.generic
+    end
+
+    def server_stream(service_name, method_name, request, metadata = nil, timeout: nil)
+      method = resolve(service_name, method_name)
+      stream = @channel.server_stream(
+        method.path, BoundMessage.new(method.input, request, @model), metadata, timeout: timeout
+      )
+      DynamicRecvStream.new(stream, method.output, @model)
+    end
+
+    def client_stream(service_name, method_name, requests, metadata = nil, timeout: nil)
+      method = resolve(service_name, method_name)
+      resp = BoundMessage.new(method.output, nil, @model)
+      @channel.client_stream(
+        method.path, requests.map { |r| BoundMessage.new(method.input, r, @model) }, resp, metadata, timeout: timeout
+      )
+      resp.generic
+    end
+
+    def bidi(service_name, method_name, requests, metadata = nil, timeout: nil)
+      method = resolve(service_name, method_name)
+      stream = @channel.bidi(
+        method.path, requests.map { |r| BoundMessage.new(method.input, r, @model) }, metadata, timeout: timeout
+      )
+      DynamicRecvStream.new(stream, method.output, @model)
+    end
+
+    private
+
+    def resolve(service_name, method_name)
+      @model.services.fetch(service_name).methods.fetch(method_name)
+    end
+  end
+end