gritz-core 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 600c0b33c1d7f7008866ee20d789504559715612886cd3f8dc33413e5192cb36
-  data.tar.gz: c3797690d572a4d29f5275946b16f84b5717fb19e4f31fd6a20217ece840eb92
+  metadata.gz: fc43859887cac5ffa9e137f2cab8911a4a6ef79ed4c522380d55869446c360a9
+  data.tar.gz: adfbe678ac9b1af0f507cad8fb69c16bfea7acbe4a422bacfce1e6b90747f34b
 SHA512:
-  metadata.gz: f2858b3d8e39c28d309a3acce2255fcc42ec4aba071b2b79735025a840973ffe0016183204eb7e87c67b1a14f11fef48ffa9e6560234cfd5da0866ccd195f68f
-  data.tar.gz: 149a97e113197dc7691152d5aa0f7e246adb55cc0bb90a699b122078ea3272cd32787461808b78d7379804c83a487866f503d8eea7f135a5c356c011e40a2209
+  metadata.gz: 0c1d9ef947490cfa7c5832cca9d1c20f0c7e093798e56c4d3b0b261c80279ae1a55f2b747ea2f9c42af99c126ac91a3c55098d18a186d61a5ab362e1caad0b1d
+  data.tar.gz: 6e859a121f10896fb4e38f8cbf669e33ce504637026aa2269d338f003a64f02190b8299b59e145a4909bd5cf6cbd0d62fbab3fac630952154e880cd900cf0014

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 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.
+- Configure optional gRPC Reflection through the `reflection` setting.
+- Avoid unnecessary supervisor snapshot allocation when status consumers are paused.
+- Publish worker metrics at `status_interval` to reduce supervisor overhead; retain retries and final shutdown totals.
+- Eagerly load the transport-independent framework before application warmup so forked workers can share its memory.
+- Send supervisor snapshots at `status_interval`, with immediate lifecycle and health changes, to reduce parent-process allocation.
+- Reuse signal, status and admin read buffers to avoid allocating memory on every idle poll.
+
 ## 0.4.0
 
 - Define lazy, fork-safe clients with process-local shared connections, per-call middleware, deadline propagation and selected request headers.

data/README.md

@@ -6,14 +6,18 @@ 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.
 
+The optional `Gritz::Compat::Gruf` module adapts Gruf controllers, returned response streams and server interceptors. `gritz-migrate-gruf` converts supported static configuration without executing the source file. See the [Gruf migration guide](docs/guides/migrating-from-gruf.md). Add [gritz-rails](https://github.com/gritzrpc/gritz-rails) for Rails execution, generators and development reloading.
+
 ## Development
 
 ```sh

data/exe/gritz-migrate-gruf

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "gritz/core"
+require "optparse"
+
+begin
+  destination = nil
+  parser = OptionParser.new do |options|
+    options.banner = "Usage: gritz-migrate-gruf SOURCE [--output config/gritz.rb]"
+    options.on("--output PATH", "Write a new file; existing files are never overwritten") { |path| destination = path }
+  end
+  parser.parse!
+  raise OptionParser::MissingArgument, "SOURCE" unless ARGV.size == 1
+
+  output = Gritz::Compat::Gruf::ConfigConverter.new.convert(File.read(ARGV.first))
+  if destination
+    File.open(destination, File::WRONLY | File::CREAT | File::EXCL) { |file| file.write(output) }
+  else
+    $stdout.write(output)
+  end
+rescue Gritz::ConfigurationError, OptionParser::ParseError, SystemCallError => e
+  warn "gritz-migrate-gruf: #{e.message}"
+  exit 1
+end

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/compat/gruf/config_converter.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module Gritz
+  module Compat
+    module Gruf
+      # Converts a deliberately small, literal-only subset of Gruf.configure.
+      # @api public
+      class ConfigConverter
+        ARGUMENTS = {
+          "grpc.max_receive_message_length" => [:max_receive_message_size, 1],
+          "grpc.max_send_message_length" => [:max_send_message_size, 1],
+          "grpc.max_metadata_size" => [:max_metadata_size, 1],
+          "grpc.max_connection_age_ms" => [:max_connection_age, 1000.0],
+          "grpc.max_connection_age_grace_ms" => [:max_connection_age_grace, 1000.0],
+          "grpc.keepalive_time_ms" => [:keepalive_time, 1000.0]
+        }.freeze
+
+        # @param source [String] Ruby source containing one static Gruf.configure block
+        # @return [String] Gritz configuration requiring manual review before use
+        # @raise [Gritz::ConfigurationError] when a setting or expression cannot be converted
+        # @api public
+        def convert(source)
+          settings = assignments(source)
+          output = { workers: 0 }
+          settings.each do |name, value|
+            case name
+            when "server_binding_url" then output[:bind] = value
+            when "rpc_server_options" then server_options(value, output)
+            when "use_ssl", "ssl_crt_file", "ssl_key_file" then next
+            when "default_client_host", "default_channel_credentials"
+              unsupported("#{name}: configure Gritz::Client.define manually")
+            else unsupported("#{name}: manual migration required; see migrating-from-gruf.md")
+            end
+          end
+          config = Gritz::Configuration.new
+          output.each { |name, value| config.public_send("#{name}=", value) }
+          config.validate!
+          tls = tls_options(settings)
+          output[:tls] = tls unless tls.empty?
+          ["# Review controller registration, interceptors and fork safety before starting.",
+           'require "gritz/compat/gruf"', "", *output.map { |name, value| "#{name}(#{value.inspect})" }, "",
+           "# register_controller YourMigratedController", ""].join("\n")
+        end
+
+        private
+
+        def assignments(source)
+          tree = Ripper.sexp(source)
+          unsupported("invalid Ruby syntax; manual correction required") unless tree
+          statements = tree[1].reject { |node| node[0] == :void_stmt }
+          unsupported("expected one Gruf.configure block; other executable code needs manual migration") unless statements.size == 1
+          node = statements.first
+          call = node[1]
+          block = node[2]
+          unless node[0] == :method_add_block && call&.dig(0) == :call && call.dig(3, 1) == "configure" &&
+                 %i[var_ref top_const_ref].include?(call.dig(1, 0)) && call.dig(1, 1, 1) == "Gruf"
+            unsupported("expected Gruf.configure; manual migration required")
+          end
+          params = block&.dig(1, 1)
+          unless %i[do_block brace_block].include?(block&.dig(0)) && params&.dig(0) == :params &&
+                 params[1]&.size == 1 && params[2..].all?(&:nil?) && block.dig(1, 2) == false
+            unsupported("configure needs one block variable; manual migration required")
+          end
+          variable = params[1][0][1]
+          body = block[2]
+          if block[0] == :do_block
+            unsupported("rescue/ensure needs manual migration") unless body[2..].all?(&:nil?)
+            body = body[1]
+          end
+          body.each_with_object({}) do |statement, values|
+            next if statement[0] == :void_stmt
+
+            field = statement[1]
+            unless statement[0] == :assign && field&.dig(0) == :field && field.dig(1, 0) == :var_ref && field.dig(1, 1, 1) == variable
+              unsupported("only literal assignments are supported; interceptors and other code require manual migration")
+            end
+            name = field[3][1]
+            unsupported("duplicate setting #{name}; manual migration required") if values.key?(name)
+            values[name] = literal(statement[2])
+          end
+        end
+
+        def literal(node)
+          case node[0]
+          when :@int then Integer(node[1].delete("_"), 0)
+          when :@float then Float(node[1].delete("_"))
+          when :string_literal
+            parts = node[1][1..]
+            unsupported("strings must be literals without interpolation or escapes") unless parts.all? { |part|
+              part[0] == :@tstring_content && !part[1].include?("\\")
+            }
+            parts.map { |part| part[1] }.join
+          when :symbol_literal
+            token = node.dig(1, 1)
+            unsupported("symbol must be a static literal") unless %i[@ident @op @const].include?(token&.dig(0))
+            token[1].to_sym
+          when :@label then node[1].delete_suffix(":").to_sym
+          when :var_ref
+            return { "true" => true, "false" => false, "nil" => nil }.fetch(node[1][1]) if node[1][0] == :@kw
+
+            unsupported("dynamic values need manual migration; use static literals")
+          when :unary
+            unsupported("only negative numeric literals are supported") unless node[1] == :-@ && %i[@int @float].include?(node.dig(2, 0))
+            -literal(node[2])
+          when :hash
+            pairs = node.dig(1, 1) || []
+            pairs.each_with_object({}) do |pair, values|
+              unsupported("hash splats need manual migration; use literal entries") unless pair[0] == :assoc_new
+              key = literal(pair[1])
+              unsupported("duplicate hash key #{key}; manual migration required") if values.key?(key)
+              values[key] = literal(pair[2])
+            end
+          else unsupported("dynamic values need manual migration; only static literals are supported")
+          end
+        rescue ArgumentError, KeyError
+          unsupported("invalid literal; manual migration required")
+        end
+
+        def server_options(options, output)
+          unsupported("rpc_server_options must be a literal Hash") unless options.is_a?(Hash)
+          options.each do |name, value|
+            case name
+            when :pool_size then output[:threads] = value
+            when :max_waiting_requests then output[:max_waiting_requests] = value
+            when :server_args
+              unsupported("server_args must be a literal Hash") unless value.is_a?(Hash)
+              value.each do |key, argument|
+                conversion = ARGUMENTS[key]
+                unsupported("#{key}: manual C-core argument migration required") unless conversion
+                unsupported("#{key} must be a numeric literal") unless argument.is_a?(Numeric)
+                setting, divisor = conversion
+                output[setting] = argument / divisor
+              end
+            else unsupported("#{name}: manual rpc_server_options migration required")
+            end
+          end
+        end
+
+        def tls_options(settings)
+          enabled = settings.fetch("use_ssl", false)
+          unsupported("use_ssl must be a boolean literal") unless [true, false].include?(enabled)
+          paths = %w[ssl_crt_file ssl_key_file]
+          unless enabled
+            paths.each { |key| unsupported("#{key} requires use_ssl=true; manual review required") if settings.key?(key) }
+            return {}
+          end
+          unless paths.all? { |key| settings[key].is_a?(String) && !settings[key].empty? }
+            unsupported("use_ssl=true requires ssl_crt_file and ssl_key_file; manual review required")
+          end
+          { cert: settings.fetch("ssl_crt_file"), key: settings.fetch("ssl_key_file") }
+        end
+
+        def unsupported(message) = raise Gritz::ConfigurationError, message
+      end
+    end
+  end
+end

data/lib/gritz/compat/gruf.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "gritz/core"
+require "json"
+
+module Gritz
+  module Compat
+    # Selected Gruf 2.22 controller/interceptor APIs, without loading Gruf or grpc.
+    # @api public
+    module Gruf
+      REQUEST_KEY = Object.new.freeze
+
+      # @api private
+      def self.request_for(context)
+        context.store[REQUEST_KEY] ||= Request.new(context)
+      end
+
+      # Wraps a Gruf-style interceptor as a Gritz server middleware.
+      # @param klass [Class] interceptor implementing #call and yielding to the action
+      # @return [Class] middleware accepted by Middleware::Stack#use
+      # @api public
+      def self.interceptor(klass)
+        Class.new(InterceptorAdapter) do
+          define_method(:initialize) { |app, **options| super(app, klass, options) }
+        end
+      end
+
+      class RequestContext < Hash
+        def [](key) = super(convert_key(key))
+
+        def []=(key, value)
+          super(convert_key(key), value)
+        end
+
+        def fetch(key, ...) = super(convert_key(key), ...)
+        def key?(key) = super(convert_key(key))
+        def merge!(other, &) = super(other.transform_keys { |key| convert_key(key) }, &)
+        alias update merge!
+
+        private
+
+        def convert_key(key) = key.is_a?(Symbol) ? key.to_s : key
+      end
+
+      class ActiveCall
+        def initialize(context) = @context = context
+        def metadata = @context.metadata
+        def deadline = @context.deadline
+        def peer = @context.peer
+        def cancelled? = @context.cancelled?
+        def output_metadata = @context.call.trailing_metadata
+      end
+
+      class Request
+        attr_reader :context, :active_call, :error
+
+        def initialize(context)
+          @rpc_context = context
+          @original = Gritz::Controller::Request.for(context)
+          @context = RequestContext.new
+          @active_call = ActiveCall.new(context)
+          @error = Error.new
+        end
+
+        def service = @rpc_context.method.service_class
+        def method_key = @rpc_context.method.action
+        def request_class = @rpc_context.method.input_type
+        def response_class = @rpc_context.method.output_type
+        def metadata = @rpc_context.metadata
+        def type = self
+        def client_streamer? = @rpc_context.method.kind == :client_streaming
+        def server_streamer? = @rpc_context.method.kind == :server_streaming
+        def bidi_streamer? = @rpc_context.method.kind == :bidi
+        def request_response? = @rpc_context.method.kind == :unary
+
+        def service_key
+          name = service.name || @rpc_context.method.service
+          name.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2')
+              .gsub("::", ".").downcase.delete_suffix(".service")
+        end
+
+        def method_name = "#{service_key}.#{method_key}"
+
+        def message
+          return @original.message unless @rpc_context.method.client_streaming?
+
+          @message ||= client_streamer? ? proc { |&block| @original.each_message(&block) } : @original.each_message
+        end
+
+        def messages(&block)
+          return [message] unless @rpc_context.method.client_streaming?
+
+          block ? @original.each_message(&block) : @original.each_message
+        end
+      end
+
+      class Error
+        Field = Struct.new(:field_name, :error_code, :message)
+        DebugInfo = Struct.new(:detail, :stack_trace)
+        attr_accessor :code, :app_code, :message
+        attr_reader :field_errors, :debug_info, :metadata
+
+        def initialize
+          @field_errors = []
+          @metadata = {}
+        end
+
+        def add_field_error(field, code, message = "") = @field_errors << Field.new(field, code, message)
+        def has_field_errors? = !@field_errors.empty? # rubocop:disable Naming/PredicatePrefix -- Preserve the upstream Gruf method name.
+
+        def set_debug_info(detail, stack_trace = [])
+          @debug_info = DebugInfo.new(detail, stack_trace.is_a?(String) ? stack_trace.split("\n") : Array(stack_trace))
+        end
+
+        def metadata=(value)
+          @metadata = value.transform_values(&:to_s)
+        end
+
+        def to_h
+          { code:, app_code:, message:, field_errors: field_errors.map(&:to_h), debug_info: debug_info.to_h }
+        end
+
+        def fail!(_active_call = nil)
+          canonical = { bad_request: :invalid_argument, unauthorized: :permission_denied }.fetch(code, code)
+          trailers = metadata.merge("error-internal-bin" => JSON.generate(to_h))
+          raise Gritz::Errors.for_code(canonical).new(message, metadata: trailers)
+        end
+      end
+
+      module ErrorHelpers
+        def add_field_error(...) = error.add_field_error(...)
+        def has_field_errors? = error.has_field_errors? # rubocop:disable Naming/PredicatePrefix -- Preserve the upstream Gruf method name.
+        def set_debug_info(...) = error.set_debug_info(...)
+
+        def fail!(code, app_code = nil, message = "", metadata = {})
+          error.code = code.to_sym
+          error.app_code = app_code ? app_code.to_sym : error.code
+          error.message = message.to_s
+          error.metadata = metadata
+          error.fail!(request.active_call)
+        end
+      end
+
+      # Controller base retaining selected Gruf request, error and streaming APIs.
+      # @api public
+      class Controller < Gritz::Controller
+        include ErrorHelpers
+
+        def self.bound_service = service_class
+
+        def self.action_defined?(action)
+          super && ![Controller, ErrorHelpers].include?(instance_method(action).owner)
+        end
+
+        def initialize(context:)
+          super
+          @request = Gruf.request_for(context)
+        end
+
+        def error = request.error
+
+        def process(action)
+          result = super
+          return result unless context.method.server_streaming?
+
+          result.each { |message| stream.write(message) } if result.respond_to?(:each)
+          nil
+        end
+      end
+
+      Base = Controller
+
+      # Base for migrated interceptors whose #call yields to the next handler.
+      # @api public
+      class ServerInterceptor
+        include ErrorHelpers
+
+        attr_reader :request, :error, :options
+
+        def initialize(request, error, options = {})
+          @request = request
+          @error = error
+          @options = options
+        end
+      end
+
+      class InterceptorAdapter
+        def initialize(app, klass, options)
+          @app = app
+          @klass = klass
+          @options = options
+        end
+
+        def call(context)
+          request = Gruf.request_for(context)
+          @klass.new(request, request.error, @options.dup).call { @app.call(context) }
+        end
+      end
+    end
+  end
+end

data/lib/gritz/configuration.rb

@@ -10,7 +10,7 @@ module Gritz
       workers: 0, threads: 16, max_waiting_requests: 64,
       transport: :native, listener_strategy: :reuseport,
       bind: "0.0.0.0:50051", admin_bind: "127.0.0.1:9090",
-      fork_mode: :clean, fork_guard: :raise, strict_routes: false,
+      fork_mode: :clean, fork_guard: :raise, strict_routes: false, reflection: false,
       drain_delay: 5.0, shutdown_timeout: 25.0, worker_boot_timeout: 60.0,
       worker_timeout: 30.0, status_interval: 1.0, min_ready_workers: 1,
       phased_restart_surge: 1, max_connection_age: 300.0,
@@ -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?
@@ -148,6 +153,7 @@ module Gritz
 
     def preload!
       @preloaders.each(&:call)
+      Core::LOADER.eager_load
     end
 
     def add_hook(name, &block)

data/lib/gritz/controller.rb

@@ -42,7 +42,7 @@ module Gritz
 
     def initialize(context:)
       @context = context
-      @request = Request.new(context.call, context)
+      @request = Request.for(context)
       @stream = Stream.new(context.call, context)
     end
 
@@ -93,6 +93,13 @@ module Gritz
 
     # @api public
     class Request
+      STORE_KEY = Object.new.freeze
+
+      # @api private
+      def self.for(context)
+        context.store[STORE_KEY] ||= new(context.call, context)
+      end
+
       def initialize(call, context)
         @call = call
         @context = context

data/lib/gritz/core/version.rb

@@ -2,6 +2,6 @@
 
 module Gritz
   module Core
-    VERSION = "0.4.0"
+    VERSION = "0.6.0"
   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/supervisor/admin_server.rb

@@ -23,6 +23,7 @@ module Gritz
         @metrics = metrics
         @logger = logger
         @clients = {}
+        @read_buffer = +""
       end
 
       def ios = [@io, *@clients.keys]
@@ -68,7 +69,7 @@ module Gritz
       end
 
       def read_request(socket, client)
-        chunk = socket.read_nonblock(4096, exception: false)
+        chunk = socket.read_nonblock(4096, @read_buffer, exception: false)
         return if chunk == :wait_readable
         return drop(socket) if chunk.nil?