Struct NetworkNode 

pub struct NetworkNode<T: NodeType, D: DhtPersistentStorage> {
    peer_id: PeerId,
    swarm: Swarm<NetworkDef<T::SignatureKey, D>>,
    kademlia_record_ttl: Duration,
    consensus_key_to_pid_map: Arc<Mutex<BiMap<T::SignatureKey, PeerId>>>,
    listener_id: Option<ListenerId>,
    direct_message_state: DMBehaviour,
    dht_handler: DHTBehaviour<T::SignatureKey, D>,
    resend_tx: Option<UnboundedSender<ClientRequest>>,
    saw_inbound_connection: bool,
    expected_kad_protocol: StreamProtocol,
    same_network_peers: HashSet<PeerId>,
    dht_put_quorum: Option<NonZeroUsize>,
}

Network definition

Fields

peer_id: PeerId

peer id of network node

swarm: Swarm<NetworkDef<T::SignatureKey, D>>

the swarm of networkbehaviours

kademlia_record_ttl: Duration

The Kademlia record TTL

consensus_key_to_pid_map: Arc<Mutex<BiMap<T::SignatureKey, PeerId>>>

The map from consensus keys to peer IDs

listener_id: Option<ListenerId>

the listener id we are listening on, if it exists

direct_message_state: DMBehaviour

Handler for direct messages

dht_handler: DHTBehaviour<T::SignatureKey, D>

Handler for DHT Events

resend_tx: Option<UnboundedSender<ClientRequest>>

Channel to resend requests, set to Some when we call spawn_listeners

saw_inbound_connection: bool

Whether a peer ever connected to us.

Used to warn the operator when the advertised address is likely not publicly reachable.

expected_kad_protocol: StreamProtocol

Kademlia StreamProtocol expected from same-network peers.

same_network_peers: HashSet<PeerId>

Peers confirmed via identify to share our network discriminator. Gates NewExternalAddrOfPeer, whose event carries no protocols to check directly.

dht_put_quorum: Option<NonZeroUsize>

Implementations

impl<T: NodeType, D: DhtPersistentStorage> NetworkNode<T, D>

pub fn num_connected(&self) -> usize

Returns number of peers this node is connected to

pub fn connected_pids(&self) -> HashSet<PeerId>

return hashset of PIDs this node is connected to

pub async fn start_listen( &mut self, listen_addr: Multiaddr, ) -> Result<Multiaddr, NetworkError>

starts the swarm listening on listen_addr and optionally dials into peer known_peer returns the address the swarm is listening upon

pub fn add_known_peers(&mut self, known_peers: &[(PeerId, Multiaddr)])

initialize the DHT with known peers add the peers to kademlia and then the spawn_listeners function will start connecting to peers

pub async fn new( config: NetworkNodeConfig, dht_persistent_storage: D, consensus_key_to_pid_map: Arc<Mutex<BiMap<T::SignatureKey, PeerId>>>, ) -> Result<Self, NetworkError>

Creates a new Network with the given settings.

Currently:

• Generates a random key pair and associated PeerId
• Launches a hopefully production ready transport: QUIC v1 (RFC 9000) + DNS
• Generates a connection to the “broadcast” topic
• Creates a swarm to manage peers and events

Errors

• If we fail to generate the transport or any of the behaviours

Panics

If 5 < 0

fn on_identify_received(&mut self, peer_id: PeerId, info: IdentifyInfo)

Identify is the first point a peer’s network is detectable; drop other networks.

pub fn put_record(&mut self, query: KadPutQuery)

Publish a key/value to the record store.

Panics

If the default replication factor is None

async fn handle_client_requests( &mut self, msg: Option<ClientRequest>, ) -> Result<bool, NetworkError>

event handler for client events currently supported actions include

• shutting down the swarm
• gossipping a message to known peers on the global topic
• returning the id of the current peer
• subscribing to a topic
• unsubscribing from a toipc
• direct messaging a peer

async fn handle_swarm_events( &mut self, event: SwarmEvent<NetworkEventInternal>, send_to_client: &UnboundedSender<NetworkEvent>, ) -> Result<(), NetworkError>

event handler for events emitted from the swarm

pub fn spawn_listeners( self, ) -> Result<(UnboundedSender<ClientRequest>, UnboundedReceiver<NetworkEvent>, SwarmTaskHandle), NetworkError>

Spawn a task to listen for requests on the returned channel as well as any events produced by libp2p

Errors

• If we fail to create the channels or the bootstrap channel

pub fn peer_id(&self) -> PeerId

Get a reference to the network node’s peer id.

fn warn_if_unreachable(&self)

One-shot reachability check.

Run NO_INBOUND_CONNECTION_GRACE_PERIOD after the swarm loop starts. A healthy, publicly reachable node receives inbound connections shortly after joining. If we are listening but no peer has connected to us by now, the advertised address is likely wrong or blocked, so point the operator at it. If we have no connections at all, not even outbound, the problem is more fundamental than the advertised address.

Trait Implementations

impl<T: NodeType, D: DhtPersistentStorage> Debug for NetworkNode<T, D>

where Arc<Mutex<BiMap<T::SignatureKey, PeerId>>>: Debug, DHTBehaviour<T::SignatureKey, D>: Debug,

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

Formats the value using the given formatter.