gritz-async 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 59d377f48d334487af680d8fe06e5df46db7d537575b78e24d0a23bd7c2a6257
+  data.tar.gz: 8f6442cfe1bf49317590b37476d52e15cc3212f5a9d971d7bab465a91a428ccb
+SHA512:
+  metadata.gz: 7aa534c767bbea2737f46780d40e76d83da144a00352a8ec02896b0961334be10d97e9dd24ab0e375778ee5b8231c04fc1216d6e04a7602e5d4241ae234a2ddf
+  data.tar.gz: 1b1999373166196387c5bf5437f9c0cafb22fd7de9270bcd568f09174a47db6b91393720a8e0f81ff84a29e0a4c730b897e289d3c8f7c46cf3232de8004f619d

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0
+
+Initial release.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 ydah
+
+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/README.md

@@ -0,0 +1,87 @@
+# Gritz Async
+
+Experimental Fiber-based gRPC server adapter for [Gritz](https://github.com/gritzrpc/gritz-core), built on `async-grpc`. Requires CRuby 3.3+. Each RPC runs in a Fiber; workers inherit a TCP listener that stays open across master replacement.
+
+The runtime depends on `gritz-core`, `async-grpc` and their protobuf/HTTP dependencies. It does not install the official `grpc` gem or `gritz-native`. The `gritz` meta gem selects Native, so Async applications install `gritz-async` instead.
+
+## Install
+
+```ruby
+gem "gritz-async", "~> 0.1.0"
+```
+
+Until the initial release, use `gem "gritz-async", git: "https://github.com/gritzrpc/gritz-async.git", branch: "main"`. Core 0.6.0 must be available. See [release instructions](docs/guides/releasing.md).
+
+## Quick start
+
+Generate protobuf **messages** with `protoc --ruby_out=lib hello.proto`. Declare the service with the matching protobuf package and service name; the generated `*_services_pb.rb` file uses the official grpc gem and is unnecessary for the Async server.
+
+```ruby
+# config/gritz.rb
+require "gritz/async"
+require_relative "../lib/hello_pb"
+
+class Greeter < Gritz::Async::Service
+  self.service_name = "helloworld.Greeter"
+  rpc :SayHello, Helloworld::HelloRequest, Helloworld::HelloReply
+end
+
+class GreeterController < Gritz::Controller
+  bind Greeter
+  def say_hello
+    Helloworld::HelloReply.new(message: "Hello, #{request.message.name}")
+  end
+end
+
+transport :async
+listener_strategy :inherited_fd
+workers 0
+bind "127.0.0.1:50051"
+register_controller GreeterController
+```
+
+```sh
+bundle exec gritz routes -C config/gritz.rb
+bundle exec gritz check -C config/gritz.rb
+bundle exec gritz start -C config/gritz.rb
+grpcurl -plaintext -proto hello.proto -d '{"name":"Ruby"}' \
+  127.0.0.1:50051 helloworld.Greeter/SayHello
+```
+
+The [hello example](examples/hello) implements unary, server-streaming, client-streaming and bidirectional RPCs. The service DSL uses `stream(MessageClass)` for streaming inputs and outputs. Controllers, middleware, errors, request IDs, rich error details and tracing use the same core API as Native.
+
+## Concurrency and process lifecycle
+
+Set `workers` above zero on Linux to fork multiple workers. With `inherited_fd`, the launcher owns one listening socket and passes it to fresh masters, which fork workers. A port of zero stays stable through worker replacement and `USR2`. `reuseport` is also supported, with the core's usual fixed-port requirement for multiple workers.
+
+The adapter has one reactor thread per worker. `threads + max_waiting_requests` bounds concurrent RPC fibers; this is a capacity limit, not a pool of OS threads. Excess calls receive `RESOURCE_EXHAUSTED`. Use scheduler-aware I/O in handlers: blocking native drivers or CPU work stop progress for other RPCs on that worker.
+
+Client cancellation and deadlines unwind scheduler-aware handlers. Graceful stop sends HTTP/2 GOAWAY, finishes accepted RPCs until `shutdown_timeout`, then closes outstanding connections. Admin `/livez`, `/readyz`, `/metrics` and `/status`, lifecycle hooks, worker resizing, phased restart and hot reexec remain available through the core supervisor.
+
+Incoming frames, decompressed payloads, serialized replies and request metadata respect the configured size limits. Defaults are 4 MiB per message and 8 KiB of metadata.
+
+## Initial release limits
+
+This experimental release serves plaintext HTTP/2 gRPC. TLS/mTLS, gRPC Health and Reflection are not implemented; TLS and Reflection configuration fails before binding. Use a TLS-terminating gRPC proxy and Gritz's HTTP readiness endpoint when needed.
+
+Native connection-age and keepalive settings do not apply to this adapter. Their shared defaults remain unchanged; changing them raises a configuration error. `fork_mode :grpc_fork_support` and Native client factories require `gritz-native`. Async applications can use `Async::GRPC::Client` for outbound calls.
+
+For Rails, select the Async transport before `rails_app`; gritz-rails 0.2.0 sets `ActiveSupport::IsolatedExecutionState.isolation_level = :fiber`. Use a scheduler-aware database driver and a suitable connection pool. gritz-otel 0.3.0 supports server tracing in isolated RPC fibers.
+
+## Development
+
+```sh
+bundle install
+COVERAGE=1 bundle exec rake
+bundle exec rubocop
+bundle exec bundler-audit check --update
+bundle exec rake build
+```
+
+CI runs Ruby 3.3, 3.4 and 4.0. The shared `Gritz::Testing::TransportContract` uses the official grpc client solely as a development dependency, verifying all four RPC forms, metadata, errors, deadlines, cancellation and graceful shutdown. Tests also run a C-core-free cluster through worker kill, resizing, phased replacement and fresh master replacement. See the [validation report](docs/reports/async-validation.md) and [upstream integration decisions](docs/adr/async-transport.md).
+
+`pkg/gritz-async.gem` is the strict-built release package. Initial publication and Trusted Publishing setup are performed by the project owner. See [CONTRIBUTING.md](CONTRIBUTING.md) and the [release guide](docs/guides/releasing.md).
+
+## License
+
+[MIT](LICENSE.txt).

data/exe/gritz

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "gritz/async"
+require "rbconfig"
+require "socket"
+
+owner_fd = ENV.delete("GRITZ_INTERNAL_OWNER_FD")
+exit Gritz::CLI.new(launch: owner_fd.nil?, owner_io: owner_fd && UNIXSocket.for_fd(Integer(owner_fd)),
+                    launch_command: [RbConfig.ruby, File.expand_path($PROGRAM_NAME), *ARGV]).run(ARGV)

data/lib/gritz/async/service.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "protocol/grpc/interface"
+
+module Gritz
+  module Async
+    # Protobuf service declarations that need no grpc C extension.
+    # Uses protocol-grpc's rpc/stream DSL, with the same service name as the .proto file.
+    # @api public
+    class Service < Protocol::GRPC::Interface
+      class << self
+        attr_accessor :service_name
+
+        def rpc_descs
+          rpcs.transform_values do |rpc|
+            Descriptor.new(rpc.request_class, rpc.response_class, rpc.streaming)
+          end
+        end
+      end
+
+      # Shapes protocol-grpc descriptors for the existing transport-independent router.
+      # @api private
+      Stream = Struct.new(:type)
+      Descriptor = Struct.new(:request_type, :response_type, :kind) do
+        def client_streamer? = kind == :client_streaming
+        def server_streamer? = kind == :server_streaming
+        def bidi_streamer? = kind == :bidirectional
+        def input = client_streamer? || bidi_streamer? ? Stream.new(request_type) : request_type
+        def output = server_streamer? || bidi_streamer? ? Stream.new(response_type) : response_type
+      end
+    end
+  end
+end

data/lib/gritz/async/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Gritz
+  module Async
+    VERSION = "0.1.0"
+  end
+end

data/lib/gritz/async.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "gritz/core"
+require_relative "async/version"
+require_relative "async/service"
+require_relative "transport/async"
+require "gritz/testing/server"

data/lib/gritz/transport/async/body.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "async/condition"
+require "protocol/http/body/wrapper"
+
+module Gritz
+  module Transport
+    class Async
+      # Delays HTTP headers until the handler sends metadata, data or a final status.
+      # @api private
+      class Body < Protocol::HTTP::Body::Wrapper
+        def initialize(body)
+          super
+          @headers_ready = ::Async::Condition.new
+        end
+
+        def release_headers
+          @released = true
+          @headers_ready.signal
+        end
+
+        def length
+          @headers_ready.wait until @released
+          super
+        end
+      end
+    end
+  end
+end

data/lib/gritz/transport/async/bridge.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "async/grpc/dispatcher"
+require "async/grpc/service"
+require "securerandom"
+require_relative "call"
+require_relative "body"
+require_relative "input"
+
+module Gritz
+  module Transport
+    class Async
+      # Reuses async-grpc's routing, framing, status and deadline implementation.
+      # @api private
+      class Bridge < ::Async::GRPC::Dispatcher
+        def initialize(adapter, routes, config:, logger:)
+          super()
+          @adapter = adapter
+          @routes = routes
+          @config = config
+          @logger = logger
+          routes.values.group_by(&:service).each do |name, descriptors|
+            interface = Class.new(Protocol::GRPC::Interface)
+            descriptors.each do |descriptor|
+              # Run unary handlers in child tasks too, so headers and cancellation
+              # can progress while the application is waiting for I/O.
+              interface.rpc(descriptor.name.to_sym, descriptor.input_type, descriptor.output_type, streaming: :bidirectional)
+            end
+            service = ::Async::GRPC::Service.new(interface, name)
+            descriptors.each { |descriptor| service.define_singleton_method(descriptor.action) { nil } }
+            register(service)
+          end
+        end
+
+        protected
+
+        def invoke_service(_service, _method, input, output, protocol)
+          protocol.response.body = Body.new(output)
+          descriptor = @routes.fetch(protocol.request.path)
+          input = Input.new(input.body, limit: @config.max_receive_message_size, message_class: descriptor.input_type, encoding: input.encoding)
+          call = Call.new(method_descriptor: descriptor, protocol:, input:, output:, max_send_size: @config.max_send_message_size)
+          owner = ::Async::Task.current
+          monitor = owner.async do
+            sleep 0.01 until call.cancelled?
+            owner.stop
+          end
+          terminal_error = nil
+          begin
+            size = protocol.request.headers.each.sum { |key, value| key.bytesize + Array(value).sum { |item| item.to_s.bytesize } + 32 }
+            raise Errors::ResourceExhausted, "request metadata exceeds max_metadata_size" if size > @config.max_metadata_size
+
+            @adapter.dispatch(call)
+          rescue Gritz::Error => e
+            terminal_error = e
+            raise
+          ensure
+            begin
+              call.finish(terminal_error)
+            ensure
+              monitor.stop
+            end
+          end
+        end
+
+        private
+
+        def assign_status(protocol, error)
+          unless error.is_a?(Gritz::Error) || error.is_a?(::Async::GRPC::DeadlineExceededError) || error.is_a?(Protocol::GRPC::Error)
+            error_id = SecureRandom.uuid
+            @logger.error("#{error_id}: #{error.full_message}")
+            error = Errors::Internal.new("internal error (#{error_id})", metadata: { "error-id" => error_id })
+            protocol.response.headers.add("error-id", error_id)
+          end
+          super
+        end
+
+        def status_for(error)
+          return [error.grpc_code, error.message] if error.is_a?(Gritz::Error)
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/gritz/transport/async/call.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "base64"
+require "google/rpc/status_pb"
+require "google/protobuf/well_known_types"
+
+module Gritz
+  module Transport
+    class Async
+      # Maps protocol-grpc streams and metadata onto the common RPC contract.
+      # @api private
+      class Call
+        include Gritz::Call
+
+        attr_reader :method_descriptor, :trailing_metadata, :deadline
+
+        def initialize(method_descriptor:, protocol:, input:, output:, max_send_size:)
+          @method_descriptor = method_descriptor
+          @protocol = protocol
+          @input = input
+          @output = output
+          @max_send_size = max_send_size
+          @deadline = Time.now + protocol.deadline.remaining if protocol.deadline
+          @trailing_metadata = {}
+        end
+
+        def metadata = @protocol.metadata.transform_values { |value| value.is_a?(Array) && value.one? ? value.first : value }
+        def cancelled? = @protocol.request.stream.closed?
+        def read = @input.read
+
+        def write(message)
+          if method_descriptor.output_type.encode(message).bytesize > @max_send_size
+            raise Errors::ResourceExhausted, "response message exceeds max_send_message_size"
+          end
+
+          @protocol.response.body.release_headers
+          @output.write(message)
+        end
+
+        def peer
+          address = @protocol.request.remote_address
+          return unless address
+
+          "#{address.ipv6? ? 'ipv6' : 'ipv4'}:#{address.ip_address}:#{address.ip_port}"
+        end
+
+        def send_initial_metadata(metadata = {})
+          merge_initial_metadata(metadata)
+          @protocol.response.body.release_headers
+        end
+
+        def merge_initial_metadata(metadata = {})
+          headers = @protocol.response.headers
+          metadata.each do |key, value|
+            headers.delete(key)
+            Array(value).each { |item| headers.add(key, encode_metadata(key, item)) }
+          end
+        end
+
+        def finish(error = nil)
+          metadata = trailing_metadata.merge(error.is_a?(Gritz::Error) ? error.metadata : {})
+          if error.is_a?(Gritz::Error) && !error.details.empty?
+            details = error.details.map { |detail| detail.is_a?(Google::Protobuf::Any) ? detail : Google::Protobuf::Any.pack(detail) }
+            metadata["grpc-status-details-bin"] = Google::Rpc::Status.encode(
+              Google::Rpc::Status.new(code: error.grpc_code, message: error.message, details:)
+            )
+          end
+          headers = @protocol.response.headers
+          headers.trailer!
+          metadata.each { |key, value| Array(value).each { |item| headers.add(key, encode_metadata(key, item)) } }
+        ensure
+          @protocol.response.body.release_headers
+        end
+
+        private
+
+        def encode_metadata(key, value) = key.end_with?("-bin") ? Base64.strict_encode64(value) : value.to_s
+      end
+    end
+  end
+end

data/lib/gritz/transport/async/input.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "protocol/grpc/body/readable"
+
+module Gritz
+  module Transport
+    class Async
+      # Bounds both the wire frame and the inflated payload before protobuf decoding.
+      # @api private
+      class Input < Protocol::GRPC::Body::Readable
+        def initialize(body, limit:, **)
+          super(body, **)
+          @limit = limit
+        end
+
+        def read
+          @prefix = true
+          super
+        end
+
+        private
+
+        def read_exactly(length)
+          check_size!(length) unless @prefix
+          @prefix = false
+          super
+        end
+
+        def decompress(data)
+          return super unless %w[gzip deflate].include?(encoding)
+
+          inflater = Zlib::Inflate.new(Zlib::MAX_WBITS + (encoding == "gzip" ? 16 : 0))
+          output = +"".b
+          inflater.inflate(data) do |chunk|
+            check_size!(output.bytesize + chunk.bytesize)
+            output << chunk
+          end
+          raise Errors::InvalidArgument, "truncated compressed request" unless inflater.finished?
+
+          output
+        rescue Zlib::Error
+          raise Errors::InvalidArgument, "invalid compressed request"
+        ensure
+          inflater&.close
+        end
+
+        def check_size!(size)
+          raise Errors::ResourceExhausted, "request message exceeds max_receive_message_size" if size > @limit
+        end
+      end
+    end
+  end
+end

data/lib/gritz/transport/async/server.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "async/http/protocol/http2"
+
+module Gritz
+  module Transport
+    class Async
+      # Owns HTTP/2 connections so shutdown can send GOAWAY and retain active streams.
+      # @api private
+      class Server
+        class Connection < ::Async::HTTP::Protocol::HTTP2::Server
+          attr_reader :last_stream_id
+
+          def drain!
+            @last_stream_id = remote_stream_id
+            frame = Protocol::HTTP2::GoawayFrame.new
+            frame.pack(@last_stream_id, 0, "")
+            # Upstream send_goaway also closes the reader, losing active responses.
+            write_frame(frame)
+          end
+        end
+
+        # A client may reset its stream while the handler is still completing.
+        module ResponseLifecycle
+          def send_response(response)
+            return response&.close if stream.closed?
+
+            super
+          rescue Protocol::HTTP2::ProtocolError
+            raise unless stream.closed?
+
+            response&.close
+          end
+        end
+
+        def initialize(app, logger)
+          @app = app
+          @logger = logger
+          @connections = {}
+        end
+
+        def accept(peer, _address)
+          connection = Connection.new(::IO::Stream(peer))
+          connection.read_connection_preface(::Async::HTTP::Protocol::HTTP2::SERVER_SETTINGS)
+          connection.drain! if @stopping
+          connection.start_connection
+          @connections[connection] = true
+          connection.each do |request|
+            request.scheme ||= "http"
+            request.extend(ResponseLifecycle)
+            next if request.stream.closed?
+
+            if connection.last_stream_id && request.stream.id > connection.last_stream_id
+              # Decode frames normally to retain HPACK and flow-control state.
+              request.stream.send_reset_stream(Protocol::HTTP2::REFUSED_STREAM)
+              next
+            end
+
+            @app.call(request)
+          end
+        rescue IOError, SystemCallError, Protocol::HTTP2::Error => e
+          @logger.debug("Async connection closed: #{e.class}")
+        ensure
+          @connections.delete(connection)
+          connection&.close
+        end
+
+        def stop(deadline:)
+          @stopping = true
+          @connections.keys.each do |connection| # rubocop:disable Style/HashEachMethods -- IO can yield while other connections change.
+            connection.drain! unless connection.closed?
+          rescue IOError, SystemCallError, Protocol::HTTP2::Error
+            connection.close
+          end
+          until @connections.empty? || Time.now >= deadline
+            break if @connections.keys.all? { |connection| connection.streams.empty? }
+
+            sleep 0.001
+          end
+          @connections.keys.each(&:close) # rubocop:disable Style/HashEachMethods -- Closing can yield and change connections.
+        end
+      end
+    end
+  end
+end

data/lib/gritz/transport/async.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "set" # rubocop:disable Lint/RedundantRequireStatement -- required by Ruby 3.3
+require "socket"
+require "async"
+require_relative "async/bridge"
+require_relative "async/server"
+
+module Gritz
+  module Transport
+    # Runs RPC controllers in fibers without the grpc C extension.
+    # @api public
+    class Async
+      def self.capabilities = Set[:unary, :client_streaming, :server_streaming, :bidi, :reuseport, :inherited_fd, :fiber].freeze
+
+      def initialize(config:, dispatcher:, logger:)
+        @config = config
+        @dispatcher = dispatcher
+        @logger = logger
+        @lock = Mutex.new
+        @inflight = {}.compare_by_identity
+        @requests_total = @rejected_total = 0
+      end
+
+      # The caller retains ownership of an inherited socket; only its duplicate is closed.
+      # @return [Integer] the selected TCP port
+      def bind(listener_spec = @config.bind)
+        raise ArgumentError, "transport is already bound" if @listener
+        raise ArgumentError, "at least one controller must be registered" if @dispatcher.router.routes.empty?
+        raise ConfigurationError, "Async reflection is not supported" if @config.reflection
+        raise ConfigurationError, "Async TLS is not supported" unless @config.tls.empty?
+
+        %i[max_connection_age max_connection_age_grace keepalive_time keepalive_permit_without_calls].each do |setting|
+          unless @config.public_send(setting) == Configuration::DEFAULTS.fetch(setting)
+            raise ConfigurationError, "#{setting} is only supported by the Native adapter"
+          end
+        end
+
+        if listener_spec.respond_to?(:accept)
+          @listener = listener_spec.dup
+        else
+          @listener = Supervisor::Listener.bind(listener_spec, reuseport: @config.listener_strategy == :reuseport)
+        end
+        @listener.local_address.ip_port
+      end
+
+      def start
+        raise ArgumentError, "transport is stopped" if @stopped
+        raise ArgumentError, "bind must be called before start" unless @listener
+        raise ArgumentError, "transport is already started" if @thread
+
+        @control_r, @control_w = IO.pipe
+        ready = Queue.new
+        @thread = Thread.new do
+          Async do |root|
+            bridge = Bridge.new(self, @dispatcher.router.routes, config: @config, logger: @logger)
+            @server = Server.new(bridge, @logger)
+            acceptor = root.async do
+              loop do
+                peer, address = @listener.accept
+                root.async(peer, address) do |_task, client, remote|
+                  @server.accept(client, remote)
+                ensure
+                  client.close unless client.closed?
+                end
+              end
+            end
+            ready << true
+            @control_r.read(1)
+            acceptor.stop
+            @listener.close
+            @server.stop(deadline: @stop_deadline)
+          ensure
+            root.children.to_a.each(&:stop)
+          end
+        rescue StandardError => e
+          ready << e
+          raise
+        end
+        result = ready.pop(timeout: 5)
+        raise(result || "Async server did not start within 5 seconds") unless result == true
+
+        self
+      end
+
+      def running? = @thread&.alive? && !@stopped
+      def wait = @thread&.value
+
+      def stop(deadline:)
+        drain!
+        return if @stopped
+
+        @stopped = true
+        @stop_deadline = deadline
+        if @thread&.alive?
+          @control_w.write(".")
+          wait
+        end
+      ensure
+        @listener&.close unless @listener&.closed?
+        @control_r&.close unless @control_r&.closed?
+        @control_w&.close unless @control_w&.closed?
+      end
+
+      def kill = stop(deadline: Time.now)
+
+      def drain!
+        @draining = true
+        self
+      end
+
+      def update_health(ready:, checks: {}) = ready && checks.values.all? && !@draining
+
+      def refresh_health
+        checks = @config.health_checks.transform_values do |check|
+          check.call ? true : false
+        rescue StandardError
+          false
+        end
+        update_health(ready: running?, checks:)
+      end
+
+      def stats
+        @lock.synchronize do
+          oldest = @inflight.values.min
+          { inflight: @inflight.size, busy: @inflight.size, capacity: @config.threads + @config.max_waiting_requests,
+            rejected_total: @rejected_total, requests_total: @requests_total,
+            oldest_inflight_age: oldest ? Process.clock_gettime(Process::CLOCK_MONOTONIC) - oldest : 0 }
+        end
+      end
+
+      # @api private
+      def dispatch(call)
+        admitted = @lock.synchronize do
+          if @inflight.size >= @config.threads + @config.max_waiting_requests
+            @rejected_total += 1
+            false
+          else
+            @inflight[call] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            @requests_total += 1
+            true
+          end
+        end
+        raise Errors::ResourceExhausted, "Async concurrency limit reached" unless admitted
+
+        result = @dispatcher.call(call)
+        call.write(result) unless call.method_descriptor.server_streaming?
+      ensure
+        @lock.synchronize { @inflight.delete(call) } if admitted
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: gritz-async
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: async-grpc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: async-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.105.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.105.0
+- !ruby/object:Gem::Dependency
+  name: googleapis-common-protos-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.20'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.20'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: gritz-core
+  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: protocol-grpc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+- !ruby/object:Gem::Dependency
+  name: protocol-http2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.29.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.29.1
+description: The Async gRPC adapter for Gritz, with inherited listeners and transport-independent
+  controllers.
+email:
+- t.yudai92@gmail.com
+executables:
+- gritz
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/gritz
+- lib/gritz/async.rb
+- lib/gritz/async/service.rb
+- lib/gritz/async/version.rb
+- lib/gritz/transport/async.rb
+- lib/gritz/transport/async/body.rb
+- lib/gritz/transport/async/bridge.rb
+- lib/gritz/transport/async/call.rb
+- lib/gritz/transport/async/input.rb
+- lib/gritz/transport/async/server.rb
+homepage: https://github.com/gritzrpc/gritz-async
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  source_code_uri: https://github.com/gritzrpc/gritz-async
+  changelog_uri: https://github.com/gritzrpc/gritz-async/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Fiber-based gRPC transport for Gritz
+test_files: []