Method build

p2p/tests/node.rs:24–93

(self)

    }

    async fn build(self) -> Result<TestRunner> {
        let rpc_server_addr = Addr::new_mem();
        let rpc_client_addr = rpc_server_addr.clone();
        let mut network_config = Config::default_with_rpc(rpc_client_addr.clone());

        // Bind to an open port
        network_config.libp2p.listening_multiaddrs = vec!["/ip4/0.0.0.0/tcp/0".parse().unwrap()];
        // Do not bootstrap
        network_config.libp2p.ceramic_peers = vec![];

        // Using an in memory DB for the tests for realistic benchmark disk DB is needed.
        let sql_pool = SqlitePool::connect_in_memory().await.unwrap();
        let peer_svc = Arc::new(ceramic_peer_svc::PeerService::new(sql_pool.clone()));
        let interest_svc = Arc::new(ceramic_interest_svc::InterestService::new(sql_pool.clone()));
        let event_svc = Arc::new(
            ceramic_event_svc::EventService::try_new(
                sql_pool,
                ceramic_event_svc::UndeliveredEventReview::Skip,
                true,
                vec![],
            )
            .await?,
        );

        let mut registry = prometheus_client::registry::Registry::default();
        let metrics = Metrics::register(&mut registry);
        let recon_metrics = recon::Metrics::register(&mut registry);
        let node_key = NodeKey::random();
        let peer_id = node_key.peer_id();
        let mut p2p = Node::new(
            network_config,
            rpc_server_addr,
            node_key.clone(),
            Arc::clone(&peer_svc),
            Some((
                Recon::new(peer_svc, PeerKeyInterests, recon_metrics.clone()),
                Recon::new(
                    Arc::clone(&event_svc),
                    ReconInterestProvider::new(node_key.id(), interest_svc),
                    recon_metrics.clone(),
                ),
            )),
            event_svc,
            metrics,
        )
        .await?;
        let cfg = iroh_rpc_client::Config {
            p2p_addr: Some(rpc_client_addr),
            channels: Some(1),
            ..Default::default()
        };

        let client = iroh_rpc_client::Client::new(cfg).await?;

        let network_events = p2p.network_events();
        let task = tokio::task::spawn(async move { p2p.run().await.unwrap() });

        let client = client.try_p2p()?;