Struct RequestMessage

pub struct RequestMessage { /* private fields */ }

Holds all the necessary data for a gRPC request, including the message, method descriptor, and optional metadata.

Implementations

impl RequestMessage

pub fn new( message_desc: MessageDescriptor, method_desc: MethodDescriptor, ) -> Self

Create a new RequestMessage with the provided message descriptor and method descriptor.

pub fn message_name(&self) -> String

Get the name of the message.

pub fn message_descriptor(&self) -> MessageDescriptor

Get the message descriptor associated with the RequestMessage.

pub fn method_descriptor(&self) -> MethodDescriptor

Get the method descriptor associated with the RequestMessage.

pub fn message(&self) -> &DynamicMessage

Gets a reference to the message.

pub fn message_mut(&mut self) -> &mut DynamicMessage

Gets a mutable reference to the message.

pub fn set_message(&mut self, message: DynamicMessage)

Set a new message for the request.

pub fn address(&self) -> &str

Get the host address.

pub fn uri(&self) -> Result<Uri>

Get the host address as uri.

Errors

• Failed to parse address to uri.

pub fn set_address(&mut self, address: &str)

Sets the host address.

Examples found in repository

examples/reflection.rs (line 21)

async fn main() -> Result<()> {
    let request = ReflectionRequest::new("http://localhost:50051");
    let desc = ProtoDescriptor::from_reflection(request).await?;
    let service = &desc.get_services()[0];
    let method = &desc.get_methods(service)[1];
    println!("Service: {:}", service.full_name());
    println!("Method:  {:}", method.full_name());
    //
    let mut req = desc.get_request(&method);
    req.set_address("http://localhost:50051");

    let mut req = desc.get_request(&method);
    req.set_address("http://localhost:50051");

    Ok(())
}

examples/metadata.rs (line 22)

async fn main() -> Result<()> {
    let desc = ProtoDescriptor::new(
        vec!["/Users/philippreiter/Rust/wireman/example"],
        vec!["grpc_simple/debugger.proto"],
    )?;
    let service = &desc.get_services()[0];
    let method = &desc.get_methods(service)[1];
    println!("Service: {:}", service.full_name());
    println!("Method:  {:}", method.full_name());

    let mut req = desc.get_request(&method);
    req.set_address("http://localhost:50051");

    let resp = do_request(&req).await?;
    println!("\nResponse:\n{:}", resp.message.to_json()?);

    Ok(())
}

examples/streaming.rs (line 23)

async fn main() -> Result<()> {
    let desc = ProtoDescriptor::new(
        vec!["/Users/philippreiter/Rust/wireman/example/server/streaming"],
        vec!["streaming.proto"],
    )?;

    let service = &desc.get_services()[0];
    let method = &desc.get_methods(service)[0];

    if !method.is_server_streaming() {
        println!("Method must be server streaming");
    }

    let mut request = desc.get_request(&method);
    request.set_address("http://localhost:50051");

    let response = call_server_streaming(&request, None).await?;

    let mut pinned = std::pin::pin!(response);
    let stream = pinned.as_mut().get_mut();

    while let Some(message) = stream.next().await {
        let message = message?;
        println!("message: {:?}", message.message);
        println!();
    }

    Ok(())
}

pub fn metadata(&self) -> &Option<Metadata>

Get the metadata associated with the request.

pub fn insert_metadata(&mut self, key: &str, val: &str) -> Result<()>

Insert metadata into the request.

Errors

• Failed to parse metadata value/key to ascii

pub fn path(&self) -> PathAndQuery

Get the URI path for gRPC calls based on the method descriptor.

Panics

Panics if constructing the path and query from a string fails.

pub fn codec(&self) -> DynamicCodec

Return the dynamic codec based on the method descriptor.

pub fn to_json(&self) -> Result<String>

Serialize the RequestMessage to a JSON string.

Errors

Returns an Error if serialization to a JSON string fails.

Trait Implementations

impl Clone for RequestMessage

fn clone(&self) -> RequestMessage

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RequestMessage

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

Formats the value using the given formatter.

impl From<RequestMessage> for Request<RequestMessage>

fn from(value: RequestMessage) -> Self

Converts to this type from the input type.

impl Serialize for RequestMessage

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.