anyhow: Context, Downcasting and Reporting

use anyhow::{Context, Result};
use std::path::Path;

fn import(dir: &Path) -> Result<usize> {
    let mut count = 0;
    for entry in std::fs::read_dir(dir).with_context(|| format!("listing {}", dir.display()))? {
        let path = entry.context("reading directory entry")?.path();
        let text = std::fs::read_to_string(&path)
            .with_context(|| format!("reading {}", path.display()))?;
        let rows: Vec<Row> = serde_json::from_str(&text)
            .with_context(|| format!("parsing {} as JSON rows", path.display()))?;
        count += store_rows(&rows).with_context(|| format!("storing rows from {}", path.display()))?;
    }
    Ok(count)
}

use anyhow::{anyhow, bail, ensure, Result};

fn parse_range(s: &str) -> Result<(u32, u32)> {
    let (a, b) = s.split_once("..").ok_or_else(|| anyhow!("expected START..END, got {s:?}"))?;
    let (a, b): (u32, u32) = (a.parse()?, b.parse()?);
    ensure!(a <= b, "range start {a} is after end {b}");
    if b - a > 10_000 {
        bail!("range {s:?} is too large ({} items, max 10000)", b - a);
    }
    Ok((a, b))
}

fn exit_code_for(err: &anyhow::Error) -> u8 {
    if let Some(e) = err.downcast_ref::<StoreError>() {
        return match e {
            StoreError::NotFound { .. } => 66, // EX_NOINPUT
            _ => 74,                           // EX_IOERR
        };
    }
    if let Some(io) = err.root_cause().downcast_ref::<std::io::Error>() {
        if io.kind() == std::io::ErrorKind::PermissionDenied {
            return 77; // EX_NOPERM
        }
    }
    1
}

let is_timeout = err.chain().any(|cause| {
    cause.downcast_ref::<std::io::Error>().is_some_and(|e| e.kind() == std::io::ErrorKind::TimedOut)
});

loading configuration

Caused by:
    0: reading app.toml
    1: No such file or directory (os error 2)

Stack backtrace:
   0: ...

pub fn report(err: &(dyn std::error::Error + 'static)) -> String {
    let mut out = err.to_string();
    let mut source = err.source();
    while let Some(cause) = source {
        out.push_str("\n  caused by: ");
        out.push_str(&cause.to_string());
        source = cause.source();
    }
    out
}

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    run(args)
}

use std::process::ExitCode;

fn main() -> ExitCode {
    match run() {
        Ok(()) => ExitCode::SUCCESS,
        Err(err) => {
            eprintln!("error: {err:#}");                 // one line for users
            if std::env::var_os("APP_DEBUG").is_some() {
                eprintln!("{err:?}");                    // full report for developers
            }
            ExitCode::from(exit_code_for(&err))
        }
    }
}

use std::process::{ExitCode, Termination};

enum Outcome {
    Done,
    NothingToDo,
    Failed(anyhow::Error),
}

impl Termination for Outcome {
    fn report(self) -> ExitCode {
        match self {
            Outcome::Done => ExitCode::SUCCESS,
            Outcome::NothingToDo => ExitCode::from(3),
            Outcome::Failed(err) => {
                eprintln!("error: {err:?}");
                ExitCode::FAILURE
            }
        }
    }
}

fn main() -> Outcome {
    match sync_all() {
        Ok(0) => Outcome::NothingToDo,
        Ok(_) => Outcome::Done,
        Err(err) => Outcome::Failed(err),
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let cfg = load_config().await.context("loading configuration")?;
    serve(cfg).await
}

// worker loop: the boundary
loop {
    let job = queue.next().await?;
    if let Err(err) = process(&job).await {
        tracing::error!(job_id = %job.id, error = %format!("{err:#}"), "job failed");
        queue.nack(job.id).await?;
    }
}

#[tracing::instrument(skip(db), err)]
async fn create_user(db: &Db, email: &str) -> Result<UserId, ApiError> {
    db.insert_user(email).await.context("inserting user").map_err(ApiError::from)
}

// anyhow -> Box<dyn Error + Send + Sync> (e.g. a framework that wants BoxError)
fn handler() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    inner().map_err(Into::into)          // From<anyhow::Error> for Box<dyn Error + Send + Sync + 'static>
}

// Box<dyn Error + Send + Sync> -> anyhow: the anyhow! macro accepts it and keeps the source chain
fn call_plugin() -> anyhow::Result<()> {
    plugin_run().map_err(|e| anyhow::anyhow!(e))
}

// String / &str errors -> anyhow
fn legacy() -> anyhow::Result<u32> {
    old_api().map_err(anyhow::Error::msg)  // old_api() -> Result<u32, String>
}

// anyhow::Error where &dyn Error is needed
fn log_it(err: &anyhow::Error) {
    let e: &(dyn std::error::Error + Send + Sync + 'static) = err.as_ref();
    eprintln!("{e}");
}

let parsed = (|| {
    let a: u32 = x.parse()?;
    let b: u32 = y.parse()?;
    anyhow::Ok(a + b)                       // pins the error type to anyhow::Error
})()?;

let task = tokio::spawn(async move {
    let body = fetch(&url).await?;
    Ok::<_, anyhow::Error>(body.len())      // same idea with turbofish
});
let len = task.await.context("fetch task panicked or was cancelled")??;