Method new

p2p/src/node.rs:150–273

(
        config: Config,
        rpc_addr: P2pAddr,
        node_key: NodeKey,
        peer_svc: impl PeerService + 'static,
        recons: Option<(P, M)>,
        block_store: Arc<S>,
        metri

    S: iroh_bitswap::Store + Send + Sync,
{
    pub async fn new(
        config: Config,
        rpc_addr: P2pAddr,
        node_key: NodeKey,
        peer_svc: impl PeerService + 'static,
        recons: Option<(P, M)>,
        block_store: Arc<S>,
        metrics: Metrics,
    ) -> Result<Self> {
        let (network_sender_in, network_receiver_in) = channel(1024); // TODO: configurable

        let Config {
            libp2p: libp2p_config,
            rpc_client,
            ..
        } = config;

        // Setup peers message channel
        let (peers_tx, peers_rx) = channel(1_000);

        let mut swarm = build_swarm(
            &libp2p_config,
            node_key.p2p_keypair(),
            recons,
            block_store,
            peers_tx.clone(),
            metrics.clone(),
        )
        .await?;

        if !libp2p_config.external_multiaddrs.is_empty() {
            peers_tx
                .send(peers::Message::NewLocalAddresses(
                    libp2p_config.external_multiaddrs.clone(),
                ))
                .await?;
        }
        for addr in &libp2p_config.external_multiaddrs {
            swarm.add_external_address(addr.clone());
        }

        let mut listen_addrs = vec![];
        for addr in &libp2p_config.listening_multiaddrs {
            Swarm::listen_on(&mut swarm, addr.clone())
                .map_err(|e| anyhow!("Failed to listen on swarm address: {}. {:#}", addr, e))?;
            listen_addrs.push(addr.clone());
        }

        // The following two statements were intentionally placed right before the return. Having them sooner caused the
        // daemon to get stuck in a loop during shutdown, unable to bind to a listen address, if there was some
        // initialization error after the RPC task was spawned, e.g. while parsing bootstrap peer multiaddrs in the
        // PeerManager.
        let rpc_task = tokio::task::spawn(async move {
            // TODO: handle error
            rpc::new(rpc_addr.clone(), P2p::new(network_sender_in))
                .await
                .map_err(|e| {
                    warn!("Failed to run RPC server on {}. {:?}", rpc_addr, e);