Panics & Failure Handling

struct Connection(&'static str);

impl Drop for Connection {
    fn drop(&mut self) {
        println!("closing {}", self.0);
    }
}

fn charge(amount_cents: u64) -> u64 {
    let _db = Connection("database");
    let fee = 100 / (amount_cents % 3); // panics when amount_cents is a multiple of 3
    amount_cents + fee
}

fn main() {
    let _cache = Connection("cache");
    println!("charged {}", charge(1000));
    println!("charged {}", charge(999));
    println!("unreachable");
}

use std::thread;

fn parse_all(lines: &[&str]) -> Vec<u32> {
    lines.iter().map(|l| l.parse().expect("line must be a number")).collect()
}

fn main() {
    let good = thread::spawn(|| parse_all(&["1", "2", "3"]));
    let bad = thread::spawn(|| parse_all(&["4", "oops", "6"]));

    println!("good: {:?}", good.join());
    match bad.join() {
        Ok(v) => println!("bad: {v:?}"),
        Err(payload) => {
            let msg = payload.downcast_ref::<String>().map(String::as_str).or_else(|| payload.downcast_ref::<&str>().copied()).unwrap_or("unknown");
            println!("bad thread panicked: {msg}");
        }
    }
    println!("main is still running");
}

use std::panic;

#[derive(Debug)]
struct InvariantViolation {
    component: &'static str,
    detail: String,
}

fn main() {
    panic::set_hook(Box::new(|_| {})); // silence the default message for this demo
    let result = panic::catch_unwind(|| {
        panic::panic_any(InvariantViolation { component: "ledger", detail: "balance went negative".into() });
    });
    let _ = panic::take_hook();

    match result {
        Err(payload) => match payload.downcast::<InvariantViolation>() {
            Ok(v) => println!("structured panic from {}: {}", v.component, v.detail),
            Err(_) => println!("some other panic"),
        },
        Ok(()) => println!("no panic"),
    }
}

use std::thread;
use std::time::Duration;

struct Worker(u32);

impl Drop for Worker {
    fn drop(&mut self) {
        println!("worker {} cleaned up", self.0);
    }
}

fn main() {
    let finished = thread::spawn(|| {
        let _w = Worker(1);
    });
    finished.join().unwrap();

    thread::spawn(|| {
        let _w = Worker(2);
        thread::sleep(Duration::from_secs(60)); // still running when main returns
    });
    thread::sleep(Duration::from_millis(50));
    println!("main returns");
}

use std::panic;
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let reported = Arc::new(Mutex::new(Vec::new()));
    let sink = Arc::clone(&reported);
    let default_hook = panic::take_hook();

    panic::set_hook(Box::new(move |info| {
        let thread = thread::current().name().unwrap_or("unnamed").to_string();
        let location = info.location().map(|l| format!("{}:{}", l.file(), l.line())).unwrap_or_default();
        let message = info.payload_as_str().unwrap_or("non-string payload");
        sink.lock().unwrap().push(format!("{{\"level\":\"fatal\",\"thread\":\"{thread}\",\"at\":\"{location}\",\"msg\":\"{message}\"}}"));
        let _ = &default_hook; // a real hook would usually also call default_hook(info)
    }));

    let h = thread::Builder::new().name("importer".into()).spawn(|| {
        let v: Vec<u8> = Vec::new();
        v[3]
    }).unwrap();
    let _ = h.join();

    for line in reported.lock().unwrap().iter() {
        println!("{line}");
    }
}

use std::backtrace::{Backtrace, BacktraceStatus};

fn load_config() -> Result<String, (String, Backtrace)> {
    // `capture` respects RUST_BACKTRACE / RUST_LIB_BACKTRACE; `force_capture` always captures.
    Err(("config file missing".to_string(), Backtrace::capture()))
}

fn main() {
    let (msg, bt) = load_config().unwrap_err();
    println!("error: {msg}");
    println!("backtrace captured: {}", bt.status() == BacktraceStatus::Captured);
    let forced = Backtrace::force_capture();
    println!("forced backtrace captured: {}", forced.status() == BacktraceStatus::Captured);
}

use std::panic::{self, AssertUnwindSafe};

fn handle_request(path: &str) -> String {
    match path {
        "/health" => "ok".to_string(),
        "/users/0" => {
            let users: Vec<&str> = vec![];
            users[0].to_string() // a bug: panics
        }
        other => format!("200 {other}"),
    }
}

fn serve(path: &str) -> String {
    match panic::catch_unwind(AssertUnwindSafe(|| handle_request(path))) {
        Ok(body) => body,
        Err(_) => "500 internal error".to_string(), // the bug was logged by the panic hook
    }
}

fn main() {
    panic::set_hook(Box::new(|info| println!("[panic hook] {}", info.payload_as_str().unwrap_or("?"))));
    for path in ["/health", "/users/0", "/users/7"] {
        println!("{path} -> {}", serve(path));
    }
}

use std::panic::{self, AssertUnwindSafe};

#[derive(Debug)]
struct Ledger {
    balances: Vec<i64>,
}

impl Ledger {
    fn total(&self) -> i64 {
        self.balances.iter().sum()
    }

    // Not panic-safe: the debit happens before the step that can panic.
    fn transfer_naive(&mut self, from: usize, to: usize, amount: i64) {
        self.balances[from] -= amount;
        self.balances[to] += amount; // panics if `to` is out of bounds
    }

    // Panic-safe: do everything that can fail first, then commit with operations that can't.
    fn transfer_safe(&mut self, from: usize, to: usize, amount: i64) {
        assert!(from < self.balances.len() && to < self.balances.len(), "unknown account");
        self.balances[from] -= amount;
        self.balances[to] += amount;
    }
}

fn main() {
    panic::set_hook(Box::new(|_| {}));
    let mut ledger = Ledger { balances: vec![100, 50] };

    let _ = panic::catch_unwind(AssertUnwindSafe(|| ledger.transfer_naive(0, 9, 30)));
    println!("after naive transfer: {:?}, total {}", ledger.balances, ledger.total());

    let mut ledger = Ledger { balances: vec![100, 50] };
    let _ = panic::catch_unwind(AssertUnwindSafe(|| ledger.transfer_safe(0, 9, 30)));
    println!("after safe transfer:  {:?}, total {}", ledger.balances, ledger.total());
}

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let queue = Arc::new(Mutex::new(vec!["job-1", "job-2"]));

    let q = Arc::clone(&queue);
    let _ = thread::spawn(move || {
        let mut jobs = q.lock().unwrap();
        jobs.push("job-3");
        panic!("worker crashed while holding the lock");
    })
    .join();

    println!("poisoned: {}", queue.is_poisoned());
    match queue.lock() {
        Ok(jobs) => println!("jobs: {jobs:?}"),
        Err(poisoned) => {
            // Decide whether the data is still usable. Here, a Vec of jobs is fine.
            let jobs = poisoned.into_inner();
            println!("recovered after a panic, jobs: {jobs:?}");
        }
    }
    queue.clear_poison(); // we checked the data; let others use the lock normally again
    println!("poisoned after clear_poison: {}", queue.is_poisoned());
}

struct FlushOnDrop;

impl Drop for FlushOnDrop {
    fn drop(&mut self) {
        panic!("flush failed in drop"); // never do this
    }
}

fn main() {
    let _file = FlushOnDrop;
    panic!("first panic");
}

struct Guard;

impl Drop for Guard {
    fn drop(&mut self) {
        println!("guard dropped");
    }
}

fn main() {
    let _g = Guard;
    panic!("boom");
}

use std::panic;
use std::sync::atomic::{AtomicU32, Ordering};
use std::thread;

static ATTEMPTS: AtomicU32 = AtomicU32::new(0);

fn consume_queue() -> u32 {
    let attempt = ATTEMPTS.fetch_add(1, Ordering::SeqCst) + 1;
    if attempt < 3 {
        panic!("malformed message on attempt {attempt}");
    }
    42 // processed messages
}

fn supervise<F: Fn() -> u32 + Send + Sync + Copy + 'static>(name: &str, job: F, max_restarts: u32) -> Option<u32> {
    for restart in 0..=max_restarts {
        let handle = thread::Builder::new().name(name.into()).spawn(job).unwrap();
        match handle.join() {
            Ok(result) => return Some(result),
            Err(payload) => {
                let msg = payload.downcast_ref::<String>().cloned().unwrap_or_default();
                println!("{name} crashed ({msg}); restart {} of {max_restarts}", restart + 1);
            }
        }
    }
    None
}

fn main() {
    panic::set_hook(Box::new(|_| {})); // the supervisor reports instead
    match supervise("consumer", consume_queue, 5) {
        Some(n) => println!("consumer finished, processed {n}"),
        None => println!("consumer gave up"),
    }
}

use std::sync::{Arc, Mutex};
use std::thread;

struct Cache {
    entries: Mutex<Vec<(String, u32)>>,
}

impl Cache {
    fn healthy(&self) -> bool {
        !self.entries.is_poisoned()
    }
    fn get(&self, key: &str) -> Result<Option<u32>, &'static str> {
        let entries = self.entries.lock().map_err(|_| "cache poisoned")?;
        Ok(entries.iter().find(|(k, _)| k == key).map(|(_, v)| *v))
    }
}

fn main() {
    let cache = Arc::new(Cache { entries: Mutex::new(vec![("a".into(), 1)]) });
    println!("healthy: {}, get(a) = {:?}", cache.healthy(), cache.get("a"));

    let c = Arc::clone(&cache);
    let _ = thread::spawn(move || {
        let mut e = c.entries.lock().unwrap();
        e.push(("b".into(), 2));
        e.retain(|(k, _)| k != "a"); // imagine this was supposed to be atomic with a refill...
        panic!("refill failed");
    })
    .join();

    println!("healthy: {}, get(a) = {:?}", cache.healthy(), cache.get("a"));
}

use std::time::Duration;

#[tokio::main]
async fn main() {
    std::panic::set_hook(Box::new(|_| {})); // keep the demo output clean

    // 1. Fire and forget: the panic is silently lost (the default hook would print to stderr).
    tokio::spawn(async {
        panic!("background refresh failed");
    });
    tokio::time::sleep(Duration::from_millis(20)).await;
    println!("nobody noticed the background task died");

    // 2. Awaited: the panic becomes a JoinError you can act on.
    let handle = tokio::spawn(async {
        let ids: Vec<u32> = vec![];
        ids[0]
    });
    match handle.await {
        Ok(id) => println!("id {id}"),
        Err(e) if e.is_panic() => {
            let payload = e.into_panic();
            let msg = payload.downcast_ref::<String>().cloned().unwrap_or_default();
            println!("task panicked: {msg}");
        }
        Err(e) => println!("task cancelled: {e}"),
    }
}

use std::panic::{self, AssertUnwindSafe};

/// Called from C: must never unwind.
#[unsafe(no_mangle)]
pub extern "C" fn parse_port(value: i64) -> i32 {
    let result = panic::catch_unwind(AssertUnwindSafe(|| {
        let port = u16::try_from(value).expect("port out of range");
        i32::from(port)
    }));
    result.unwrap_or(-1) // an error code instead of a crash
}

fn main() {
    panic::set_hook(Box::new(|_| {}));
    println!("{} {}", parse_port(8080), parse_port(70_000));
}

use std::panic;

#[track_caller]
fn require_positive(value: i64, what: &str) -> i64 {
    if value <= 0 {
        panic!("{what} must be positive, got {value}");
    }
    value
}

fn main() {
    panic::set_hook(Box::new(|info| {
        let loc = info.location().unwrap();
        println!("panic at line {}: {}", loc.line(), info.payload_as_str().unwrap_or("?"));
    }));
    let _ = panic::catch_unwind(|| {
        let qty = require_positive(3, "quantity");
        let price = require_positive(-5, "price"); // the reported line is this one
        qty * price
    });
}

#![warn(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::indexing_slicing)]

fn first_word(line: &str) -> Option<&str> {
    line.split_whitespace().next() // instead of `.split(' ').collect::<Vec<_>>()[0]`
}

fn parse_level(s: &str) -> Result<u8, String> {
    s.parse::<u8>().map_err(|e| format!("bad level {s:?}: {e}")) // instead of `.unwrap()`
}

fn main() {
    println!("{:?} {:?}", first_word("  hello world"), first_word("   "));
    println!("{:?} {:?}", parse_level("3"), parse_level("x"));
}

fn median(sorted: &[u32]) -> Option<u32> {
    debug_assert!(sorted.is_sorted(), "median needs sorted input"); // free in release
    match sorted.len() {
        0 => None,
        n if n % 2 == 1 => Some(sorted[n / 2]),
        n => Some((sorted[n / 2 - 1] + sorted[n / 2]) / 2),
    }
}

fn main() {
    println!("{:?} {:?} {:?}", median(&[]), median(&[1, 3, 9]), median(&[1, 3, 5, 9]));
}