Struct minerva_rpc::metadata::ClientInterceptor

pub struct ClientInterceptor {
    tenant: String,
    requestor: String,
}

Defines the interceptor data for any gRPC client.

The interceptor exists for the sole purpose of introducing tenant and requestor data within a given request, that is going to be sent by the client connected to a service.

Example

Consider the following dummy service that allows a remote procedure call to a ping function.

// example.proto

syntax = "proto3";
import "google/protobuf/empty.proto";

package Example;

service Example {
  rpc ping(google.protobuf.Empty) returns (google.protobuf.Empty) {}
}

Imagine that this single procedure implementation requires that tenant and requestor data are embedded within a request for this to work. For example:

// example.rs
tonic::include_proto!("example");

#[derive(Clone)]
pub struct ExampleService;

#[tonic::async_trait]
impl Example for ExampleService {
    async fn ping(&self, req: Request<()>) -> Result<(), Status> {
        let tenant = metadata::get_value(req.metadata(), "tenant")
            .ok_or_else(|| Status::failed_precondition("Missing tenant data"))?;
        let requestor = metadata::get_value(req.metadata(), "requestor")
            .ok_or_else(|| Status::failed_precondition("Missing requestor data"))?;
        println!("Tenant: {}, requestor: {}", tenant, requestor);
        Ok(Response::new(()))
    }
}

One may want to use this structure to send data as needed.

// example.rs
fn test_request() {
    use tonic::transport::Channel;
    let channel = Channel::from_static("http://localhost:1234").connect().await?;
    let client = test_client::TestClient::with_interceptor(
        channel,
        ClientInterceptor::new("company", "admin"),
    );
    let response = client.ping(Request::new(())).await?;
}

Fields

tenant: String

Tenant related to the database access while on a request.

requestor: String

Requestor of the operation, usually the login of a user.

Implementations

impl ClientInterceptor

pub fn new(tenant: &str, requestor: &str) -> Self

Creates a new ClientInterceptor from given tenant and requestor names. The tenant is closely related to the database to be manipulated, while the requestor usually is the login of the user performing the manipulation.

Trait Implementations

impl Interceptor for ClientInterceptor

fn call(&mut self, request: Request<()>) -> Result<Request<()>, Status>

Intercept a request before it is sent, optionally cancelling it.