Struct ginepro::LoadBalancedChannel

pub struct LoadBalancedChannel(_);

Implements tonic GrpcService for a client-side load balanced Channel (using The Power of Two Choices).

GrpcService

#[tokio::main]
async fn main() {
    use ginepro::LoadBalancedChannel;
    use shared_proto::pb::tester_client::TesterClient;
    use std::convert::TryInto;

    let load_balanced_channel = LoadBalancedChannel::builder(("my.hostname", 5000))
        .channel()
        .await
        .expect("failed to construct LoadBalancedChannel");

    let client = TesterClient::new(load_balanced_channel);
}

Implementations

impl LoadBalancedChannel

pub fn builder<S>(
    service_definition: S
) -> LoadBalancedChannelBuilder<DnsResolver, S> where
    S: TryInto<ServiceDefinition> + Send + Sync + 'static,
    S::Error: Into<Box<dyn Error + Send + Sync>> + Send + Sync, 

Start configuring a LoadBalancedChannel by passing in the ServiceDefinition for the gRPC server service you want to call - e.g. my.service.uri and 5000.

All the service endpoints of a ServiceDefinition will be constructed by resolving IPs for ServiceDefinition::hostname, and using the port number ServiceDefinition::port.

Trait Implementations

impl Clone for LoadBalancedChannel

fn clone(&self) -> LoadBalancedChannel

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LoadBalancedChannel

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

Formats the value using the given formatter.

impl From<LoadBalancedChannel> for Channel

fn from(channel: LoadBalancedChannel) -> Self

Converts to this type from the input type.

impl Service<Request<UnsyncBoxBody<Bytes, Status>>> for LoadBalancedChannel

type Response = Response<<Channel as GrpcService<UnsyncBoxBody<Bytes, Status>>>::ResponseBody>

Responses given by the service.

type Error = <Channel as GrpcService<UnsyncBoxBody<Bytes, Status>>>::Error

Errors produced by the service.

type Future = <Channel as GrpcService<UnsyncBoxBody<Bytes, Status>>>::Future

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, request: Request<BoxBody>) -> Self::Future

Process the request and return the response asynchronously.