Function timeout

src/ore/src/test.rs:65–83

Runs a function with a timeout. The provided closure is invoked on a thread. If the thread completes normally within the provided `duration`, its result is returned. If the thread panics within the provided `duration`, the panic is propagated to the thread calling `timeout`. Otherwise, a timeout error is returned. Note that if the invoked function does not complete in the timeout, it is not kill

(duration: Duration, f: F)

/// not killed; it is left to wind down normally. Therefore this function is
/// only appropriate in tests, where the resource leak doesn't matter.
pub fn timeout<F, T>(duration: Duration, f: F) -> Result<T, anyhow::Error>
where
    F: FnOnce() -> Result<T, anyhow::Error> + Send + 'static,
    T: Send + 'static,
{
    // Use the drop of `tx` to indicate that the thread is finished. This
    // ensures that `tx` is dropped even if `f` panics. No actual value is ever
    // sent on `tx`.
    let (tx, rx) = mpsc::channel();
    let thread = thread::spawn(|| {
        let _tx = tx;
        f()
    });
    match rx.recv_timeout(duration) {
        Ok(()) => unreachable!(),
        Err(RecvTimeoutError::Disconnected) => thread.join().unwrap(),
        Err(RecvTimeoutError::Timeout) => bail!("thread timed out"),
    }
}