Merge branch 'develop' of https://github.com/stacks-network/stacks-core into feat/signer-two-phase-commit-impl

Author: jferrant

.github/workflows/github-release.yml

@@ -90,6 +90,8 @@ jobs:
             cpu: armv7
           - arch: macos # excludes macos-armv7
             cpu: armv7
+          - arch: macos # excludes macos-x64
+            cpu: x86_64
     steps:
       - name: Build Binary (${{ matrix.arch }}_${{ matrix.cpu }})
         uses: stacks-network/actions/stacks-core/release/create-source-binary@main

Cargo.lock

@@ -90,6 +90,7 @@ mutants = "0.0.3"
 rlimit = "0.10.2"
 chrono = "0.4.19"
 tempfile = "3.3"
+proptest = { version = "1.6.0", default-features = false, features = ["std"] }
 
 [features]
 default = []

stackslib/Cargo.toml

@@ -450,6 +450,23 @@ impl BurnchainBlock {
 }
 
 impl Burnchain {
+    pub fn handle_thread_join<T>(
+        handle: std::thread::JoinHandle<Result<T, burnchain_error>>,
+        name: &str,
+    ) -> Result<T, burnchain_error> {
+        match handle.join() {
+            Ok(Ok(val)) => Ok(val),
+            Ok(Err(e)) => {
+                warn!("{} thread error: {:?}", name, e);
+                Err(e)
+            }
+            Err(_) => {
+                error!("{} thread panicked", name);
+                Err(burnchain_error::ThreadChannelError)
+            }
+        }
+    }
+
     pub fn new(
         working_dir: &str,
         chain_name: &str,
@@ -1394,15 +1411,19 @@ impl Burnchain {
         }
 
         // join up
-        let _ = download_thread.join().unwrap();
-        let _ = parse_thread.join().unwrap();
-        let (block_snapshot, state_transition_opt) = match db_thread.join().unwrap() {
-            Ok(x) => x,
-            Err(e) => {
-                warn!("Failed to join burnchain download thread: {:?}", &e);
-                return Err(burnchain_error::TrySyncAgain);
-            }
-        };
+        let download_result = Self::handle_thread_join(download_thread, "burnchain-download");
+        let parse_result = Self::handle_thread_join(parse_thread, "burnchain-parse");
+        let db_result = Self::handle_thread_join(db_thread, "burnchain-db");
+
+        if let Err(e) = download_result {
+            warn!("Download thread failed: {:?}", e);
+            return Err(e);
+        }
+        if let Err(e) = parse_result {
+            warn!("Parse thread failed: {:?}", e);
+            return Err(e);
+        }
+        let (block_snapshot, state_transition_opt) = db_result?;
 
         if block_snapshot.block_height < end_block {
             warn!(
@@ -1783,20 +1804,21 @@ impl Burnchain {
         }
 
         // join up
-        let _ = download_thread.join().unwrap();
-        let _ = parse_thread.join().unwrap();
-        let block_header = match db_thread.join().unwrap() {
-            Ok(x) => x,
-            Err(e) => {
-                warn!("Failed to join burnchain download thread: {:?}", &e);
-                if let burnchain_error::CoordinatorClosed = e {
-                    return Err(burnchain_error::CoordinatorClosed);
-                } else {
-                    return Err(burnchain_error::TrySyncAgain);
-                }
-            }
-        };
+        let download_result = Self::handle_thread_join(download_thread, "download");
+        let parse_result = Self::handle_thread_join(parse_thread, "parse");
+        let db_result = Self::handle_thread_join(db_thread, "db");
+
+        if let Err(e) = download_result {
+            warn!("Download thread failed: {:?}", e);
+            return Err(e);
+        }
+
+        if let Err(e) = parse_result {
+            warn!("Parse thread failed: {:?}", e);
+            return Err(e);
+        }
 
+        let block_header = db_result?;
         if block_header.block_height < end_block {
             warn!(
                 "Try synchronizing the burn chain again: final snapshot {} < {}",

stackslib/src/burnchains/burnchain.rs

@@ -17,6 +17,7 @@
 pub mod affirmation;
 pub mod burnchain;
 pub mod db;
+pub mod thread_join;
 
 use std::collections::HashMap;
 

stackslib/src/burnchains/tests/mod.rs

@@ -0,0 +1,101 @@
+// Copyright (C) 2025 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::time::Duration;
+use std::{panic, thread};
+
+use proptest::prelude::*;
+
+use crate::burnchains::bitcoin::Error as bitcoin_error;
+use crate::burnchains::{Burnchain, Error as burnchain_error};
+
+// Run more cases than default with PROPTEST_CASES.
+// Example:
+//     PROPTEST_CASES=500 cargo test -p stackslib -- \
+//     burnchains::tests::thread_join
+
+#[test]
+fn join_success() {
+    proptest!(|(v in any::<u32>(), s in "[ -~]{1,20}")| {
+        let h = thread::spawn(move || Ok(v));
+        let r = Burnchain::handle_thread_join::<u32>(h, &s);
+        prop_assert!(r.is_ok());
+        prop_assert_eq!(r.unwrap(), v);
+    });
+}
+
+#[test]
+fn join_with_name() {
+    proptest!(|(v in any::<u32>(), s in "[ -~]{1,20}")| {
+        let h = thread::spawn(move || Ok(v));
+        let r = Burnchain::handle_thread_join::<u32>(h, &s);
+        prop_assert!(r.is_ok());
+        prop_assert_eq!(r.unwrap(), v);
+    });
+}
+
+#[test]
+fn join_delay() {
+    proptest!(|(d in 10u64..100, v in any::<u32>(), s in "[ -~]{1,20}")| {
+        let h = thread::spawn(move || {
+            thread::sleep(Duration::from_millis(d));
+            Ok(v)
+        });
+        let r = Burnchain::handle_thread_join::<u32>(h, &s);
+        prop_assert!(r.is_ok());
+        prop_assert_eq!(r.unwrap(), v);
+    });
+}
+
+#[test]
+fn join_download_error() {
+    let h = thread::spawn(move || {
+        Err(burnchain_error::DownloadError(
+            bitcoin_error::ConnectionError,
+        ))
+    });
+    let r = Burnchain::handle_thread_join::<u32>(h, "test");
+    assert!(r.is_err());
+    match r {
+        Err(burnchain_error::DownloadError(_)) => {}
+        _ => panic!("Expected DownloadError"),
+    }
+}
+
+#[test]
+fn join_parse_error() {
+    let h = thread::spawn(move || Err(burnchain_error::ParseError));
+    let r = Burnchain::handle_thread_join::<u32>(h, "test");
+    assert!(r.is_err());
+    match r {
+        Err(burnchain_error::ParseError) => {}
+        _ => panic!("Expected ParseError"),
+    }
+}
+
+#[test]
+fn join_panics() {
+    let h = thread::spawn(|| {
+        panic!("boom");
+        #[allow(unreachable_code)]
+        Ok(42)
+    });
+    let r = Burnchain::handle_thread_join::<u32>(h, "test");
+    assert!(r.is_err());
+    match r {
+        Err(burnchain_error::ThreadChannelError) => {}
+        _ => panic!("Expected ThreadChannelError"),
+    }
+}