Struct GrpcPlugin

Source

pub struct GrpcPlugin { /* private fields */ }

Expand description

Serves tonic services from an Autumn app, on a dedicated HTTP/2 listener or on Autumn’s HTTP port (listener = "shared").

use autumn_plugin_grpc::GrpcPlugin;

autumn_web::app()
    .plugin(
        GrpcPlugin::new()
            .add_service(GreeterServer::new(MyGreeter))
            .file_descriptor_set(greeter::FILE_DESCRIPTOR_SET),
    )
    .run()
    .await;

The plugin reads [grpc] from autumn.toml (see GrpcConfig). Fluent setters apply on top of the file values.

On boot, the plugin:

builds the services (with AppState for add_service_with),
binds the listener (a failure aborts boot),
serves health and (in dev/test) reflection,
adds a grpc health indicator and grpc_server_* metrics to the actuator,
puts a GrpcHandle into AppState.

On shutdown, it drains (see GrpcHandle::shutdown).

Implementations§

Source §

impl GrpcPlugin

Source

pub fn new() -> Self

A plugin with no services, configured from [grpc].

Source

pub fn add_service<S>(self, service: S) -> Self
where S: Service<Request<TonicBody>, Error = Infallible> + NamedService + Clone + Send + Sync + 'static, S::Response: IntoResponse, S::Future: Send + 'static,

Serve a tonic service, for example GreeterServer::new(MyGreeter).

Source

pub fn add_service_with<S, F>(self, build: F) -> Self
where F: FnOnce(&AppState) -> S + Send + 'static, S: Service<Request<TonicBody>, Error = Infallible> + NamedService + Clone + Send + Sync + 'static, S::Response: IntoResponse, S::Future: Send + 'static,

Serve a tonic service that the plugin builds at startup, from AppState. Use this when the service needs the database pool or other app state.

GrpcPlugin::new().add_service_with(|state| {
    GreeterServer::new(MyGreeter::new(state.clone()))
})

Source

pub fn file_descriptor_set(self, encoded: &'static [u8]) -> Self

Add an encoded FileDescriptorSet for server reflection. Get it from tonic_prost_build (file_descriptor_set_path) and include_bytes!.

Source

pub fn layer<L>(self, layer: L) -> Self
where L: Layer<Route> + Clone + Send + Sync + 'static, L::Service: Service<Request> + Clone + Send + Sync + 'static, <L::Service as Service<Request>>::Response: IntoResponse + 'static, <L::Service as Service<Request>>::Error: Into<Infallible> + 'static, <L::Service as Service<Request>>::Future: Send + 'static,

Wrap every user service with a tower layer (for example rate limits or tracing). The layer does not wrap health or reflection, so probes and tools still work. For an auth layer, use guard.

Layers apply in call order: the last layer is the outermost.

Source

pub fn interceptor<F>(self, interceptor: F) -> Self
where F: Interceptor + Clone + Send + Sync + 'static,

Run a tonic interceptor before every user call. Like layer, it does not wrap health or reflection. For an auth interceptor, use guard_interceptor.

GrpcPlugin::new().interceptor(|mut request: tonic::Request<()>| {
    request.extensions_mut().insert(RequestStart(Instant::now()));
    Ok(request)
})

Source

pub fn guard<L>(self, layer: L, label: impl Into<String>) -> Self
where L: Layer<Route> + Clone + Send + Sync + 'static, L::Service: Service<Request> + Clone + Send + Sync + 'static, <L::Service as Service<Request>>::Response: IntoResponse + 'static, <L::Service as Service<Request>>::Error: Into<Infallible> + 'static, <L::Service as Service<Request>>::Future: Send + 'static,

Guard every user service with layer, for example an auth layer. autumn routes then shows the services as gated, with label as the middleware name.

Source

pub fn guard_interceptor<F>( self, interceptor: F, label: impl Into<String>, ) -> Self
where F: Interceptor + Clone + Send + Sync + 'static,

Guard every user service with a tonic interceptor. Like guard, with an interceptor in place of a layer.

Source

pub fn public(self) -> Self

Declare the user services open to all clients. autumn routes then shows them as public. Without guard* or public, the services are unclassified, and autumn routes audit fails.

Source

pub fn route_infos(&self) -> Vec<RouteInfo>

The gRPC services as autumn routes lists them. The method is GRPC and the path is /<service>/*. These routes are on the gRPC listener, or on the HTTP port in shared mode. A plugin on a non-default section uses the method GRPC:<section>. Autumn 0.8 refuses two plugins that declare the same method and path, and two servers can serve one service on different ports.

Source

pub fn configure( self, apply: impl Fn(&mut GrpcConfig) + Send + Sync + 'static, ) -> Self

Change the configuration in code, after files and environment.

Source

pub fn config(self, config: GrpcConfig) -> Self

Use config and read no files or environment variables. Fluent setters still apply on top.

Source

pub fn config_section(self, section: impl Into<String>) -> Self

Read a different section than [grpc]. The environment prefix changes with the section: grpc_admin reads AUTUMN_GRPC_ADMIN__*. Use this to run two servers.

Source