Struct ProtoDescriptor 

pub struct ProtoDescriptor { /* private fields */ }

Implementations

impl ProtoDescriptor

pub fn new( includes: impl IntoIterator<Item = impl AsRef<Path>>, files: impl IntoIterator<Item = impl AsRef<Path>>, ) -> Result<Self>

Instantiate DescriptorPool from proto files and include paths

Errors

• Failed to compile proto ProtoxCompileError
• Failed to generate descriptor DescriptorError

Examples found in repository

examples/metadata.rs (lines 12-15)

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 (lines 10-13)

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 async fn from_reflection(request: ReflectionRequest) -> Result<Self>

Instantiates a DescriptorPool from a grpc server that supports reflection.

Errors

Errors if server reflection or dependency resolving fails.

Examples found in repository

examples/reflection.rs (line 14)

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)[0];
    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(())
}

pub fn get_service_by_name(&self, name: &str) -> Option<ServiceDescriptor>

Returns a Service by its name

pub fn get_message_by_name(&self, name: &str) -> Option<MessageDescriptor>

Returns a Message by its name

pub fn get_method_by_name( &self, service_name: &str, method_name: &str, ) -> Option<MethodDescriptor>

Returns a Method of a service by its name

pub fn get_services(&self) -> Vec<ServiceDescriptor>

Returns all Services from the descriptor pool

Examples found in repository

examples/reflection.rs (line 15)

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)[0];
    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 16)

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 15)

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 get_methods(&self, service: &ServiceDescriptor) -> Vec<MethodDescriptor>

Examples found in repository

examples/reflection.rs (line 16)

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)[0];
    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 17)

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 16)

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 get_request_descriptor( &self, method: &MethodDescriptor, ) -> MessageDescriptor

pub fn get_response_descriptor( &self, method: &MethodDescriptor, ) -> MessageDescriptor

pub fn get_request(&self, method: &MethodDescriptor) -> RequestMessage

Examples found in repository

examples/reflection.rs (line 20)

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)[0];
    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 21)

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 22)

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 get_response(&self, method: &MethodDescriptor) -> ResponseMessage

Trait Implementations

impl Clone for ProtoDescriptor

fn clone(&self) -> ProtoDescriptor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProtoDescriptor

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

Formats the value using the given formatter.

impl Default for ProtoDescriptor

fn default() -> ProtoDescriptor

Returns the “default value” for a type.