arf 0.1.0

data/lib/arf/wire/server/peer.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Arf
+  module Wire
+    class Server
+      class Peer < Wire::BaseConnection
+        def initialize(server)
+          super()
+          @server = server
+          @id = @server.register_peer(self)
+          @log = Arf.logger.with_fields(subsystem: "Peer", id: @id)
+        end
+
+        def close
+          super
+          @server.unregister_peer(@id)
+        end
+
+        def handle_configuration(fr)
+          return protocol_error! if @configured
+
+          resp = ConfigurationFrame.new.tap(&:ack!)
+
+          if fr.compression_brotli?
+            @compression = :brotli
+            resp.compression_brotli!
+          elsif fr.compression_gzip?
+            @compression = :gzip
+            resp.compression_gzip!
+          end
+
+          resp.max_concurrent_streams = 0 # TODO
+
+          @configured = true
+          @log.debug("Configuration OK")
+          dispatch(resp)
+        end
+
+        def handle_go_away(fr)
+          return protocol_error! unless @configured
+
+          # client intends to disconnect
+          cancel_streams(fr.error_code)
+          close_connection_after_writing
+        end
+
+        def handle_make_stream(fr)
+          return protocol_error! unless @configured
+          return protocol_error! unless fetch_stream(fr.stream_id).nil?
+
+          @streams_monitor.synchronize do
+            @streams[fr.stream_id] = Stream.new(fr.stream_id, self)
+          end
+          @log.debug("Async dispatch handle_stream")
+          Reactor.post { @server.handle_stream(@streams[fr.stream_id]) }
+        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 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 reset_stream(id, code)
+          dispatch_frame(ResetStreamFrame) do |r|
+            r.stream_id = id
+            r.error_code = code
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arf/wire/server.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "server/peer"
+
+module Arf
+  module Wire
+    class Server
+      def initialize(handler)
+        @peers = {}
+        @peer_id = 0
+        @peers_monitor = Monitor.new
+        @handler = handler
+        @logger = Arf.logger.with_fields(subsystem: "Server")
+      end
+
+      def register_peer(peer)
+        @logger.debug("Registered peer", peer: peer.class.name)
+        @peers_monitor.synchronize do
+          id = @peer_id
+          @peer_id += 1
+          @peers[id] = peer
+          id
+        end
+      end
+
+      def unregister_peer(id)
+        @peers_monitor.synchronize do
+          @peers.delete(id)
+        end
+      end
+
+      def peer_by_id(id)
+        @peers_monitor.synchronize do
+          @peers[id]
+        end
+      end
+
+      def handle_stream(str)
+        @logger.debug("Handle Stream received")
+        @handler&.handle_stream(str)
+      end
+
+      def cancel_stream(str) = @handler&.cancel_stream(str)
+
+      def shutdown
+        return unless @tcp_server
+
+        @tcp_server.close
+        Arf::Reactor.detach(@tcp_server)
+        @peers_monitor.synchronize do
+          @peers.each_value { _1.go_away! ERROR_CODE_NO_ERROR, terminate: true }
+        end
+      end
+
+      def run
+        config = Arf.config
+        @tcp_server = TCPServer.new(config.bind_address, config.bind_port)
+        @tcp_server.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+        Arf::Reactor.attach_server(@tcp_server, Peer, self)
+      end
+    end
+  end
+end

data/lib/arf/wire/stream/state.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Arf
+  module Wire
+    class Stream
+      class State
+        attr_reader :code
+        attr_accessor :error
+
+        def initialize
+          @code = :open
+          @error = nil
+        end
+
+        def close
+          @code = :closed
+        end
+
+        def close_local
+          @code = case @code
+                  when :open then :half_closed_local
+                  when :half_closed_local then :half_closed_local
+                  when :half_closed_remote, :closed then :closed
+                  end
+        end
+
+        def close_remote
+          @code = case @code
+                  when :open then :half_closed_remote
+                  when :half_closed_local, :closed then :closed
+                  when :half_closed_remote then :half_closed_remote
+                  end
+        end
+
+        def closed? = (@code == :closed)
+        def remote_closed? = (@code == :half_closed_remote)
+        def local_closed? = (@code == :half_closed_local)
+
+        def may_reset_stream?
+          raise @error if @error
+          raise ClosedStreamError if closed?
+
+          true
+        end
+
+        def may_receive_data?
+          raise @error if @error
+          raise ClosedStreamError if closed? || remote_closed?
+
+          true
+        end
+
+        def may_send_reset_stream?
+          raise @error if @error
+          raise ClosedStreamError if closed? || local_closed?
+
+          true
+        end
+
+        def may_send_data?
+          raise @error if @error
+          raise ClosedStreamError if closed? || local_closed?
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/arf/wire/stream.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "stream/state"
+
+module Arf
+  module Wire
+    class Stream
+      attr_reader :id, :state
+      attr_accessor :external_id
+
+      def initialize(id, driver)
+        @id = id
+        @driver = driver
+        @state = State.new
+        @tmp_data = StringIO.new
+        @to_read_monitor = Monitor.new
+        @to_read = Queue.new
+        @handler = nil
+        @log = Arf.logger.with_fields(component: "Stream", driver: @driver.class.name)
+      end
+
+      def attach_handler(handler)
+        @log.debug("Attached handler", handler:)
+        @handler = handler
+        @to_read_monitor.synchronize do
+          @handler.handle_data(@to_read.shift) until @to_read.empty?
+        end
+      end
+
+      def handle_reset_stream(fr)
+        # return if @state.closed? # Ignore resets when stream is closed
+        @state.may_reset_stream?
+        @state.close
+        @state.error = StreamResetError.new(fr.error_code)
+      rescue ClosedStreamError
+        reset!(Wire::ERROR_CODE_STREAM_CLOSED)
+      end
+
+      def handle_data(fr)
+        @state.may_receive_data?
+        data = case fr.payload
+               when StringIO then fr.payload.string
+               when String then fr.payload
+               else fr.payload.to_s
+               end
+
+        @tmp_data.write(data)
+
+        if fr.end_data? && @tmp_data.length.positive?
+          @tmp_data.rewind
+          @to_read_monitor.synchronize do
+            if @handler && @to_read.empty?
+              @handler.handle_data(@tmp_data)
+            else
+              @to_read << @tmp_data
+            end
+            @tmp_data = StringIO.new
+          end
+        end
+        @state.close_remote if fr.end_stream?
+      rescue ClosedStreamError
+        reset!(Wire::ERROR_CODE_STREAM_CLOSED)
+      end
+
+      def reset!(code)
+        write(ResetStreamFrame) do |fr|
+          fr.stream_id = @id
+          fr.error_code = code
+        end
+      end
+
+      def reset(code)
+        @state.may_send_reset_stream?
+        @state.close
+        reset!(code)
+      end
+
+      def close_local
+        @state.may_send_data?
+        @state.close_local
+        write(DataFrame) do |fr|
+          fr.end_data!
+          fr.end_stream!
+        end
+      end
+
+      def read
+        raise @state.error if @state.error
+
+        begin
+          val = @to_read.shift(true)
+          return val if val
+        rescue ThreadError
+          nil
+        end
+
+        @state.may_receive_data?
+        nil
+      end
+
+      def read_blocking
+        raise @state.error if @state.error
+
+        val = @to_read.shift
+        return val if val
+
+        nil
+      end
+
+      def write(type, &)
+        @log.debug("Dispatching", type:)
+        inst = type.new(&)
+        inst.stream_id = @id if inst.respond_to?(:stream_id=)
+        @driver.dispatch(inst)
+      end
+
+      def write_data(value, end_stream: false)
+        @state.may_send_data?
+
+        @log.dump("Writing", value, source: caller[0])
+        Wire.data_frames_from_buffer(@id, value, end_stream:).each do |fr|
+          @driver.dispatch(fr)
+        end
+        @state.close_local if end_stream
+      end
+    end
+  end
+end

data/lib/arf/wire/wait_signal.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Arf
+  module Wire
+    class WaitSignal
+      def initialize
+        @mutex = Mutex.new
+        @cond = Thread::ConditionVariable.new
+      end
+
+      def wait
+        @mutex.synchronize do
+          @cond.wait(@mutex)
+        end
+      end
+
+      def broadcast
+        @mutex.synchronize do
+          @cond.broadcast
+        end
+      end
+    end
+  end
+end

data/lib/arf/wire.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "wire/encoding"
+require_relative "wire/wait_signal"
+require_relative "wire/frame_kind"
+require_relative "wire/error_code"
+require_relative "wire/errors"
+require_relative "wire/frame"
+require_relative "wire/frames"
+require_relative "wire/base_connection"
+require_relative "wire/client"
+require_relative "wire/frame_reader"
+require_relative "wire/stream"
+require_relative "wire/server"

data/lib/arf.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "securerandom"
+require "openssl"
+require "monitor"
+
+Thread.abort_on_exception = true
+
+require "zlib"
+require "brotli"
+require "logrb"
+require "nio"
+require "concurrent"
+
+require_relative "arf/version"
+require_relative "arf/configuration"
+require_relative "arf/reactor"
+require_relative "arf/errors"
+require_relative "arf/io/buffer"
+require_relative "arf/io/limit_reader"
+require_relative "arf/io/compression"
+require_relative "arf/observer"
+require_relative "arf/types"
+require_relative "arf/proto"
+require_relative "arf/wire"
+require_relative "arf/status"
+require_relative "arf/rpc"
+require_relative "arf/context"
+require_relative "arf/server"
+
+module Arf
+  def self.configure
+    inst = Configuration.instance
+    yield inst if block_given?
+    nil
+  end
+
+  def self.configuration = Configuration.instance
+  def self.config = configuration
+  def self.logger = configuration.logger
+
+  def self.connect(host, port)
+    Reactor.connect(host, port, Wire::Client)
+  end
+end

metadata

@@ -0,0 +1,195 @@
+--- !ruby/object:Gem::Specification
+name: arf
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vito Sartori
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-12-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: brotli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: logrb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+- !ruby/object:Gem::Dependency
+  name: nio4r
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: zlib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: Opinionated RPC framework for inter-process, inter-application communication
+email:
+- hey@vito.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".ruby-version"
+- LICENSE.txt
+- Rakefile
+- lib/arf.rb
+- lib/arf/configuration.rb
+- lib/arf/context.rb
+- lib/arf/errors.rb
+- lib/arf/io/buffer.rb
+- lib/arf/io/compression.rb
+- lib/arf/io/limit_reader.rb
+- lib/arf/observer.rb
+- lib/arf/proto.rb
+- lib/arf/proto/array.rb
+- lib/arf/proto/boolean.rb
+- lib/arf/proto/bytes.rb
+- lib/arf/proto/decoder.rb
+- lib/arf/proto/encoder.rb
+- lib/arf/proto/float.rb
+- lib/arf/proto/map.rb
+- lib/arf/proto/registry.rb
+- lib/arf/proto/scalar.rb
+- lib/arf/proto/string.rb
+- lib/arf/proto/struct.rb
+- lib/arf/proto/types.rb
+- lib/arf/proto/union.rb
+- lib/arf/reactor.rb
+- lib/arf/rpc.rb
+- lib/arf/rpc/base_message.rb
+- lib/arf/rpc/client_base.rb
+- lib/arf/rpc/end_stream.rb
+- lib/arf/rpc/enum.rb
+- lib/arf/rpc/message_kind.rb
+- lib/arf/rpc/metadata.rb
+- lib/arf/rpc/method_meta.rb
+- lib/arf/rpc/request.rb
+- lib/arf/rpc/responder.rb
+- lib/arf/rpc/response.rb
+- lib/arf/rpc/service_base.rb
+- lib/arf/rpc/start_stream.rb
+- lib/arf/rpc/stream_error.rb
+- lib/arf/rpc/stream_item.rb
+- lib/arf/rpc/stream_metadata.rb
+- lib/arf/rpc/struct.rb
+- lib/arf/server.rb
+- lib/arf/status.rb
+- lib/arf/types.rb
+- lib/arf/types/array_type.rb
+- lib/arf/types/base_type.rb
+- lib/arf/types/coercion.rb
+- lib/arf/types/in_out_stream.rb
+- lib/arf/types/input_stream.rb
+- lib/arf/types/map_type.rb
+- lib/arf/types/mixin.rb
+- lib/arf/types/output_stream.rb
+- lib/arf/types/streamer.rb
+- lib/arf/version.rb
+- lib/arf/wire.rb
+- lib/arf/wire/base_connection.rb
+- lib/arf/wire/client.rb
+- lib/arf/wire/encoding.rb
+- lib/arf/wire/error_code.rb
+- lib/arf/wire/errors.rb
+- lib/arf/wire/frame.rb
+- lib/arf/wire/frame_kind.rb
+- lib/arf/wire/frame_reader.rb
+- lib/arf/wire/frames.rb
+- lib/arf/wire/frames/base_frame.rb
+- lib/arf/wire/frames/configuration_frame.rb
+- lib/arf/wire/frames/data_frame.rb
+- lib/arf/wire/frames/go_away_frame.rb
+- lib/arf/wire/frames/make_stream_frame.rb
+- lib/arf/wire/frames/ping_frame.rb
+- lib/arf/wire/frames/reset_stream_frame.rb
+- lib/arf/wire/server.rb
+- lib/arf/wire/server/peer.rb
+- lib/arf/wire/stream.rb
+- lib/arf/wire/stream/state.rb
+- lib/arf/wire/wait_signal.rb
+homepage: https://github.com/arf-rpc/arf-ruby
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/arf-rpc/arf-ruby
+  changelog_uri: https://github.com/arf-rpc/arf-ruby/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: arf stands for Another RPC Framework
+test_files: []