Struct libp2p_networking::network::NetworkNode

pub struct NetworkNode<T: NodeType> {
    keypair: Keypair,
    peer_id: PeerId,
    swarm: Swarm<NetworkDef<T::SignatureKey>>,
    config: NetworkNodeConfig<T>,
    listener_id: Option<ListenerId>,
    direct_message_state: DMBehaviour,
    dht_handler: DHTBehaviour<T::SignatureKey>,
    resend_tx: Option<UnboundedSender<ClientRequest>>,
    bootstrap_tx: Option<Sender<InputEvent>>,
}

Network definition

Fields

keypair: Keypair

The keypair for the node

peer_id: PeerId

peer id of network node

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

the swarm of networkbehaviours

config: NetworkNodeConfig<T>

the configuration parameters of the netework

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>

Handler for DHT Events

resend_tx: Option<UnboundedSender<ClientRequest>>

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

bootstrap_tx: Option<Sender<InputEvent>>

Send to the bootstrap task to tell it to start a bootstrap

Implementations

impl<T: NodeType> NetworkNode<T>

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<T>) -> 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

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 currectly 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 async fn spawn_listeners( self, ) -> Result<(UnboundedSender<ClientRequest>, UnboundedReceiver<NetworkEvent>), NetworkError>

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

pub fn peer_id(&self) -> PeerId

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

Trait Implementations

impl<T: NodeType> Debug for NetworkNode<T>

where NetworkNodeConfig<T>: Debug, DHTBehaviour<T::SignatureKey>: Debug,

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

Formats the value using the given formatter.