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;

    let load_balanced_channel = LoadBalancedChannel::builder(("my_hostname", 5000))
        .await
        .expect("failed to read system conf")
        .channel();

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

Implementations

impl LoadBalancedChannel

pub async fn builder<H: Into<ServiceDefinition>>(
    service_definition: H
) -> Result<LoadBalancedChannelBuilder<DnsResolver>, Error>

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

Performs the conversion.

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

type Response = Response<<Channel as GrpcService<BoxBody>>::ResponseBody>

Responses given by the service.

type Error = <Channel as GrpcService<BoxBody>>::Error

Errors produced by the service.

type Future = <Channel as GrpcService<BoxBody>>::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.