use {
crate::waitable_condvar::WaitableCondvar,
std::{
sync::{
atomic::{AtomicBool, Ordering},
Arc, Mutex,
},
thread::JoinHandle,
time::Duration,
},
};
#[derive(Debug)]
pub(crate) struct VerifyAccountsHashInBackground {
pub(crate) verified: Arc<AtomicBool>,
complete: Arc<WaitableCondvar>,
thread: Mutex<Option<JoinHandle<bool>>>,
background_completed: Arc<AtomicBool>,
}
impl Default for VerifyAccountsHashInBackground {
fn default() -> Self {
Self {
complete: Arc::default(),
verified: Arc::new(AtomicBool::new(false)),
thread: Mutex::new(None::<JoinHandle<bool>>),
background_completed: Arc::new(AtomicBool::new(false)),
}
}
}
impl VerifyAccountsHashInBackground {
pub(crate) fn start(&self, start: impl FnOnce() -> JoinHandle<bool>) {
self.verified.store(false, Ordering::Release);
*self.thread.lock().unwrap() = Some(start());
}
pub(crate) fn background_finished(&self) {
self.complete.notify_all();
self.background_completed.store(true, Ordering::Release);
}
pub(crate) fn verification_complete(&self) {
self.verified.store(true, Ordering::Release);
}
pub fn wait_for_complete(&self) {
let mut lock = self.thread.lock().unwrap();
if lock.is_none() {
return; }
let result = lock.take().unwrap().join().unwrap();
if !result {
panic!("initial hash verification failed");
}
self.verification_complete();
}
pub(crate) fn check_complete(&self) -> bool {
if self.verified.load(Ordering::Acquire) {
return true;
}
if self.complete.wait_timeout(Duration::default())
&& !self.background_completed.load(Ordering::Acquire)
{
false
} else {
self.wait_for_complete();
true
}
}
}
#[cfg(test)]
pub(crate) mod tests {
use {super::*, std::thread::Builder};
#[test]
fn test_default() {
let def = VerifyAccountsHashInBackground::default();
assert!(!def.check_complete());
assert!(!def.verified.load(Ordering::Acquire));
assert!(def.thread.lock().unwrap().is_none());
def.verification_complete();
assert!(def.check_complete());
}
fn start_thread_and_return(
verify: &Arc<VerifyAccountsHashInBackground>,
result: bool,
action: impl FnOnce() + Send + 'static,
) {
assert!(!verify.check_complete());
let verify_ = Arc::clone(verify);
verify.start(|| {
Builder::new()
.name("solBgHashVerfy".to_string())
.spawn(move || {
assert!(!verify_.check_complete());
action();
verify_.background_finished();
result
})
.unwrap()
});
}
#[test]
fn test_real() {
solana_logger::setup();
let verify = Arc::new(VerifyAccountsHashInBackground::default());
start_thread_and_return(&verify, true, || {});
verify.wait_for_complete();
assert!(verify.check_complete());
}
#[test]
#[should_panic(expected = "initial hash verification failed")]
fn test_panic() {
let verify = Arc::new(VerifyAccountsHashInBackground::default());
start_thread_and_return(&verify, false, || {});
verify.wait_for_complete();
assert!(!verify.check_complete());
}
#[test]
fn test_long_running() {
solana_logger::setup();
let verify = Arc::new(VerifyAccountsHashInBackground::default());
let finish = Arc::new(AtomicBool::default());
let finish_ = finish.clone();
start_thread_and_return(&verify, true, move || {
while !finish_.load(Ordering::Relaxed) {}
});
assert!(!verify.check_complete());
finish.store(true, Ordering::Relaxed);
verify.wait_for_complete();
assert!(verify.check_complete());
}
}