Struct NetworkManager

pub struct NetworkManager<N = EthNetworkPrimitives>
where
    N: NetworkPrimitives,
{ /* private fields */ }

Manages the entire state of the network.

This is an endless Future that consistently drives the state of the entire network forward.

The NetworkManager is the container type for all parts involved with advancing the network.

include_mmd!(“docs/mermaid/network-manager.mmd”)

Implementations

impl<N> NetworkManager<N>

where N: NetworkPrimitives,

pub fn set_transactions( &mut self, tx: UnboundedSender<NetworkTransactionEvent<N>>, )

Sets the dedicated channel for events indented for the TransactionsManager.

pub fn set_eth_request_handler(&mut self, tx: Sender<IncomingEthRequest<N>>)

Sets the dedicated channel for events indented for the EthRequestHandler.

pub fn add_rlpx_sub_protocol(&mut self, protocol: impl IntoRlpxSubProtocol)

Adds an additional protocol handler to the RLPx sub-protocol list.

pub const fn handle(&self) -> &NetworkHandle<N>

Returns the NetworkHandle that can be cloned and shared.

The NetworkHandle can be used to interact with this NetworkManager

pub const fn secret_key(&self) -> SecretKey

Returns the secret key used for authenticating sessions.

pub async fn new<C>( config: NetworkConfig<C, N>, ) -> Result<NetworkManager<N>, NetworkError>

where C: BlockNumReader + 'static,

Creates the manager of a new network.

The NetworkManager is an endless future that needs to be polled in order to advance the state of the entire network.

pub async fn builder<C>( config: NetworkConfig<C, N>, ) -> Result<NetworkBuilder<(), (), N>, NetworkError>

where C: BlockNumReader + 'static,

Create a new NetworkManager instance and start a NetworkBuilder to configure all components of the network

use reth_network::{config::rng_secret_key, NetworkConfig, NetworkManager};
use reth_network_peers::mainnet_nodes;
use reth_provider::test_utils::NoopProvider;
use reth_transaction_pool::TransactionPool;
async fn launch<Pool: TransactionPool>(pool: Pool) {
    // This block provider implementation is used for testing purposes.
    let client = NoopProvider::default();

    // The key that's used for encrypting sessions and to identify our node.
    let local_key = rng_secret_key();

    let config =
        NetworkConfig::builder(local_key).boot_nodes(mainnet_nodes()).build(client.clone());
    let transactions_manager_config = config.transactions_manager_config.clone();

    // create the network instance
    let (handle, network, transactions, request_handler) = NetworkManager::builder(config)
        .await
        .unwrap()
        .transactions(pool, transactions_manager_config)
        .request_handler(client)
        .split_with_handle();
}

pub const fn into_builder(self) -> NetworkBuilder<(), (), N>

Create a NetworkBuilder to configure all components of the network

pub const fn local_addr(&self) -> SocketAddr

Returns the SocketAddr that listens for incoming tcp connections.

pub fn num_connected_peers(&self) -> usize

How many peers we’re currently connected to.

pub fn peer_id(&self) -> &FixedBytes<64>

Returns the [PeerId] used in the network.

pub fn all_peers(&self) -> impl Iterator<Item = NodeRecord>

Returns an iterator over all peers in the peer set.

pub fn num_known_peers(&self) -> usize

Returns the number of peers in the peer set.

pub fn peers_handle(&self) -> PeersHandle

Returns a new [PeersHandle] that can be cloned and shared.

The [PeersHandle] can be used to interact with the network’s peer set.

pub fn write_peers_to_file( &self, persistent_peers_file: &Path, ) -> Result<(), FsPathError>

Collect the peers from the NetworkManager and write them to the given persistent_peers_file.

pub fn fetch_client(&self) -> FetchClient<N>

Returns a new FetchClient that can be cloned and shared.

The FetchClient is the entrypoint for sending requests to the network.

pub fn status(&self) -> NetworkStatus

Returns the current [NetworkStatus] for the local node.

pub async fn run_until_graceful_shutdown<F, R>( self, shutdown: GracefulShutdown, shutdown_hook: F, ) -> R

where F: FnOnce(NetworkManager<N>) -> R,

Drives the NetworkManager future until a GracefulShutdown signal is received.

This invokes the given function shutdown_hook while holding the graceful shutdown guard.

Trait Implementations

impl<N> Debug for NetworkManager<N>

where N: Debug + NetworkPrimitives, <N as NetworkPrimitives>::Block: Debug,

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

Formats the value using the given formatter.

impl<N> Future for NetworkManager<N>

where N: NetworkPrimitives,

type Output = ()

The type of value produced on completion.

fn poll( self: Pin<&mut NetworkManager<N>>, cx: &mut Context<'_>, ) -> Poll<<NetworkManager<N> as Future>::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl RethNetworkConfig for NetworkManager

fn add_rlpx_sub_protocol(&mut self, protocol: impl IntoRlpxSubProtocol)

Adds a new additional protocol to the RLPx sub-protocol list.

fn secret_key(&self) -> SecretKey

Returns the secret key used for authenticating sessions.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 2976 bytes