Struct conec::client::Client

pub struct Client { /* fields omitted */ }

The Client end of a connection to the Coordinator

See library documentation for an example of constructing a Client.

Implementations

impl Client

pub async fn new(
    config: ClientConfig
) -> Result<(Self, IncomingStreams), ClientError>

Construct a Client and connect to the Coordinator

pub fn new_proxied_stream(&mut self, to: String) -> ConnectingStream

Open a new stream to another client, proxied through the Coordinator

pub fn new_direct_stream(&mut self, to: String) -> ConnectingStream

Open a new stream to another client via a direct channel.

It is only possible to open another stream to a client for which there is an open channel, either because that client connected to this one or because this client called Client::new_channel.

pub fn new_stream_with_id(&self, to: String, sid: StreamId) -> ConnectingStream

Open a new proxied stream to another client with an explicit stream-id. This can be useful for coordination in applications where peers share multiple data streams (e.g., clients might agree that sid 1 is for values of type T1, sid 2 is for values of type T2, etc.).

The sid argument must be different for every call to this function for a given Client object. If mixing calls to this function with calls to Client::new_proxied_stream or Client::new_direct_stream, avoid using sid >= 1<<63, since these values are used automatically by those functions.

pub fn new_channel(&mut self, to: String) -> ConnectingChannel

Open a new channel directly to another client

Note that a client that is not listening for new channels can nevertheless open a new channel to one that is listening.

pub fn close_channel(&self, peer: String) -> ClosingChannel

Close an open channel

Currently, attempting to re-open a channel after closing causes what appears to be a transport error. XXX(#1)

pub fn new_broadcast(&mut self, chan: String) -> ConnectingStream

Open or connect to a broadcast stream

A broadcast stream is a many-to-many stream proxied through the Coordinator. Any Client who knows the stream's name can send to and receive from it.

Broadcast streams may suffer from the slow receiver problem: senders cannot make progress until the slowest receiver drains its incoming buffer. The NonblockingInStream adapter may help to address this issue.

pub fn new_stream(&mut self, to: String) -> ConnectingStream

Open a new stream to another client

This function first attempts to open a direct stream to the client and then, if that fails, falls back to a proxied stream through the Coordinator.

pub fn get_broadcast_count(&mut self, chan: String) -> BroadcastCounting

Count the current members of a broadcast channel

Request from Coordinator the current count of senders and receivers on a given broadcast channel. The result is a future that, when forced, returns either an error or the tuple (#senders, #receivers).