arf 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8268851fe0bf2d0252c65f9a42b58a5e1335f5d5a5bdff839ff3961a1e530e69
+  data.tar.gz: 1ba718db7a6a8372c1cb813437c1bd17e6925456eca5c3709d15b48f8a7567d0
+SHA512:
+  metadata.gz: fd37152c07e7c8f78c57e5f4dcc7530f18e2d61fc615978992f0fae6c98e2ddd65ac544974da2c153394f724e774f78c3367ca0046b3a387b01e9d2134ec2d73
+  data.tar.gz: ff4bc35c94c938c3c0a9b904ec33fbabad4428bd418d922d6f7e12876f8ce1262b5070e9bbde81a1140a9185aceda39dbe1569fed154398120e2a5d55d5cbac4

data/.ruby-version

@@ -0,0 +1 @@
+3.3.5

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Vito Sartori
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/arf/configuration.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Arf
+  class Configuration
+    TLS_OPTS = {
+      private_key_file: :tls_private_key_file,
+      private_key: :tls_private_key,
+      private_key_pass: :tls_private_key_pass,
+      cert_chain_file: :tls_cert_chain_file,
+      cert: :tls_cert,
+      verify_peer: :tls_verify_peer,
+      sni_hostname: :tls_sni_hostname,
+      cipher_list: :tls_cipher_list,
+      ssl_version: :tls_ssl_version,
+      ecdh_curve: :tls_ecdh_curve,
+      dhparam: :tls_dhparam,
+      fail_if_no_peer_cert: :tls_fail_if_no_peer_cert
+    }.freeze
+
+    attr_accessor :bind_address, :bind_port,
+                  :enable_tls, :tls_private_key_file, :tls_private_key,
+                  :tls_private_key_pass, :tls_cert_chain_file, :tls_cert,
+                  :tls_verify_peer, :tls_sni_hostname, :tls_cipher_list,
+                  :tls_ssl_version, :tls_ecdh_curve, :tls_dhparam,
+                  :tls_fail_if_no_peer_cert,
+                  :client_compression
+    attr_writer :logger
+
+    # Determines the log verbosity level. Valid options are:
+    # - :debug
+    # - :info (default)
+    # - :warn
+    # - :fatal
+    # - :error
+    attr_reader :log_level
+
+    def initialize
+      @bind_address = "127.0.0.1"
+      @bind_port = 2730
+      @log_level = :info
+    end
+
+    def tls_configuration
+      return @tls_configuration unless @tls_configuration.nil?
+
+      @tls_configuration = TLS_OPTS
+        .map { |k, v| [k, send(v)] }
+        .compact
+        .to_h
+    end
+
+    def enable_tls? = enable_tls
+
+    def logger
+      @logger ||= Logrb.new($stderr, level: @log_level)
+    end
+
+    def log_level=(level)
+      @log_level = level
+      logger.level = level
+    end
+
+    def self.instance
+      @instance ||= new
+    end
+  end
+end

data/lib/arf/context.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Arf
+  class Context
+    attr_accessor :request_id, :log, :stream, :request,
+                  :has_recv_stream, :recv_stream_error, :recv_stream_started,
+                  :has_send_stream, :send_stream_error, :send_stream_started, :send_stream_type, :send_stream_finished,
+                  :has_sent_response, :response, :error
+
+    def initialize(req_id, log, stream)
+      @request_id = req_id
+      @log = log
+      @stream = stream
+
+      @request = nil
+      @error = nil
+
+      @has_recv_stream = false
+      @recv_stream_error = nil
+      @recv_stream_started_lock = Monitor.new
+      @recv_stream_started = false
+
+      @has_send_stream = false
+      @send_stream_error = nil
+      @send_stream_started = false
+      @send_stream_started_lock = Monitor.new
+      @send_stream_finished = false
+      @send_stream_type = nil
+
+      @has_sent_response = false
+      @response = Arf::RPC::Response.new
+    end
+
+    def prepare
+      @has_recv_stream = @request.streaming
+      @response.metadata.set("arf-request-id", @request_id)
+    end
+
+    def recv
+      raise RPC::NoStreamError, true unless has_recv_stream
+      raise @error if @error
+      raise @recv_stream_error if @recv_stream_error
+
+      loop do
+        v = _read_stream_item
+        return v if v
+      end
+    end
+
+    def stream_send(val)
+      raise RPC::NoStreamError, false unless @has_send_stream
+      raise @error if @error
+      raise @send_stream_error if @send_stream_error
+
+      unless has_sent_response
+        # Arf::RPC::Service makes sure this method can be called now. If it
+        # allowed calling without a response being sent, it is acceptable to
+        # push a response as-is, as the client does not expect parameters as
+        # response other than the stream being sent.
+        @log.debug("Pushing synthetic response for method without response values")
+        @response.status = :ok
+        @response.streaming = true
+        @response.params = []
+        send_response
+      end
+
+      begin
+        unless @send_stream_started
+          @send_stream_started_lock.synchronize do
+            next if @send_stream_started
+
+            @log.debug("Pushing StartStream frame")
+            @stream.write_data(RPC::BaseMessage.encode(RPC::StartStream.new))
+            @send_stream_started = true
+          end
+        end
+
+        @log.debug("Pushing StreamItem frame")
+        @stream.write_data(RPC::BaseMessage.encode(RPC::StreamItem.new(value: val)))
+      rescue StandardError => e
+        @send_stream_error = e
+        raise
+      end
+    end
+
+    def send_stream_metadata
+      @stream.write_data(RPC::BaseMessage.encode(RPC::StreamMetadata.new(metadata: @response.metadata)))
+    end
+
+    def end_send
+      return if @send_stream_finished
+      raise RPC::NoStreamError, false unless @has_send_stream
+      raise @error if @error
+      raise @send_stream_error if @send_stream_error
+
+      @send_stream_finished = true
+
+      begin
+        @stream.write_data(RPC::BaseMessage.encode(RPC::EndStream.new), end_stream: true)
+      rescue StandardError => e
+        @log.error("Failed running #end_send", e)
+        @error = e
+        raise
+      end
+    end
+
+    def send_response(end_stream: false)
+      @log.debug("Sending response", response: @response)
+
+      @has_sent_response = true
+      @send_stream_started = false
+
+      @response.status ||= :ok
+      @log.debug("Start stream write data")
+      @stream.write_data(RPC::BaseMessage.encode(@response), end_stream:)
+      @log.debug("Send response done")
+    rescue Exception => e
+      @log.error("Failed sending response", e)
+      @error = e
+      raise
+    end
+
+    private
+
+    def _read_stream_item
+      begin
+        unless @recv_stream_started
+          @recv_stream_started_lock.synchronize do
+            next if @recv_stream_started
+
+            msg = RPC::BaseMessage.initialize_from(@stream.read_blocking)
+            if msg.is_a?(RPC::StartStream)
+              @recv_stream_started = true
+            else
+              @error = RPC::StreamFailureError.new("Received unexpected message kind waiting for StartStream")
+              raise @error
+            end
+          end
+        end
+
+        msg = RPC::BaseMessage.initialize_from(@stream.read_blocking)
+      rescue StandardError => e
+        @log.error("Failed starting recv_stream", e)
+        @recv_stream_error = e
+        raise
+      end
+
+      case msg
+      when RPC::StreamItem
+        msg.value
+
+      when RPC::EndStream
+        @recv_stream_error = RPC::StreamEndError.new
+        raise @recv_stream_error
+
+      when RPC::StreamError
+        @recv_stream_error = msg
+        raise @recv_stream_error
+
+      when RPC::StreamMetadata
+        @request.metadata.replace!(msg.metadata)
+        nil
+
+      else
+        @error = RPC::StreamFailureError.new("Received unexpected message kind during stream")
+        raise @error
+      end
+    end
+  end
+end

data/lib/arf/errors.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Arf
+  class Error < StandardError; end
+  class UnknownTypeError < Error; end
+  class InvalidEncodingTypeError < Error; end
+  class UnsupportedNestedUnionError < Error; end
+  class DecodeFailedError < Error; end
+  class UnknownMeessageError < Error; end
+end

data/lib/arf/io/buffer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Arf
+  module IO
+    class Buffer
+      def initialize
+        @buf = StringIO.new
+      end
+
+      def write(v) = tap { write_raw([v].pack("C*")) }
+      def write_raw(v) = tap { @buf.write(v) }
+      def reset = @buf.tap(&:rewind).truncate(0)
+      def length = @buf.length
+      def rewind = @buf.rewind
+      def read(*) = @buf.read(*)
+      def string = @buf.tap(&:rewind).string
+
+      def extract
+        buf = @buf
+        @buf = StringIO.new
+        buf
+      end
+    end
+  end
+end

data/lib/arf/io/compression.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Arf
+  module IO
+    class BaseCompressor
+      def self.compress(value)
+        return nil if value.nil?
+
+        value = value.string if value.is_a? StringIO
+        value = do_compress(value)
+        value.is_a?(StringIO) ? value : StringIO.new(value)
+      end
+
+      def self.decompress(value)
+        return nil if value.nil?
+
+        value = value.string if value.is_a? StringIO
+        value = do_decompress(value)
+        value.is_a?(StringIO) ? value : StringIO.new(value)
+      end
+    end
+
+    class NoneCompressor
+      def self.compress(value) = value
+      def self.decompress(value) = value
+    end
+
+    class GzipCompressor < BaseCompressor
+      def self.do_compress(value) = Zlib::Deflate.deflate(value)
+      def self.do_decompress(value) = Zlib::Inflate.inflate(value)
+    end
+
+    class BrotliCompressor < BaseCompressor
+      def self.do_compress(value) = Brotli.deflate(value)
+      def self.do_decompress(value) = Brotli.inflate(value)
+    end
+
+    COMPRESSOR = {
+      none: NoneCompressor,
+      gzip: GzipCompressor,
+      brotli: BrotliCompressor
+    }.freeze
+  end
+end

data/lib/arf/io/limit_reader.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Arf
+  module IO
+    class LimitReader
+      def initialize(io, size)
+        @io = io
+        @left = size
+      end
+
+      def readpartial(size)
+        size = normalize_size(size)
+        @io.readpartial(size).tap { @left -= _1.length }
+      end
+
+      def read(size)
+        size = normalize_size(size)
+        @io.read(size).tap { @left -= _1.length }
+      end
+
+      private
+
+      def normalize_size(size)
+        raise EOFError if @left.zero?
+
+        [@left, size].min
+      end
+    end
+  end
+end

data/lib/arf/observer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Arf
+  class Observer
+    def initialize
+      @handler = nil
+      @primed = false
+      @mutex = Monitor.new
+    end
+
+    def attach_handler(handler)
+      @handler = handler
+    end
+
+    def prime
+      @primed = true
+    end
+
+    def modify
+      @mutex.synchronize do
+        yield
+        if @primed
+          @primed = false
+          Arf::Reactor.post { @handler.observer_changed(self) }
+        end
+      end
+    end
+  end
+end

data/lib/arf/proto/array.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Arf
+  module Proto
+    ARRAY_EMPTY_MASK = 0x01 << 4
+
+    def self.encode_array(v)
+      b = IO::Buffer.new
+      t = TYPE_ARRAY
+      if v.empty?
+        t |= ARRAY_EMPTY_MASK
+        return b.write(t).string if v.empty?
+      end
+
+      b.write(t).write_raw(encode_uint64(v.length))
+      v.each { b.write_raw(encode(_1)) }
+      b.string
+    end
+
+    def self.decode_array(header, io)
+      return [] if header.anybits?(ARRAY_EMPTY_MASK)
+
+      len = decode_uint64(io)
+      arr = []
+      len.times do
+        arr << decode(io)
+      end
+      arr
+    end
+  end
+end

data/lib/arf/proto/boolean.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Arf
+  module Proto
+    BOOL_FLAG_MASK = 0x01 << 4
+
+    def self.encode_boolean(b)
+      v = TYPE_BOOLEAN
+      v |= BOOL_FLAG_MASK if b
+      [v].pack("C*")
+    end
+
+    def self.decode_boolean(header, _io) = header.allbits?(BOOL_FLAG_MASK)
+  end
+end

data/lib/arf/proto/bytes.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Arf
+  module Proto
+    BYTES_EMPTY_MASK = 0x01 << 4
+
+    def self.encode_bytes(b)
+      v = TYPE_BYTES
+
+      if b.empty?
+        v |= BYTES_EMPTY_MASK
+        return [v].pack("C*")
+      end
+
+      IO::Buffer.new
+        .write(v)
+        .write_raw(encode_uint64(b.length))
+        .write_raw(b)
+        .string
+    end
+
+    def self.decode_bytes(header, io)
+      return "" if header.anybits?(BYTES_EMPTY_MASK)
+
+      size = decode_uint64(io)
+      data = StringIO.new
+      until size.zero?
+        read = io.readpartial(size)
+        data.write(read)
+        size -= read.length
+      end
+      data.string
+    end
+  end
+end

data/lib/arf/proto/decoder.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Arf
+  module Proto
+    def self.decode(io)
+      type, header = read_type(io)
+      case type
+      when TYPE_VOID
+        nil
+      when TYPE_SCALAR
+        decode_scalar(header, io)
+      when TYPE_BOOLEAN
+        decode_boolean(header, io)
+      when TYPE_FLOAT
+        decode_float(header, io)
+      when TYPE_STRING
+        decode_string(header, io)
+      when TYPE_BYTES
+        decode_bytes(header, io)
+      when TYPE_ARRAY
+        decode_array(header, io)
+      when TYPE_MAP
+        decode_map(header, io)
+      when TYPE_STRUCT
+        decode_struct(header, io)
+      when TYPE_UNION
+        decode_union(header, io)
+      end
+    end
+  end
+end

data/lib/arf/proto/encoder.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Arf
+  module Proto
+    def self.encode(value)
+      case value
+      when NilClass
+        [TYPE_VOID].pack("C*")
+      when String, Symbol
+        encode_string(value.to_s)
+      when TrueClass, FalseClass
+        encode_boolean(value)
+      when Float
+        if value.between?(FLOAT32_MIN_VALUE, FLOAT32_MAX_VALUE)
+          encode_float32(value)
+        else
+          encode_float64(value)
+        end
+      when Integer
+        encode_scalar(value, signed: value.negative?)
+      when Array
+        encode_array(value)
+      when Hash
+        encode_map(value)
+      else
+        unless value.class.ancestors.include? Arf::RPC::Struct
+          raise InvalidEncodingTypeError, "Unable to encode value of type #{value.class.name}"
+        end
+
+        encode_struct(value)
+
+      end
+    end
+
+    def self.encode_as(value, type)
+      return [TYPE_VOID].pack("C*") if value.nil?
+
+      case type
+      when :uint8, :uint16, :uint32, :uint64
+        encode_scalar(value, signed: false)
+      when :int8, :int16, :int32, :int64
+        encode_scalar(value, signed: true)
+      when :float32
+        encode_float32(value)
+      when :float64
+        encode_float64(value)
+      when :bool
+        encode_boolean(value)
+      when :string
+        encode_string(value)
+      when :bytes
+        encode_bytes(value)
+      else
+        if type.is_a?(Arf::Types::MapType)
+          encode_map(value)
+        elsif type.is_a?(Arf::Types::ArrayType)
+          encode_array(value)
+        elsif type.is_a?(String) && value.class.ancestors.include?(Arf::RPC::Struct)
+          encode_struct(value)
+        elsif type.is_a?(Class) && type.ancestors.include?(Arf::RPC::Struct)
+          encode_struct(value)
+        elsif type.is_a?(Class) && type.ancestors.include?(Arf::RPC::Enum)
+          encode_scalar(type.to_i(value), signed: false)
+        else
+          raise InvalidEncodingTypeError,
+                "Unable to encode value of type #{value.class.name} (reported type is #{type.inspect})"
+        end
+      end
+    end
+  end
+end

data/lib/arf/proto/float.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Arf
+  module Proto
+    FLOAT64_MASK = 0x01 << 4
+    FLOAT_EMPTY_MASK = 0x01 << 5
+    FLOAT32_MIN_VALUE = -3.4028235e38
+    FLOAT32_MAX_VALUE = 3.4028235e38
+
+    def self.encode_float32(value)
+      t = TYPE_FLOAT
+      if value.zero?
+        t |= FLOAT_EMPTY_MASK
+        return [t].pack("C*")
+      end
+
+      [
+        [t].pack("C*"),
+        [value].pack("g").unpack("N").pack("L>")
+      ].join
+    end
+
+    def self.encode_float64(value)
+      t = TYPE_FLOAT | FLOAT64_MASK
+      if value.zero?
+        t |= FLOAT_EMPTY_MASK
+        return [t].pack("C*")
+      end
+
+      [
+        [t].pack("C*"),
+        [value].pack("G").unpack("Q>").pack("Q>")
+      ].join
+    end
+
+    def self.decode_float(header, io)
+      return 0.0 if header.anybits?(FLOAT_EMPTY_MASK)
+
+      bits = header.nobits?(FLOAT64_MASK) ? 32 : 64
+      data = io.read(bits / 8)
+      if bits == 32
+        data.unpack("L>").pack("L>").unpack1("g")
+      else
+        data.unpack("Q>").pack("Q>").unpack1("G")
+      end
+    end
+  end
+end