gritz-core 0.5.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed1b7320b17241d7bf44746aff7108965c5bd4ef5c5acfeb26bade59786c5775
-  data.tar.gz: 062fa21a3446621c20990013a0bb7a6dd23c38803d5e58597902f83079dba21c
+  metadata.gz: 365ed02137d42c5182e6f09a10544c189d7fe0d70fc0faffd2864b752e13e40c
+  data.tar.gz: 797d64d766c36257ef700d7647045d317c4027ed4b7295f959f54fec2139849e
 SHA512:
-  metadata.gz: 0f4702d111e9e72546b8a0a219703e355fba71a7ecbcd064d7c2fca60461789ee8c5c03dc98d050d843302f71506e9a9169bc88c9c8d73671231ff8ca8ca6035
-  data.tar.gz: 3fc17735fed2dc9068e54aae5853d6595d344458cb535eaa3be2ec8a63d2cd1c5d1f546175183639b3fa6f3309506bfa8d3041b91211456982023b187b6cb1a7
+  metadata.gz: 8cdc413c2a357fb5e98ce5c397ae5e1b69d136f89752d479d4960367fc0a2cf6d99dabeebede608aa2f7c8f948ee542640ff4f269323a7aa203d5ef07c027296
+  data.tar.gz: 3da9357cc46ca9f495f997803929d489e3ca691074cdad0b1e33f49457bcbc35d58ad37b3331b754b08967a3ff5376dfd60f6a02943a8e6e3e8fac34f78a35a7

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.6.1
+
+- Avoid formatting suppressed RPC completion logs, preserving responses, status mapping and metrics when INFO logging is disabled.
+
+## 0.6.0
+
+- Run Async workers through the same supervisor, CLI and real-server test helper as Native workers.
+- Retain one inherited listener across forked workers and fresh master replacement, including ephemeral ports and recycling.
+- Share adapter wire tests through `Gritz::Testing::TransportContract` without loading optional test dependencies in production.
+- Preserve Async deadline errors through the standard exception middleware.
+
 ## 0.5.0
 
 - Migrate Gruf controllers and server interceptors through `Gritz::Compat::Gruf`, with a configuration conversion tool.

data/README.md

@@ -6,10 +6,12 @@ Transport-independent controllers, routing, middleware, configuration, forked-wo
 require "gritz/core"
 ```
 
-Use [gritz](https://github.com/gritzrpc/gritz) for the default framework and executable, or combine this gem with [gritz-native](https://github.com/gritzrpc/gritz-native) for the official grpc gem adapter. The Fiber adapter `gritz-async` is planned.
+Use [gritz](https://github.com/gritzrpc/gritz) for the default framework and executable, or combine this gem with [gritz-native](https://github.com/gritzrpc/gritz-native) for the official grpc gem adapter. The experimental [gritz-async](https://github.com/gritzrpc/gritz-async) adapter runs RPCs in fibers and supports inherited TCP listeners without installing the official grpc gem.
 
 Controller tests can load `gritz/testing/rspec` or `gritz/testing/minitest` and run without a network or the grpc gem. See the [controller examples](https://github.com/gritzrpc/gritz#controllers) and [configuration guide](docs/guides/configuration.md).
 
+`Gritz::Testing::Server` selects the configured adapter for real-socket tests; require that adapter's entrypoint first. Adapter suites explicitly require `gritz/testing/transport_contract` to run shared wire checks with RSpec, the official grpc client and googleapis-common-protos-types as test dependencies. Production eager loading skips this shared test suite.
+
 Supervised servers support phased replacement, fresh-interpreter hot reexec, request/memory/lifetime recycling, Admin HTTP probes and process-wide Prometheus totals. The CLI keeps one lifecycle owner across master generations; application controllers and gRPC resources stay in serving processes.
 
 `Gritz::Client.define` creates lazy, fork-safe client constants with deadline propagation, selected request headers and middleware around complete streams. See the [client guide](docs/guides/clients.md). Optional [gritz-otel](https://github.com/gritzrpc/gritz-otel) adds server/client spans and worker OTLP metrics after fork.

data/lib/gritz/cli.rb

@@ -16,7 +16,8 @@ module Gritz
     RUBY
 
     def self.child_command(argv)
-      [RbConfig.ruby, "-I", $LOAD_PATH.join(File::PATH_SEPARATOR), "-rgritz/core", "-e", CHILD_BOOTSTRAP, "--", *argv]
+      library = defined?(Transport::Async) ? "gritz/async" : "gritz/core"
+      [RbConfig.ruby, "-I", $LOAD_PATH.join(File::PATH_SEPARATOR), "-r#{library}", "-e", CHILD_BOOTSTRAP, "--", *argv]
     end
 
     def initialize(stdout: $stdout, stderr: $stderr, env: ENV, status_io: nil, owner_io: nil, launch: false, launch_command: nil)
@@ -63,7 +64,9 @@ module Gritz
 
       path ||= "config/gritz.rb" if File.file?("config/gritz.rb")
       guard = ForkGuard.activate(mode: :record) if command != "routes"
-      require "gritz/native" if command != "routes"
+      if command != "routes" && Gem.loaded_specs.key?("gritz-native") && !defined?(Transport::Async)
+        require "gritz/native"
+      end
       config = Configuration.load(path: path, env: @env, overrides: overrides)
       if command == "check"
         config.preload! if config.preload_app?
@@ -71,10 +74,12 @@ module Gritz
         return 1 unless guard.violations.empty?
 
         config.validate_runtime!
+        require "gritz/#{config.transport}"
         Router.new(controllers: config.controllers, strict: config.strict_routes, logger: logger)
         @stdout.puts "Configuration and fork safety checks passed"
       elsif command == "start"
         config.validate_runtime!
+        require "gritz/#{config.transport}"
         if config.workers.positive? && config.fork_mode == :clean
           raise guard.violations.first if config.fork_guard == :raise && !guard.violations.empty?
 
@@ -83,14 +88,27 @@ module Gritz
         @stdout.sync = true if @stdout.respond_to?(:sync=)
         @owner_channel&.write(type: "configured", pid: Process.pid, workers: config.workers, bind: config.bind,
                               admin_bind: config.admin_bind, min_ready_workers: config.min_ready_workers, pid_file: config.pid_file,
-                              reexec_timeout: config.reexec_timeout, drain_delay: config.drain_delay, shutdown_timeout: config.shutdown_timeout)
+                              reexec_timeout: config.reexec_timeout, drain_delay: config.drain_delay, shutdown_timeout: config.shutdown_timeout,
+                              listener_strategy: config.listener_strategy.to_s)
+        if @owner_channel && config.listener_strategy == :inherited_fd
+          until @owner_channel.flush
+            raise ConfigurationError, "listener owner closed its control channel" if @owner_channel.closed?
+
+            @owner_channel.io.wait_writable(0.01)
+          end
+          begin
+            listener = @owner_channel.io.recv_io(Socket)
+          rescue IOError, SocketError => e
+            raise ConfigurationError, "listener owner failed to pass its socket: #{e.message}"
+          end
+        end
         if config.workers.positive?
-          return Supervisor::Master.new(config, logger: logger, status_io: @status_io, owner_channel: @owner_channel).run
+          return Supervisor::Master.new(config, logger: logger, status_io: @status_io, owner_channel: @owner_channel, listener:).run
         end
 
         ForkGuard.deactivate
         config.preload! if config.preload_app?
-        return Worker::Runner.new(index: 0, config: config, logger: logger, owner_channel: @owner_channel).run
+        return Worker::Runner.new(index: 0, config: config, logger: logger, owner_channel: @owner_channel, listener:).run
       else
         config.preload! if config.preload_app?
         router = Router.new(controllers: config.controllers, strict: config.strict_routes, logger: logger)
@@ -107,6 +125,7 @@ module Gritz
     ensure
       ForkGuard.deactivate if guard
       @owner_channel&.close
+      listener&.close unless listener&.closed?
     end
   end
 end

data/lib/gritz/configuration.rb

@@ -117,8 +117,11 @@ module Gritz
     # Fail before allocating transport resources for unsupported release features.
     def validate_runtime!
       validate!
-      raise ConfigurationError, "This release supports transport :native" unless transport == :native
-      raise ConfigurationError, "This release supports listener_strategy :reuseport" unless listener_strategy == :reuseport
+      supported = transport == :native ? %i[reuseport] : %i[reuseport inherited_fd]
+      raise ConfigurationError, "#{transport} does not support listener_strategy #{listener_strategy}" unless supported.include?(listener_strategy)
+      if transport != :native && fork_mode == :grpc_fork_support
+        raise ConfigurationError, "grpc_fork_support requires transport :native"
+      end
       unless metrics_backend == :pipe || (metrics_backend == :otlp && metrics_recorder_factory)
         raise ConfigurationError, "metrics_backend requires an installed recorder (:pipe is built in)"
       end
@@ -126,7 +129,9 @@ module Gritz
 
       unless worker_recycle.empty?
         raise ConfigurationError, "worker_recycle requires workers > 0" unless workers.positive?
-        raise ConfigurationError, "worker_recycle requires a fixed bind port" if bind.end_with?(":0")
+        if bind.end_with?(":0") && listener_strategy != :inherited_fd
+          raise ConfigurationError, "worker_recycle requires a fixed bind port"
+        end
       end
       raise ConfigurationError, "grpc_fork_support requires workers > 0" if workers.zero? && fork_mode != :clean
       raise ConfigurationError, "at least one controller must be registered" if controllers.empty?

data/lib/gritz/core/version.rb

@@ -2,6 +2,6 @@
 
 module Gritz
   module Core
-    VERSION = "0.5.0"
+    VERSION = "0.6.1"
   end
 end

data/lib/gritz/core.rb

@@ -13,7 +13,8 @@ module Gritz
     LOADER.inflector.inflect("dsl" => "DSL", "cli" => "CLI")
     LOADER.push_dir(__dir__, namespace: Gritz)
     LOADER.ignore(__FILE__, File.join(__dir__, "errors.rb"), File.join(__dir__, "core/version.rb"))
-    LOADER.do_not_eager_load(File.join(__dir__, "testing/rspec.rb"), File.join(__dir__, "testing/minitest.rb"))
+    LOADER.do_not_eager_load(File.join(__dir__, "testing/rspec.rb"), File.join(__dir__, "testing/minitest.rb"),
+                             File.join(__dir__, "testing/transport_contract.rb"))
     LOADER.setup
   end
 end

data/lib/gritz/middleware/exception_mapper.rb

@@ -27,6 +27,8 @@ module Gritz
         end
 
         case e.class.name
+        when "Async::GRPC::DeadlineExceededError"
+          raise Errors::DeadlineExceeded, "deadline exceeded"
         when "ActiveRecord::RecordNotFound"
           raise Errors::NotFound, "record not found"
         when "ActiveRecord::RecordInvalid"

data/lib/gritz/middleware/logging.rb

@@ -22,22 +22,23 @@ module Gritz
         code = :internal
         raise
       ensure
-        duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000
-        fields = { request_id: context.request_id, service: context.method.service,
-                   method: context.method.name, code: code, duration_ms: duration.round(3),
-                   peer: context.peer, worker: context.worker, pid: Process.pid, bytes_in: context.bytes_in, bytes_out: context.bytes_out }
-        fields.merge!(context.store.fetch(:gritz_error, {}))
-        fields = prepare(fields, context.log_redact)
-        message = if context.log_format == :logfmt
-                    fields.map do |key, value|
-                      value = value.to_s if value.is_a?(Symbol)
-                      value = JSON.generate(value) if value.is_a?(Hash) || value.is_a?(Array)
-                      "#{key}=#{JSON.generate(value)}"
-                    end.join(" ")
-                  else
-                    JSON.generate(fields)
-                  end
-        context.logger.info(message)
+        context.logger.info do
+          duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000
+          fields = { request_id: context.request_id, service: context.method.service,
+                     method: context.method.name, code: code, duration_ms: duration.round(3),
+                     peer: context.peer, worker: context.worker, pid: Process.pid, bytes_in: context.bytes_in, bytes_out: context.bytes_out }
+          fields.merge!(context.store.fetch(:gritz_error, {}))
+          fields = prepare(fields, context.log_redact)
+          if context.log_format == :logfmt
+            fields.map do |key, value|
+              value = value.to_s if value.is_a?(Symbol)
+              value = JSON.generate(value) if value.is_a?(Hash) || value.is_a?(Array)
+              "#{key}=#{JSON.generate(value)}"
+            end.join(" ")
+          else
+            JSON.generate(fields)
+          end
+        end
       end
 
       private

data/lib/gritz/supervisor/launcher.rb

@@ -138,6 +138,10 @@ module Gritz
       def configure_generation(generation, metadata)
         return if generation.metadata || @stopping
 
+        if metadata[:listener_strategy] && !%w[reuseport inherited_fd].include?(metadata[:listener_strategy])
+          raise ConfigurationError, "Invalid master listener_strategy"
+        end
+
         %i[admin_bind bind pid_file].each do |field|
           raise ConfigurationError, "Missing master #{field}" unless metadata[field].is_a?(String)
         end
@@ -149,7 +153,7 @@ module Gritz
           raise ConfigurationError, "Invalid master #{field}" unless value.is_a?(Numeric) && value.finite? && value >= 0
         end
         if @metadata
-          %i[admin_bind bind pid_file].each do |field|
+          %i[admin_bind bind pid_file listener_strategy].each do |field|
             raise ConfigurationError, "USR2 cannot change #{field}" unless metadata[field] == @metadata[field]
           end
         else
@@ -160,6 +164,10 @@ module Gritz
         end
         generation.metadata = metadata
         generation.deadline = [generation.deadline, monotonic + metadata[:reexec_timeout]].min
+        if metadata[:listener_strategy] == "inherited_fd"
+          @listener ||= Listener.bind(metadata[:bind])
+          generation.channel.io.send_io(@listener)
+        end
       end
 
       def ready_workers(generation)
@@ -188,7 +196,7 @@ module Gritz
           return
         end
 
-        if @active.metadata[:bind].end_with?(":0")
+        if @active.metadata[:bind].end_with?(":0") && !@listener
           @reexec = { state: "failed", error: "USR2 requires a fixed RPC port" }
           @logger.warn(@reexec[:error])
           return
@@ -371,6 +379,7 @@ module Gritz
         @admin&.close
         @observer&.close
         @signals&.close
+        @listener&.close
         if @written_pid && File.file?(@pid_path) && File.read(@pid_path).strip == @written_pid.to_s
           File.unlink(@pid_path)
         end

data/lib/gritz/supervisor/listener.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Gritz
+  module Supervisor
+    # Creates a plain TCP listener without initializing a transport or scheduler.
+    # @api private
+    module Listener
+      def self.bind(address, reuseport: false)
+        host, _, port = address.rpartition(":")
+        info = Addrinfo.tcp(host.delete_prefix("[").delete_suffix("]"), Integer(port))
+        socket = Socket.new(info.afamily, Socket::SOCK_STREAM)
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1) if reuseport
+        socket.bind(info)
+        socket.listen(Socket::SOMAXCONN)
+        socket
+      rescue StandardError
+        socket&.close
+        raise
+      end
+    end
+  end
+end

data/lib/gritz/supervisor/master.rb

@@ -10,12 +10,13 @@ module Gritz
       SIGNALS = %w[TERM INT QUIT TTIN TTOU HUP CHLD USR1 USR2].freeze
       attr_reader :workers
 
-      def initialize(config, logger: Logger.new($stdout), status_io: nil, owner_channel: nil)
+      def initialize(config, logger: Logger.new($stdout), status_io: nil, owner_channel: nil, listener: nil)
         @config = config
         @logger = logger
         @workers = {}
         @desired = config.workers
         @owner_channel = owner_channel
+        @listener = listener
         @reports = owner_channel || (StatusChannel.new(status_io) if status_io)
         @metrics = Metrics::Aggregator.new
         @forwarded = []
@@ -27,7 +28,8 @@ module Gritz
         @config.validate_runtime!
         raise ConfigurationError, "Supervisor requires workers > 0" unless @desired.positive?
 
-        require "gritz/native"
+        require "gritz/#{@config.transport}"
+        @listener ||= Listener.bind(@config.bind) if @config.listener_strategy == :inherited_fd
         @signals = SignalQueue.new(signals: SIGNALS)
         unless @owner_channel
           @admin = AdminServer.new(bind: @config.admin_bind, status: -> { status }, ready: -> { ready? },
@@ -36,7 +38,7 @@ module Gritz
         @guard = ForkGuard.activate(mode: @config.fork_mode == :clean ? @config.fork_guard : :off, logger: @logger)
         @config.preload! if @config.preload_app?
         Process.warmup if @config.preload_app? && Process.respond_to?(:warmup)
-        if @config.workers > 1 && !RUBY_PLATFORM.include?("linux")
+        if @config.transport == :native && @config.workers > 1 && !RUBY_PLATFORM.include?("linux")
           @logger.warn("Multiple native workers require Linux for SO_REUSEPORT load balancing; use workers 0 on macOS")
         end
         maintain_worker_count
@@ -118,7 +120,7 @@ module Gritz
             @admin&.close
             @workers.each_value(&:close)
             Transport::Native.postfork_child if experimental
-            exit_status = Worker::Runner.new(index: index, status_io: writer, config: @config, logger: @logger).run
+            exit_status = Worker::Runner.new(index: index, status_io: writer, config: @config, logger: @logger, listener: @listener).run
           rescue StandardError, LoadError, SyntaxError, SystemExit => e
             @logger.error("Worker #{index} failed: #{e.full_message}")
             exit_status = 1
@@ -242,7 +244,7 @@ module Gritz
         when "TTIN"
           if @replacement || !@replacement_queue.empty?
             @logger.warn("Wait for phased restart before resizing workers")
-          elsif !@shutdown_at && @config.bind.end_with?(":0")
+          elsif !@shutdown_at && @config.bind.end_with?(":0") && !@listener
             @logger.warn("Cannot add a reuseport worker with port 0; configure a fixed bind port")
           elsif !@shutdown_at
             @desired += 1
@@ -293,7 +295,7 @@ module Gritz
       end
 
       def fixed_port?
-        return true unless @config.bind.end_with?(":0")
+        return true if @listener || !@config.bind.end_with?(":0")
 
         @logger.warn("Worker replacement requires a fixed bind port")
         false
@@ -340,7 +342,7 @@ module Gritz
       def check_recycle
         return if @shutdown_at || @replacement || !@replacement_queue.empty? || @config.worker_recycle.empty?
         return if @recycle_retry_at && now < @recycle_retry_at
-        return if @config.bind.end_with?(":0")
+        return if @config.bind.end_with?(":0") && !@listener
 
         @workers.each_value do |handle|
           next unless handle.state == "ready" && !handle.term_at
@@ -429,6 +431,7 @@ module Gritz
         @workers.clear
         @signals&.close
         @admin&.close
+        @listener&.close
         flush_forwarded
         @reports&.close
       end

data/lib/gritz/testing/server.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Gritz
+  module Testing
+    # Starts a single-process server for integration tests.
+    # @api public
+    class Server
+      attr_reader :port, :address, :transport
+
+      def self.start(config = nil, controllers: nil, middleware: nil, logger: Logger.new(File::NULL))
+        config ||= Configuration.new.tap do |settings|
+          settings.workers = 0
+          settings.bind = "127.0.0.1:0"
+        end
+        config.controllers = controllers if controllers
+        config.middleware = middleware if middleware
+        server = new(config, logger:).start
+        return server unless block_given?
+
+        begin
+          yield server
+        ensure
+          server.stop
+        end
+      end
+
+      def initialize(config, logger:)
+        @config = config
+        @logger = logger
+        config.validate_single_process!
+      end
+
+      def start
+        raise ArgumentError, "Testing::Server is already started or stopped" if @started || @stopped
+
+        @started = true
+        begin
+          @config.preload! if @config.preload_app?
+          router = Router.new(controllers: @config.controllers, strict: @config.strict_routes, logger: @logger)
+          @lifecycle_started = true
+          @config.run_hooks(:on_worker_boot, 0)
+          @recorder = @config.metrics_recorder_factory&.call(worker: 0)
+          dispatcher = Dispatcher.new(router:, middleware: @config.middleware, logger: @logger, metrics: @recorder)
+          @transport = Transport.const_get(@config.transport.to_s.capitalize).new(config: @config, dispatcher:, logger: @logger)
+          @port = transport.bind
+          @address = @config.bind.sub(/:\d+\z/, ":#{port}")
+          transport.start
+          unless @config.health_checks.empty?
+            @health_stop = Queue.new
+            @health_thread = Thread.new do
+              transport.refresh_health until @health_stop.pop(timeout: @config.status_interval)
+            end
+          end
+          self
+        rescue StandardError
+          stop
+          raise
+        end
+      end
+
+      def stop
+        return if @stopped
+
+        @stopped = true
+        deadline = monotonic + @config.shutdown_timeout
+        begin
+          @health_stop&.push(true)
+          if @health_thread && !@health_thread.join([deadline - monotonic, 0].max)
+            @health_thread.kill.join
+          end
+          transport&.stop(deadline: Time.now + [deadline - monotonic, 0].max)
+        ensure
+          begin
+            @config.run_hooks(:on_worker_shutdown, 0) if @lifecycle_started
+          ensure
+            begin
+              @recorder&.observe_rejected(transport.stats.fetch(:rejected_total, 0)) if transport
+              @recorder&.observe_worker({ pid: Process.pid, index: 0, state: "stopped" })
+            ensure
+              @recorder&.close(timeout: [deadline - monotonic, 0].max)
+            end
+          end
+        end
+      end
+
+      private
+
+      def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/gritz/testing/transport_contract.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require "rspec/core"
+require "rspec/expectations"
+require "grpc"
+require "google/rpc/status_pb"
+require "google/rpc/error_details_pb"
+require "gritz/testing/server"
+
+module Gritz
+  module Testing
+    # Shared wire tests using the official gRPC client as an independent oracle.
+    # Include with adapter:, service:, stub:, request:, reply: for a four-method fixture.
+    # Explicitly requiring this helper needs RSpec and grpc as test dependencies.
+    # @api public
+    module TransportContract
+    end
+  end
+end
+
+RSpec.shared_examples Gritz::Testing::TransportContract do |adapter:, service:, stub:, request:, reply:|
+  let(:contract_request) { request }
+  let(:contract_reply) { reply }
+
+  define_method(:contract_controller) do |&block|
+    response = reply
+    Class.new(Gritz::Controller) do
+      bind service
+      define_method(:say_hello) { response.new(message: self.request.message.name) }
+      define_method(:list_greetings) { 3.times { |i| stream.write(response.new(message: "#{self.request.message.name}:#{i}")) } }
+      define_method(:record_names) { response.new(count: self.request.each_message.count) }
+      define_method(:chat) { self.request.each_message { |msg| stream.write(response.new(message: msg.name)) } }
+      class_eval(&block) if block
+    end
+  end
+
+  define_method(:with_contract_server) do |controller = contract_controller, **settings, &block|
+    config = Gritz::Configuration.new
+    config.transport = adapter
+    config.listener_strategy = adapter == :async ? :inherited_fd : :reuseport
+    config.bind = "127.0.0.1:0"
+    settings.each { |key, value| config.public_send("#{key}=", value) }
+    Gritz::Testing::Server.start(config, controllers: [controller]) do |server|
+      client = stub.new(server.address, :this_channel_is_insecure)
+      block.call(client, server)
+    end
+  end
+
+  it "preserves unary protobuf messages" do
+    with_contract_server { |client| expect(client.say_hello(contract_request.new(name: "Ruby")).message).to eq("Ruby") }
+  end
+
+  it "preserves ordered server streaming messages" do
+    with_contract_server do |client|
+      expect(client.list_greetings(contract_request.new(name: "x")).map(&:message)).to eq(%w[x:0 x:1 x:2])
+    end
+  end
+
+  it "reads client streams through half-close" do
+    with_contract_server do |client|
+      expect(client.record_names(%w[a b c].map { |name| contract_request.new(name:) }).count).to eq(3)
+    end
+  end
+
+  it "replies to bidi input before the client half-closes" do
+    gate = Queue.new
+    requests = Enumerator.new do |output|
+      output << contract_request.new(name: "first")
+      gate.pop
+      output << contract_request.new(name: "second")
+    end
+    with_contract_server do |client|
+      responses = client.chat(requests, deadline: Time.now + 5)
+      expect(responses.next.message).to eq("first")
+      gate << true
+      expect(responses.next.message).to eq("second")
+      expect { responses.next }.to raise_error(StopIteration)
+    end
+  ensure
+    gate << true
+  end
+
+  it "sends streaming output before the controller returns" do
+    gate = Queue.new
+    response = contract_reply
+    controller = contract_controller do
+      define_method(:list_greetings) do
+        stream.write(response.new(message: "first"))
+        gate.pop
+        stream.write(response.new(message: "second"))
+      end
+    end
+    with_contract_server(controller) do |client|
+      responses = client.list_greetings(contract_request.new, deadline: Time.now + 5)
+      expect(responses.next.message).to eq("first")
+      gate << true
+      expect(responses.next.message).to eq("second")
+      expect { responses.next }.to raise_error(StopIteration)
+    end
+  ensure
+    gate << true
+  end
+
+  it "passes binary metadata, deadline and peer, with separate headers and trailers" do
+    observations = Queue.new
+    response = contract_reply
+    controller = contract_controller do
+      define_method(:say_hello) do
+        observations << [context.metadata, context.deadline, context.peer, context.peer_identity]
+        context.call.send_initial_metadata("answer" => "initial", "reply-bin" => "\x00\xff".b, "repeat-bin" => ["a".b, "b".b])
+        context.call.trailing_metadata["answer"] = "trailing"
+        context.call.trailing_metadata["trailer-bin"] = "\x00\xfe".b
+        response.new(message: context.request_id)
+      end
+    end
+    with_contract_server(controller) do |client|
+      deadline = Time.now + 5
+      operation = client.say_hello(contract_request.new, return_op: true, deadline:,
+                                                         metadata: { "x-request-id" => "req-1", "request-bin" => "\x00\xfd".b, "repeat" => %w[a b] })
+      expect(operation.execute.message).to eq("req-1")
+      expect(operation.metadata).to include("answer" => "initial", "reply-bin" => "\x00\xff".b, "x-request-id" => "req-1")
+      expect(operation.trailing_metadata).to include("answer" => "trailing", "trailer-bin" => "\x00\xfe".b)
+      expect(operation.metadata["repeat-bin"]).to eq(%w[a b])
+      metadata, actual_deadline, peer, identity = observations.pop(timeout: 2)
+      expect(metadata).to include("request-bin" => "\x00\xfd".b)
+      expect(metadata["repeat"]).to eq(%w[a b])
+      expect(actual_deadline).to be_within(0.1).of(deadline)
+      expect(peer).to match(/ipv[46]:/)
+      expect(identity).to be_nil
+    end
+  end
+
+  it "encodes application status, metadata and rich protobuf details" do
+    controller = contract_controller do
+      def say_hello
+        fail!(:not_found, "missing", metadata: { "lookup" => "failed" },
+                                     details: [Google::Rpc::ResourceInfo.new(resource_type: "name", resource_name: "Ruby")])
+      end
+    end
+    with_contract_server(controller) do |client|
+      expect { client.say_hello(contract_request.new) }.to raise_error(GRPC::NotFound) do |error|
+        expect(error.details).to eq("missing")
+        expect(error.metadata).to include("lookup" => "failed")
+        status = Google::Rpc::Status.decode(error.metadata.fetch("grpc-status-details-bin"))
+        expect([status.code, status.message]).to eq([5, "missing"])
+        expect(status.details.first.unpack(Google::Rpc::ResourceInfo).resource_name).to eq("Ruby")
+      end
+    end
+  end
+
+  it "preserves a non-OK status after streamed messages" do
+    response = contract_reply
+    controller = contract_controller do
+      define_method(:list_greetings) do
+        stream.write(response.new(message: "first"))
+        fail!(:permission_denied, "revoked", metadata: { "reason" => "revoked" })
+      end
+    end
+    with_contract_server(controller) do |client|
+      responses = client.list_greetings(contract_request.new)
+      expect(responses.next.message).to eq("first")
+      expect { responses.next }.to raise_error(GRPC::PermissionDenied) do |error|
+        expect(error.metadata).to include("reason" => "revoked")
+      end
+    end
+  end
+
+  it "hides internal exception messages" do
+    controller = contract_controller { def say_hello = raise("database secret") }
+    with_contract_server(controller) do |client|
+      expect { client.say_hello(contract_request.new) }.to raise_error(GRPC::Internal) do |error|
+        expect(error.details).not_to include("database secret")
+        expect(error.metadata).to have_key("error-id")
+      end
+    end
+  end
+
+  it "rejects an unimplemented controller action" do
+    controller = Class.new(Gritz::Controller) { bind service }
+    with_contract_server(controller) do |client|
+      expect { client.say_hello(contract_request.new) }.to raise_error(GRPC::Unimplemented)
+    end
+  end
+
+  it "honors an active call deadline" do
+    controller = contract_controller { def say_hello = sleep(1) }
+    with_contract_server(controller) do |client|
+      expect { client.say_hello(contract_request.new, deadline: Time.now + 0.05) }.to raise_error(GRPC::DeadlineExceeded)
+    end
+  end
+
+  it "returns CANCELLED when the client cancels an active call" do
+    entered = Queue.new
+    gate = Queue.new
+    controller = contract_controller do
+      define_method(:say_hello) do
+        entered << true
+        gate.pop
+        fail!(:cancelled, "cancelled")
+      end
+    end
+    with_contract_server(controller) do |client|
+      operation = client.say_hello(contract_request.new, return_op: true, deadline: Time.now + 5)
+      caller = Thread.new do
+        operation.execute
+      rescue GRPC::BadStatus => e
+        e
+      end
+      expect(entered.pop(timeout: 2)).to be(true)
+      operation.cancel
+      expect(caller.join(2)).not_to be_nil
+      expect(caller.value).to be_a(GRPC::Cancelled)
+      gate << true
+    ensure
+      gate << true
+      operation&.cancel
+      caller&.join(5)
+    end
+  end
+
+  it "finishes an in-flight response during graceful shutdown" do
+    entered = Queue.new
+    gate = Queue.new
+    response = contract_reply
+    controller = contract_controller do
+      define_method(:say_hello) do
+        entered << true
+        gate.pop
+        response.new(message: "completed")
+      end
+    end
+    with_contract_server(controller) do |client, server|
+      caller = Thread.new { client.say_hello(contract_request.new, deadline: Time.now + 5) }
+      expect(entered.pop(timeout: 2)).to be(true)
+      stopper = Thread.new { server.transport.stop(deadline: Time.now + 3) }
+      sleep 0.02 # Let shutdown enter its drain phase while the application remains blocked.
+      gate << true
+      expect(caller.value.message).to eq("completed")
+      expect(stopper.join(4)).not_to be_nil
+      expect(server.transport.stats).to include(inflight: 0)
+    ensure
+      gate << true
+      caller&.join(5)
+      stopper&.join(5)
+    end
+  end
+
+  it "enforces the shutdown deadline on a blocked controller" do
+    entered = Queue.new
+    controller = contract_controller do
+      define_method(:say_hello) do
+        entered << true
+        Queue.new.pop
+      end
+    end
+    with_contract_server(controller) do |client, server|
+      caller = Thread.new do
+        client.say_hello(contract_request.new, deadline: Time.now + 5)
+      rescue GRPC::BadStatus => e
+        e
+      end
+      expect(entered.pop(timeout: 2)).to be(true)
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      server.transport.stop(deadline: Time.now + 0.05)
+      expect(Process.clock_gettime(Process::CLOCK_MONOTONIC) - started).to be < 1
+      expect(caller.join(2)).not_to be_nil
+      expect(caller.value).to be_a(GRPC::BadStatus)
+      expect(server.transport.running?).to be(false)
+    end
+  end
+end

data/lib/gritz/worker/runner.rb

@@ -7,11 +7,12 @@ module Gritz
     # Owns transport resources and heartbeats in one serving process.
     # @api private
     class Runner
-      def initialize(index:, config:, logger:, status_io: nil, owner_channel: nil)
+      def initialize(index:, config:, logger:, status_io: nil, owner_channel: nil, listener: nil)
         @index = index
         @config = config
         @logger = logger
         @owner_channel = owner_channel
+        @listener = listener
         @status = owner_channel || (Supervisor::StatusChannel.new(status_io) if status_io)
         @recorder = Metrics::Recorder.new
         @metrics = Metrics::Aggregator.new
@@ -24,7 +25,7 @@ module Gritz
         begin
           @signals = Supervisor::SignalQueue.new(signals: %w[TERM INT QUIT HUP USR1 USR2])
           report("booting")
-          require "gritz/native"
+          require "gritz/#{@config.transport}"
           @boot_started = true
           @config.preload! unless @config.preload_app?
           @config.run_hooks(:on_worker_boot, @index)
@@ -32,8 +33,8 @@ module Gritz
           router = Router.new(controllers: @config.controllers, strict: @config.strict_routes, logger: @logger)
           dispatcher = Dispatcher.new(router:, middleware: @config.middleware, logger: @logger, metrics: @recorder,
                                       worker: @index, log_format: @config.log_format, log_redact: @config.log_redact)
-          @adapter = Transport::Native.new(config: @config, dispatcher:, logger: @logger)
-          @port = @adapter.bind(@config.bind)
+          @adapter = Transport.const_get(@config.transport.to_s.capitalize).new(config: @config, dispatcher:, logger: @logger)
+          @port = @adapter.bind(@listener || @config.bind)
           @adapter.start
           unless @status
             @admin = Supervisor::AdminServer.new(bind: @config.admin_bind, status: -> { snapshot }, ready: -> { ready? },

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gritz-core
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Yudai Takada
@@ -152,6 +152,7 @@ files:
 - lib/gritz/router.rb
 - lib/gritz/supervisor/admin_server.rb
 - lib/gritz/supervisor/launcher.rb
+- lib/gritz/supervisor/listener.rb
 - lib/gritz/supervisor/master.rb
 - lib/gritz/supervisor/signal_queue.rb
 - lib/gritz/supervisor/status_channel.rb
@@ -161,6 +162,8 @@ files:
 - lib/gritz/testing/minitest.rb
 - lib/gritz/testing/rpc_helper.rb
 - lib/gritz/testing/rspec.rb
+- lib/gritz/testing/server.rb
+- lib/gritz/testing/transport_contract.rb
 - lib/gritz/worker/runner.rb
 homepage: https://github.com/gritzrpc/gritz-core
 licenses: