mina_node_testing/scenarios/multi_node/
sync_4_block_producers.rs

1use std::time::Duration;
2
3use node::BlockProducerConfig;
4
5use crate::{
6    node::{RustNodeBlockProducerTestingConfig, RustNodeTestingConfig},
7    scenario::{ListenerNode, ScenarioStep},
8    scenarios::ClusterRunner,
9};
10
11/// Create and Sync up 4 block producer nodes.
12///
13/// 1. Create 4 block producer nodes.
14/// 2. Connect them to each other along with the initial node.
15/// 3. Wait for all nodes to be synced.
16#[derive(documented::Documented, Default, Clone, Copy)]
17pub struct MultiNodeSync4BlockProducers;
18
19impl MultiNodeSync4BlockProducers {
20    pub async fn run(self, mut runner: ClusterRunner<'_>) {
21        let (initial_node, node_config) = runner
22            .nodes_iter()
23            .next()
24            .map(|(id, node)| (id, node.config().clone()))
25            .unwrap();
26
27        let mut block_producers = runner.block_producer_sec_keys(initial_node);
28
29        let [whale1, whale2, fish1, fish2] = std::array::from_fn(|_| {
30            let (sec_key, _) = block_producers.pop().unwrap();
31            runner.add_rust_node(RustNodeTestingConfig {
32                block_producer: Some(RustNodeBlockProducerTestingConfig {
33                    config: BlockProducerConfig {
34                        pub_key: sec_key.public_key().into(),
35                        custom_coinbase_receiver: None,
36                        proposed_protocol_version: None,
37                    },
38                    sec_key,
39                }),
40                ..node_config.clone()
41            })
42        });
43
44        // TODO(binier): proper way to wait for all nodes to be ready.
45        tokio::time::sleep(Duration::from_secs(2)).await;
46
47        runner
48            .exec_step(ScenarioStep::ConnectNodes {
49                dialer: whale1,
50                listener: ListenerNode::Rust(initial_node),
51            })
52            .await
53            .unwrap();
54        runner
55            .exec_step(ScenarioStep::ConnectNodes {
56                dialer: whale2,
57                listener: ListenerNode::Rust(initial_node),
58            })
59            .await
60            .unwrap();
61        runner
62            .exec_step(ScenarioStep::ConnectNodes {
63                dialer: fish1,
64                listener: ListenerNode::Rust(initial_node),
65            })
66            .await
67            .unwrap();
68        runner
69            .exec_step(ScenarioStep::ConnectNodes {
70                dialer: fish2,
71                listener: ListenerNode::Rust(initial_node),
72            })
73            .await
74            .unwrap();
75
76        eprintln!("waiting for 4 block producer nodes to sync up.");
77        runner
78            .run_until_nodes_synced(Duration::from_secs(3 * 60), &[whale1, whale2, fish1, fish2])
79            .await
80            .unwrap();
81        eprintln!("4 block producer nodes create and synced up.");
82    }
83}