Struct tonic::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) -> Self

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, ) -> Self

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

source

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

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 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 {}))
    }
}