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.

graph TB
  handle(NetworkHandle)
  events(NetworkEvents)
  transactions(Transactions Task)
  ethrequest(ETH Request Task)
  discovery(Discovery Task)
  subgraph NetworkManager
    direction LR
    subgraph Swarm
        direction TB
        B1[(Session Manager)]
        B2[(Connection Lister)]
        B3[(Network State)]
    end
 end
 handle <--> |request response channel| NetworkManager
 NetworkManager --> |Network events| events
 transactions <--> |transactions| NetworkManager
 ethrequest <--> |ETH request handing| NetworkManager
 discovery --> |Discovered peers| NetworkManager

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, EthNetworkPrimitives, NetworkConfig, NetworkManager,
};
use reth_network_peers::mainnet_nodes;
use reth_storage_api::noop::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::<_, EthNetworkPrimitives>::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<N> RethNetworkConfig for NetworkManager<N>

where N: NetworkPrimitives,

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