Struct sn_networking::Network

pub struct Network {
    pub swarm_cmd_sender: Sender<SwarmCmd>,
    pub peer_id: PeerId,
    pub root_dir_path: PathBuf,
}

API to interact with the underlying Swarm

Fields

swarm_cmd_sender: Sender<SwarmCmd>

peer_id: PeerId

root_dir_path: PathBuf

Implementations

impl Network

pub async fn start_listening(&self, addr: Multiaddr) -> Result<(), Error>

Listen for incoming connections on the given address.

pub async fn add_to_routing_table( &self, peer_id: PeerId, peer_addr: Multiaddr ) -> Result<(), Error>

Dial the given peer at the given address.

pub async fn dial(&self, addr: Multiaddr) -> Result<(), Error>

Dial the given peer at the given address.

pub async fn client_get_closest_peers( &self, key: &NetworkAddress ) -> Result<Vec<PeerId>, Error>

Returns the closest peers to the given XorName, sorted by their distance to the xor_name. Excludes the client’s PeerId while calculating the closest peers.

pub async fn node_get_closest_peers( &self, key: &NetworkAddress ) -> Result<Vec<PeerId>, Error>

Returns the closest peers to the given NetworkAddress, sorted by their distance to the key.

Includes our node’s PeerId while calculating the closest peers.

pub async fn get_closest_local_peers( &self, key: &NetworkAddress ) -> Result<Vec<PeerId>, Error>

Returns the closest peers to the given NetworkAddress that is fetched from the local Routing Table. It is ordered by increasing distance of the peers Note self peer_id is not included in the result.

pub async fn get_all_local_peers(&self) -> Result<Vec<PeerId>, Error>

Returns all the PeerId from all the KBuckets from our local Routing Table Also contains our own PeerId.

pub async fn node_send_to_closest( &self, request: &Request ) -> Result<Vec<Result<Response, Error>>, Error>

Send Request to the closest peers. If self is among the closest_peers, the Request is forwarded to itself and handled. Then a corresponding Response is created and is forwarded to itself. Hence the flow remains the same and there is no branching at the upper layers.

pub async fn send_req_no_reply_to_closest( &self, request: &Request ) -> Result<(), Error>

Send Request to the closest peers and ignore reply If self is among the closest_peers, the Request is forwarded to itself and handled. Then a corresponding Response is created and is forwarded to itself. Hence the flow remains the same and there is no branching at the upper layers.

pub async fn send_req_no_reply_to_self_closest( &self, request: &Request ) -> Result<(), Error>

Send Request to the closest peers to self

pub async fn client_send_to_closest( &self, request: &Request, expect_all_responses: bool ) -> Result<Vec<Result<Response, Error>>, Error>

Send Request to the closest peers. Self is not present among the recipients.

pub async fn get_record_keys_closest_to_target( &self, target: &NetworkAddress, distance: Distance ) -> Result<Vec<RecordKey>, Error>

Returns the list of keys that are within the provided distance to the target

pub async fn get_record_from_network( &self, key: RecordKey ) -> Result<Record, Error>

Get the Record from the network

pub async fn get_local_record( &self, key: &RecordKey ) -> Result<Option<Record>, Error>

Get Record from the local RecordStore

pub async fn put_local_record(&self, record: Record) -> Result<(), Error>

Put Record to the local RecordStore Must be called after the validations are performed on the Record

pub async fn get_all_local_record_addresses( &self ) -> Result<HashSet<NetworkAddress>, Error>

Get the RecordAddress of all the Records stored locally

pub async fn is_key_present_locally( &self, key: &RecordKey ) -> Result<bool, Error>

Returns true if a RecordKey is present locally in the RecordStore

pub async fn add_keys_to_replication_fetcher( &self, peer: PeerId, keys: Vec<NetworkAddress> ) -> Result<Vec<(PeerId, NetworkAddress)>, Error>

pub async fn notify_fetch_result( &self, peer: PeerId, key: NetworkAddress, result: bool ) -> Result<Vec<(PeerId, NetworkAddress)>, Error>

pub async fn set_record_distance_range( &self, distance: Distance ) -> Result<(), Error>

Set the acceptable range of record entry. A record is removed from the storage if the distance between the record and the node is greater than the provided distance.

pub async fn send_request( &self, req: Request, peer: PeerId ) -> Result<Response, Error>

Send Request to the the given PeerId and await for the response. If self is the recipient, then the Request is forwarded to itself and handled, and a corresponding Response is created and returned to itself. Hence the flow remains the same and there is no branching at the upper layers.

pub async fn send_req_ignore_reply( &self, req: Request, peer: PeerId ) -> Result<(), Error>

Send Request to the the given PeerId and do not await a response here. Instead the Response will be handled by the common response_handler

pub async fn send_response( &self, resp: Response, channel: MsgResponder ) -> Result<(), Error>

Send a Response through the channel opened by the requester.

pub async fn get_swarm_local_state(&self) -> Result<SwarmLocalState, Error>

Return a SwarmLocalState with some information obtained from swarm’s local state.

pub async fn send_and_get_responses( &self, peers: Vec<PeerId>, req: &Request, get_all_responses: bool ) -> Vec<Result<Response, Error>>

Send a Request to the provided set of peers and wait for their responses concurrently. If get_all_responses is true, we wait for the responses from all the peers. NB TODO: Will return an error if the request timeouts. If get_all_responses is false, we return the first successful response that we get

Trait Implementations

impl Clone for Network

fn clone(&self) -> Network

Returns a copy of the value.

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

Performs copy-assignment from source.