Merge pull request #813 from openmina/feat/improve-ci-hostnames

Improve CI hostnames

Author: vlad9486

.github/workflows/ci.yaml

@@ -296,6 +296,7 @@ jobs:
       # TODO: remove when replayer supports identify
       KEEP_CONNECTION_WITH_UNKNOWN_STREAM: true
       OPENMINA_SCENARIO_SEEDS: ${{ needs.k8s-peers.outputs.peers }}
+      REPLAYER_MULTIADDR: "/dns4/1.k8.openmina.com/tcp/31968/p2p/12D3KooWPayQEdprqY2m3biReUUybA5LoULpJE7YWu6wetEKKELv"
       BPF_ALIAS: /coda/0.0.1/29936104443aaf264a7f0192ac64b1c7173198c1ed404c1bcff5e562e05eb7f6-0.0.0.0
     strategy:
       matrix:

node/testing/src/hosts.rs

@@ -0,0 +1,28 @@
+/// This should be the only place where environment variables are converted to addresses.
+///
+use std::{env, str::FromStr};
+
+use node::p2p::connection::outgoing::P2pConnectionOutgoingInitOpts;
+
+use crate::scenario::ListenerNode;
+
+pub fn replayer() -> P2pConnectionOutgoingInitOpts {
+    // "/dns4/1.k8.openmina.com/tcp/31968/p2p/12D3KooWPayQEdprqY2m3biReUUybA5LoULpJE7YWu6wetEKKELv",
+
+    let multiaddr = env::var("REPLAYER_MULTIADDR")
+        .expect("must set variable `REPLAYER_MULTIADDR`")
+        .parse::<libp2p::Multiaddr>()
+        .expect("`REPLAYER_MULTIADDR` must be a valid multiaddress");
+    (&multiaddr).try_into().expect("must be valid init opts")
+}
+
+pub fn devnet() -> Vec<ListenerNode> {
+    let seeds = std::env::var("OPENMINA_SCENARIO_SEEDS")
+        .unwrap_or_else(|_| node::p2p::DEVNET_SEEDS.join(" "));
+    seeds
+        .split_whitespace()
+        .map(P2pConnectionOutgoingInitOpts::from_str)
+        .filter_map(Result::ok)
+        .map(Into::into)
+        .collect()
+}

node/testing/src/lib.rs

@@ -12,6 +12,7 @@ pub mod scenarios;
 pub mod service;
 pub mod simulator;
 
+pub mod hosts;
 pub mod network_debugger;
 
 mod server;

node/testing/src/scenarios/p2p/pubsub.rs

@@ -1,8 +1,8 @@
 use std::time::Duration;
 
 use crate::{
+    hosts,
     node::RustNodeTestingConfig,
-    scenario::ListenerNode,
     scenarios::{ClusterRunner, Driver},
 };
 
@@ -16,7 +16,7 @@ impl P2pReceiveBlock {
             // make sure it will not ask initial peers
             .ask_initial_peers_interval(Duration::from_secs(3600))
             .max_peers(1)
-            .initial_peers(vec![ListenerNode::Custom("/dns4/seed-2.devnet.gcp.o1test.net/tcp/10003/p2p/12D3KooWLjs54xHzVmMmGYb7W5RVibqbwD1co7M2ZMfPgPm7iAag".parse().unwrap())]);
+            .initial_peers(vec![hosts::devnet()[0].clone()]);
         let retransmitter_openmina_node = runner.add_rust_node(config);
         let retransmitter_peer_id = runner
             .node(retransmitter_openmina_node)

node/testing/src/scenarios/record_replay/bootstrap.rs

@@ -1,9 +1,10 @@
 use std::time::Duration;
 
-use node::{p2p::connection::outgoing::P2pConnectionOutgoingInitOpts, ActionKind};
+use node::ActionKind;
 use openmina_node_native::replay_state_with_input_actions;
 
 use crate::{
+    hosts,
     node::{Recorder, RustNodeTestingConfig, TestPeerId},
     scenarios::{ClusterRunner, RunCfg, RunCfgAdvanceTime},
 };
@@ -15,17 +16,7 @@ pub struct RecordReplayBootstrap;
 
 impl RecordReplayBootstrap {
     pub async fn run(self, mut runner: ClusterRunner<'_>) {
-        let seeds_var = std::env::var("OPENMINA_SCENARIO_SEEDS");
-        let seeds = seeds_var.as_ref().map_or_else(
-            |_| node::p2p::DEVNET_SEEDS.to_vec(),
-            |val| val.split_whitespace().collect(),
-        );
-
-        let initial_peers = seeds
-            .iter()
-            .map(|s| s.parse::<P2pConnectionOutgoingInitOpts>().unwrap())
-            .map(Into::into)
-            .collect::<Vec<_>>();
+        let initial_peers = hosts::devnet();
 
         let node_id = runner.add_rust_node(RustNodeTestingConfig {
             initial_time: redux::Timestamp::global_now(),

node/testing/src/scenarios/solo_node/basic_connectivity_accept_incoming.rs

@@ -7,6 +7,7 @@ use node::p2p::{connection::outgoing::P2pConnectionOutgoingInitOpts, PeerId};
 use rand::Rng;
 
 use crate::{
+    hosts,
     node::{DaemonJson, OcamlNodeTestingConfig, RustNodeTestingConfig},
     scenario::{ListenerNode, ScenarioStep},
     scenarios::ClusterRunner,
@@ -28,21 +29,10 @@ impl SoloNodeBasicConnectivityAcceptIncoming {
         const STEPS: usize = 6_000;
         const STEP_DELAY: Duration = Duration::from_millis(200);
 
-        let seeds_var = std::env::var("OPENMINA_SCENARIO_SEEDS");
-        let seeds = seeds_var.as_ref().map_or_else(
-            |_| node::p2p::DEVNET_SEEDS.to_vec(),
-            |val| val.split_whitespace().collect(),
-        );
-
-        let initial_peers = seeds
-            .iter()
-            .map(|s| s.parse::<Multiaddr>().unwrap())
-            .map(|maddr| P2pConnectionOutgoingInitOpts::try_from(&maddr).unwrap())
-            .map(ListenerNode::from)
-            .collect::<Vec<_>>();
+        let initial_peers = hosts::devnet();
         eprintln!("set max peers per node: {MAX_PEERS_PER_NODE}");
-        for seed in seeds {
-            eprintln!("add initial peer: {seed}");
+        for seed in &initial_peers {
+            eprintln!("add initial peer: {seed:?}");
         }
         let config = RustNodeTestingConfig::devnet_default()
             .ask_initial_peers_interval(Duration::from_secs(3600))

node/testing/src/scenarios/solo_node/basic_connectivity_initial_joining.rs

@@ -7,6 +7,7 @@ use libp2p::Multiaddr;
 use node::p2p::connection::outgoing::P2pConnectionOutgoingInitOpts;
 
 use crate::{
+    hosts,
     node::RustNodeTestingConfig,
     scenario::{ListenerNode, ScenarioStep},
     scenarios::ClusterRunner,
@@ -28,21 +29,10 @@ impl SoloNodeBasicConnectivityInitialJoining {
         const STEPS: usize = 3_000;
         const STEP_DELAY: Duration = Duration::from_millis(200);
 
-        let seeds_var = std::env::var("OPENMINA_SCENARIO_SEEDS");
-        let seeds = seeds_var.as_ref().map_or_else(
-            |_| node::p2p::DEVNET_SEEDS.to_vec(),
-            |val| val.split_whitespace().collect(),
-        );
-
-        let initial_peers = seeds
-            .iter()
-            .map(|s| s.parse::<Multiaddr>().unwrap())
-            .map(|maddr| P2pConnectionOutgoingInitOpts::try_from(&maddr).unwrap())
-            .map(ListenerNode::from)
-            .collect::<Vec<_>>();
+        let initial_peers = hosts::devnet();
         eprintln!("set max peers per node: {MAX_PEERS_PER_NODE}");
-        for seed in seeds {
-            eprintln!("add initial peer: {seed}");
+        for seed in &initial_peers {
+            eprintln!("add initial peer: {seed:?}");
         }
         let config = RustNodeTestingConfig::devnet_default()
             .ask_initial_peers_interval(Duration::from_secs(3600))

node/testing/src/scenarios/solo_node/bootstrap.rs

@@ -1,12 +1,10 @@
 use std::time::Duration;
 
-use node::{
-    p2p::connection::outgoing::P2pConnectionOutgoingInitOpts,
-    transition_frontier::sync::TransitionFrontierSyncState,
-};
+use node::transition_frontier::sync::TransitionFrontierSyncState;
 use tokio::time::Instant;
 
 use crate::{
+    hosts,
     node::RustNodeTestingConfig,
     scenario::{ListenerNode, ScenarioStep},
     scenarios::ClusterRunner,
@@ -27,16 +25,12 @@ impl SoloNodeBootstrap {
 
         const TIMEOUT: Duration = Duration::from_secs(60 * 40);
 
-        const REPLAYER_1: & str =
-            "/dns4/1.k8.openmina.com/tcp/31968/p2p/12D3KooWPayQEdprqY2m3biReUUybA5LoULpJE7YWu6wetEKKELv";
-        let replayer = (&REPLAYER_1.parse::<libp2p::Multiaddr>().unwrap())
-            .try_into()
-            .unwrap();
+        let replayer = hosts::replayer();
 
-        let node_id =
-            runner.add_rust_node(RustNodeTestingConfig::devnet_default().initial_peers(vec![
-                ListenerNode::Custom(P2pConnectionOutgoingInitOpts::LibP2P(replayer)),
-            ]));
+        let node_id = runner.add_rust_node(
+            RustNodeTestingConfig::devnet_default()
+                .initial_peers(vec![ListenerNode::Custom(replayer)]),
+        );
         eprintln!("launch Openmina node with default configuration, id: {node_id}");
 
         let mut timeout = TIMEOUT;