mina_node_testing/scenarios/p2p/
signaling.rs

1use std::{collections::BTreeSet, time::Duration};
2
3use node::{
4    p2p::{P2pPeerAction, PeerId},
5    Action, P2pAction,
6};
7
8use crate::{
9    cluster::ClusterConfig,
10    node::RustNodeTestingConfig,
11    scenarios::{ClusterRunner, DynEffectsData, RunCfg},
12};
13
14/// Makes sure that when using WebRTC only nodes, peers can discover
15/// each other and connect to each other via p2p signaling.
16#[derive(documented::Documented, Default, Clone, Copy)]
17pub struct P2pSignaling;
18
19impl P2pSignaling {
20    pub fn default_cluster_config(
21        self,
22        mut config: ClusterConfig,
23    ) -> Result<ClusterConfig, anyhow::Error> {
24        config.set_all_rust_to_rust_use_webrtc();
25        Ok(config)
26    }
27
28    pub async fn run(self, mut runner: ClusterRunner<'_>) {
29        const NODES_N: usize = 4;
30
31        let seed_config = RustNodeTestingConfig::devnet_default();
32        let seed = runner.add_rust_node(seed_config.clone());
33
34        let node_config = seed_config.initial_peers(vec![seed.into()]);
35        let _node_1 = runner.add_rust_node(node_config.clone());
36        let _node_2 = runner.add_rust_node(node_config.clone());
37        let _node_3 = runner.add_rust_node(node_config.clone());
38
39        let node_peers: [_; NODES_N] = std::array::from_fn(|_| BTreeSet::<PeerId>::new());
40        let node_peers = DynEffectsData::new(node_peers);
41
42        runner
43            .run(
44                RunCfg::default()
45                    .timeout(Duration::from_secs(60))
46                    .advance_time(1..=100)
47                    .action_handler(move |node_id, _state, _, action| {
48                        if action.action().kind().to_string().contains("Signaling") {
49                            let me = _state.p2p.my_id();
50                            let me_pk = me.to_public_key().unwrap();
51                            dbg!((me, me_pk, action.action()));
52                        }
53                        match action.action() {
54                            Action::P2p(P2pAction::Peer(P2pPeerAction::Ready {
55                                peer_id, ..
56                            })) => {
57                                node_peers.inner()[node_id.index()].insert(*peer_id);
58                                dbg!(node_peers.inner())
59                                    .iter()
60                                    .all(|v| v.len() == NODES_N - 1)
61                            }
62                            _ => false,
63                        }
64                    }),
65            )
66            .await
67            .expect("peers didn't discover each other");
68    }
69}