Struct zebra_network::peer::client::Client

pub struct Client {
    pub connection_info: Arc<ConnectionInfo>,
    pub(crate) shutdown_tx: Option<Sender<CancelHeartbeatTask>>,
    pub(crate) server_tx: Sender<ClientRequest>,
    pub(crate) inv_collector: Sender<InventoryResponse<(AtLeastOne<InventoryHash>, PeerSocketAddr), (AtLeastOne<InventoryHash>, PeerSocketAddr)>>,
    pub(crate) error_slot: ErrorSlot,
    pub(crate) connection_task: JoinHandle<()>,
    pub(crate) heartbeat_task: JoinHandle<Result<(), BoxError>>,
}

The “client” duplex half of a peer connection.

Fields

connection_info: Arc<ConnectionInfo>

The metadata for the connected peer service.

shutdown_tx: Option<Sender<CancelHeartbeatTask>>

Used to shut down the corresponding heartbeat. This is always Some except when we take it on drop.

server_tx: Sender<ClientRequest>

Used to send Requests to the remote peer.

inv_collector: Sender<InventoryResponse<(AtLeastOne<InventoryHash>, PeerSocketAddr), (AtLeastOne<InventoryHash>, PeerSocketAddr)>>

Used to register missing inventory in client Responses, so that the peer set can route retries to other clients.

error_slot: ErrorSlot

A slot for an error shared between the Connection and the Client that uses it.

None unless the connection or client have errored.

connection_task: JoinHandle<()>

A handle to the task responsible for connecting to the peer.

heartbeat_task: JoinHandle<Result<(), BoxError>>

A handle to the task responsible for sending periodic heartbeats.

Implementations

impl Client

fn poll_heartbeat( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), SharedPeerError>>

Check if this connection’s heartbeat task has exited.

Returns an error if the heartbeat task exited. Otherwise, schedules the client task for wakeup when the heartbeat task finishes, or the channel closes, and returns Pending.

Panics

If the heartbeat task panicked.

fn poll_connection( &mut self, context: &mut Context<'_> ) -> Poll<Result<(), SharedPeerError>>

Check if the connection’s request/response task has exited.

Returns an error if the connection task exited. Otherwise, schedules the client task for wakeup when the connection task finishes, and returns Pending.

Panics

If the connection task panicked.

fn set_task_exited_error( &mut self, task_name: &str, error: PeerError ) -> Result<(), SharedPeerError>

Properly update the error slot after a background task has unexpectedly stopped.

fn poll_request( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), SharedPeerError>>

Poll for space in the shared request sender channel.

Returns an error if the sender channel is closed. If there is no space in the channel, returns Pending, and schedules the task for wakeup when there is space available.

fn poll_client( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), SharedPeerError>>

Poll for space in the shared request sender channel, and for errors in the connection tasks.

Returns an error if the sender channel is closed, or the heartbeat or connection tasks have terminated. If there is no space in the channel, returns Pending, and schedules the task for wakeup when there is space available, or one of the tasks terminates.

fn shutdown(&mut self)

Shut down the resources held by the client half of this peer connection.

Stops further requests to the remote peer, and stops the heartbeat task.

Trait Implementations

impl Debug for Client

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

Formats the value using the given formatter.

impl Drop for Client

fn drop(&mut self)

Executes the destructor for this type.

impl From<Client> for LoadTrackedClient

Create a new LoadTrackedClient wrapping the provided client service.

fn from(client: Client) -> Self

Converts to this type from the input type.

impl Service<Request> for Client

type Response = Response

Responses given by the service.

type Error = SharedPeerError

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<Client as Service<Request>>::Response, <Client as Service<Request>>::Error>> + Send>>

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) -> Self::Future

Process the request and return the response asynchronously.