arf 0.1.0

data/lib/arf/status.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Arf
+  module Status
+    OK                  = 0
+    CANCELLED           = 1
+    UNKNOWN             = 2
+    INVALID_ARGUMENT    = 3
+    DEADLINE_EXCEEDED   = 4
+    NOT_FOUND           = 5
+    ALREADY_EXISTS      = 6
+    PERMISSION_DENIED   = 7
+    RESOURCE_EXHAUSTED  = 8
+    FAILED_PRECONDITION = 9
+    ABORTED             = 10
+    OUT_OF_RANGE        = 11
+    UNIMPLEMENTED       = 12
+    INTERNAL_ERROR      = 13
+    UNAVAILABLE         = 14
+    DATA_LOSS           = 15
+    UNAUTHENTICATED     = 16
+
+    TO_SYMBOL = {
+      OK => :ok,
+      CANCELLED => :cancelled,
+      UNKNOWN => :unknown,
+      INVALID_ARGUMENT => :invalid_argument,
+      DEADLINE_EXCEEDED => :deadline_exceeded,
+      NOT_FOUND => :not_found,
+      ALREADY_EXISTS => :already_exists,
+      PERMISSION_DENIED => :permission_denied,
+      RESOURCE_EXHAUSTED => :resource_exhausted,
+      FAILED_PRECONDITION => :failed_precondition,
+      ABORTED => :aborted,
+      OUT_OF_RANGE => :out_of_range,
+      UNIMPLEMENTED => :unimplemented,
+      INTERNAL_ERROR => :internal_error,
+      UNAVAILABLE => :unavailable,
+      DATA_LOSS => :data_loss,
+      UNAUTHENTICATED => :unauthenticated
+    }.freeze
+
+    FROM_SYMBOL = TO_SYMBOL.to_a.to_h(&:reverse)
+
+    STATUS_TEXT = {
+      ok: "OK",
+      cancelled: "Cancelled",
+      unknown: "Unknown",
+      invalid_argument: "Invalid Argument",
+      deadline_exceeded: "Deadline Exceeded",
+      not_found: "Not Found",
+      already_exists: "Already Exists",
+      permission_denied: "Permission Denied",
+      resource_exhausted: "Resource Exhausted",
+      failed_precondition: "Failed Precondition",
+      aborted: "Aborted",
+      out_of_range: "Out of Range",
+      unimplemented: "Unimplemented",
+      internal_error: "Internal Error",
+      unavailable: "Unavailable",
+      data_loss: "Data Loss",
+      unauthenticated: "Unauthenticated"
+    }.freeze
+
+    class BadStatus < Arf::Error
+      attr_reader :code
+
+      def initialize(code, msg = nil)
+        @code = code.is_a?(Symbol) ? code : TO_SYMBOL[code]
+        @msg = msg || STATUS_TEXT[@code] || "Unknown status"
+        super(@msg)
+      end
+    end
+  end
+end

data/lib/arf/types/array_type.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Arf
+  module Types
+    class ArrayType < BaseType
+      attr_reader :type
+
+      def initialize(v)
+        super()
+        @type = v
+      end
+
+      def self.[](v) = new(v)
+
+      def resolved_type
+        @resolved_type ||= resolve_type(@type)
+      end
+
+      def bind(to) = tap { @bind = to }
+
+      def coerce(val) = val.map { coerce_value(_1, resolved_type) }
+    end
+  end
+end

data/lib/arf/types/base_type.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Arf
+  module Types
+    class BaseType
+      def bind(to) = tap { @bind = to }
+      def coerce_value(*) = Arf::Types.coerce_value(*)
+
+      def resolve_type(type)
+        type.is_a?(String) ? @bind.find_type(type) : type
+      end
+    end
+  end
+end

data/lib/arf/types/coercion.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Arf
+  module Types
+    def self.coerce_value(value, type)
+      if Types::INTEGERS.include?(type)
+        value.to_i
+      elsif Types::FLOATS.include?(type)
+        value.to_f
+      elsif type == :string
+        value.to_s
+      elsif type == :bytes
+        case value
+        when StringIO then value.string
+        when String then value
+        when Array then value.pack("C*")
+        else
+          raise ArgumentError, "Invalid type for bytes: #{i.class.name}"
+        end
+      elsif type == :bool
+        !!value
+      elsif type.is_a?(Class)
+        case value
+        when Hash then type.new(**value)
+        when type then value
+        else
+          raise ArgumentError,
+                "Cannot initialize #{type} with #{value.inspect} (#{value.class}). " \
+                "You may want to use an instance of #{type}, or a Hash"
+        end
+      elsif type.is_a?(Arf::Types::ArrayType) || type.is_a?(Arf::Types::MapType)
+        type.coerce(value)
+      end
+    end
+  end
+end

data/lib/arf/types/in_out_stream.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Arf
+  module Types
+    class InOutStream
+      def self.[](input, output) = new(input, output)
+
+      attr_accessor :input, :output
+
+      def initialize(input, output)
+        @input = input
+        @output = output
+      end
+
+      def resolved_input(resolver)
+        return input if input.is_a? Symbol
+
+        @resolved_input ||= resolver.find_type(input)
+      end
+
+      def resolved_output(resolver)
+        return output if output.is_a? Symbol
+
+        @resolved_output ||= resolver.find_type(output)
+      end
+    end
+  end
+end

data/lib/arf/types/input_stream.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Arf
+  module Types
+    class InputStream < Streamer
+    end
+  end
+end

data/lib/arf/types/map_type.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Arf
+  module Types
+    class MapType < BaseType
+      attr_reader :key, :value
+
+      def initialize(k, v)
+        super()
+        @key = k
+        @value = v
+      end
+
+      def self.[](k, v) = new(k, v)
+
+      def resolved_types
+        return @resolved_types if @resolved_types
+
+        key = resolve_type(@key)
+        value = resolve_type(@value)
+        @resolved_types = [key, value]
+      end
+
+      def coerce(val)
+        key_type, value_type = resolved_types
+        val
+          .transform_keys { coerce_value(_1, key_type) }
+          .transform_values { coerce_value(_1, value_type) }
+      end
+    end
+  end
+end

data/lib/arf/types/mixin.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Arf
+  module Types
+    module Mixin
+      MapType = ::Arf::Types::MapType
+      ArrayType = ::Arf::Types::ArrayType
+      InputStream = ::Arf::Types::InputStream
+      OutputStream = ::Arf::Types::OutputStream
+      InOutStream = ::Arf::Types::InOutStream
+      Streamer = ::Arf::Types::Streamer
+
+      module ClassMethods
+        def find_type(named)
+          components = named.split("::")
+          if components.first.empty?
+            # Look from the root, starting at Object
+            ::Arf::Types.lookup_type(Object, components[1...], direction: :down)
+          else
+            # Look from local scope upwards
+            ::Arf::Types.lookup_type(self, components, direction: :up)
+          end
+        end
+      end
+
+      def self.included(base) = base.extend(ClassMethods)
+    end
+  end
+end

data/lib/arf/types/output_stream.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Arf
+  module Types
+    class OutputStream < Streamer
+    end
+  end
+end

data/lib/arf/types/streamer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Arf
+  module Types
+    class Streamer
+      def self.[](type) = new(type)
+
+      attr_accessor :type
+
+      def initialize(type)
+        @type = type
+      end
+
+      def resolved_type(resolver)
+        return type if type.is_a? Symbol
+
+        @resolved_type ||= resolver.find_type(type)
+      end
+    end
+  end
+end

data/lib/arf/types.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "types/coercion"
+require_relative "types/base_type"
+require_relative "types/array_type"
+require_relative "types/map_type"
+require_relative "types/streamer"
+require_relative "types/in_out_stream"
+require_relative "types/input_stream"
+require_relative "types/output_stream"
+require_relative "types/mixin"
+
+module Arf
+  module Types
+    INTEGERS = %i[uint8 uint16 uint32 uint64 int8 int16 int32 int64].freeze
+    FLOATS = %i[float32 float64].freeze
+    OTHERS = %i[bool string bytes].freeze
+
+    def self.try_const_get(mod, name)
+      mod.const_get(name)
+    rescue NameError
+      nil
+    end
+
+    def self.lookup_type(mod, path, direction:)
+      key = [mod, path.join("::"), direction]
+      @lookup_cache ||= {}
+      return @lookup_cache[key] if @lookup_cache.key? key
+
+      v = if direction == :up
+            lookup_type_up(mod, path)
+          else
+            lookup_type_down(mod, path)
+          end
+
+      @lookup_cache[key] = v
+    end
+
+    def self.lookup_type_up(mod, path)
+      return mod if path.empty?
+
+      key = path.first
+      v = try_const_get(mod, key)
+      if v
+        lookup_type_down(v, path.tap(&:shift))
+      elsif mod == Object
+        nil
+      else
+        parent = mod.name.split("::").tap(&:pop).last
+        return nil if parent.nil?
+
+        v = try_const_get(mod, parent)
+        return nil if v.nil?
+
+        lookup_type_down(v, path)
+      end
+    end
+
+    def self.lookup_type_down(mod, path)
+      return mod if path.empty?
+
+      key = path.first
+      v = try_const_get(mod, key)
+      return nil unless v
+
+      lookup_type_down(v, path.tap(&:shift))
+    end
+  end
+end

data/lib/arf/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Arf
+  VERSION = "0.1.0"
+end

data/lib/arf/wire/base_connection.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Arf
+  module Wire
+    class BaseConnection
+      def initialize
+        @_write_lock = Monitor.new
+        @_write_buffer = Queue.new
+        @_write_head = nil
+        @compression = :none
+        @last_stream_id = 0
+        @reader = FrameReader.new
+        @configured = false
+        @pong_signal = WaitSignal.new
+
+        @streams = {}
+        @streams_monitor = Monitor.new
+
+        @configuration_ready_lock = Mutex.new
+        @configuration_ready_signal = Thread::ConditionVariable.new
+        @registered = false
+      end
+
+      def registered? = @registered
+
+      def registered!
+        @registered = true
+        @_write_lock.synchronize do
+          Arf::Reactor.client_writes_pending(self) unless @_write_buffer.empty?
+        end
+      end
+
+      def wait_configuration
+        return if @configured
+
+        loop do
+          @configuration_ready_lock.synchronize do
+            @configuration_ready_signal.wait(@configuration_ready_lock)
+            return if @configured
+          end
+        end
+      end
+
+      def recv(data)
+        data.each_byte do |b|
+          v = @reader.feed(b)
+          next unless v
+
+          handle_frame(v)
+        end
+      end
+
+      def handle_frame(raw_frame)
+        frame = raw_frame.specialize(@compression)
+        case frame
+        when ConfigurationFrame
+          handle_configuration(frame)
+        when PingFrame
+          handle_ping(frame)
+        when GoAwayFrame
+          handle_go_away(frame)
+        when MakeStreamFrame
+          handle_make_stream(frame)
+        when ResetStreamFrame
+          handle_reset_stream(frame)
+        when DataFrame
+          handle_data(frame)
+        else
+          protocol_error!
+        end
+      rescue UnknownFrameKindError, InvalidFrameLengthError
+        protocol_error!
+      end
+
+      def cancel_streams(code)
+        @streams_monitor.synchronize do
+          @streams.each_value do |v|
+            v.reset(code)
+          rescue ClosedStreamError, StreamResetError
+            next
+          end
+        end
+      end
+
+      def ping
+        wait_configuration
+        @streams_monitor.synchronize do
+          dispatch_frame(PingFrame) do |p|
+            p.payload = SecureRandom.bytes(8)
+          end
+        end
+      end
+
+      def wait_pong = @pong_signal.wait
+
+      def fetch_stream(id) = @streams_monitor.synchronize { @streams[id] }
+
+      def arf_close_after_writing?
+        @arf_close_after_writing || false
+      end
+
+      def close_connection = Reactor.detach_client(self)
+
+      def close
+        close_connection
+      end
+
+      def close_connection_after_writing
+        @arf_close_after_writing = true
+      end
+
+      def send_data(data)
+        @_write_lock.synchronize do
+          @_write_buffer << data
+        end
+        Reactor.client_writes_pending(self) if registered?
+        data.bytesize
+      end
+
+      def handle_ping(fr)
+        return protocol_error! unless @configured
+
+        if fr.ack?
+          @pong_signal.broadcast
+          return
+        end
+
+        dispatch_frame(PingFrame) do |p|
+          p.ack!
+          p.payload = fr.payload
+        end
+      end
+
+      def dispatch_frame(type, terminate: false, &)
+        dispatch(type.new(&))
+        close_connection_after_writing if terminate
+      end
+
+      def dispatch(frame)
+        send_data(frame.to_frame.bytes(@compression))
+      end
+
+      def protocol_error! = go_away!(ERROR_CODE_PROTOCOL_ERROR, terminate: true)
+
+      def go_away!(code, extra_data: nil, terminate: false)
+        dispatch_frame(GoAwayFrame, terminate:) do |g|
+          g.last_stream_id = @last_stream_id
+          g.error_code = code
+          g.additional_data = extra_data if extra_data
+        end
+      end
+
+      def flush_write_buffer(io)
+        @_write_lock.synchronize do
+          loop do
+            if @_write_head.nil?
+              return true if @_write_buffer.empty?
+
+              @_write_head = @_write_buffer.pop
+            end
+
+            written = io.write_nonblock(@_write_head, exception: false)
+            case written
+            when :wait_writable
+              return false
+            when @_write_head.bytesize
+              @_write_head = nil
+            else
+              @_write_head = @_write_head.byteslice(written, @_write_head.bytesize)
+              return false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arf/wire/client.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Arf
+  module Wire
+    class Client < BaseConnection
+      def post_init
+        dispatch_frame(ConfigurationFrame) do |fr|
+          compression = Arf.config.client_compression
+          case compression
+          when :brotli
+            fr.compression_brotli!
+          when :gzip
+            fr.compression_gzip!
+          else
+            Arf.config.client_compression = :none
+          end
+
+          @compression = Arf.config.client_compression
+        end
+      end
+
+      def handle_ping(fr)
+        return protocol_error! unless @configured
+
+        if fr.ack?
+          @pong_signal.broadcast
+          return
+        end
+
+        dispatch_frame(PingFrame) do |p|
+          p.ack!
+          p.payload = fr.payload
+        end
+      end
+
+      def handle_go_away(fr)
+        return protocol_error! unless @configured
+
+        # server intends to disconnect
+        cancel_streams(fr.error_code)
+        close_connection_after_writing
+      end
+
+      def handle_reset_stream(fr)
+        return protocol_error! unless @configured
+
+        str = fetch_stream(fr.stream_id)
+        return protocol_error! unless str
+
+        str.handle_reset_stream(fr)
+      end
+
+      def handle_configuration(fr)
+        return protocol_error! if !fr.ack? || @configured
+
+        @configured = true
+        @configuration_ready_lock.synchronize do
+          @configuration_ready_signal.broadcast
+        end
+      end
+
+      def handle_data(fr)
+        return protocol_error! unless @configured
+
+        str = fetch_stream(fr.stream_id)
+        return reset_stream(fr.stream_id, ERROR_CODE_PROTOCOL_ERROR) unless str
+
+        str.handle_data(fr)
+      end
+
+      def new_stream
+        wait_configuration
+        id = nil
+        @streams_monitor.synchronize do
+          @last_stream_id += 1
+          id = @last_stream_id
+          @streams[id] = Stream.new(id, self)
+          dispatch_frame(MakeStreamFrame) do |fr|
+            fr.stream_id = id
+          end
+        end
+        @streams[id]
+      end
+
+      def terminate(reason)
+        dispatch_frame(GoAwayFrame) do |g|
+          g.error_code = reason
+          g.last_stream_id = @last_stream_id
+        end
+        close_connection_after_writing
+      end
+
+      def close
+        wait_configuration
+        @streams_monitor.synchronize do
+          close_connection
+        end
+      end
+    end
+  end
+end

data/lib/arf/wire/encoding.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Arf
+  module Wire
+    MAX_PAYLOAD = 65_535
+
+    def self.encode_uint16(v) = [v].pack("S>")
+    def self.encode_uint32(v) = [v].pack("L>")
+    def self.decode_uint16(io) = io.read(2).unpack1("S>")
+    def self.decode_uint32(io) = io.read(4).unpack1("L>")
+
+    def self.data_frames_from_buffer(id, buf, end_stream: false)
+      buf = case buf
+            when StringIO then buf.string
+            when String then buf
+            else buf.to_s
+            end
+
+      len = buf.length
+      if len <= MAX_PAYLOAD
+        return [
+          DataFrame.new do |fr|
+            fr.stream_id = id
+            fr.end_data!
+            fr.end_stream! if end_stream
+            fr.payload = buf
+          end
+        ]
+      end
+
+      frames = []
+      written = 0
+      loop do
+        to_write = [len - written, MAX_PAYLOAD].min
+        end_data = (len - written - to_write).zero?
+        frames << DataFrame.new do |fr|
+          fr.stream_id = id
+          fr.end_data! if end_data
+          fr.end_stream! if end_stream
+          fr.payload = buf[written...written + to_write]
+        end
+        written += to_write
+        break if end_data
+      end
+
+      frames
+    end
+  end
+end