cumulus_client_bootnodes/
task.rs
use crate::{
advertisement::{BootnodeAdvertisement, BootnodeAdvertisementParams},
config::paranode_protocol_name,
discovery::{BootnodeDiscovery, BootnodeDiscoveryParams},
};
use cumulus_primitives_core::{relay_chain::BlockId, ParaId};
use cumulus_relay_chain_interface::RelayChainInterface;
use log::{debug, error};
use num_traits::Zero;
use parachains_common::Hash as ParaHash;
use sc_network::{request_responses::IncomingRequest, service::traits::NetworkService, Multiaddr};
use sc_service::TaskManager;
use std::sync::Arc;
const LOG_TARGET: &str = "bootnodes";
pub struct StartBootnodeTasksParams<'a> {
pub embedded_dht_bootnode: bool,
pub dht_bootnode_discovery: bool,
pub para_id: ParaId,
pub task_manager: &'a mut TaskManager,
pub relay_chain_interface: Arc<dyn RelayChainInterface>,
pub relay_chain_fork_id: Option<String>,
pub relay_chain_network: Arc<dyn NetworkService>,
pub request_receiver: async_channel::Receiver<IncomingRequest>,
pub parachain_network: Arc<dyn NetworkService>,
pub advertise_non_global_ips: bool,
pub parachain_genesis_hash: ParaHash,
pub parachain_fork_id: Option<String>,
pub parachain_public_addresses: Vec<Multiaddr>,
}
async fn bootnode_advertisement(
para_id: ParaId,
relay_chain_interface: Arc<dyn RelayChainInterface>,
relay_chain_network: Arc<dyn NetworkService>,
request_receiver: async_channel::Receiver<IncomingRequest>,
parachain_network: Arc<dyn NetworkService>,
advertise_non_global_ips: bool,
parachain_genesis_hash: ParaHash,
parachain_fork_id: Option<String>,
public_addresses: Vec<Multiaddr>,
) {
let bootnode_advertisement = BootnodeAdvertisement::new(BootnodeAdvertisementParams {
para_id,
relay_chain_interface,
relay_chain_network,
request_receiver,
parachain_network,
advertise_non_global_ips,
parachain_genesis_hash,
parachain_fork_id,
public_addresses,
});
if let Err(e) = bootnode_advertisement.run().await {
error!(target: LOG_TARGET, "Bootnode advertisement terminated with error: {e}");
}
}
async fn bootnode_discovery(
para_id: ParaId,
parachain_network: Arc<dyn NetworkService>,
parachain_genesis_hash: ParaHash,
parachain_fork_id: Option<String>,
relay_chain_interface: Arc<dyn RelayChainInterface>,
relay_chain_fork_id: Option<String>,
relay_chain_network: Arc<dyn NetworkService>,
) {
let relay_chain_genesis_hash =
match relay_chain_interface.header(BlockId::Number(Zero::zero())).await {
Ok(Some(header)) => header.hash().as_bytes().to_vec(),
Ok(None) => {
error!(
target: LOG_TARGET,
"Bootnode discovery: relay chain genesis hash does not exist",
);
return;
},
Err(e) => {
error!(
target: LOG_TARGET,
"Bootnode discovery: failed to obtain relay chain genesis hash: {e}",
);
return;
},
};
let paranode_protocol_name =
paranode_protocol_name(relay_chain_genesis_hash, relay_chain_fork_id.as_deref());
let bootnode_discovery = BootnodeDiscovery::new(BootnodeDiscoveryParams {
para_id,
parachain_network,
parachain_genesis_hash,
parachain_fork_id,
relay_chain_interface,
relay_chain_network,
paranode_protocol_name,
});
match bootnode_discovery.run().await {
Ok(()) => std::future::pending().await,
Err(e) => error!(target: LOG_TARGET, "Bootnode discovery terminated with error: {e}"),
}
}
pub fn start_bootnode_tasks(
StartBootnodeTasksParams {
embedded_dht_bootnode,
dht_bootnode_discovery,
para_id,
task_manager,
relay_chain_interface,
relay_chain_fork_id,
relay_chain_network,
request_receiver,
parachain_network,
advertise_non_global_ips,
parachain_genesis_hash,
parachain_fork_id,
parachain_public_addresses,
}: StartBootnodeTasksParams,
) {
debug!(
target: LOG_TARGET,
"Embedded DHT bootnode enabled: {embedded_dht_bootnode}; \
DHT bootnode discovery enabled: {dht_bootnode_discovery}",
);
if embedded_dht_bootnode {
task_manager.spawn_essential_handle().spawn(
"cumulus-dht-bootnode-advertisement",
None,
bootnode_advertisement(
para_id,
relay_chain_interface.clone(),
relay_chain_network.clone(),
request_receiver,
parachain_network.clone(),
advertise_non_global_ips,
parachain_genesis_hash,
parachain_fork_id.clone(),
parachain_public_addresses,
),
);
}
if dht_bootnode_discovery {
task_manager.spawn_essential_handle().spawn(
"cumulus-dht-bootnode-discovery",
None,
bootnode_discovery(
para_id,
parachain_network,
parachain_genesis_hash,
parachain_fork_id,
relay_chain_interface,
relay_chain_fork_id,
relay_chain_network,
),
);
}
}