arf 0.1.0

data/lib/arf/rpc/response.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Arf
+  module RPC
+    class Response < BaseMessage
+      kind :response
+      has_status
+      has_metadata
+      has_streaming
+      attr_accessor :params
+
+      def encode
+        flags = 0x00
+        flags |= (0x01 << 0x00) if streaming?
+
+        params = @params.map { Proto.encode(_1) }
+
+        IO::Buffer.new
+          .write_raw(encode_uint16(@status))
+          .write(flags)
+          .write_raw(@metadata.encode)
+          .write_raw(encode_uint16(params.length))
+          .write_raw(params.join)
+          .string
+      end
+
+      def ok? = status == :ok
+
+      def decode(data)
+        @status = decode_uint16(data)
+        flags = data.readbyte
+        @streaming = !flags.nobits?((0x01 << 0x00))
+        @metadata = Metadata.new.decode(data)
+        len = decode_uint16(data)
+        @params = []
+        len.times { @params << Proto.decode(data) }
+      end
+
+      def result
+        return @params if status == :ok
+
+        raise Status::BadStatus.new(@status, @metadata.get("arf-status-description"))
+      end
+    end
+  end
+end

data/lib/arf/rpc/service_base.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Arf
+  module RPC
+    class ServiceBase
+      include Arf::Types::Mixin
+
+      class YieldWithoutRespondError < Arf::Error
+        def initialize
+          super("This RPC method has response fields that must be sent before " \
+                "starting a stream. Please invoke #respond with the response " \
+                "parameters before yielding a value to the stream.")
+        end
+      end
+
+      class YieldWithoutStreamError < Arf::Error
+        def initialize
+          super("This RPC method does not have an output stream and cannot " \
+                "yield values.")
+        end
+      end
+
+      class YieldOnClosedStream < Arf::Error
+        def initialize
+          super("Cannot call yield after closing the output stream.")
+        end
+      end
+
+      def self.register(id, cls)
+        @services ||= {}
+        @services[id] = cls
+      end
+
+      def self.by_id(id)
+        @services ||= {}
+        @services[id]
+      end
+
+      def self.arf_service_id(id)
+        @arf_service_id = id
+        ::Arf::RPC::ServiceBase.register(id, self)
+      end
+
+      def self.respond_to_rpc?(name)
+        return true if @service_methods&.key?(name.to_sym)
+
+        if superclass != Arf::RPC::ServiceBase && superclass.respond_to?(:respond_to_rpc?)
+          return superclass.respond_to_rpc?(name)
+        end
+
+        false
+      end
+
+      def self.rpc_method_meta(name)
+        name = name.to_sym unless name.is_a? Symbol
+        return @service_methods[name] if @service_methods&.key?(name)
+
+        if superclass != Arf::RPC::ServiceBase && superclass.respond_to?(:rpc_method_meta)
+          return superclass.rpc_method_meta(name)
+        end
+
+        nil
+      end
+
+      def self.rpc(name, inputs: nil, outputs: nil)
+        inputs ||= {}
+        outputs = [outputs].compact unless outputs.is_a? Array
+
+        @service_methods ||= {}
+        @service_methods[name] = MethodMeta.new(inputs, outputs)
+        define_method(name) { unimplemented! }
+      end
+
+      attr_reader :log, :request
+
+      def arf_execute_request(ctx)
+        @context = ctx
+        @request = ctx.request
+        @metadata = @request.metadata
+        @service = @request.service
+        @method = @request.method
+        @log = ctx.log
+        @method_meta = self.class.rpc_method_meta(@method)
+        needs_response = @method_meta.output?
+        @context.prepare
+        if (str = @method_meta.output_stream)
+          @context.has_send_stream = true
+          @context.send_stream_type = str
+        end
+
+        @context.response.metadata.attach_observer(self)
+
+        output_type = @method_meta.output_stream&.resolved_type(self.class)
+
+        result = nil
+        begin
+          result = send(@method, *@request.params) do |val|
+            raise YieldWithoutStreamError unless ctx.has_send_stream
+            raise YieldWithoutRespondError if !ctx.has_sent_response && needs_response
+            raise YieldOnClosedStream if ctx.send_stream_finished
+
+            ctx.stream_send(Arf::Types.coerce_value(val, output_type))
+            nil
+          end
+        rescue Exception => e
+          @log.error("Failed executing ##{@method}", e)
+          error!
+        end
+        @log.debug("Finished executing request", method: @method, result:)
+        result
+      end
+
+      def observer_changed(_observer)
+        # We just have a single observer, it will be response metadata.
+        return unless ctx.send_stream_started && !ctx.send_stream_finished
+
+        ctx.stream_send_metadata
+      end
+
+      def recv = @context.recv
+
+      def set_meta(k, v) = @context.response.metadata.set(k, v)
+      def add_meta(k, v) = @context.response.metadata.add(k, v)
+
+      def respond(value, code: nil)
+        code ||= :ok
+
+        @context.response.params = @method_meta.coerce_result(value, self.class)
+        @context.response.status = code
+        @context.send_response
+      end
+
+      def unimplemented! = raise Status::BadStatus, :unimplemented
+      def error! = raise Status::BadStatus, :internal_error
+    end
+  end
+end

data/lib/arf/rpc/start_stream.rb

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

data/lib/arf/rpc/stream_error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Arf
+  module RPC
+    class StreamError < BaseMessage
+      kind :stream_error
+      has_status
+      has_metadata
+
+      def encode
+        IO::Buffer.new
+          .write_raw(encode_uint16(@status))
+          .write_raw(metadata.encode)
+          .string
+      end
+
+      def decode(data)
+        @status = decode_uint16(data)
+        @metadata = Metadata.new.decode(data)
+      end
+    end
+  end
+end

data/lib/arf/rpc/stream_item.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Arf
+  module RPC
+    class StreamItem < BaseMessage
+      kind :stream_item
+      attr_accessor :value
+
+      def encode = Proto.encode(@value)
+
+      def decode(data)
+        @value = Proto.decode(data)
+      end
+    end
+  end
+end

data/lib/arf/rpc/stream_metadata.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Arf
+  module RPC
+    class StreamMetadata < BaseMessage
+      kind :stream_metadata
+      has_metadata
+
+      def encode = metadata.encode
+
+      def decode(data)
+        @metadata = Metadata.new.decode(data)
+      end
+    end
+  end
+end

data/lib/arf/rpc/struct.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+module Arf
+  module RPC
+    class Struct
+      include Arf::Types::Mixin
+
+      def self.arf_struct_id(v = nil)
+        return @arf_struct_id if v.nil?
+
+        @arf_struct_id = v
+        Arf::Proto::Registry.register! self
+        v
+      end
+
+      def self.validate_subclass(type, v)
+        cls = find_type(type)
+        if cls.ancestors.include?(Arf::RPC::Enum)
+          !cls.to_i(v).nil?
+        else
+          v.is_a?(cls) || v.is_a?(Hash)
+        end
+      end
+
+      def self.validator_for_type(type, optional:)
+        validator = if ::Arf::Types::INTEGERS.include?(type)
+                      ->(v) { v.is_a?(Float) || v.is_a?(Integer) }
+                    elsif ::Arf::Types::FLOATS.include?(type)
+                      ->(v) { v.is_a?(Float) || v.is_a?(Integer) }
+                    elsif type == :string
+                      ->(v) { v.is_a?(String) }
+                    elsif type == :bool
+                      ->(v) { v.is_a?(TrueClass) || v.is_a?(FalseClass) }
+                    elsif type == :bytes
+                      ->(v) { v.is_a?(StringIO) || v.is_a?(String) }
+                    elsif type.is_a? MapType
+                      ->(v) { v.is_a? Hash }
+                    elsif type.is_a? ArrayType
+                      ->(v) { v.is_a? Array }
+                    elsif type.is_a? String
+                      # Validation for nested classes must be done at time of assignment
+                      # since we can't rely on it being available during the field's
+                      # definition.
+                      ->(v) { validate_subclass(type, v) }
+                    elsif type.ancestors.include?(Arf::RPC::Enum)
+                      ->(v) { !type.to_i(v).nil? }
+                    else
+                      raise ArgumentError, "Invalid type #{type.inspect} (#{type.class.name})"
+                    end
+
+        if optional
+          ->(v) { v.nil? || validator.call(v) }
+        else
+          validator
+        end
+      end
+
+      def self.default_for_type(type)
+        if ::Arf::Types::INTEGERS.include?(type)
+          0
+        elsif ::Arf::Types::FLOATS.include?(type)
+          0.0
+        elsif type == :string
+          ""
+        elsif type == :bool
+          false
+        elsif type == :bytes
+          ""
+        elsif type.is_a? MapType
+          {}
+        elsif type.is_a? ArrayType
+          []
+        elsif type.is_a? String
+          # Validation for nested classes must be done at time of assignment
+          # since we can't rely on it being available during the field's
+          # definition.
+          cls = find_type(type)
+          if cls.ancestors.include?(Arf::RPC::Enum)
+            default_for_type(cls)
+          else
+            cls.new
+          end
+        elsif type.ancestors.include?(Arf::RPC::Enum)
+          type.options.keys.first
+        else
+          raise ArgumentError, "Invalid type #{type.inspect} (#{type.class.name})"
+        end
+      end
+
+      def self.field(id, name, type, optional: false)
+        @fields ||= []
+        @fields << { id:, name: name.to_s, type:, optional: }
+        attr_reader(name)
+
+        validator = validator_for_type(type, optional:)
+        define_method("#{name}=") do |v|
+          unless validator.call(v)
+            raise ArgumentError, "Invalid value for #{self.class.name}.#{name}, type #{type}: #{v.inspect}"
+          end
+
+          v = _coerce(v, type)
+
+          instance_variable_set("@__arf_union_set_id", id) if union? && !@skip_union_setter
+          instance_variable_set("@#{name}", v)
+        end
+      end
+
+      def self.all_fields
+        @all_fields ||= @fields
+          .map do |v|
+            next v unless v[:id] == :union
+
+            find_type(v[:type])
+              .all_fields
+              .map { _1.merge(via: v[:name]) }
+          end
+          .flatten
+      end
+
+      def self.fields = @fields || []
+      def self.field_by_id(id) = @fields.find { _1[:id] == id }
+      def self.field_by_name(name) = name.to_s.then { |n| @fields.find { _1[:name] == n } }
+
+      def self.union!
+        @union = true
+        attr_reader(:__arf_union_set_id)
+      end
+
+      def self.union? = @union || false
+
+      def arf_struct_id = self.class.arf_struct_id
+      def union? = self.class.union?
+
+      def initialize(**kwargs)
+        cls = self.class
+        kwargs.each_pair do |k, v|
+          field = cls.field_by_name(k)
+          raise ArgumentError, "#{cls.name}: Unknown field #{k}" unless field
+
+          v = _coerce(v, field[:type])
+          send("#{k}=", v)
+        end
+
+        @skip_union_setter = true
+        # Initialize missing variables
+        cls.fields.each do |f|
+          next if f[:optional]
+
+          send("#{f[:name]}=", cls.default_for_type(f[:type])) if instance_variable_get("@#{f[:name]}").nil?
+        end
+
+        if union? && __arf_union_set_id.nil?
+          @skip_union_setter = false
+          # Set the first field
+          f = cls.fields.first
+          send("#{f[:name]}=", cls.default_for_type(f[:type]))
+        end
+      ensure
+        @skip_union_setter = false
+      end
+
+      def _coerce(value, type)
+        cls = self.class
+        case type
+        when String
+          type = cls.find_type(type)
+          if type.ancestors.include?(Arf::RPC::Enum)
+            type.to_sym(value)
+          else
+            case value
+            when Hash then type.new(**value)
+            when type then value
+            else
+              raise ArgumentError,
+                    "Cannot initialize #{type} with #{value.inspect} (#{value.class}). Did you mean to use a Hash?"
+            end
+          end
+        when ArrayType
+          type.coerce(value)
+        when MapType
+          type.coerce(value)
+        else
+          ::Arf::Types.coerce_value(value, type)
+        end
+      end
+
+      def decode_fields(fields)
+        fields.each_pair do |id, value|
+          meta = self.class.all_fields.find { _1[:id] == id }
+          unless meta
+            puts "WARNING: Skipping field ID #{id} without matching ID on target type #{self.class.name}"
+            next
+          end
+          if meta[:via]
+            union_field = self.class.all_fields.find { _1[:id] == value[:id] }
+            instance_variable_get("@#{meta[:via]}")
+              .send("#{union_field[:name]}=", value[:value])
+            next
+          end
+
+          next if meta[:optional] && value.nil?
+
+          instance_variable_set("@#{meta[:name]}", _coerce(value, meta[:type]))
+        end
+        self
+      end
+
+      def ==(other)
+        return false unless other.is_a? self.class
+
+        return eq_union(other) if union?
+
+        eq_struct(other)
+      end
+
+      def eq_struct(other)
+        self.class.fields.each do |v|
+          return false unless send(v[:name]) == other.send(v[:name])
+        end
+        true
+      end
+
+      def eq_union(other)
+        return false unless other.__arf_union_set_id == __arf_union_set_id
+
+        self.class.fields.each do |v|
+          return false if instance_variable_get("@#{v[:name]}") != other.instance_variable_get("@#{v[:name]}")
+        end
+
+        true
+      end
+
+      def hashify(value)
+        case value
+        when nil then nil
+        when Arf::RPC::Struct then value.to_h
+        when Array then value.map { hashify(_1) }
+        when Hash then value.transform_values { |v| hashify(v) }
+        else value
+        end
+      end
+
+      def to_h
+        if union?
+          set = self.class.fields.find { _1[:id] == __arf_union_set_id }
+          return { set[:name] => hashify(instance_variable_get("@#{set[:name]}")) }
+        end
+
+        self.class.fields
+          .to_h { |f| [f[:name], hashify(instance_variable_get("@#{f[:name]}"))] }
+          .compact
+      end
+    end
+  end
+end

data/lib/arf/rpc.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "rpc/struct"
+require_relative "rpc/enum"
+require_relative "rpc/message_kind"
+require_relative "rpc/base_message"
+require_relative "rpc/metadata"
+require_relative "rpc/request"
+require_relative "rpc/response"
+require_relative "rpc/start_stream"
+require_relative "rpc/end_stream"
+require_relative "rpc/stream_error"
+require_relative "rpc/stream_item"
+require_relative "rpc/stream_metadata"
+require_relative "rpc/method_meta"
+
+require_relative "rpc/service_base"
+require_relative "rpc/client_base"
+require_relative "rpc/responder"

data/lib/arf/server.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Arf
+  class Server
+    def self.pseudo_uuid
+      hostname = Socket.gethostname
+      lambda do
+        "#{hostname}-#{SecureRandom.hex(8)}"
+      end
+    end
+
+    def default_options
+      @default_options ||= {
+        max_concurrent_streams: 0,
+        logger: Arf.configuration.logger,
+        id_generator: Server.pseudo_uuid
+      }.merge
+    end
+
+    def initialize(**opts)
+      opts = default_options.merge(opts)
+      opts[:id_generator] ||= Server.pseudo_uuid
+      @logger = opts[:logger]
+      @id_generator = opts[:id_generator]
+      @max_concurrent_streams = opts[:max_concurrent_streams]
+      @server = Arf::Wire::Server.new(self)
+      @interceptors = []
+    end
+
+    def register_interceptor(callable, &block)
+      callable ||= block
+      @interceptors << callable
+    end
+
+    def run = @server.run
+    def shutdown = @server.shutdown
+
+    def handle_stream(stream)
+      req_id = @id_generator.call
+      stream.external_id = req_id
+      log = @logger.with_fields(request_id: req_id)
+      log.debug("Servicing stream")
+      ctx = Context.new(req_id, log, stream)
+      log.debug("Reading request...", thread: Thread.current.name)
+      msg = RPC::BaseMessage.initialize_from(stream.read_blocking)
+      unless msg.is_a? RPC::Request
+        log.info("Rejecting stream as it does not start with a Request frame")
+        stream.write_data(RPC::BaseMessage.encode(RPC::Response.new(
+                                                    status: :failed_precondition,
+                                                    metadata: {
+                                                      "arf-request-id" => req_id,
+                                                      "arf-status-description" => "Missing Request frame"
+                                                    }
+                                                  )))
+        stream.close_local
+        return
+      end
+
+      log.debug("Request read OK")
+      ctx.request = msg
+      # chain interceptors
+      call_next(0, ctx)
+      handle_request(ctx)
+    end
+
+    def handle_request(ctx)
+      base_svc = Arf::RPC::ServiceBase.by_id(ctx.request.service)
+      svc = base_svc&.subclasses&.first
+
+      if svc.nil?
+        ctx.log.info("Rejecting request as there's no service registered with the requested name",
+                     service: ctx.request.service, method: ctx.request.method)
+        failure(ctx, :unimplemented)
+        return false
+      end
+
+      unless svc.respond_to_rpc?(ctx.request.method)
+        ctx.log.info("Rejecting request as service does not respond to the requested method",
+                     service: ctx.request.service, method: ctx.request.method)
+        failure(ctx, :unimplemented)
+        return false
+      end
+
+      ctx.log.debug("Handler got request")
+
+      svc_inst = svc.new
+
+      begin
+        result = svc_inst.arf_execute_request(ctx)
+      rescue Status::BadStatus => e
+        failure(ctx, e.code, e.message)
+        return false
+      rescue Exception => e
+        ctx.log.error("Failed invoking method #{ctx.request.method}", e)
+        failure(ctx, :internal_error)
+        return false
+      end
+
+      ctx.end_send if ctx.has_send_stream
+      svc_inst.respond(result) unless ctx.has_sent_response
+      true
+    end
+
+    def failure(ctx, status, message = nil)
+      resp = RPC::Response.new(
+        status: Status::FROM_SYMBOL[status],
+        metadata: {
+          "arf-status-description" => message || Status::STATUS_TEXT[status]
+        }
+      )
+      ctx.stream.write_data(RPC::BaseMessage.encode(resp), end_stream: true)
+      ctx.has_sent_response = true
+    end
+
+    def cancel_stream(stream); end
+
+    def call_next(index, ctx)
+      return unless index < @interceptors.size
+
+      @interceptors[index].call(ctx) { call_next(index + 1, ctx) }
+    end
+  end
+end