Struct teaclave_rpc::Request

source · [−]

pub struct Request<T> { /* private fields */ }

Expand description

A gRPC request and metadata from an RPC call.

Implementations

source

impl<T> Request<T>

source

pub fn new(message: T) -> Request<T>

Create a new gRPC request.

Request::new(HelloRequest {
   name: "Bob".into(),
});

source

pub fn get_ref(&self) -> &T

Get a reference to the message

source

pub fn get_mut(&mut self) -> &mut T

Get a mutable reference to the message

source

pub fn metadata(&self) -> &MetadataMap

Get a reference to the custom request metadata.

source

pub fn metadata_mut(&mut self) -> &mut MetadataMap

Get a mutable reference to the request metadata.

source

pub fn into_inner(self) -> T

Consumes self, returning the message

source

pub fn into_parts(self) -> (MetadataMap, Extensions, T)

Consumes self returning the parts of the request.

source

pub fn from_parts(
 metadata: MetadataMap,
 extensions: Extensions,
 message: T
) -> Request<T>

Create a new gRPC request from metadata, extensions and message.

source

pub fn from_http(http: Request<T>) -> Request<T>

Convert an HTTP request to a gRPC request

source

pub fn local_addr(&self) -> Option<SocketAddr>

Get the local address of this connection.

This will return None if the IO type used does not implement Connected or when using a unix domain socket. This currently only works on the server side.

source

pub fn remote_addr(&self) -> Option<SocketAddr>

Get the remote address of this connection.

This will return None if the IO type used does not implement Connected or when using a unix domain socket. This currently only works on the server side.

source

pub fn peer_certs(&self) -> Option<Arc<Vec<Certificate, Global>>>

Get the peer certificates of the connected client.

This is used to fetch the certificates from the TLS session and is mostly used for mTLS. This currently only returns Some on the server side of the transport server with TLS enabled connections.

source

pub fn set_timeout(&mut self, deadline: Duration)

Set the max duration the request is allowed to take.

Requires the server to support the grpc-timeout metadata, which Tonic does.

The duration will be formatted according to the spec and use the most precise unit possible.

Example:

use std::time::Duration;
use tonic::Request;

let mut request = Request::new(());

request.set_timeout(Duration::from_secs(30));

let value = request.metadata().get("grpc-timeout").unwrap();

assert_eq!(
    value,
    // equivalent to 30 seconds
    "30000000u"
);

source

pub fn extensions(&self) -> &Extensions

Returns a reference to the associated extensions.

source

pub fn extensions_mut(&mut self) -> &mut Extensions

Returns a mutable reference to the associated extensions.

Example

Extensions can be set in interceptors:

use tonic::{Request, service::interceptor};

struct MyExtension {
    some_piece_of_data: String,
}

interceptor(|mut request: Request<()>| {
    request.extensions_mut().insert(MyExtension {
        some_piece_of_data: "foo".to_string(),
    });

    Ok(request)
});

And picked up by RPCs:

use tonic::{async_trait, Status, Request, Response};

#[async_trait]
impl TestService for MyService {
    async fn handler(&self, req: Request<Input>) -> Result<Response<Output>, Status> {
        let value: &MyExtension = req.extensions().get::<MyExtension>().unwrap();

        Ok(Response::new(Output {}))
    }
}