Struct PeerChannel 

pub struct PeerChannel<R>
where
    R: Ratchet,
{ /* private fields */ }

Implementations

impl<R> PeerChannel<R>

where R: Ratchet,

pub fn upgrade(&self, restore_udp: bool) -> Result<(), NetworkError>

Re-arms this connection’s P2P path campaign; see PathControl::upgrade.

pub fn path_control(&self) -> PathControl

A handle that can upgrade after Self::split.

pub fn take_restored_udp(&mut self) -> Option<UnboundedReceiver<UdpChannel<R>>>

The UDP channels later recoveries restore (see PathControl::upgrade), each replacing the one before, which ended with the route it rode. Some once, on a P2P channel.

pub fn peer_protocol_version(&self) -> Option<u32>

The other end’s PROTOCOL_VERSION: from the connect packet on a client-server channel, and from the peer’s key-exchange signal on a P2P channel. None when the peer (or a server relaying for it) predates carrying it.

pub fn p2p_path(&self) -> P2pPath

The path this connection’s traffic currently takes (direct, TURN relay, or the Citadel server). The channel is delivered as soon as it is usable, which is over the server relay: NAT traversal runs in the background and the path changes in place, to P2pPath::Direct or P2pPath::Turn when a P2P route attaches and back to P2pPath::ServerRelay if it is lost. Messages keep flowing, in order and exactly once, across every change. Use Self::ensure_direct to wait for a P2P route, or Self::path_changes to follow the path without polling.

pub fn ensure_direct( &self, ) -> impl Future<Output = Result<P2pPath, NetworkError>> + Send + 'static

Resolves once this connection runs over a P2P route, with that route’s path (P2pPath::Direct, or P2pPath::Turn when a TURN config was supplied); resolves Err (it never hangs) once the background campaign has ended without one — every attempt failed, the NATs are incompatible and no TURN config was supplied, or the connection closed. It has no timeout of its own. If a P2P route is later lost the connection falls back to the relay and retries a bounded number of times; a new call waits for that retry. After the campaign gave up, Self::upgrade re-arms it.

pub fn path_changes(&self) -> Receiver<P2pPathStatus>

A receiver that wakes on every change of this connection’s path or upgrade campaign.

pub fn p2p_relayed_both(&self) -> bool

On a P2pPath::Turn path, whether both peers relay through their own allocation (relay-to-relay: two TURN servers’ egress per packet) rather than one.

pub fn p2p_path_cell(&self) -> P2pPathCell

A handle that keeps reporting the path after Self::split.

pub fn connection_id(&self) -> Option<Ticket>

The P2P connection this channel is: the id every report of its end names (DisconnectToken::connection_id, the same on both peers). A connection that replaced it under the same peer CID has another, so a late report of this one’s end can be told apart. None for a C2S channel, whose session is named by channel_id.

pub fn get_peer_cid(&self) -> u64

Gets the CID of the endpoint

pub fn get_session_cid(&self) -> u64

Gets the CID of the local user

pub fn get_peer_conn_type(&self) -> Option<PeerConnectionType>

Gets the metadata of the virtual connection

pub fn split(self) -> (PeerChannelSendHalf<R>, PeerChannelRecvHalf<R>)

In order to use the PeerChannel properly, split must be called in order to receive an asynchronous interface. The SendHalf implements Sink, whereas the RecvHalf implements Stream

Trait Implementations

impl<R> Debug for PeerChannel<R>

where R: Debug + Ratchet,

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

Formats the value using the given formatter.