Struct ConnPool 

pub struct ConnPool<F: ClientFacts, P: ClientTransport> { /* private fields */ }

Connection pool to the one server address (supports async and blocking context)

There’s a worker accepting task post in bounded channel.

Even when the server address is not reachable, the worker coroutine will not exit, until ConnPool is dropped.

The background coroutine will:

• monitor the address with ping task (action 0)
• cleanup the task in channel with error_handle when the address is unhealthy

If the connection is healthy and there’s incoming, the worker will spawn another coroutine for monitor purpose.

considering:

• The task incoming might never stop until faulty pool remove from pools collection
• If ping mixed with task with real business, might blocked due to throttler of in-flight message in the stream.

Implementations

impl<F: ClientFacts, P: ClientTransport> ConnPool<F, P>

pub fn new(facts: Arc<F>, rt: &P::RT, addr: &str, channel_size: usize) -> Self

pub fn is_healthy(&self) -> bool

pub fn get_addr(&self) -> &str

pub async fn send_req(&self, task: F::Task)

pub fn send_req_blocking(&self, task: F::Task)

pub fn spawn(&self, rt: &P::RT)

by default there’s one worker thread after initiation, but you can pre-spawn more thread if the connection is not enough to achieve desired throughput.

Trait Implementations

impl<F: ClientFacts, P: ClientTransport> ClientCaller for ConnPool<F, P>

type Facts = F

async fn send_req(&self, task: F::Task)

fn get_codec(&self) -> <Self::Facts as ClientFacts>::Codec

impl<F: ClientFacts, P: ClientTransport> ClientCallerBlocking for ConnPool<F, P>

type Facts = F

fn send_req_blocking(&self, task: F::Task)

fn get_codec(&self) -> <Self::Facts as ClientFacts>::Codec

impl<F: ClientFacts, P: ClientTransport> Clone for ConnPool<F, P>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.