Struct sn_networking::Network

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

API to interact with the underlying Swarm

Fields

swarm_cmd_sender: Sender<SwarmCmd>

peer_id: PeerId

root_dir_path: PathBuf

Implementations

impl Network

pub fn sign(&self, msg: &[u8]) -> Result<Vec<u8>, Error>

Signs the given data with the node’s keypair.

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

Listen for incoming connections on 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 get_our_close_group(&self) -> Result<Vec<PeerId>, Error>

Returns the current set of members in our close group. This list is sorted in ascending order based on the distance to self. The first element is self.

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_store_cost_from_network( &self, record_address: NetworkAddress, any_cost_will_do: bool ) -> Result<Token, Error>

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

Get the Record from the network Carry out re-attempts if required In case a target_record is provided, only return when fetched target. Otherwise count it as a failure when all attempts completed.

pub async fn get_local_storecost(&self) -> Result<Token, Error>

Get the cost of storing the next 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_record( &self, record: Record, verify_store: bool ) -> Result<(), Error>

Put Record to network optionally verify the record is stored after putting it to network

pub 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 is_key_present_locally( &self, key: &RecordKey ) -> Result<bool, Error>

Returns true if a RecordKey is present locally in the RecordStore

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

Returns the Addresses of all the locally stored Records

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

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

Send Request to 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 fn send_req_ignore_reply( &self, req: Request, peer: PeerId ) -> Result<(), Error>

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

pub 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.