tonic-rails 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f526af49b4f7647168bcdf7d64131c00c63880d3372f0355d60aa7e347240856
-  data.tar.gz: 7698d7d70a8e3c75ef3ee63ec46ce032267688e12cb86fbca35bf74e41f6f29f
+  metadata.gz: c1578d591791ff33ce8365ae3fe5b5a6bb5dfbac8759e4f9762c7c511e71057a
+  data.tar.gz: e23782ccd2cf964d5db2cf25c98547780525e20d7880f0dab85a0c4c956b45cd
 SHA512:
-  metadata.gz: ad814eb2ab41e6009649bd5307a8f304e3f1baab030f00a25045b65ec0bd1279aa7eceac041d141932281073ce650172191e0fcfbec9c74066f5c224b64e811c
-  data.tar.gz: b1cc149c6beb0f3bb2f99579cc5b4ef4e13964654a93969b431bf0032a25f9fa624f5888748eb0fe37fef1c13762146b881aec6d3347cbc27fe0fee468990275
+  metadata.gz: 616f736a4e29cd3fcf8fd4297d6159d9abb145f3973b27a08f6f2c153bf7f5ae87422870ef304dab552e62f8ef7b3037716432c89bfd5d12088ef97e1ae58166
+  data.tar.gz: 07a9749e9188700473883761291731a3f0b947bcdf4d986cd55df81dcb658229863149cfda1174a186a0cfe321e8e09810b7c1113232fefdc38c0ca2f1bba962

data/CHANGELOG.md

@@ -7,6 +7,38 @@ minor versions may contain breaking changes.
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-10-11
+
+### Added
+
+- Generators: `rails g tonic_rails:install` (initializer, proto and
+  generated-code directories, Puma plugin) and `rails g tonic_rails:service
+  Item GetItem ListItems:server` (proto, handler with a stub per RPC,
+  registration, and an RSpec or Minitest test).
+- Controller-style callbacks for handlers: `before_rpc`, `after_rpc` and
+  `around_rpc` with `only:` / `except:`, plus `current_rpc` and `request`
+  accessors.
+- `rescue_from` (ActiveSupport::Rescuable) with a `code:` shorthand that maps
+  an exception class to a gRPC status.
+- `peer` in handlers: the client's address and, with mutual TLS, its
+  certificate (`peer.certificate`, an `OpenSSL::X509::Certificate`).
+  `Testing.call`/`invoke` accept `peer:`.
+- App-controlled health: `config.health_check` (polled every
+  `health_check_interval` seconds inside the Rails executor) and
+  `Tonic::Rails.server.serving!` / `not_serving!` for the whole server or
+  individual services, so readiness probes reflect real dependency health.
+- Test helpers: the `raise_grpc_error(code).with_message(...)` RSpec matcher
+  (`require "tonic/rails/testing/rspec"`) and `assert_grpc_error` for Minitest
+  (`Tonic::Rails::Testing::Assertions`). Both accept `Tonic::Rails::RpcError`
+  and the grpc gem's `GRPC::BadStatus`.
+
+### Changed
+
+- `tonic_rails:compile_protos` requires protoc 22 or newer and says so,
+  instead of generating code google-protobuf 4 can't load (older protoc,
+  such as Ubuntu's 3.21 package, emits a Ruby DSL that google-protobuf 4
+  removed).
+
 ## [0.2.0] - 2026-10-11
 
 ### Added
@@ -84,6 +116,7 @@ First public release.
 - Precompiled native gems for Linux (x86_64, aarch64; glibc and musl) and
   macOS (x86_64, arm64), Ruby 3.3 to 4.0.
 
-[Unreleased]: https://github.com/CodingAnarchy/tonic-rails/compare/v0.2.0...HEAD
+[Unreleased]: https://github.com/CodingAnarchy/tonic-rails/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/CodingAnarchy/tonic-rails/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/CodingAnarchy/tonic-rails/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/CodingAnarchy/tonic-rails/releases/tag/v0.1.0

data/Cargo.lock

@@ -1023,7 +1023,7 @@ dependencies = [
 
 [[package]]
 name = "tonic_rails_native"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "axum",
  "bytes",

data/README.md

@@ -60,10 +60,31 @@ On platforms without a precompiled gem, installation builds the
 extension from source, which needs a [Rust toolchain](https://rustup.rs).
 
 To generate Ruby classes from your `.proto` files you also need `protoc`
-(the Protocol Buffers compiler) during development.
+(the Protocol Buffers compiler) **22.0 or newer** during development.
+Older versions, such as Ubuntu's `protobuf-compiler` package (3.21),
+generate code that google-protobuf 4 can't load; install a current
+release from the [protobuf releases page](https://github.com/protocolbuffers/protobuf/releases)
+or Homebrew.
 
 ## Quick start
 
+The generators set everything up:
+
+```sh
+bin/rails generate tonic_rails:install
+bin/rails generate tonic_rails:service Item GetItem ListItems:server
+bin/rails tonic_rails:compile_protos
+```
+
+`install` adds `config/initializers/tonic_rails.rb` (load path for
+generated code, configuration, handler registration), `app/protos/`,
+`lib/grpc/`, and the Puma plugin. `service` writes the `.proto`, a handler
+in `app/grpc/` with a stub per RPC, its registration, and a spec (or
+Minitest test). RPCs take an optional `:server`, `:client` or `:bidi`
+streaming kind.
+
+The rest of this section shows the same steps by hand.
+
 ### 1. Define the service
 
 ```protobuf
@@ -236,11 +257,54 @@ Any other exception becomes `INTERNAL` with the message `internal error`.
 The real exception is logged and passed to `Rails.error.report`, so your
 error tracker sees it.
 
+### Callbacks and rescue_from
+
+Handlers get controller-style callbacks and exception mapping:
+
+```ruby
+class ItemService
+  include Tonic::Rails::Base
+  rpc_service "demo.v1.ItemService"
+
+  before_rpc :authenticate, except: :ListItems
+  around_rpc :with_tenant
+  after_rpc { StatsD.increment("grpc.#{current_rpc}") }
+
+  rescue_from ActiveRecord::RecordNotFound, code: :not_found
+  rescue_from ActiveRecord::RecordInvalid, code: :invalid_argument, message: ->(e) { e.record.errors.full_messages.join(", ") }
+  rescue_from Pundit::NotAuthorizedError, with: :forbidden
+
+  private
+
+  def authenticate
+    @user = User.from_token(grpc_metadata["authorization"])
+    raise Tonic::Rails::RpcError.new("invalid token", code: :unauthenticated) unless @user
+  end
+
+  def with_tenant(&) = Tenant.switch(@user.tenant, &)
+
+  def forbidden(_e) = raise(Tonic::Rails::RpcError.new("not allowed", code: :permission_denied))
+end
+```
+
+- `before_rpc`, `after_rpc` and `around_rpc` accept method names or a
+  block, plus `only:` / `except:` with RPC names (`:GetItem` or
+  `:get_item`). Raising in a `before_rpc` stops the call.
+- `current_rpc` is the RPC being handled and `request` the decoded
+  request, so callbacks can inspect it.
+- `after_rpc` runs once a streamed response has been fully sent.
+- `rescue_from` covers the handler and its callbacks. With `code:`, the
+  exception's message is sent to the client unless you pass `message:`.
+  Handlers given with `with:` or a block must raise an `RpcError`.
+  Anything unmapped becomes `INTERNAL`, as before.
+
 ### Metadata, deadlines and shutdown
 
 ```ruby
 def get_item(request)
   token = grpc_metadata["authorization"]   # request headers, lower-case
+  peer.ip                                    # client address ("10.0.4.17")
+  peer.certificate&.subject                  # client certificate, with mutual TLS
   deadline_ms                                # ms left before the client's deadline, or nil
   deadline_exceeded?                         # true once it has passed
   cancelled?                                 # true while the server shuts down
@@ -322,6 +386,30 @@ result.headers["x-cache"]    # => "hit"
 result.trailers["x-cost-ms"] # => "3"
 ```
 
+Matchers for gRPC statuses work with `Testing.call` and with the official
+`grpc` client's errors:
+
+```ruby
+# spec/rails_helper.rb
+require "tonic/rails/testing/rspec"
+
+expect { Tonic::Rails::Testing.call(ItemService, :GetItem, { id: 0 }) }
+  .to raise_grpc_error(:not_found).with_message(/0/)
+```
+
+```ruby
+# Minitest
+require "tonic/rails/testing/minitest"
+
+class ItemServiceTest < ActiveSupport::TestCase
+  include Tonic::Rails::Testing::Assertions
+
+  test "missing items" do
+    assert_grpc_error(:not_found) { Tonic::Rails::Testing.call(ItemService, :GetItem, { id: 0 }) }
+  end
+end
+```
+
 ## Configuration
 
 Set options in `config/application.rb` or an environment file:
@@ -353,6 +441,8 @@ end
 | `tls_client_ca_path` | `nil` | PEM CA bundle; requires client certificates (mutual TLS) |
 | `drain_timeout` | `10` | Seconds to let in-flight calls finish on shutdown |
 | `keepalive_interval`, `keepalive_timeout` | `15`, `5` | HTTP/2 PING interval and timeout, seconds |
+| `health_check` | `nil` | Callable; while false or raising, health reports `NOT_SERVING` |
+| `health_check_interval` | `5` | Seconds between health checks |
 | `compression` | `false` | gzip responses over 1 KiB for clients that accept it |
 | `reflection` | `false` | Serve `grpc.reflection.v1`; exposes your schema |
 | `interceptors` | `[]` | See [Interceptors](#interceptors) |
@@ -399,7 +489,19 @@ Don't combine it with the plugin.
 - **Health checks.** `grpc.health.v1.Health` reports `SERVING` for the
   server (`""`) and every registered service, and flips to `NOT_SERVING`
   as soon as shutdown begins. Point your load balancer or Kubernetes
-  gRPC probes at it.
+  gRPC probes at it. To make readiness reflect your dependencies, add a
+  check that runs every `health_check_interval` seconds (default 5):
+
+  ```ruby
+  config.health_check = -> { ActiveRecord::Base.connection.active? }
+  ```
+
+  While it returns false or raises, the server reports `NOT_SERVING`
+  (calls are still served). You can also mark the server or a service
+  yourself, for example during maintenance:
+  `Tonic::Rails.server.not_serving!("demo.v1.ItemService")` and
+  `serving!`. A service is `SERVING` only while the check passes and it
+  isn't marked otherwise.
 - **Graceful shutdown.** On SIGTERM or SIGINT the server stops
   accepting connections, tells clients to go away (HTTP/2 GOAWAY), lets
   in-flight calls finish for up to `drain_timeout` seconds, then exits.

data/ext/tonic_rails_native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tonic_rails_native"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2024"
 rust-version = "1.88"
 publish = false

data/ext/tonic_rails_native/src/dispatch.rs

@@ -21,10 +21,11 @@ use magnus::{Value, value::Opaque};
 use tokio::sync::mpsc;
 use tonic::Code;
 use tonic::body::Body as TonicBody;
+use tonic::transport::server::{TcpConnectInfo, TlsConnectInfo};
 
 use crate::body::{ErrorBody, ResponseBody, ServerStats};
 use crate::framing::{MessageReader, append_metadata, parse_grpc_timeout};
-use crate::gvl::{DispatchContext, RequestError, StreamMessage};
+use crate::gvl::{DispatchContext, Peer, RequestError, StreamMessage};
 use crate::log::Level;
 
 /// Messages buffered per direction before backpressure applies.
@@ -166,6 +167,7 @@ impl DispatchInner {
             request_rx,
             request_error: request_error.clone(),
             log: self.stats.log.clone(),
+            peer: peer_of(&req),
         });
 
         match self.request_tx.try_send(ctx) {
@@ -241,6 +243,26 @@ impl DispatchInner {
     }
 }
 
+/// The client's address and, if it presented one over TLS, its
+/// certificate chain.  tonic records both on the request.
+fn peer_of<B>(req: &Request<B>) -> Peer {
+    let address = req
+        .extensions()
+        .get::<TcpConnectInfo>()
+        .and_then(TcpConnectInfo::remote_addr)
+        .map(|addr| addr.to_string());
+    let certificates = req
+        .extensions()
+        .get::<TlsConnectInfo<TcpConnectInfo>>()
+        .and_then(TlsConnectInfo::peer_certs)
+        .map(|chain| chain.iter().map(|der| der.to_vec()).collect())
+        .unwrap_or_default();
+    Peer {
+        address,
+        certificates,
+    }
+}
+
 /// Read the request body and forward each unframed message to the
 /// handler.  Dropping `tx` signals end of stream; errors are recorded
 /// in `error` first so the reader can distinguish them.

data/ext/tonic_rails_native/src/gvl.rs

@@ -369,6 +369,15 @@ pub struct DispatchContext {
     pub request_rx: mpsc::Receiver<Vec<u8>>,
     pub request_error: Arc<RequestError>,
     pub log: LogSink,
+    pub peer: Peer,
+}
+
+/// The client connection: remote address and, with mutual TLS, its
+/// certificate chain (DER, leaf first).
+#[derive(Default)]
+pub struct Peer {
+    pub address: Option<String>,
+    pub certificates: Vec<Vec<u8>>,
 }
 
 /// Bounds on how long one thread keeps the GVL to drain a busy queue.
@@ -441,6 +450,7 @@ fn run_handler(ctx: DispatchContext) {
         request_rx,
         request_error,
         log,
+        peer,
     } = ctx;
 
     let trailers = Arc::new(Mutex::new(Metadata::new()));
@@ -454,6 +464,7 @@ fn run_handler(ctx: DispatchContext) {
         request_rx,
         request_error,
         trailers.clone(),
+        &peer,
     );
     let end = StreamMessage::End {
         status: result.err().map(|e| error_status(&e, &log)),
@@ -474,6 +485,7 @@ fn call_handler(
     request_rx: mpsc::Receiver<Vec<u8>>,
     request_error: Arc<RequestError>,
     trailers: Arc<Mutex<Metadata>>,
+    peer: &Peer,
 ) -> Result<(), Error> {
     let md = ruby.hash_new_capa(metadata.len());
     for (k, v) in metadata {
@@ -496,6 +508,16 @@ fn call_handler(
     if let Some(ms) = timeout_ms {
         call.aset(ruby.to_symbol("timeout_ms"), ms as u64)?;
     }
+    if let Some(address) = &peer.address {
+        call.aset(ruby.to_symbol("peer_address"), ruby.str_new(address))?;
+    }
+    if !peer.certificates.is_empty() {
+        let certificates = ruby.ary_new_capa(peer.certificates.len());
+        for der in &peer.certificates {
+            certificates.push(ruby.str_from_slice(der))?;
+        }
+        call.aset(ruby.to_symbol("peer_certificates"), certificates)?;
+    }
 
     let callback = ruby.get_inner(callback);
     let result = callback.funcall::<_, _, Value>("call", (ruby.str_new(path), md, call));

data/ext/tonic_rails_native/src/lib.rs

@@ -71,6 +71,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     )?;
     class.define_method("start_server", method!(NativeServer::start_server, 0))?;
     class.define_method("serve_worker", method!(NativeServer::serve_worker, 0))?;
+    class.define_method("set_health", method!(NativeServer::set_health, 2))?;
     class.define_method("begin_shutdown", method!(NativeServer::begin_shutdown, 0))?;
     class.define_method("wait_for_drain", method!(NativeServer::wait_for_drain, 1))?;
     class.define_method("stop_workers", method!(NativeServer::stop_workers, 0))?;

data/ext/tonic_rails_native/src/server.rs

@@ -409,6 +409,27 @@ impl NativeServer {
         Ok(())
     }
 
+    /// Set the grpc.health.v1 status of one service ("" = the whole
+    /// server).  Returns false if the server isn't running.
+    pub fn set_health(&self, service: String, serving: bool) -> bool {
+        let Some(r) = self
+            .running
+            .lock()
+            .as_ref()
+            .map(|r| (r.runtime.handle().clone(), r.health.clone()))
+        else {
+            return false;
+        };
+        let (handle, health) = r;
+        let status = if serving {
+            ServingStatus::Serving
+        } else {
+            ServingStatus::NotServing
+        };
+        handle.block_on(health.set_service_status(service, status));
+        true
+    }
+
     /// Mark everything NOT_SERVING and stop accepting new connections.
     /// Existing connections receive GOAWAY; in-flight RPCs continue.
     pub fn begin_shutdown(&self) {

data/lib/generators/tonic_rails/install/install_generator.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module TonicRails
+  module Generators
+    # rails generate tonic_rails:install
+    #
+    # Sets an app up for gRPC: an initializer (load path for generated
+    # protobuf code, configuration, handler registration), the proto and
+    # generated-code directories, and the Puma plugin.
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      class_option :skip_puma, type: :boolean, default: false,
+                               desc: "Don't add `plugin :tonic_rails` to config/puma.rb"
+      class_option :skip_next_steps, type: :boolean, default: false, hide: true
+
+      def create_initializer
+        template "tonic_rails.rb.tt", "config/initializers/tonic_rails.rb"
+      end
+
+      def create_directories
+        create_file "app/protos/.keep"
+        create_file "lib/grpc/.keep"
+      end
+
+      def add_puma_plugin
+        return if options[:skip_puma]
+
+        puma = "config/puma.rb"
+        return unless File.exist?(File.join(destination_root, puma))
+        return if File.read(File.join(destination_root, puma)).match?(/plugin\s+:tonic_rails/)
+
+        append_to_file puma, "\n# Run the tonic-rails gRPC server alongside Puma.\nplugin :tonic_rails\n"
+      end
+
+      def show_next_steps
+        return if options[:skip_next_steps]
+
+        say "\nNext: rails generate tonic_rails:service Item GetItem ListItems:server", :green
+      end
+    end
+  end
+end

data/lib/generators/tonic_rails/install/templates/tonic_rails.rb.tt

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Ruby code generated from app/protos by `bin/rails tonic_rails:compile_protos`
+# lives in lib/grpc. Its files require each other by plain name, so put the
+# directory on the load path and keep Zeitwerk away from it.
+Rails.root.join("lib/grpc").then do |generated|
+  $LOAD_PATH.unshift(generated.to_s) unless $LOAD_PATH.include?(generated.to_s)
+  Rails.autoloaders.main.ignore(generated)
+end
+
+Tonic::Rails.configure do |config|
+  # config.bind_address = "0.0.0.0:50051"
+  # config.dispatch_threads = ENV.fetch("RAILS_MAX_THREADS", 5).to_i
+  # config.reflection = Rails.env.development?
+  # config.health_check = -> { ActiveRecord::Base.connection.active? }
+end
+
+# Handlers in app/grpc are autoloaded; register them here so they're
+# picked up again after code reloads.
+Rails.application.config.to_prepare do
+end

data/lib/generators/tonic_rails/service/service_generator.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module TonicRails
+  module Generators
+    # rails generate tonic_rails:service Item GetItem ListItems:server ImportItems:client Sync:bidi
+    #
+    # Creates a .proto with the service and its messages, a handler with a
+    # method per RPC, the handler's registration, and a test.
+    class ServiceGenerator < ::Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      STREAM_KINDS = %w[unary server client bidi].freeze
+
+      argument :rpcs, type: :array, default: [], banner: "Rpc[:server|:client|:bidi] ..."
+
+      class_option :package, type: :string,
+                             desc: "Protobuf package (default: <app name>.v1)"
+
+      def check_rpcs
+        rpc_specs.each do |rpc|
+          next if rpc[:name].match?(/\A[A-Z][A-Za-z0-9]*\z/) && STREAM_KINDS.include?(rpc[:kind])
+
+          raise Thor::Error, "Invalid RPC #{rpc[:raw].inspect}: use CamelCase names, optionally :server, :client or :bidi"
+        end
+      end
+
+      def create_proto
+        template "service.proto.tt", "app/protos/#{package_path}/#{service_file}_service.proto"
+      end
+
+      def create_handler
+        template "handler.rb.tt", "app/grpc/#{service_file}_service.rb"
+      end
+
+      def register_handler
+        initializer = "config/initializers/tonic_rails.rb"
+        invoke "tonic_rails:install", [], skip_next_steps: true unless File.exist?(File.join(destination_root, initializer))
+        inject_into_file initializer, "  Tonic::Rails.server.register(#{service_class})\n",
+                         after: "Rails.application.config.to_prepare do\n"
+      end
+
+      def create_test
+        if File.directory?(File.join(destination_root, "spec"))
+          template "service_spec.rb.tt", "spec/grpc/#{service_file}_service_spec.rb"
+        else
+          template "service_test.rb.tt", "test/grpc/#{service_file}_service_test.rb"
+        end
+      end
+
+      def show_next_steps
+        say "\nNext: bin/rails tonic_rails:compile_protos, then fill in app/grpc/#{service_file}_service.rb", :green
+      end
+
+      private
+
+      # "Item" and "ItemService" both mean the service ItemService.
+      def service_base
+        class_name.delete_suffix("Service")
+      end
+
+      def service_file
+        service_base.underscore
+      end
+
+      def service_class
+        "#{service_base}Service"
+      end
+
+      def package
+        options[:package] || "#{app_name}.v1"
+      end
+
+      def app_name
+        app = defined?(::Rails.application) && ::Rails.application
+        name = app ? app.class.module_parent_name : File.basename(destination_root)
+        name.to_s.underscore.tr("-", "_").presence || "app"
+      end
+
+      def package_path
+        package.tr(".", "/")
+      end
+
+      def ruby_module
+        package.split(".").map(&:camelize).join("::")
+      end
+
+      def full_service_name
+        "#{package}.#{service_class}"
+      end
+
+      def rpc_specs
+        list = rpcs.empty? ? ["Get#{service_base}"] : rpcs
+        list.map do |raw|
+          name, kind = raw.split(":", 2)
+          { raw: raw, name: name.to_s, kind: kind || "unary", method: name.to_s.underscore }
+        end
+      end
+
+      def proto_rpc_line(rpc)
+        request = "#{rpc[:name]}Request"
+        response = "#{rpc[:name]}Response"
+        request = "stream #{request}" if %w[client bidi].include?(rpc[:kind])
+        response = "stream #{response}" if %w[server bidi].include?(rpc[:kind])
+        "rpc #{rpc[:name]}(#{request}) returns (#{response});"
+      end
+    end
+  end
+end

data/lib/generators/tonic_rails/service/templates/handler.rb.tt

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "<%= package_path %>/<%= service_file %>_service_pb"
+
+class <%= service_class %>
+  include Tonic::Rails::Base
+
+  rpc_service "<%= full_service_name %>"
+  request_format :message
+<% rpc_specs.each do |rpc| %>
+<% case rpc[:kind] -%>
+<% when "unary" -%>
+  # @param request [<%= ruby_module %>::<%= rpc[:name] %>Request]
+  # @return [<%= ruby_module %>::<%= rpc[:name] %>Response]
+  def <%= rpc[:method] %>(request)
+    raise Tonic::Rails::RpcError.new("<%= rpc[:name] %> is not implemented yet", code: :unimplemented)
+  end
+<% when "server" -%>
+  # @param request [<%= ruby_module %>::<%= rpc[:name] %>Request]
+  # @return [Enumerable<<%= ruby_module %>::<%= rpc[:name] %>Response>] each element is streamed as it's produced
+  def <%= rpc[:method] %>(request)
+    raise Tonic::Rails::RpcError.new("<%= rpc[:name] %> is not implemented yet", code: :unimplemented)
+  end
+<% when "client" -%>
+  # @param requests [Enumerator<<%= ruby_module %>::<%= rpc[:name] %>Request>] yields messages as they arrive
+  # @return [<%= ruby_module %>::<%= rpc[:name] %>Response]
+  def <%= rpc[:method] %>(requests)
+    raise Tonic::Rails::RpcError.new("<%= rpc[:name] %> is not implemented yet", code: :unimplemented)
+  end
+<% else -%>
+  # @param requests [Enumerator<<%= ruby_module %>::<%= rpc[:name] %>Request>] yields messages as they arrive
+  # @return [Enumerable<<%= ruby_module %>::<%= rpc[:name] %>Response>]
+  def <%= rpc[:method] %>(requests)
+    raise Tonic::Rails::RpcError.new("<%= rpc[:name] %> is not implemented yet", code: :unimplemented)
+  end
+<% end -%>
+<% end -%>
+end

data/lib/generators/tonic_rails/service/templates/service.proto.tt

@@ -0,0 +1,16 @@
+syntax = "proto3";
+
+package <%= package %>;
+
+service <%= service_class %> {
+<% rpc_specs.each do |rpc| -%>
+  <%= proto_rpc_line(rpc) %>
+<% end -%>
+}
+<% rpc_specs.each do |rpc| %>
+message <%= rpc[:name] %>Request {
+}
+
+message <%= rpc[:name] %>Response {
+}
+<% end -%>

data/lib/generators/tonic_rails/service/templates/service_spec.rb.tt

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+require "tonic/rails/testing/rspec"
+
+RSpec.describe <%= service_class %> do
+<% rpc_specs.each_with_index do |rpc, i| -%>
+<% if i.positive? %>
+<% end -%>
+  describe "<%= rpc[:name] %>" do
+    it "is not implemented yet" do
+      request = <%= %w[client bidi].include?(rpc[:kind]) ? "[#{ruby_module}::#{rpc[:name]}Request.new]" : "#{ruby_module}::#{rpc[:name]}Request.new" %>
+      expect { Tonic::Rails::Testing.call(described_class, :<%= rpc[:name] %>, request) }.to raise_grpc_error(:unimplemented)
+    end
+  end
+<% end -%>
+end

data/lib/generators/tonic_rails/service/templates/service_test.rb.tt

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "tonic/rails/testing/minitest"
+
+class <%= service_class %>Test < ActiveSupport::TestCase
+  include Tonic::Rails::Testing::Assertions
+<% rpc_specs.each do |rpc| %>
+  test "<%= rpc[:name] %> is not implemented yet" do
+    request = <%= %w[client bidi].include?(rpc[:kind]) ? "[#{ruby_module}::#{rpc[:name]}Request.new]" : "#{ruby_module}::#{rpc[:name]}Request.new" %>
+    assert_grpc_error(:unimplemented) { Tonic::Rails::Testing.call(<%= service_class %>, :<%= rpc[:name] %>, request) }
+  end
+<% end -%>
+end