fix concurrent_openchannel test: add retry

Author: zoedberg

src/test/concurrent_openchannel.rs

@@ -12,92 +12,97 @@ async fn concurrent_openchannel() {
     const PUSH_MSAT: u64 = 20000;
     const ASSET_AMOUNT: u64 = 100;
 
-    let maker_peer_port = NODE1_PEER_PORT;
-    let taker1_peer_port = NODE2_PEER_PORT;
-    let taker2_peer_port = NODE3_PEER_PORT;
-    let taker3_peer_port = NODE4_PEER_PORT;
-    let taker4_peer_port = NODE5_PEER_PORT;
-    let taker5_peer_port = NODE6_PEER_PORT;
+    let node1_peer_port = NODE1_PEER_PORT;
+    let node2_peer_port = NODE2_PEER_PORT;
+    let node3_peer_port = NODE3_PEER_PORT;
+    let node4_peer_port = NODE4_PEER_PORT;
+    let node5_peer_port = NODE5_PEER_PORT;
+    let node6_peer_port = NODE6_PEER_PORT;
 
-    let test_dir_maker = format!("{TEST_DIR_BASE}maker");
-    let test_dir_taker1 = format!("{TEST_DIR_BASE}taker1");
-    let test_dir_taker2 = format!("{TEST_DIR_BASE}taker2");
-    let test_dir_taker3 = format!("{TEST_DIR_BASE}taker3");
-    let test_dir_taker4 = format!("{TEST_DIR_BASE}taker4");
-    let test_dir_taker5 = format!("{TEST_DIR_BASE}taker5");
+    let test_dir_node1 = format!("{TEST_DIR_BASE}node1");
+    let test_dir_node2 = format!("{TEST_DIR_BASE}node2");
+    let test_dir_node3 = format!("{TEST_DIR_BASE}node3");
+    let test_dir_node4 = format!("{TEST_DIR_BASE}node4");
+    let test_dir_node5 = format!("{TEST_DIR_BASE}node5");
+    let test_dir_node6 = format!("{TEST_DIR_BASE}node6");
 
-    let (maker_addr, _) = start_node(&test_dir_maker, maker_peer_port, false).await;
-    let (taker1_addr, _) = start_node(&test_dir_taker1, taker1_peer_port, false).await;
-    let (taker2_addr, _) = start_node(&test_dir_taker2, taker2_peer_port, false).await;
-    let (taker3_addr, _) = start_node(&test_dir_taker3, taker3_peer_port, false).await;
-    let (taker4_addr, _) = start_node(&test_dir_taker4, taker4_peer_port, false).await;
-    let (taker5_addr, _) = start_node(&test_dir_taker5, taker5_peer_port, false).await;
+    let (node1_addr, _) = start_node(&test_dir_node1, node1_peer_port, false).await;
+    let (node2_addr, _) = start_node(&test_dir_node2, node2_peer_port, false).await;
+    let (node3_addr, _) = start_node(&test_dir_node3, node3_peer_port, false).await;
+    let (node4_addr, _) = start_node(&test_dir_node4, node4_peer_port, false).await;
+    let (node5_addr, _) = start_node(&test_dir_node5, node5_peer_port, false).await;
+    let (node6_addr, _) = start_node(&test_dir_node6, node6_peer_port, false).await;
 
-    fund_and_create_utxos(maker_addr, None).await;
-    create_utxos(maker_addr, false, Some(5), Some(110000)).await;
-    fund_and_create_utxos(taker1_addr, None).await;
-    fund_and_create_utxos(taker2_addr, None).await;
-    fund_and_create_utxos(taker3_addr, None).await;
-    fund_and_create_utxos(taker4_addr, None).await;
-    fund_and_create_utxos(taker5_addr, None).await;
+    fund_and_create_utxos(node1_addr, None).await;
+    create_utxos(node1_addr, false, Some(5), Some(110000)).await;
+    fund_and_create_utxos(node2_addr, None).await;
+    fund_and_create_utxos(node3_addr, None).await;
+    fund_and_create_utxos(node4_addr, None).await;
+    fund_and_create_utxos(node5_addr, None).await;
+    fund_and_create_utxos(node6_addr, None).await;
 
-    let asset_id = issue_asset_nia(maker_addr).await.asset_id;
+    let asset_id = issue_asset_nia(node1_addr).await.asset_id;
 
-    let _maker_pubkey = node_info(maker_addr).await.pubkey;
-    let taker1_pubkey = node_info(taker1_addr).await.pubkey;
-    let taker2_pubkey = node_info(taker2_addr).await.pubkey;
-    let taker3_pubkey = node_info(taker3_addr).await.pubkey;
-    let taker4_pubkey = node_info(taker4_addr).await.pubkey;
-    let taker5_pubkey = node_info(taker5_addr).await.pubkey;
+    let _node1_pubkey = node_info(node1_addr).await.pubkey;
+    let node2_pubkey = node_info(node2_addr).await.pubkey;
+    let node3_pubkey = node_info(node3_addr).await.pubkey;
+    let node4_pubkey = node_info(node4_addr).await.pubkey;
+    let node5_pubkey = node_info(node5_addr).await.pubkey;
+    let node6_pubkey = node_info(node6_addr).await.pubkey;
 
     let (_channel_mt_1, _channel_mt_2, _channel_mt_3, _channel_mt_4, _channel_mt_5) = tokio::join!(
-        open_channel(
-            maker_addr,
-            &taker1_pubkey,
-            Some(taker1_peer_port),
+        open_channel_with_retry(
+            node1_addr,
+            &node2_pubkey,
+            Some(node2_peer_port),
             Some(CHANNEL_CAPACITY_SAT),
             Some(PUSH_MSAT),
             Some(ASSET_AMOUNT),
             Some(&asset_id),
+            20,
         ),
-        open_channel(
-            maker_addr,
-            &taker2_pubkey,
-            Some(taker2_peer_port),
+        open_channel_with_retry(
+            node1_addr,
+            &node3_pubkey,
+            Some(node3_peer_port),
             Some(CHANNEL_CAPACITY_SAT),
             Some(PUSH_MSAT),
             Some(ASSET_AMOUNT),
             Some(&asset_id),
+            20,
         ),
-        open_channel(
-            maker_addr,
-            &taker3_pubkey,
-            Some(taker3_peer_port),
+        open_channel_with_retry(
+            node1_addr,
+            &node4_pubkey,
+            Some(node4_peer_port),
             Some(CHANNEL_CAPACITY_SAT),
             Some(PUSH_MSAT),
             Some(ASSET_AMOUNT),
             Some(&asset_id),
+            20,
         ),
-        open_channel(
-            maker_addr,
-            &taker4_pubkey,
-            Some(taker4_peer_port),
+        open_channel_with_retry(
+            node1_addr,
+            &node5_pubkey,
+            Some(node5_peer_port),
             Some(CHANNEL_CAPACITY_SAT),
             Some(PUSH_MSAT),
             Some(ASSET_AMOUNT),
             Some(&asset_id),
+            20,
         ),
-        open_channel(
-            maker_addr,
-            &taker5_pubkey,
-            Some(taker5_peer_port),
+        open_channel_with_retry(
+            node1_addr,
+            &node6_pubkey,
+            Some(node6_peer_port),
             Some(CHANNEL_CAPACITY_SAT),
             Some(PUSH_MSAT),
             Some(ASSET_AMOUNT),
             Some(&asset_id),
+            20,
         )
     );
 
-    let maker_usable_channels = node_info(maker_addr).await.num_usable_channels;
-    assert_eq!(maker_usable_channels, 5);
+    let node1_usable_channels = node_info(node1_addr).await.num_usable_channels;
+    assert_eq!(node1_usable_channels, 5);
 }

src/test/mod.rs

@@ -1055,7 +1055,55 @@ async fn open_channel(
 }
 
 #[allow(clippy::too_many_arguments)]
-async fn open_channel_with_custom_data(
+async fn open_channel_with_retry(
+    node_address: SocketAddr,
+    dest_peer_pubkey: &str,
+    dest_peer_port: Option<u16>,
+    capacity_sat: Option<u64>,
+    push_msat: Option<u64>,
+    asset_amount: Option<u64>,
+    asset_id: Option<&str>,
+    max_retries: u32,
+) -> Channel {
+    let mut attempt = 0;
+    loop {
+        attempt += 1;
+        let result = open_channel_raw(
+            node_address,
+            dest_peer_pubkey,
+            dest_peer_port,
+            capacity_sat,
+            push_msat,
+            asset_amount,
+            asset_id,
+            None,
+            None,
+            None,
+            true,
+        )
+        .await;
+
+        match result {
+            Ok(channel) => return channel,
+            Err(status) if status == reqwest::StatusCode::FORBIDDEN && attempt < max_retries => {
+                println!(
+                    "Channel opening in progress (attempt {}/{}), retrying in 5s...",
+                    attempt, max_retries
+                );
+                tokio::time::sleep(std::time::Duration::from_secs(5)).await;
+            }
+            Err(status) => {
+                panic!(
+                    "Failed to open channel after {} attempts with status: {}",
+                    attempt, status
+                );
+            }
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn open_channel_raw(
     node_address: SocketAddr,
     dest_peer_pubkey: &str,
     dest_peer_port: Option<u16>,
@@ -1067,12 +1115,11 @@ async fn open_channel_with_custom_data(
     fee_proportional_millionths: Option<u32>,
     temporary_channel_id: Option<&str>,
     with_anchors: bool,
-) -> Channel {
+) -> Result<Channel, reqwest::StatusCode> {
     println!(
         "opening channel with {asset_amount:?} of asset {asset_id:?} from node {node_address} \
               to {dest_peer_pubkey}"
     );
-    stop_mining();
 
     let blockcount = get_block_count();
     let t_0 = OffsetDateTime::now_utc();
@@ -1110,11 +1157,13 @@ async fn open_channel_with_custom_data(
         .send()
         .await
         .unwrap();
-    _check_response_is_ok(res)
-        .await
-        .json::<OpenChannelResponse>()
-        .await
-        .unwrap();
+
+    let status = res.status();
+    if !status.is_success() {
+        return Err(status);
+    }
+
+    res.json::<OpenChannelResponse>().await.unwrap();
 
     let t_0 = OffsetDateTime::now_utc();
     let mut channel_id = None;
@@ -1131,7 +1180,7 @@ async fn open_channel_with_custom_data(
             if channel.funding_txid.is_some() {
                 let txout = _get_txout(channel.funding_txid.as_ref().unwrap());
                 if !txout.is_empty() {
-                    mine_n_blocks(true, 6);
+                    mine_n_blocks(false, 6);
                     channel_id = Some(channel.channel_id.clone());
                     channel_funded = true;
                     continue;
@@ -1153,14 +1202,45 @@ async fn open_channel_with_custom_data(
             .find(|c| c.channel_id == channel_id)
             .unwrap();
         if channel.ready {
-            return channel.clone();
+            return Ok(channel.clone());
         }
         if (OffsetDateTime::now_utc() - t_0).as_seconds_f32() > 10.0 {
             panic!("channel is taking too long to be ready")
         }
     }
 }
 
+#[allow(clippy::too_many_arguments)]
+async fn open_channel_with_custom_data(
+    node_address: SocketAddr,
+    dest_peer_pubkey: &str,
+    dest_peer_port: Option<u16>,
+    capacity_sat: Option<u64>,
+    push_msat: Option<u64>,
+    asset_amount: Option<u64>,
+    asset_id: Option<&str>,
+    fee_base_msat: Option<u32>,
+    fee_proportional_millionths: Option<u32>,
+    temporary_channel_id: Option<&str>,
+    with_anchors: bool,
+) -> Channel {
+    open_channel_raw(
+        node_address,
+        dest_peer_pubkey,
+        dest_peer_port,
+        capacity_sat,
+        push_msat,
+        asset_amount,
+        asset_id,
+        fee_base_msat,
+        fee_proportional_millionths,
+        temporary_channel_id,
+        with_anchors,
+    )
+    .await
+    .expect("channel opening should succeed")
+}
+
 async fn post_asset_media(node_address: SocketAddr, file_path: &str) -> String {
     println!("posting asset media on node {node_address}");
     let file_bytes = tokio::fs::read(file_path).await.unwrap();