Struct Network

pub struct Network { /* private fields */ }

API to interact with the underlying Swarm

Implementations

impl Network

pub async fn get_transactions( &self, address: TransactionAddress, ) -> Result<Vec<Transaction>, NetworkError>

Gets Transactions at TransactionAddress from the Network.

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 dial(&self, addr: Multiaddr) -> Result<(), NetworkError>

Dial the given peer at the given address. This function will only be called for the bootstrap nodes.

pub async fn client_get_all_close_peers_in_range_or_close_group( &self, key: &NetworkAddress, ) -> Result<Vec<PeerId>, 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 node_get_closest_peers( &self, key: &NetworkAddress, ) -> Result<Vec<PeerId>, NetworkError>

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_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>, NetworkError>

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

pub async fn get_replicate_candidates( &self, data_addr: NetworkAddress, ) -> Result<Vec<PeerId>, NetworkError>

Returns the replicate candidates in range.

pub async fn verify_chunk_existence( &self, chunk_address: NetworkAddress, nonce: Nonce, expected_proof: ChunkProof, quorum: Quorum, retry_strategy: Option<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, ignore_peers: Vec<PeerId>, ) -> Result<Vec<(PeerId, 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_register_record_from_network( &self, key: RecordKey, ) -> Result<HashMap<XorName, Record>, NetworkError>

Get register from network. Due to the nature of the p2p network, it’s not guaranteed there is only one version exists in the network all the time. The scattering of the register will be more like ring layered. Meanwhile, kad::get_record will terminate with first majority copies returned, which has the risk of returning with old versions. So, to improve the accuracy, query closest_peers first, then fetch registers And merge them if they are with different content.

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 transactions and registers. For transactions, it accumulates the transactions and returns an error if more than one. For registers, it merges the registers and returns the merged record.

pub async fn get_local_quoting_metrics( &self, key: RecordKey, ) -> 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: RecordType)

Notify ReplicationFetch a fetch attempt is completed. (but it won’t trigger any real writes to disk, say fetched an old version of register)

pub fn put_local_record(&self, record: Record)

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, RecordType>, NetworkError>

Returns the Addresses of all the locally stored Records

pub async fn send_request( &self, req: Request, peer: PeerId, ) -> Result<Response, 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_req_ignore_reply(&self, req: Request, peer: PeerId)

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)

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 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 async fn get_all_close_peers_in_range_or_close_group( &self, key: &NetworkAddress, client: bool, ) -> Result<Vec<PeerId>, NetworkError>

Returns the closest peers to the given XorName, sorted by their distance to the xor_name. If client is false, then include self among the closest_peers

If less than CLOSE_GROUP_SIZE peers are found, it will return all the peers.

pub async fn send_and_get_responses( &self, peers: &[PeerId], req: &Request, get_all_responses: bool, ) -> BTreeMap<PeerId, Result<Response, 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

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.