arf 0.1.0

data/lib/arf/rpc/base_message.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Arf
+  module RPC
+    class BaseMessage
+      def self.register(kind, cls)
+        @messages ||= {}
+        @messages[kind] = cls
+      end
+
+      def self.message_by_kind(kind)
+        @messages ||= {}
+        @messages[kind]
+      end
+
+      def self.initialize_from(data)
+        type = MESSAGE_KIND_FROM_BYTE[data.readbyte] || :invalid
+        raise "Cannot decode invalid message" if type == :invalid
+
+        instance = message_by_kind(type).new
+        instance.decode(data)
+        instance
+      end
+
+      def self.encode(message)
+        IO::Buffer.new
+          .write(MESSAGE_KIND_FROM_SYMBOL[message.kind])
+          .write_raw(message.encode)
+          .string
+      end
+
+      def self.has_status
+        define_method(:status=) do |val|
+          case val
+          when Symbol
+            @status = Status::FROM_SYMBOL[val]
+            raise ArgumentError, "Invalid value #{val.inspect} for status: Unknown status" unless @status
+          when Integer
+            if Status::TO_SYMBOL[val].nil?
+              raise ArgumentError, "Invalid value #{val.inspect} for status: Unknown status"
+            end
+
+            @status = val
+          else
+            raise ArgumentError, "Invalid value #{val.inspect} for status: Expected symbol or integer"
+          end
+        end
+
+        define_method(:status) do
+          return nil if @status.nil?
+
+          Status::TO_SYMBOL[@status] || :unknown
+        end
+      end
+
+      def self.has_metadata
+        attr_reader :metadata
+
+        define_method(:metadata=) do |val|
+          case val
+          when NilClass
+            @metadata = Metadata.new
+          when Metadata
+            @metadata = val
+          when Hash
+            @metadata = Metadata.new(**val)
+          else
+            raise ArgumentError, "Invalid value #{val.inspect} for metadata: Expected nil, Arf::RPC::Metadata, or Hash"
+          end
+        end
+      end
+
+      def self.has_streaming
+        attr_accessor :streaming
+
+        define_method(:streaming?) { @streaming }
+      end
+
+      def self.kind(kind = nil)
+        return @kind if kind.nil?
+
+        @kind = kind
+        define_method(:kind) { self.class.kind }
+        BaseMessage.register(kind, self)
+        kind
+      end
+
+      def initialize(**kwargs)
+        kwargs.each { |k, v| send("#{k}=", v) }
+        @params ||= [] if respond_to? :params=
+        @streaming ||= false if respond_to? :streaming=
+        @metadata ||= Metadata.new if respond_to? :metadata=
+      end
+
+      def encode = ""
+
+      def decode(_data) = nil
+
+      def decode_string(data)
+        type, header = Proto.read_type(data)
+        raise "Invalid message payload" if type != Proto::TYPE_STRING
+
+        Proto.decode_string(header, data)
+      end
+
+      def decode_bytes(data)
+        type, header = Proto.read_type(data)
+        raise "Invalid message payload" if type != Proto::TYPE_BYTES
+
+        Proto.decode_bytes(header, data)
+      end
+
+      def decode_uint16(data) = Wire.decode_uint16(data)
+      def encode_uint16(value) = Wire.encode_uint16(value)
+      def encode_string(str) = Proto.encode_string(str)
+      def encode_bytes(data) = Proto.encode_bytes(data)
+    end
+  end
+end

data/lib/arf/rpc/client_base.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Arf
+  module RPC
+    class ClientBase
+      include Arf::Types::Mixin
+
+      def self.arf_service_id(id)
+        @arf_service_id = id
+      end
+
+      def self.rpc(name, inputs: nil, outputs: nil)
+        @rpc_metadata ||= {}
+        inputs ||= {}
+        outputs = [outputs].compact unless outputs.is_a? Array
+
+        @rpc_metadata[name] = {
+          name:, inputs: inputs.dup, outputs: outputs.dup
+        }
+
+        inputs = inputs.to_a
+          .map do |type|
+            if type.last.is_a? InputStream
+              outputs << type.last
+              next nil
+            end
+            type
+          end
+          .compact.to_h
+
+        if outputs.length > 1 && outputs[-2].is_a?(Streamer) && outputs[-1].is_a?(Streamer)
+          input = outputs.find { _1.is_a? InputStream }
+          output = outputs.find { _1.is_a? OutputStream }
+
+          outputs = outputs[...-2]
+          outputs << InOutStream[input.type, output.type]
+        end
+
+        @rpc_metadata[name][:native_inputs] = inputs
+        @rpc_metadata[name][:native_outputs] = outputs
+
+        internal_name = "_#{name}"
+        service_name = @arf_service_id
+
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          # def name(param, param, param, **metadata, &block)
+          #   internal_name(params, param, param, **metadata, &block)
+          # end
+          def #{name}(#{inputs.keys.join(", ")}#{inputs.length.positive? ? ", " : ""}**metadata, &block)
+            #{internal_name}(#{inputs.keys.join(", ")}#{inputs.length.positive? ? ", " : ""}**metadata, &block)
+          end
+        RUBY
+
+        define_method(internal_name) do |*args, **metadata, &block|
+          _invoke_method(service_name, name, inputs.values, outputs, args, metadata, &block)
+        end
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      def _invoke_method(service_id, method_name, inputs, outputs, args, meta)
+        mapped_args = args.map.with_index do |v, idx|
+          raw_type = case (t = inputs[idx])
+                     when Symbol then t
+                     when String then self.class.find_type(t)
+                     else
+                       raise ArgumentError, "Unknown type definition #{v.inspect}"
+                     end
+
+          Arf::Types.coerce_value(v, raw_type)
+        end
+
+        # Obtain a stream from @client
+        str = @client.new_stream
+
+        # Push the request
+        streaming = outputs.any? { _1.is_a?(InputStream) || _1.is_a?(InOutStream) }
+        req = Request.new(
+          streaming:,
+          metadata: meta,
+          service: service_id,
+          method: method_name,
+          params: mapped_args
+        )
+
+        input_type = nil
+        output_type = nil
+
+        streamer = outputs.last
+        case streamer
+        when InputStream
+          input_type = streamer.resolved_type(self.class)
+        when OutputStream
+          output_type = streamer.resolved_type(self.class)
+        when InOutStream
+          input_type = streamer.resolved_input(self.class)
+          output_type = streamer.resolved_output(self.class)
+        end
+
+        resp = Responder.new(str, input_type, output_type)
+
+        str.write_data(BaseMessage.encode(req), end_stream: !streaming)
+
+        resp
+      end
+    end
+  end
+end

data/lib/arf/rpc/end_stream.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Arf
+  module RPC
+    class EndStream < BaseMessage
+      kind :end_stream
+    end
+  end
+end

data/lib/arf/rpc/enum.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Arf
+  module RPC
+    class Enum
+      def self.option(**kwargs)
+        @options ||= {}
+        kwargs.each { |k, v| @options[k.to_sym] = v }
+      end
+
+      def self.option_by_name(name)
+        @options ||= {}
+        @options[name.to_sym]
+      end
+
+      def self.option_by_value(value)
+        @options ||= {}
+        @options.find { _2 == value }&.first
+      end
+
+      class << self
+        attr_reader :options
+      end
+
+      def self.to_i(value)
+        case value
+        when Symbol, String
+          option_by_name(value) or raise(ArgumentError, "Invalid value #{value.inspect} for #{self}")
+        when Integer
+          option_by_value(value) or raise(ArgumentError, "Invalid value #{value.inspect} for #{self}")
+          value
+        else
+          raise ArgumentError, "Invalid value type #{value.class}. Expected Symbol, String or Integer."
+        end
+      end
+
+      def self.to_sym(value)
+        case value
+        when Symbol, String
+          value = value.to_sym
+          option_by_name(value) or raise(ArgumentError, "Invalid value #{value.inspect} for #{self}")
+          value
+        when Integer
+          option_by_value(value) or raise(ArgumentError, "Invalid value #{value.inspect} for #{self}")
+        else
+          raise ArgumentError, "Invalid value type #{value.class}. Expected Symbol, String or Integer."
+        end
+      end
+    end
+  end
+end

data/lib/arf/rpc/message_kind.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Arf
+  module RPC
+    MESSAGE_KIND_INVALID         = 0x00
+    MESSAGE_KIND_REQUEST         = 0x01
+    MESSAGE_KIND_RESPONSE        = 0x02
+    MESSAGE_KIND_START_STREAM    = 0x03
+    MESSAGE_KIND_STREAM_ITEM     = 0x04
+    MESSAGE_KIND_STREAM_METADATA = 0x05
+    MESSAGE_KIND_END_STREAM      = 0x06
+    MESSAGE_KIND_STREAM_ERROR    = 0x07
+
+    MESSAGE_KIND_FROM_BYTE = {
+      MESSAGE_KIND_INVALID => :invalid,
+      MESSAGE_KIND_REQUEST => :request,
+      MESSAGE_KIND_RESPONSE => :response,
+      MESSAGE_KIND_START_STREAM => :start_stream,
+      MESSAGE_KIND_STREAM_ITEM => :stream_item,
+      MESSAGE_KIND_STREAM_METADATA => :stream_metadata,
+      MESSAGE_KIND_END_STREAM => :end_stream,
+      MESSAGE_KIND_STREAM_ERROR => :stream_error
+    }.freeze
+
+    MESSAGE_KIND_FROM_SYMBOL = MESSAGE_KIND_FROM_BYTE.to_a.to_h(&:reverse)
+  end
+end

data/lib/arf/rpc/metadata.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Arf
+  module RPC
+    class Metadata < BaseMessage
+      def initialize(**kwargs)
+        super()
+        @pairs = {}
+        @dirty = false
+        @observer = Observer.new
+        kwargs.each { |k, v| set(k, v) }
+      end
+
+      def attach_observer(obs)
+        @observer.attach_handler(obs)
+      end
+
+      def add(k, v) = @observer.modify { _add(k, v) }
+
+      def [](k) = @pairs[k]
+      def get(k) = @pairs[k]&.first
+
+      def []=(k, v)
+        @observer.modify { _add(k, v) }
+      end
+
+      def set(k, v)
+        v = [v] unless v.is_a? Array
+        @observer.modify do
+          @pairs[k] = []
+          v.each { _add(k, _1) }
+        end
+      end
+
+      def merge!(other)
+        @observer.modify do
+          other.each do |k, v|
+            @pairs[k] ||= []
+            @pairs[k].append(*v)
+          end
+          @dirty = true
+        end
+        self
+      end
+
+      def replace!(other)
+        @observer.modify do
+          @pairs = {}
+          other.each do |k, v|
+            @pairs[k] ||= []
+            @pairs[k].append(*v)
+          end
+          @dirty = true
+        end
+        self
+      end
+
+      def key?(k) = @pairs.key?(k.to_s)
+      alias has_key? key?
+
+      def each(&block) = tap { @pairs.each(&block) }
+      alias each_pair each
+
+      def keys = @pairs.keys
+      def each_key(&block) = tap { @pairs.keys(&block) }
+
+      def dirty? = @dirty
+
+      def encode
+        pairs = []
+        @pairs.each do |k, v|
+          v.each { pairs << [k, _1] }
+        end
+        keys = IO::Buffer.new
+        values = IO::Buffer.new
+        pairs.each do |p|
+          keys.write_raw(encode_string(p.first))
+          values.write_raw(encode_bytes(p.last))
+        end
+
+        @dirty = false
+        IO::Buffer.new
+          .write_raw(encode_uint16(pairs.length))
+          .write_raw(keys.string)
+          .write_raw(values.string)
+          .string
+      end
+
+      def decode(data)
+        len = decode_uint16(data)
+        keys = []
+        values = []
+
+        len.times { keys << decode_string(data) }
+        len.times { values << decode_bytes(data) }
+
+        @pairs = {}
+        keys.zip(values).each { |pair| _add(*pair) }
+        @dirty = false
+
+        self
+      end
+
+      private
+
+      def _add(k, v)
+        k = k.to_s
+        v = case v
+            when String then v
+            when StringIO then v.string
+            else v.to_s
+            end
+
+        @pairs[k] ||= []
+        @pairs[k] << v
+        @dirty = true
+      end
+    end
+  end
+end

data/lib/arf/rpc/method_meta.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Arf
+  module RPC
+    class MethodMeta
+      Streamer = Arf::Types::Streamer
+      InOutStream = Arf::Types::InOutStream
+
+      ANY_STREAMER = ->(v) { v.is_a?(Streamer) || v.is_a?(InOutStream) }
+      NOT_STREAMER = ->(v) { !v.is_a?(Streamer) && !v.is_a?(InOutStream) }
+
+      def initialize(inputs, outputs)
+        @inputs = inputs || {}
+        @outputs = outputs || []
+      end
+
+      def output_stream = @outputs.find(&ANY_STREAMER)
+      def input_stream = @inputs.values.find(&ANY_STREAMER)
+      def output_stream? = !output_stream.nil?
+      def input_stream? = !input_stream.nil?
+      def output? = @outputs.any?(&NOT_STREAMER)
+      def inputs? = @inputs.values.any?(&NOT_STREAMER)
+      def output_types = @outputs.filter(&NOT_STREAMER)
+
+      def coerce_result(value, resolver)
+        return [] if value.nil?
+
+        [value].flatten.map.with_index do |v, idx|
+          expected_type = output_types[idx]
+          case expected_type
+          when String
+            Arf::Types.coerce_value(v, resolver.find_type(expected_type))
+          when Arf::Types::BaseType
+            expected_type.coerce(v)
+          else
+            Arf::Types.coerce_value(v, expected_type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arf/rpc/request.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Arf
+  module RPC
+    class Request < BaseMessage
+      kind :request
+      has_streaming
+      has_metadata
+      attr_accessor :service, :method, :params
+
+      def encode
+        flags = 0x00
+        flags |= (0x01 << 0x00) if streaming?
+
+        params = @params.map { Proto.encode(_1) }
+
+        IO::Buffer.new
+          .write_raw(encode_string(@service))
+          .write_raw(encode_string(@method))
+          .write(flags)
+          .write_raw(@metadata.encode)
+          .write_raw(encode_uint16(params.length))
+          .write_raw(params.join)
+          .string
+      end
+
+      def decode(data)
+        @service = decode_string(data)
+        @method = decode_string(data)
+        flags = data.readbyte
+        @streaming = !flags.nobits?((0x01 << 0x00))
+        @metadata = Metadata.new.decode(data)
+        params_len = decode_uint16(data)
+        @params = []
+        params_len.times { @params << Proto.decode(data) }
+      end
+    end
+  end
+end

data/lib/arf/rpc/responder.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Arf
+  module RPC
+    class Responder
+      def initialize(str, input_stream_type, output_stream_type)
+        @metadata = Metadata.new
+        @stream = str
+
+        @response = nil
+        @response_error = nil
+        @response_lock = Mutex.new
+        @response_cond = Thread::ConditionVariable.new
+
+        @input_stream_type = output_stream_type
+        @has_input_stream = !output_stream_type.nil?
+        @input_stream_started = false
+        @input_stream_error = nil
+        @input_stream_completed = false
+        @input_stream_items = Queue.new
+        @input_stream_closed_lock = Mutex.new
+        @input_stream_closed = false
+
+        @output_stream_type = input_stream_type
+        @has_output_stream = !input_stream_type.nil?
+        @output_stream_started_lock = Mutex.new
+        @output_stream_started = false
+        @output_stream_error = nil
+        @output_stream_closed_lock = Mutex.new
+        @output_stream_closed = false
+
+        str.attach_handler(self)
+      end
+
+      def handle_data(value)
+        msg = BaseMessage.initialize_from(value)
+        case msg
+        when Response
+          @response_lock.synchronize do
+            @response = msg
+            @metadata.merge!(msg.metadata)
+            if @response.status == :ok
+              @params = msg.params
+            else
+              @response_error = Status::BadStatus.new(
+                @response.status,
+                @response.metadata.get("arf-status-description")
+              )
+            end
+            @response_cond.broadcast
+          end
+
+        when StartStream
+          @input_stream_started = true
+
+        when EndStream
+          @input_stream_completed = true
+          @input_stream_items.close
+
+        when StreamMetadata
+          @metadata.replace!(msg.metadata)
+
+        when StreamItem
+          return if @input_stream_completed
+
+          @input_stream_closed_lock.synchronize do
+            return if @input_stream_closed
+          end
+          @input_stream_items << msg.value
+        end
+      end
+
+      def push(value, **kwargs)
+        raise ArgumentError, "#push receives either a value or kwargs, not both." if value && !kwargs.empty?
+
+        raise RPC::NoStreamError, false unless @has_output_stream
+        raise @output_stream_error if @output_stream_error
+
+        # TODO: Warn? Error?
+        return if @output_stream_closed
+
+        @output_stream_closed_lock.synchronize do
+          return if @output_stream_closed
+        end
+
+        @output_stream_started_lock.synchronize do
+          next if @output_stream_started
+
+          @stream.write_data(BaseMessage.encode(StartStream.new))
+          @output_stream_started = true
+        end
+
+        @stream.write_data(BaseMessage.encode(StreamItem.new(value:)))
+        value
+      end
+
+      alias << push
+
+      def recv
+        raise RPC::NoStreamError, true unless @has_input_stream
+        raise @input_stream_error if @input_stream_error
+
+        @input_stream_items.pop
+      end
+
+      def each
+        loop do
+          item = recv
+          break if item.nil?
+
+          yield item
+        rescue StopIteration
+          break
+        end
+        self
+      end
+
+      def close_send
+        return if @output_stream_closed
+
+        @output_stream_closed_lock.synchronize do
+          @output_stream_closed = true
+          @stream.write_data(BaseMessage.encode(EndStream.new))
+        end
+      end
+
+      def close_recv
+        return if @input_stream_closed
+
+        @input_stream_closed_lock.synchronize do
+          @input_stream_closed = true
+          @input_stream_items.close
+        end
+      end
+
+      def _wait_response(throw_error: true)
+        raise @response_error if @response_error && throw_error
+
+        return if @response
+
+        catch :break_loop do
+          loop do
+            @response_lock.synchronize do
+              @response_cond.wait(@response_lock)
+              next if @response.nil?
+
+              throw :break_loop
+            end
+          end
+        end
+      end
+
+      def params
+        _wait_response
+        normalize_response_params
+      end
+
+      def normalize_response_params
+        if @response.params.empty?
+          nil
+        elsif @response.params.length == 1
+          @response.params.first
+        else
+          @response.params
+        end
+      end
+
+      def metadata
+        # It makes little sense to access metadata before a response is
+        # received. Given that:
+        _wait_response
+
+        @metadata
+      end
+
+      def status
+        _wait_response(throw_error: false)
+        @response.status
+      end
+
+      def success?
+        status == :ok
+      end
+    end
+  end
+end