Struct NetworkWorker

pub struct NetworkWorker<B, H>
where
    B: BlockT + 'static,
    H: ExHashT,
{ /* private fields */ }

Main network worker. Must be polled in order for the network to advance.

You are encouraged to poll this in a separate background thread or task.

Implementations

impl<B, H> NetworkWorker<B, H>

where B: BlockT + 'static, H: ExHashT,

pub fn new(params: Params<B, H, Self>) -> Result<Self, Error>

Creates the network service.

Returns a NetworkWorker that implements Future and must be regularly polled in order for the network processing to advance. From it, you can extract a NetworkService using worker.service(). The NetworkService can be shared through the codebase.

pub fn status(&self) -> NetworkStatus

High-level network status information.

pub fn total_bytes_inbound(&self) -> u64

Returns the total number of bytes received so far.

pub fn total_bytes_outbound(&self) -> u64

Returns the total number of bytes sent so far.

pub fn num_connected_peers(&self) -> usize

Returns the number of peers we’re connected to.

pub fn add_known_address(&mut self, peer_id: PeerId, addr: Multiaddr)

Adds an address for a node.

pub fn service(&self) -> &Arc<NetworkService<B, H>>

Return a NetworkService that can be shared through the code base and can be used to manipulate the worker.

pub fn local_peer_id(&self) -> &PeerId

Returns the local PeerId.

pub fn listen_addresses(&self) -> impl Iterator<Item = &Multiaddr>

Returns the list of addresses we are listening on.

Does NOT include a trailing /p2p/ with our PeerId.

pub fn network_state(&mut self) -> NetworkState

Get network state.

Note: Use this only for debugging. This API is unstable. There are warnings literally everywhere about this. Please don’t use this function to retrieve actual information.

pub fn remove_reserved_peer(&self, peer: PeerId)

Removes a PeerId from the list of reserved peers.

pub fn add_reserved_peer(&self, peer: MultiaddrWithPeerId) -> Result<(), String>

Adds a PeerId and its Multiaddr as reserved.

impl<B, H> NetworkWorker<B, H>

where B: BlockT + 'static, H: ExHashT,

pub async fn run(self)

Run the network.

pub async fn next_action(&mut self) -> bool

Perform one action on the network.

Returns false when the worker should be shutdown. Use in tests only.

Trait Implementations

impl<B, H> NetworkBackend<B, H> for NetworkWorker<B, H>

where B: BlockT + 'static, H: ExHashT,

fn network_service(&self) -> Arc<dyn NetworkServiceT>

Get handle to NetworkService of the NetworkBackend.

fn peer_store( bootnodes: Vec<PeerId>, metrics_registry: Option<Registry>, ) -> Self::PeerStore

Create PeerStore.

fn notification_config( protocol_name: ProtocolName, fallback_names: Vec<ProtocolName>, max_notification_size: u64, handshake: Option<NotificationHandshake>, set_config: SetConfig, _metrics: NotificationMetrics, _peerstore_handle: Arc<dyn PeerStoreProvider>, ) -> (Self::NotificationProtocolConfig, Box<dyn NotificationService>)

Create notification protocol configuration.

fn request_response_config( protocol_name: ProtocolName, fallback_names: Vec<ProtocolName>, max_request_size: u64, max_response_size: u64, request_timeout: Duration, inbound_queue: Option<Sender<IncomingRequest>>, ) -> Self::RequestResponseProtocolConfig

Create request-response protocol configuration.

fn run<'async_trait>( self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait,

Start NetworkBackend event loop.

type NotificationProtocolConfig = NonDefaultSetConfig

Type representing notification protocol-related configuration.

type RequestResponseProtocolConfig = ProtocolConfig

Type representing request-response protocol-related configuration.

type NetworkService<Block, Hash> = Arc<NetworkService<B, H>>

Type implementing NetworkService for the networking backend.

type PeerStore = PeerStore

Type implementing PeerStore.

type BitswapConfig = ProtocolConfig

Bitswap config.

fn new(params: Params<B, H, Self>) -> Result<Self, Error>

where Self: Sized,

Create new NetworkBackend.

fn register_notification_metrics( registry: Option<&Registry>, ) -> NotificationMetrics

Register metrics that are used by the notification protocols.

fn bitswap_server( client: Arc<dyn BlockBackend<B> + Send + Sync>, ) -> (Pin<Box<dyn Future<Output = ()> + Send>>, Self::BitswapConfig)

Create Bitswap server.

impl<B, H> Unpin for NetworkWorker<B, H>

where B: BlockT + 'static, H: ExHashT,