Struct rings_node::prelude::Swarm

pub struct Swarm { /* private fields */ }

The transport and dht management.

Implementations

impl Swarm

pub async fn record_sent(&self, did: Did) -> impl Future<Output = ()>

Record a succeeded message sent

pub async fn record_sent_failed(&self, did: Did) -> impl Future<Output = ()>

Record a failed message sent

pub async fn behaviour_good(&self, did: Did) -> impl Future<Output = bool>

Check that a Did is behaviour good

pub async fn new_connection( &self, did: Did ) -> impl Future<Output = Result<ConnectionRef<WebrtcConnection>, Error>>

Create new connection that will be handled by swarm.

pub async fn get_and_check_connection( &self, did: Did ) -> impl Future<Output = Option<ConnectionRef<WebrtcConnection>>>

Get connection by did and check if it is connected.

pub fn get_connection( &self, did: Did ) -> Option<ConnectionRef<WebrtcConnection>>

Get connection by did.

pub fn get_connections( &self ) -> Vec<(Did, ConnectionRef<WebrtcConnection>), Global>

Get all connections in transport.

pub fn get_connection_ids(&self) -> Vec<Did, Global>

Get dids of all connections in transport.

impl Swarm

pub fn did(&self) -> Did

Get did of self.

pub fn dht(&self) -> Arc<PeerRing, Global>

Get DHT(Distributed Hash Table) of self.

pub fn session_sk(&self) -> &SessionSk

Retrieves the session sk associated with the current instance. The session sk provides a segregated approach to manage private keys. It generates session secret keys for the bound entries of PKIs (Public Key Infrastructure).

pub async fn poll_message( &self ) -> impl Future<Output = Option<MessagePayload<Message>>>

This method is required because web-sys components is not Send which means an async loop cannot running concurrency.

pub async fn listen_once( &self ) -> impl Future<Output = Option<(MessagePayload<Message>, Vec<MessageHandlerEvent, Global>)>>

This method is required because web-sys components is not Send This method will return events already consumed (landed), which is ok to be ignore. which means a listening loop cannot running concurrency.

pub async fn handle_message_handler_event( &self, event: &MessageHandlerEvent ) -> impl Future<Output = Result<Vec<MessageHandlerEvent, Global>, Error>>

Event handler of Swarm.

pub fn handle_message_handler_events<'life0, 'life_self, 'async_recursion>( &'life_self self, events: &'life0 Vec<MessageHandlerEvent, Global> ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_recursion, Global>>where 'life0: 'async_recursion, 'life_self: 'async_recursion,

Batch handle events

pub async fn disconnect( &self, did: Did ) -> impl Future<Output = Result<(), Error>>

Disconnect a connection. There are three steps:

1. remove from DHT;
2. remove from Transport;
3. close the connection;

pub async fn connect( &self, did: Did ) -> impl Future<Output = Result<ConnectionRef<WebrtcConnection>, Error>>

Connect a given Did. If the did is already connected, return directly, else try prepare offer and establish connection by dht. This function may returns a pending connection or connected connection.

pub async fn connect_via( &self, did: Did, next_hop: Did ) -> impl Future<Output = Result<ConnectionRef<WebrtcConnection>, Error>>

Similar to connect, but this function will try connect a Did by given hop.

pub async fn inspect(&self) -> impl Future<Output = SwarmInspect>

Check the status of swarm

impl Swarm

pub async fn listen(self: Arc<Swarm, Global>) -> impl Future<Output = ()>

Listener for native envirement, It will just launch a loop.

Trait Implementations

impl<const REDUNDANT: u16> ChordStorageInterface<REDUNDANT> for Swarm

fn storage_fetch<'life0, 'async_trait>( &'life0 self, vid: Did ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Swarm: 'async_trait,

Fetch virtual node, if exist in localstoreage, copy it to the cache, else Query Remote Node

fn storage_store<'life0, 'async_trait>( &'life0 self, vnode: VirtualNode ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Swarm: 'async_trait,

Store VirtualNode, TryInto<VirtualNode> is implemented for alot of types

fn storage_append_data<'life0, 'life1, 'async_trait>( &'life0 self, topic: &'life1 str, data: Encoded ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, 'life1: 'async_trait, Swarm: 'async_trait,

append data to Data type virtual node

fn storage_touch_data<'life0, 'life1, 'async_trait>( &'life0 self, topic: &'life1 str, data: Encoded ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, 'life1: 'async_trait, Swarm: 'async_trait,

append data to Data type virtual node uniquely

impl ChordStorageInterfaceCacheChecker for Swarm

fn storage_check_cache<'life0, 'async_trait>( &'life0 self, vid: Did ) -> Pin<Box<dyn Future<Output = Option<VirtualNode>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Swarm: 'async_trait,

Check local cache

impl ConnectionHandshake for Swarm

fn prepare_connection_offer<'life0, 'async_trait>( &'life0 self, peer: Did ) -> Pin<Box<dyn Future<Output = Result<(ConnectionRef<WebrtcConnection>, ConnectNodeSend), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Swarm: 'async_trait,

Create new connection and its offer.

fn answer_remote_connection<'life0, 'life1, 'async_trait>( &'life0 self, peer: Did, offer_msg: &'life1 ConnectNodeSend ) -> Pin<Box<dyn Future<Output = Result<(ConnectionRef<WebrtcConnection>, ConnectNodeReport), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, 'life1: 'async_trait, Swarm: 'async_trait,

Answer the offer of remote connection.

fn accept_remote_connection<'life0, 'life1, 'async_trait>( &'life0 self, peer: Did, answer_msg: &'life1 ConnectNodeReport ) -> Pin<Box<dyn Future<Output = Result<ConnectionRef<WebrtcConnection>, Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, 'life1: 'async_trait, Swarm: 'async_trait,

Accept the answer of remote connection.

fn create_offer<'life0, 'async_trait>( &'life0 self, peer: Did ) -> Pin<Box<dyn Future<Output = Result<(ConnectionRef<WebrtcConnection>, MessagePayload<Message>), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Swarm: 'async_trait,

Creaet new connection and its answer. This function will wrap the offer inside a payload with verification.

fn answer_offer<'life0, 'async_trait>( &'life0 self, offer_payload: MessagePayload<Message> ) -> Pin<Box<dyn Future<Output = Result<(ConnectionRef<WebrtcConnection>, MessagePayload<Message>), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Swarm: 'async_trait,

Answer the offer of remote connection. This function will verify the answer payload and will wrap the answer inside a payload with verification.

fn accept_answer<'life0, 'async_trait>( &'life0 self, answer_payload: MessagePayload<Message> ) -> Pin<Box<dyn Future<Output = Result<(Did, ConnectionRef<WebrtcConnection>), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Swarm: 'async_trait,

Accept the answer of remote connection. This function will verify the answer payload and will return its did with the connection.

impl ConnectionManager for Swarm

fn disconnect<'life0, 'async_trait>( &'life0 self, did: Did ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Swarm: 'async_trait,

Disconnect a connection. There are three steps:

1. remove from DHT;
2. remove from Transport;
3. close the connection;

fn connect<'life0, 'async_trait>( &'life0 self, did: Did ) -> Pin<Box<dyn Future<Output = Result<ConnectionRef<WebrtcConnection>, Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Swarm: 'async_trait,

Connect a given Did. If the did is already connected, return directly, else try prepare offer and establish connection by dht. This function may returns a pending connection or connected connection.

fn connect_via<'life0, 'async_trait>( &'life0 self, did: Did, next_hop: Did ) -> Pin<Box<dyn Future<Output = Result<ConnectionRef<WebrtcConnection>, Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Swarm: 'async_trait,

Similar to connect, but this function will try connect a Did by given hop.

impl Judegement for Swarm

fn record_connect<'life0, 'async_trait>( &'life0 self, did: Did ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Swarm: 'async_trait,

Record a succeeded connected

fn record_disconnected<'life0, 'async_trait>( &'life0 self, did: Did ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Swarm: 'async_trait,

Record a disconnected

fn should_connect<'life0, 'async_trait>( &'life0 self, did: Did ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Swarm: 'async_trait,

Asynchronously checks if a connection should be established with the provided DID.

impl JudgeConnection for Swarm

fn disconnect<'life0, 'async_trait>( &'life0 self, did: Did ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Self: Sync + 'async_trait,

Asynchronously disconnects the connection associated with the provided DID after recording the disconnection.

fn connect<'life0, 'async_trait>( &'life0 self, did: Did ) -> Pin<Box<dyn Future<Output = Result<ConnectionRef<WebrtcConnection>, Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Self: Sync + 'async_trait,

Asynchronously establishes a new connection and returns the connection associated with the provided DID if should_connect returns true; otherwise, returns an error.

fn connect_via<'life0, 'async_trait>( &'life0 self, did: Did, next_hop: Did ) -> Pin<Box<dyn Future<Output = Result<ConnectionRef<WebrtcConnection>, Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Self: Sync + 'async_trait,

Asynchronously establishes a new connection via a specified next hop DID and returns the connection associated with the provided DID if should_connect returns true; otherwise, returns an error.

impl<T> PayloadSender<T> for Swarmwhere T: Clone + Serialize + DeserializeOwned + Send + Sync + 'static + Debug,

fn session_sk(&self) -> &SessionSk

Get the session sk

fn dht(&self) -> Arc<PeerRing, Global>

Get access to DHT.

fn do_send_payload<'life0, 'async_trait>( &'life0 self, did: Did, payload: MessagePayload<T> ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Swarm: 'async_trait,

Send a message payload to a specified DID.

fn infer_next_hop( &self, next_hop: Option<Did>, destination: Did ) -> Result<Did, Error>

Infer the next hop for a message by calling dht.find_successor().

fn send_payload<'life0, 'async_trait>( &'life0 self, payload: MessagePayload<T> ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Self: Sync + 'async_trait,

Alias for do_send_payload that sets the next hop to payload.relay.next_hop.

fn send_message<'life0, 'async_trait>( &'life0 self, msg: T, destination: Did ) -> Pin<Box<dyn Future<Output = Result<Uuid, Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Self: Sync + 'async_trait,

Send a message to a specified destination.

fn send_message_by_hop<'life0, 'async_trait>( &'life0 self, msg: T, destination: Did, next_hop: Did ) -> Pin<Box<dyn Future<Output = Result<Uuid, Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Self: Sync + 'async_trait,

Send a message to a specified destination by specified next hop.

fn send_direct_message<'life0, 'async_trait>( &'life0 self, msg: T, destination: Did ) -> Pin<Box<dyn Future<Output = Result<Uuid, Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Self: Sync + 'async_trait,

Send a direct message to a specified destination.

fn send_report_message<'life0, 'life1, 'async_trait>( &'life0 self, payload: &'life1 MessagePayload<T>, msg: T ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Send a report message to a specified destination.

fn forward_by_relay<'life0, 'life1, 'async_trait>( &'life0 self, payload: &'life1 MessagePayload<T>, relay: MessageRelay ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Forward a payload message by relay. It just create a new payload, cloned data, resigned with session and send

fn forward_payload<'life0, 'life1, 'async_trait>( &'life0 self, payload: &'life1 MessagePayload<T>, next_hop: Option<Did> ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Forward a payload message, with the next hop inferred by the DHT.

fn reset_destination<'life0, 'life1, 'async_trait>( &'life0 self, payload: &'life1 MessagePayload<T>, next_hop: Did ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Reset the destination to a secp DID.

impl<const REDUNDANT: u16> SubringInterface<REDUNDANT> for Swarm

fn subring_join<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, 'life1: 'async_trait, Swarm: 'async_trait,

add did into current chord subring. send direct message with JoinSubring type, which will handled by next node.