Struct madsim_tonic::Request

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

A gRPC request and metadata from an RPC call.

Implementations

impl<T> Request<T>

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

Create a new gRPC request.

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

pub fn get_ref(&self) -> &T

Get a reference to the message

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

Get a mutable reference to the message

pub fn metadata(&self) -> &MetadataMap

Get a reference to the custom request metadata.

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

Get a mutable reference to the request metadata.

pub fn into_inner(self) -> T

Consumes self, returning the message

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

Consumes self returning the parts of the request.

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

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

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

Convert an HTTP request to a gRPC request

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.

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.

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"
);

pub fn extensions(&self) -> &Extensions

Returns a reference to the associated extensions.

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

Trait Implementations

impl<T> Debug for Request<T>

where T: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> IntoRequest<T> for Request<T>

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request

impl<T> IntoStreamingRequest for Request<T>

where T: Stream + Send + 'static,

type Stream = T

The RPC request stream type

type Message = <T as Stream>::Item

The RPC request type

fn into_streaming_request(self) -> Request<T>

Wrap the stream of messages in a tonic::Request