Struct NodeRemote 

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

allows convenient communication with the server

Implementations

impl<R> NodeRemote<R>

where R: Ratchet,

pub fn traffic(&self) -> NodeTrafficSnapshot

This node’s traffic by class (direct and TURN P2P, P2P relayed through the server, client-server, group broadcast), across all its sessions. Monotonic.

pub fn rebind_local(&self) -> Result<RebindReport, NetworkError>

Moves every client-role QUIC endpoint this node holds (C2S QUIC, and the dialing side of direct and TURN P2P paths) to a fresh socket on the current local address, so their connections migrate without a new handshake. Call it when the local network changes. Local only: nothing crosses the wire. See proto::misc::local_rebind for what cannot move.

pub async fn send_with_custom_ticket( &self, ticket: Ticket, request: NodeRequest, ) -> Result<(), NetworkError>

Sends a request to the server with a custom ticket.

pub async fn send(&self, request: NodeRequest) -> Result<Ticket, NetworkError>

Sends a request to the server and returns a ticket for tracking the response.

pub async fn send_callback_subscription( &self, request: NodeRequest, ) -> Result<KernelStreamSubscription<R>, NetworkError>

Convenience method for sending and awaiting for a response for the related ticket

pub async fn shutdown(&self) -> Result<(), NetworkError>

Safely shutsdown the internal server

pub fn get_next_ticket(&self) -> Ticket

pub fn try_send_with_custom_ticket( &self, ticket: Ticket, request: NodeRequest, ) -> Result<(), TrySendError<(NodeRequest, Ticket)>>

pub fn try_send( &self, request: NodeRequest, ) -> Result<(), TrySendError<(NodeRequest, Ticket)>>

pub fn local_node_type(&self) -> &NodeType

pub fn account_manager(&self) -> &AccountManager<R, R>

Trait Implementations

impl<R> Clone for NodeRemote<R>

where R: Clone + Ratchet,

fn clone(&self) -> NodeRemote<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R> Debug for NodeRemote<R>

where R: Ratchet,

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

Formats the value using the given formatter.

impl<R: Ratchet> ProtocolRemoteExt<R> for NodeRemote<R>

fn register<'life0, 'async_trait, T, P, V, K>( &'life0 self, addr: T, full_name: P, username: V, proposed_password: K, default_security_settings: SessionSecuritySettings, server_password: Option<PreSharedKey>, ) -> Pin<Box<dyn Future<Output = Result<RegisterSuccess, NetworkError>> + Send + 'async_trait>>

where T: 'async_trait + ToSocketAddrs + Send, P: 'async_trait + Into<String> + Send, V: 'async_trait + Into<String> + Send, K: 'async_trait + Into<SecBuffer> + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Registers with custom settings Returns a ticket which is used to uniquely identify the request in the protocol

fn register_admitted<'life0, 'async_trait, T, P, V, K>( &'life0 self, addr: T, full_name: P, username: V, proposed_password: K, default_security_settings: SessionSecuritySettings, server_password: Option<PreSharedKey>, admission: Option<String>, ) -> Pin<Box<dyn Future<Output = Result<RegisterSuccess, NetworkError>> + Send + 'async_trait>>

where T: 'async_trait + ToSocketAddrs + Send, P: 'async_trait + Into<String> + Send, V: 'async_trait + Into<String> + Send, K: 'async_trait + Into<SecBuffer> + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

As register, carrying an admission token (a Turnstile response) for a server that asks fresh registrations for one. A refusal is a PqSignInAdmissionRequired or PqSignInAdmissionFailed error.

fn register_to_endpoint<'life0, 'async_trait, P, V, K>( &'life0 self, endpoint: WebSocketEndpoint, full_name: P, username: V, proposed_password: K, default_security_settings: SessionSecuritySettings, server_password: Option<PreSharedKey>, ) -> Pin<Box<dyn Future<Output = Result<RegisterSuccess, NetworkError>> + Send + 'async_trait>>

where P: 'async_trait + Into<String> + Send, V: 'async_trait + Into<String> + Send, K: 'async_trait + Into<SecBuffer> + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Registers with a server reached by a WebSocket URL (wss://org.example.net/, or ws://host:port/path) rather than at an address of its own: a server behind an HTTP edge, which is told apart from the edge’s other servers by hostname and path. The account remembers the URL, so a later connect with credentials dials it too.

fn register_to_endpoint_admitted<'life0, 'async_trait, P, V, K>( &'life0 self, endpoint: WebSocketEndpoint, full_name: P, username: V, proposed_password: K, default_security_settings: SessionSecuritySettings, server_password: Option<PreSharedKey>, admission: Option<String>, ) -> Pin<Box<dyn Future<Output = Result<RegisterSuccess, NetworkError>> + Send + 'async_trait>>

where P: 'async_trait + Into<String> + Send, V: 'async_trait + Into<String> + Send, K: 'async_trait + Into<SecBuffer> + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

As register_to_endpoint, carrying an admission token.

fn server_endpoint<'life0, 'async_trait>( &'life0 self, cid: u64, ) -> Pin<Box<dyn Future<Output = Result<Option<WebSocketEndpoint>, NetworkError>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

The WebSocket URL the local account cid registered to (see register_to_endpoint), or None when its server is the address in its connection info. Behind an HTTP edge that address is one of the edge’s, shared with every other server there, so it does not identify the server; this does.

fn register_with_defaults<'life0, 'async_trait, T, P, V, K>( &'life0 self, addr: T, full_name: P, username: V, proposed_password: K, ) -> Pin<Box<dyn Future<Output = Result<RegisterSuccess, NetworkError>> + Send + 'async_trait>>

where T: 'async_trait + ToSocketAddrs + Send, P: 'async_trait + Into<String> + Send, V: 'async_trait + Into<String> + Send, K: 'async_trait + Into<SecBuffer> + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Registers using the default settings. The default uses No Google FCM keys and the default session security settings Returns a ticket which is used to uniquely identify the request in the protocol

fn connect<'life0, 'async_trait>( &'life0 self, auth: AuthenticationRequest, connect_mode: ConnectMode, udp_mode: UdpMode, keep_alive_timeout: Option<Duration>, session_security_settings: SessionSecuritySettings, server_password: Option<PreSharedKey>, ) -> Pin<Box<dyn Future<Output = Result<CitadelClientServerConnection<R>, NetworkError>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Connects with custom settings Returns a ticket which is used to uniquely identify the request in the protocol

fn connect_with_defaults<'life0, 'async_trait>( &'life0 self, auth: AuthenticationRequest, ) -> Pin<Box<dyn Future<Output = Result<CitadelClientServerConnection<R>, NetworkError>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Connects with the default settings If FCM keys were created during the registration phase, then those keys will be used for the session. If new FCM keys need to be used, consider using Self::connect

fn find_target<'life0, 'async_trait, T, P>( &'life0 self, local_user: T, peer: P, ) -> Pin<Box<dyn Future<Output = Result<SymmetricIdentifierHandleRef<'_, R>, NetworkError>> + Send + 'async_trait>>

where T: 'async_trait + Into<UserIdentifier> + Send, P: 'async_trait + Into<UserIdentifier> + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Creates a valid target identifier used to make protocol requests. Raw user IDs or usernames can be used

fn propose_target<'life0, 'async_trait, T, P>( &'life0 self, local_user: T, peer: P, ) -> Pin<Box<dyn Future<Output = Result<SymmetricIdentifierHandleRef<'_, R>, NetworkError>> + Send + 'async_trait>>

where T: 'async_trait + Into<UserIdentifier> + Send, P: 'async_trait + Into<UserIdentifier> + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Creates a proposed target from the valid local user to an unregistered peer in the network. Used when creating registration requests for peers. Currently only supports LocalGroup <-> LocalGroup peer connections

fn get_local_group_peers<'life0, 'async_trait, T>( &'life0 self, local_user: T, limit: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<Vec<LocalGroupPeerFullInfo>, NetworkError>> + Send + 'async_trait>>

where T: 'async_trait + Into<UserIdentifier> + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Returns a list of local group peers on the network for local_user. May or may not be registered to the user. To get a list of registered users to local_user, run Self::get_local_group_mutual_peers

fn get_local_group_mutual_peers<'life0, 'async_trait, T>( &'life0 self, local_user: T, ) -> Pin<Box<dyn Future<Output = Result<Vec<LocalGroupPeerFullInfo>, NetworkError>> + Send + 'async_trait>>

where T: 'async_trait + Into<UserIdentifier> + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

Returns a list of mutually-registered peers with the local_user

fn probe_server<'life0, 'async_trait>( &'life0 self, cid: u64, timeout: Duration, ) -> Pin<Box<dyn Future<Output = ServerProbeOutcome> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Round-trips an authenticated probe to the server of session cid now, rather than on the keep-alive schedule (15 minutes, 45 to time out): Ok(rtt), Timeout when no answer came within timeout, or Error when it could not be sent (no such connected session, or a server below protocol 0.12.1, which cannot answer one). Over a WebSocket the probe also sends a WebSocket ping.

fn abandon_session<'life0, 'async_trait>( &'life0 self, cid: u64, ) -> Pin<Box<dyn Future<Output = Result<(), NetworkError>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Ends session cid here and now, without asking the server: its transport is dropped, the session is forgotten and its CID freed, so the next login is not refused with “Session for CID .. already exists”. For a link that died silently (after probe_server timed out): the server’s copy is replaced by that login’s resume token. Resolves once the session has dropped; Err when this node holds no session for cid.

fn sessions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<ActiveSessions, NetworkError>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Returns all the active sessions in the protocol, including all P2P connections hierarchically placed as children to C2S connections

fn rebind_local(&self) -> Result<RebindReport, NetworkError>

Moves this node’s live client-role QUIC endpoints to fresh sockets on the current local address, so Direct and TURN QUIC paths (and a C2S QUIC connection) migrate without a new handshake. Call it on a local network change. Local only, so not version-gated; see NodeRemote::rebind_local.

impl<R> Remote<R> for NodeRemote<R>

where R: Ratchet,

fn send<'life0, 'async_trait>( &'life0 self, request: NodeRequest, ) -> Pin<Box<dyn Future<Output = Result<Ticket, NetworkError>> + Send + 'async_trait>>

where 'life0: 'async_trait, NodeRemote<R>: 'async_trait,

Sends a request to the server and returns a ticket for tracking the response.

fn send_with_custom_ticket<'life0, 'async_trait>( &'life0 self, ticket: Ticket, request: NodeRequest, ) -> Pin<Box<dyn Future<Output = Result<(), NetworkError>> + Send + 'async_trait>>

where 'life0: 'async_trait, NodeRemote<R>: 'async_trait,

Sends a request to the server with a custom ticket.

fn send_callback_subscription<'life0, 'async_trait>( &'life0 self, request: NodeRequest, ) -> Pin<Box<dyn Future<Output = Result<KernelStreamSubscription<R>, NetworkError>> + Send + 'async_trait>>

where 'life0: 'async_trait, NodeRemote<R>: 'async_trait,

Sends a request to the server and returns a subscription for callback events.

fn account_manager(&self) -> &AccountManager<R, R>

Returns the account manager instance.

fn get_next_ticket(&self) -> Ticket

Returns the next available ticket.

impl<R> Unpin for NodeRemote<R>

where R: Ratchet,