Struct Network

pub struct Network { /* private fields */ }

API to interact with the underlying Swarm

Implementations

impl Network

pub fn new( network_swarm_cmd_sender: Sender<NetworkSwarmCmd>, local_swarm_cmd_sender: Sender<LocalSwarmCmd>, peer_id: PeerId, keypair: Keypair, ) -> Self

pub fn peer_id(&self) -> PeerId

Returns the PeerId of the instance.

pub fn keypair(&self) -> &Keypair

Returns the Keypair of the instance.

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

Signs the given data with the node’s keypair.

pub fn verify(&self, msg: &[u8], sig: &[u8]) -> bool

Verifies a signature for the given data and the node’s public key.

pub fn get_pub_key(&self) -> Vec<u8>

Returns the protobuf serialised PublicKey to allow messaging out for share.

pub async fn get_local_peers_with_multiaddr( &self, ) -> Result<Vec<(PeerId, Vec<Multiaddr>)>, NetworkError>

Returns a list of peers in local RT and their correspondent Multiaddr. Does not include self

pub async fn get_kbuckets( &self, ) -> Result<BTreeMap<u32, Vec<PeerId>>, NetworkError>

Returns a map where each key is the ilog2 distance of that Kbucket and each value is a vector of peers in that bucket. Does not include self

pub async fn get_closest_k_value_local_peers( &self, ) -> Result<Vec<(PeerId, Addresses)>, NetworkError>

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

pub async fn get_close_peers_to_the_target( &self, key: NetworkAddress, num_of_peers: usize, ) -> Result<Vec<(PeerId, Addresses)>, NetworkError>

Returns X close peers to the target. Note: self is not included

pub async fn verify_chunk_existence( &self, chunk_address: NetworkAddress, close_nodes: Vec<(PeerId, Addresses)>, nonce: Nonce, expected_proof: ChunkProof, quorum: ResponseQuorum, _retry_strategy: RetryStrategy, ) -> Result<(), NetworkError>

Get the Chunk existence proof from the close nodes to the provided chunk address. This is to be used by client only to verify the success of the upload.

pub async fn get_store_quote_from_network( &self, record_address: NetworkAddress, data_type: u32, data_size: usize, ignore_peers: Vec<PeerId>, ) -> Result<Vec<(PeerId, Addresses, PaymentQuote)>, NetworkError>

Get the store costs from the majority of the closest peers to the provided RecordKey. Record already exists will have a cost of zero to be returned.

Ignore the quote from any peers from ignore_peers. This is useful if we want to repay a different PeerId on failure.

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

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.

It also handles the split record error for GraphEntry.

pub async fn get_local_quoting_metrics( &self, key: RecordKey, data_type: u32, data_size: usize, ) -> Result<(QuotingMetrics, bool), NetworkError>

Get the quoting metrics for storing the next record from the network

pub fn notify_payment_received(&self)

Notify the node receicced a payment.

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

Get Record from the local RecordStore

pub async fn is_peer_shunned( &self, target: NetworkAddress, ) -> Result<bool, NetworkError>

Whether the target peer is considered blacklisted by self

pub async fn put_record( &self, record: Record, cfg: &PutRecordCfg, ) -> Result<(), NetworkError>

Put Record to network Optionally verify the record is stored after putting it to network If verify is on, we retry.

pub fn notify_fetch_completed( &self, key: RecordKey, record_type: ValidationType, )

Notify ReplicationFetch a fetch attempt is completed. (but it won’t trigger any real writes to disk)

pub fn put_local_record(&self, record: Record, is_client_put: bool)

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

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

Returns true if a RecordKey is present locally in the RecordStore

pub async fn get_all_local_record_addresses( &self, ) -> Result<HashMap<NetworkAddress, ValidationType>, NetworkError>

Returns the Addresses of all the locally stored Records

pub async fn send_request( &self, req: Request, peer: PeerId, addrs: Addresses, ) -> Result<(Response, Option<ConnectionInfo>), NetworkError>

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.

If an outbound issue is raised, we retry once more to send the request before returning an error.

pub fn send_response(&self, resp: Response, channel: MsgResponder)

Send a Response through the channel opened by the requester.

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

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

pub fn trigger_interval_replication(&self)

pub fn add_fresh_records_to_the_replication_fetcher( &self, holder: NetworkAddress, keys: Vec<(NetworkAddress, ValidationType)>, )

pub fn record_node_issues(&self, peer_id: PeerId, issue: NodeIssue)

pub fn historical_verify_quotes(&self, quotes: Vec<(PeerId, PaymentQuote)>)

pub fn trigger_irrelevant_record_cleanup(&self)

pub fn add_network_density_sample(&self, distance: KBucketDistance)

pub fn notify_peer_scores(&self, peer_scores: Vec<(PeerId, bool)>)

pub fn notify_node_version(&self, peer: PeerId, version: String)

pub fn remove_peer(&self, peer: PeerId)

pub async fn get_closest_peers( &self, key: &NetworkAddress, ) -> Result<Vec<(PeerId, Addresses)>, NetworkError>

Returns the closest peers to the given XorName, sorted by their distance to the xor_name.

pub async fn get_n_closest_peers( &self, key: &NetworkAddress, n: usize, ) -> Result<Vec<(PeerId, Addresses)>, NetworkError>

Returns the n closest peers to the given XorName, sorted by their distance to the xor_name.

pub async fn client_get_close_group( &self, key: &NetworkAddress, ) -> Result<Vec<(PeerId, Addresses)>, NetworkError>

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 send_and_get_responses( &self, peers: &[(PeerId, Addresses)], req: &Request, get_all_responses: bool, ) -> BTreeMap<PeerId, Result<(Response, Option<ConnectionInfo>), NetworkError>>

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

pub async fn get_network_density( &self, ) -> Result<Option<KBucketDistance>, NetworkError>

Get the estimated network density (i.e. the responsible_distance_range).

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.

impl Debug for Network

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

Formats the value using the given formatter.