diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index aff610908..e000007f3 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -9,6 +9,7 @@ concurrency: jobs: build: strategy: + fail-fast: false matrix: platform: [ ubuntu-latest, diff --git a/src/builder.rs b/src/builder.rs index b99c44cec..b4232e1cb 100644 --- a/src/builder.rs +++ b/src/builder.rs @@ -75,7 +75,6 @@ use std::default::Default; use std::fmt; use std::fs; use std::path::PathBuf; -use std::sync::atomic::AtomicBool; use std::sync::{Arc, Mutex, Once, RwLock}; use std::time::SystemTime; use vss_client::headers::{FixedHeaders, LnurlAuthToJwtProvider, VssHeaderProvider}; @@ -1105,7 +1104,6 @@ fn build_with_store_internal( } // Initialize the status fields. - let is_listening = Arc::new(AtomicBool::new(false)); let node_metrics = match read_node_metrics(Arc::clone(&kv_store), Arc::clone(&logger)) { Ok(metrics) => Arc::new(RwLock::new(metrics)), Err(e) => { @@ -1679,7 +1677,6 @@ fn build_with_store_internal( peer_store, payment_store, is_running, - is_listening, node_metrics, }) } diff --git a/src/lib.rs b/src/lib.rs index e7e27273b..8c9377b06 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -167,7 +167,7 @@ use rand::Rng; use std::default::Default; use std::net::ToSocketAddrs; -use std::sync::atomic::{AtomicBool, Ordering}; +use std::process::Command; use std::sync::{Arc, Mutex, RwLock}; use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; @@ -203,7 +203,6 @@ pub struct Node { peer_store: Arc>>, payment_store: Arc, is_running: Arc>, - is_listening: Arc, node_metrics: Arc>, } @@ -305,9 +304,7 @@ impl Node { if let Some(listening_addresses) = &self.config.listening_addresses { // Setup networking let peer_manager_connection_handler = Arc::clone(&self.peer_manager); - let mut stop_listen = self.stop_sender.subscribe(); let listening_logger = Arc::clone(&self.logger); - let listening_indicator = Arc::clone(&self.is_listening); let mut bind_addrs = Vec::with_capacity(listening_addresses.len()); @@ -325,45 +322,79 @@ impl Node { bind_addrs.extend(resolved_address); } - self.runtime.spawn_cancellable_background_task(async move { - { - let listener = - tokio::net::TcpListener::bind(&*bind_addrs).await - .unwrap_or_else(|e| { - log_error!(listening_logger, "Failed to bind to listen addresses/ports - is something else already listening on it?: {}", e); - panic!( - "Failed to bind to listen address/port - is something else already listening on it?", - ); - }); - - listening_indicator.store(true, Ordering::Release); - - loop { - let peer_mgr = Arc::clone(&peer_manager_connection_handler); - tokio::select! { - _ = stop_listen.changed() => { - log_debug!( - listening_logger, - "Stopping listening to inbound connections." + let logger = Arc::clone(&listening_logger); + let listeners = self.runtime.block_on(async move { + let mut listeners = Vec::new(); + + // Try to bind to all addresses + for addr in &*bind_addrs { + match tokio::net::TcpListener::bind(addr).await { + Ok(listener) => { + log_trace!(logger, "Listener bound to {}", addr); + listeners.push(listener); + }, + Err(e) => { + let pid = std::process::id(); + println!("Failed to bind to port {}: {} (this pid: {})", addr, e, pid); + + let output = Command::new("lsof") + .args(&["-i", &format!(":{}", &addr.port())]) + .output() + .expect("failed to execute lsof"); + + println!("LSOF output: {}", String::from_utf8_lossy(&output.stdout)); + + let output = Command::new("netstat") + .args(&["-an"]) + .output() + .expect("failed to execute netstat"); + + println!("Netstat output: {}", String::from_utf8_lossy(&output.stdout)); + + log_error!( + logger, + "Failed to bind to {}: {} - is something else already listening?", + addr, + e ); - break; - } - res = listener.accept() => { - let tcp_stream = res.unwrap().0; - tokio::spawn(async move { - lightning_net_tokio::setup_inbound( - Arc::clone(&peer_mgr), - tcp_stream.into_std().unwrap(), - ) - .await; - }); - } + return Err(Error::InvalidSocketAddress); + }, } } - } - listening_indicator.store(false, Ordering::Release); - }); + Ok(listeners) + })?; + + for listener in listeners { + let logger = Arc::clone(&listening_logger); + let peer_mgr = Arc::clone(&peer_manager_connection_handler); + let mut stop_listen = self.stop_sender.subscribe(); + let runtime = Arc::clone(&self.runtime); + self.runtime.spawn_cancellable_background_task(async move { + loop { + tokio::select! { + _ = stop_listen.changed() => { + log_debug!( + logger, + "Stopping listening to inbound connections." + ); + break; + } + res = listener.accept() => { + let tcp_stream = res.unwrap().0; + let peer_mgr = Arc::clone(&peer_mgr); + runtime.spawn_cancellable_background_task(async move { + lightning_net_tokio::setup_inbound( + Arc::clone(&peer_mgr), + tcp_stream.into_std().unwrap(), + ) + .await; + }); + } + } + } + }); + } } // Regularly reconnect to persisted peers. @@ -675,7 +706,8 @@ impl Node { /// Returns the status of the [`Node`]. pub fn status(&self) -> NodeStatus { let is_running = *self.is_running.read().unwrap(); - let is_listening = self.is_listening.load(Ordering::Acquire); + let is_listening = + is_running && self.config.listening_addresses.as_ref().map_or(false, |v| !v.is_empty()); let current_best_block = self.channel_manager.current_best_block().into(); let locked_node_metrics = self.node_metrics.read().unwrap(); let latest_lightning_wallet_sync_timestamp = @@ -981,6 +1013,14 @@ impl Node { // We need to use our main runtime here as a local runtime might not be around to poll // connection futures going forward. + + log_info!( + self.logger, + "Attempt connection to peer {}@{}..", + peer_info.node_id, + peer_info.address + ); + self.runtime.block_on(async move { con_cm.connect_peer_if_necessary(con_node_id, con_addr).await })?; diff --git a/tests/common/mod.rs b/tests/common/mod.rs index 0a1e8cbd2..e6add6585 100644 --- a/tests/common/mod.rs +++ b/tests/common/mod.rs @@ -179,6 +179,7 @@ pub(crate) fn setup_bitcoind_and_electrsd() -> (BitcoinD, ElectrsD) { let mut bitcoind_conf = corepc_node::Conf::default(); bitcoind_conf.network = "regtest"; bitcoind_conf.args.push("-rest"); + bitcoind_conf.view_stdout = true; let bitcoind = BitcoinD::with_conf(bitcoind_exe, &bitcoind_conf).unwrap(); let electrs_exe = env::var("ELECTRS_EXE") @@ -188,6 +189,7 @@ pub(crate) fn setup_bitcoind_and_electrsd() -> (BitcoinD, ElectrsD) { let mut electrsd_conf = electrsd::Conf::default(); electrsd_conf.http_enabled = true; electrsd_conf.network = "regtest"; + electrsd_conf.view_stderr = true; let electrsd = ElectrsD::with_conf(electrs_exe, &bitcoind, &electrsd_conf).unwrap(); (bitcoind, electrsd) } @@ -202,7 +204,7 @@ pub(crate) fn random_storage_path() -> PathBuf { pub(crate) fn random_port() -> u16 { let mut rng = thread_rng(); - rng.gen_range(5000..65535) + rng.gen_range(5000..32768) } pub(crate) fn random_listening_addresses() -> Vec { @@ -227,7 +229,7 @@ pub(crate) fn random_node_alias() -> Option { Some(NodeAlias(bytes)) } -pub(crate) fn random_config(anchor_channels: bool) -> TestConfig { +pub(crate) fn random_config(anchor_channels: bool, node_id: String) -> TestConfig { let mut node_config = Config::default(); if !anchor_channels { @@ -249,7 +251,9 @@ pub(crate) fn random_config(anchor_channels: bool) -> TestConfig { println!("Setting random LDK node alias: {:?}", alias); node_config.node_alias = alias; - TestConfig { node_config, ..Default::default() } + let log_writer = TestLogWriter::Custom(Arc::new(MultiNodeLogger::new(node_id))); + + TestConfig { node_config, log_writer } } #[cfg(feature = "uniffi")] @@ -274,24 +278,28 @@ pub(crate) struct TestConfig { macro_rules! setup_builder { ($builder: ident, $config: expr) => { #[cfg(feature = "uniffi")] - let $builder = Builder::from_config($config.clone()); + let mut $builder = Builder::from_config($config.node_config.clone()); #[cfg(not(feature = "uniffi"))] - let mut $builder = Builder::from_config($config.clone()); + let mut $builder = Builder::from_config($config.node_config.clone()); + + crate::common::set_builder_log_writer(&mut $builder, &$config); }; } pub(crate) use setup_builder; +use crate::common::logging::MultiNodeLogger; + pub(crate) fn setup_two_nodes( chain_source: &TestChainSource, allow_0conf: bool, anchor_channels: bool, anchors_trusted_no_reserve: bool, ) -> (TestNode, TestNode) { println!("== Node A =="); - let config_a = random_config(anchor_channels); + let config_a = random_config(anchor_channels, "node_a".to_string()); let node_a = setup_node(chain_source, config_a, None); println!("\n== Node B =="); - let mut config_b = random_config(anchor_channels); + let mut config_b = random_config(anchor_channels, "node_b".to_string()); if allow_0conf { config_b.node_config.trusted_peers_0conf.push(node_a.node_id()); } @@ -311,7 +319,7 @@ pub(crate) fn setup_two_nodes( pub(crate) fn setup_node( chain_source: &TestChainSource, config: TestConfig, seed_bytes: Option>, ) -> TestNode { - setup_builder!(builder, config.node_config); + setup_builder!(builder, config); match chain_source { TestChainSource::Esplora(electrsd) => { let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap()); @@ -350,18 +358,6 @@ pub(crate) fn setup_node( }, } - match &config.log_writer { - TestLogWriter::FileWriter => { - builder.set_filesystem_logger(None, None); - }, - TestLogWriter::LogFacade => { - builder.set_log_facade_logger(); - }, - TestLogWriter::Custom(custom_log_writer) => { - builder.set_custom_logger(Arc::clone(custom_log_writer)); - }, - } - if let Some(seed) = seed_bytes { #[cfg(feature = "uniffi")] { @@ -383,6 +379,20 @@ pub(crate) fn setup_node( node } +pub(crate) fn set_builder_log_writer(builder: &mut Builder, config: &TestConfig) { + match &config.log_writer { + TestLogWriter::FileWriter => { + builder.set_filesystem_logger(None, None); + }, + TestLogWriter::LogFacade => { + builder.set_log_facade_logger(); + }, + TestLogWriter::Custom(custom_log_writer) => { + builder.set_custom_logger(Arc::clone(custom_log_writer)); + }, + } +} + pub(crate) fn generate_blocks_and_wait( bitcoind: &BitcoindClient, electrs: &E, num: usize, ) { diff --git a/tests/integration_tests_cln.rs b/tests/integration_tests_cln.rs index f77311fb2..8e3e9eb9b 100644 --- a/tests/integration_tests_cln.rs +++ b/tests/integration_tests_cln.rs @@ -44,7 +44,7 @@ fn test_cln() { common::generate_blocks_and_wait(&bitcoind_client, &electrs_client, 1); // Setup LDK Node - let config = common::random_config(true); + let config = common::random_config(true, "ldk_node".to_string()); let mut builder = Builder::from_config(config.node_config); builder.set_chain_source_esplora("http://127.0.0.1:3002".to_string(), None); diff --git a/tests/integration_tests_lnd.rs b/tests/integration_tests_lnd.rs index 0232e8f2e..4565e0a0a 100755 --- a/tests/integration_tests_lnd.rs +++ b/tests/integration_tests_lnd.rs @@ -41,7 +41,7 @@ async fn test_lnd() { common::generate_blocks_and_wait(&bitcoind_client, &electrs_client, 1); // Setup LDK Node - let config = common::random_config(true); + let config = common::random_config(true, "ldk_node".to_string()); let mut builder = Builder::from_config(config.node_config); builder.set_chain_source_esplora("http://127.0.0.1:3002".to_string(), None); diff --git a/tests/integration_tests_rust.rs b/tests/integration_tests_rust.rs index f2e8407cd..b90038f08 100644 --- a/tests/integration_tests_rust.rs +++ b/tests/integration_tests_rust.rs @@ -12,7 +12,6 @@ use common::{ expect_channel_pending_event, expect_channel_ready_event, expect_event, expect_payment_claimable_event, expect_payment_received_event, expect_payment_successful_event, generate_blocks_and_wait, - logging::MultiNodeLogger, logging::{init_log_logger, validate_log_entry, TestLogWriter}, open_channel, open_channel_push_amt, premine_and_distribute_funds, premine_blocks, prepare_rbf, random_config, random_listening_addresses, setup_bitcoind_and_electrsd, setup_builder, @@ -151,10 +150,10 @@ fn multi_hop_sending() { // Setup and fund 5 nodes let mut nodes = Vec::new(); - for _ in 0..5 { - let config = random_config(true); + for node_idx in 0..5 { + let config = random_config(true, format!("node_{}", node_idx)); let sync_config = EsploraSyncConfig { background_sync_config: None }; - setup_builder!(builder, config.node_config); + setup_builder!(builder, config); builder.set_chain_source_esplora(esplora_url.clone(), Some(sync_config)); let node = builder.build().unwrap(); node.start().unwrap(); @@ -244,7 +243,7 @@ fn multi_hop_sending() { #[test] fn start_stop_reinit() { let (bitcoind, electrsd) = setup_bitcoind_and_electrsd(); - let config = random_config(true); + let config = random_config(true, "single_node".to_string()); let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap()); @@ -252,7 +251,7 @@ fn start_stop_reinit() { Arc::new(TestSyncStore::new(config.node_config.storage_dir_path.clone().into())); let sync_config = EsploraSyncConfig { background_sync_config: None }; - setup_builder!(builder, config.node_config); + setup_builder!(builder, config); builder.set_chain_source_esplora(esplora_url.clone(), Some(sync_config)); let node = builder.build_with_store(Arc::clone(&test_sync_store)).unwrap(); @@ -276,9 +275,6 @@ fn start_stop_reinit() { node.sync_wallets().unwrap(); assert_eq!(node.list_balances().spendable_onchain_balance_sats, expected_amount.to_sat()); - let log_file = format!("{}/ldk_node.log", config.node_config.clone().storage_dir_path); - assert!(std::path::Path::new(&log_file).exists()); - node.stop().unwrap(); assert_eq!(node.stop(), Err(NodeError::NotRunning)); @@ -289,7 +285,7 @@ fn start_stop_reinit() { assert_eq!(node.stop(), Err(NodeError::NotRunning)); drop(node); - setup_builder!(builder, config.node_config); + setup_builder!(builder, config); builder.set_chain_source_esplora(esplora_url.clone(), Some(sync_config)); let reinitialized_node = builder.build_with_store(Arc::clone(&test_sync_store)).unwrap(); @@ -601,7 +597,7 @@ fn onchain_wallet_recovery() { let seed_bytes = vec![42u8; 64]; - let original_config = random_config(true); + let original_config = random_config(true, "original_node".to_string()); let original_node = setup_node(&chain_source, original_config, Some(seed_bytes.clone())); let premine_amount_sat = 100_000; @@ -640,7 +636,7 @@ fn onchain_wallet_recovery() { drop(original_node); // Now we start from scratch, only the seed remains the same. - let recovered_config = random_config(true); + let recovered_config = random_config(true, "recovered_node".to_string()); let recovered_node = setup_node(&chain_source, recovered_config, Some(seed_bytes)); recovered_node.sync_wallets().unwrap(); @@ -693,17 +689,17 @@ fn run_rbf_test(is_insert_block: bool) { let chain_source_esplora = TestChainSource::Esplora(&electrsd); macro_rules! config_node { - ($chain_source: expr, $anchor_channels: expr) => {{ - let config_a = random_config($anchor_channels); + ($chain_source: expr, $anchor_channels: expr, $node_id: expr) => {{ + let config_a = random_config($anchor_channels, $node_id); let node = setup_node(&$chain_source, config_a, None); node }}; } let anchor_channels = false; let nodes = vec![ - config_node!(chain_source_electrsd, anchor_channels), - config_node!(chain_source_bitcoind, anchor_channels), - config_node!(chain_source_esplora, anchor_channels), + config_node!(chain_source_electrsd, anchor_channels, "node_electrsd".to_string()), + config_node!(chain_source_bitcoind, anchor_channels, "node_bitcoind".to_string()), + config_node!(chain_source_esplora, anchor_channels, "node_esplora".to_string()), ]; let (bitcoind, electrs) = (&bitcoind.client, &electrsd.client); @@ -811,7 +807,7 @@ fn run_rbf_test(is_insert_block: bool) { #[test] fn sign_verify_msg() { let (_bitcoind, electrsd) = setup_bitcoind_and_electrsd(); - let config = random_config(true); + let config = random_config(true, "single_node".to_string()); let chain_source = TestChainSource::Esplora(&electrsd); let node = setup_node(&chain_source, config, None); @@ -837,10 +833,7 @@ fn do_connection_restart_behavior(persist: bool) { let node_id_b = node_b.node_id(); let node_addr_b = node_b.listening_addresses().unwrap().first().unwrap().clone(); - - while !node_b.status().is_listening { - std::thread::sleep(std::time::Duration::from_millis(10)); - } + assert!(node_b.status().is_listening); node_a.connect(node_id_b, node_addr_b, persist).unwrap(); @@ -890,10 +883,7 @@ fn concurrent_connections_succeed() { let node_id_b = node_b.node_id(); let node_addr_b = node_b.listening_addresses().unwrap().first().unwrap().clone(); - - while !node_b.status().is_listening { - std::thread::sleep(std::time::Duration::from_millis(10)); - } + assert!(node_b.status().is_listening); let mut handles = Vec::new(); for _ in 0..10 { @@ -1136,31 +1126,23 @@ fn static_invoice_server() { let (bitcoind, electrsd) = setup_bitcoind_and_electrsd(); let chain_source = TestChainSource::Esplora(&electrsd); - let mut config_sender = random_config(true); + let mut config_sender = random_config(true, "sender ".to_string()); config_sender.node_config.listening_addresses = None; config_sender.node_config.node_alias = None; - config_sender.log_writer = - TestLogWriter::Custom(Arc::new(MultiNodeLogger::new("sender ".to_string()))); let node_sender = setup_node(&chain_source, config_sender, None); - let mut config_sender_lsp = random_config(true); + let mut config_sender_lsp = random_config(true, "sender_lsp ".to_string()); config_sender_lsp.node_config.async_payment_services_enabled = true; - config_sender_lsp.log_writer = - TestLogWriter::Custom(Arc::new(MultiNodeLogger::new("sender_lsp ".to_string()))); let node_sender_lsp = setup_node(&chain_source, config_sender_lsp, None); - let mut config_receiver_lsp = random_config(true); + let mut config_receiver_lsp = random_config(true, "receiver_lsp".to_string()); config_receiver_lsp.node_config.async_payment_services_enabled = true; - config_receiver_lsp.log_writer = - TestLogWriter::Custom(Arc::new(MultiNodeLogger::new("receiver_lsp".to_string()))); let node_receiver_lsp = setup_node(&chain_source, config_receiver_lsp, None); - let mut config_receiver = random_config(true); + let mut config_receiver = random_config(true, "receiver ".to_string()); config_receiver.node_config.listening_addresses = None; config_receiver.node_config.node_alias = None; - config_receiver.log_writer = - TestLogWriter::Custom(Arc::new(MultiNodeLogger::new("receiver ".to_string()))); let node_receiver = setup_node(&chain_source, config_receiver, None); let address_sender = node_sender.onchain_payment().new_address().unwrap(); @@ -1253,7 +1235,7 @@ fn test_node_announcement_propagation() { let chain_source = TestChainSource::Esplora(&electrsd); // Node A will use both listening and announcement addresses - let mut config_a = random_config(true); + let mut config_a = random_config(true, "node_a".to_string()); let node_a_alias_string = "ldk-node-a".to_string(); let mut node_a_alias_bytes = [0u8; 32]; node_a_alias_bytes[..node_a_alias_string.as_bytes().len()] @@ -1265,7 +1247,7 @@ fn test_node_announcement_propagation() { config_a.node_config.announcement_addresses = Some(node_a_announcement_addresses.clone()); // Node B will only use listening addresses - let mut config_b = random_config(true); + let mut config_b = random_config(true, "node_b".to_string()); let node_b_alias_string = "ldk-node-b".to_string(); let mut node_b_alias_bytes = [0u8; 32]; node_b_alias_bytes[..node_b_alias_string.as_bytes().len()] @@ -1525,8 +1507,8 @@ fn lsps2_client_service_integration() { max_client_to_self_delay: 1024, }; - let service_config = random_config(true); - setup_builder!(service_builder, service_config.node_config); + let service_config = random_config(true, "service_node".to_string()); + setup_builder!(service_builder, service_config); service_builder.set_chain_source_esplora(esplora_url.clone(), Some(sync_config)); service_builder.set_liquidity_provider_lsps2(lsps2_service_config); let service_node = service_builder.build().unwrap(); @@ -1535,15 +1517,15 @@ fn lsps2_client_service_integration() { let service_node_id = service_node.node_id(); let service_addr = service_node.listening_addresses().unwrap().first().unwrap().clone(); - let client_config = random_config(true); - setup_builder!(client_builder, client_config.node_config); + let client_config = random_config(true, "client_node".to_string()); + setup_builder!(client_builder, client_config); client_builder.set_chain_source_esplora(esplora_url.clone(), Some(sync_config)); client_builder.set_liquidity_source_lsps2(service_node_id, service_addr, None); let client_node = client_builder.build().unwrap(); client_node.start().unwrap(); - let payer_config = random_config(true); - setup_builder!(payer_builder, payer_config.node_config); + let payer_config = random_config(true, "payer_node".to_string()); + setup_builder!(payer_builder, payer_config); payer_builder.set_chain_source_esplora(esplora_url.clone(), Some(sync_config)); let payer_node = payer_builder.build().unwrap(); payer_node.start().unwrap(); @@ -1729,7 +1711,7 @@ fn facade_logging() { let chain_source = TestChainSource::Esplora(&electrsd); let logger = init_log_logger(LevelFilter::Trace); - let mut config = random_config(false); + let mut config = random_config(false, "single_node".to_string()); config.log_writer = TestLogWriter::LogFacade; println!("== Facade logging starts =="); @@ -1813,7 +1795,7 @@ async fn drop_in_async_context() { let chain_source = TestChainSource::Esplora(&electrsd); let seed_bytes = vec![42u8; 64]; - let config = random_config(true); + let config = random_config(true, "single_node".to_string()); let node = setup_node(&chain_source, config, Some(seed_bytes)); node.stop().unwrap(); } diff --git a/tests/integration_tests_vss.rs b/tests/integration_tests_vss.rs index 9d6ec158c..b089cedee 100644 --- a/tests/integration_tests_vss.rs +++ b/tests/integration_tests_vss.rs @@ -17,9 +17,11 @@ fn channel_full_cycle_with_vss_store() { let (bitcoind, electrsd) = common::setup_bitcoind_and_electrsd(); println!("== Node A =="); let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap()); - let config_a = common::random_config(true); - let mut builder_a = Builder::from_config(config_a.node_config); + let config_a = common::random_config(true, "node_a".to_string()); + let mut builder_a = Builder::from_config(config_a.node_config.clone()); builder_a.set_chain_source_esplora(esplora_url.clone(), None); + crate::common::set_builder_log_writer(&mut builder_a, &config_a); + let vss_base_url = std::env::var("TEST_VSS_BASE_URL").unwrap(); let node_a = builder_a .build_with_vss_store_and_fixed_headers( @@ -31,9 +33,11 @@ fn channel_full_cycle_with_vss_store() { node_a.start().unwrap(); println!("\n== Node B =="); - let config_b = common::random_config(true); - let mut builder_b = Builder::from_config(config_b.node_config); + let config_b = common::random_config(true, "node_b".to_string()); + let mut builder_b = Builder::from_config(config_b.node_config.clone()); builder_b.set_chain_source_esplora(esplora_url.clone(), None); + crate::common::set_builder_log_writer(&mut builder_b, &config_b); + let node_b = builder_b .build_with_vss_store_and_fixed_headers( vss_base_url, diff --git a/tests/reorg_test.rs b/tests/reorg_test.rs index 707b67e88..7a174a6db 100644 --- a/tests/reorg_test.rs +++ b/tests/reorg_test.rs @@ -22,17 +22,17 @@ proptest! { let chain_source_esplora = TestChainSource::Esplora(&electrsd); macro_rules! config_node { - ($chain_source: expr, $anchor_channels: expr) => {{ - let config_a = random_config($anchor_channels); + ($chain_source: expr, $anchor_channels: expr, $node_id: expr) => {{ + let config_a = random_config($anchor_channels, $node_id); let node = setup_node(&$chain_source, config_a, None); node }}; } let anchor_channels = true; let nodes = vec![ - config_node!(chain_source_electrsd, anchor_channels), - config_node!(chain_source_bitcoind, anchor_channels), - config_node!(chain_source_esplora, anchor_channels), + config_node!(chain_source_electrsd, anchor_channels, "node_electrsd".to_string()), + config_node!(chain_source_bitcoind, anchor_channels, "node_bitcoind".to_string()), + config_node!(chain_source_esplora, anchor_channels, "node_esplora".to_string()), ]; let (bitcoind, electrs) = (&bitcoind.client, &electrsd.client);