Switch from anyhow to miette and improve some errs

Signed-off-by: Ryan Bottriell <[email protected]>

Add a format Wrapped error variant

The previous method mashed strings together, losing any context which we
don't want to do.

Signed-off-by: Ryan Bottriell <[email protected]>
Signed-off-by: Ryan Bottriell <[email protected]>

Add error doc page and link in diagnostics

This will allow us to assign specific error codes and link users to our
documentation site with longer form, and supplementary material related
to the error and how it might be resolved.

Signed-off-by: Ryan Bottriell <[email protected]>
Signed-off-by: Ryan Bottriell <[email protected]>

Add specific error information for mkdir /spfs

Signed-off-by: Ryan Bottriell <[email protected]>
Signed-off-by: Ryan Bottriell <[email protected]>

Use miette for errors in spk as well

Signed-off-by: Ryan Bottriell <[email protected]>
Signed-off-by: Ryan Bottriell <[email protected]>

Propagate miette usage to windows code

Signed-off-by: Ryan Bottriell <[email protected]>
Signed-off-by: Ryan Bottriell <[email protected]>

Attach the path to repository open

Signed-off-by: Ryan Bottriell <[email protected]>
Signed-off-by: Ryan Bottriell <[email protected]>

Introduce a local error type OpenRepositoryError

This also comes with the MigrationError type, which both work together
to refine the set of errors that can happen when opening a repository.
This allows each condition to have richer diagnostic information for
anyone encountering the error.

Signed-off-by: Ryan Bottriell <[email protected]>
Signed-off-by: Ryan Bottriell <[email protected]>

Add spfs init command for making repos

Signed-off-by: Ryan Bottriell <[email protected]>
Signed-off-by: Ryan Bottriell <[email protected]>

Fill in missing error code docs

Signed-off-by: Ryan Bottriell <[email protected]>

Remove uneccessary use of into_diagnostic

Signed-off-by: Ryan Bottriell <[email protected]>

Author: rydrman

Cargo.lock

@@ -33,7 +33,6 @@ edition = "2021"
 version = "0.38.0"
 
 [workspace.dependencies]
-anyhow = "1.0"
 bytes = "1.5"
 arc-swap = "1.6.0"
 async-trait = "0.1"
@@ -54,6 +53,7 @@ fuser = "0.12"
 glob = "0.3"
 indicatif = "0.17.5"
 libc = "0.2.80"
+miette = "5.10"
 nix = "0.26.2"
 nom = "7.1"
 nom-supreme = "0.8"

Cargo.toml

@@ -12,13 +12,13 @@ path = "src/cmd_clean.rs"
 sentry = ["spfs-cli-common/sentry"]
 
 [dependencies]
-anyhow = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true }
 colored = { workspace = true }
+miette = { workspace = true, features = ["fancy"] }
 question = "0.2.2"
 spfs = { path = "../../spfs" }
 spfs-cli-common = { path = "../common" }
 tokio = { version = "1.20", features = ["rt", "rt-multi-thread"] }
 tracing = { workspace = true }
-url = { version = "2.2", features = ["serde"] }
+url = { version = "2.2", features = ["serde"] }

crates/spfs-cli/cmd-clean/Cargo.toml

@@ -7,10 +7,10 @@
 
 use std::collections::HashSet;
 
-use anyhow::Result;
 use chrono::prelude::*;
 use clap::Parser;
 use colored::Colorize;
+use miette::Result;
 use spfs_cli_common as cli;
 use spfs_cli_common::CommandName;
 
@@ -237,7 +237,7 @@ fn age_to_date(age: &str) -> Result<DateTime<Utc>> {
         .parse()
         .map_err(|err| spfs::Error::from(format!("{err:?}")))?;
     if num < 0 {
-        anyhow::bail!("provided age must be greater than zero: '{age}'");
+        miette::bail!("provided age must be greater than zero: '{age}'");
     }
 
     match postfix {
@@ -247,6 +247,6 @@ fn age_to_date(age: &str) -> Result<DateTime<Utc>> {
         "h" => Ok(Utc::now() - chrono::Duration::hours(num)),
         "m" => Ok(Utc::now() - chrono::Duration::minutes(num)),
         "s" => Ok(Utc::now() - chrono::Duration::seconds(num)),
-        _ => anyhow::bail!("Unknown age postfix: '{postfix}', must be one of y, w, d, h, m, s"),
+        _ => miette::bail!("Unknown age postfix: '{postfix}', must be one of y, w, d, h, m, s"),
     }
 }

crates/spfs-cli/cmd-clean/src/cmd_clean.rs

@@ -12,8 +12,8 @@ path = "src/cmd_enter.rs"
 sentry = ["spfs-cli-common/sentry"]
 
 [dependencies]
-anyhow = { workspace = true }
 clap = { workspace = true }
+miette = { workspace = true, features = ["fancy"] }
 nix = { workspace = true }
 spfs = { path = "../../spfs" }
 spfs-cli-common = { path = "../common" }

crates/spfs-cli/cmd-enter/Cargo.toml

@@ -10,10 +10,10 @@ use std::ffi::OsString;
 use std::sync::atomic::Ordering;
 use std::time::Instant;
 
-use anyhow::{Context, Result};
 use clap::{Args, Parser};
 #[cfg(feature = "sentry")]
 use cli::configure_sentry;
+use miette::{Context, Result};
 use spfs::monitor::SPFS_MONITOR_FOREGROUND_LOGGING_VAR;
 use spfs::storage::fs::RenderSummary;
 use spfs_cli_common as cli;
@@ -222,12 +222,12 @@ impl CmdEnter {
                     // proceed with using the runtime, so we don't ignore this
                     // error and hope for the best. Using this new environment
                     // puts whatever is using it at risk of data loss.
-                    anyhow::bail!(
+                    miette::bail!(
                         "spfs-monitor disappeared unexpectedly, it is unsafe to continue. Setting ${SPFS_MONITOR_FOREGROUND_LOGGING_VAR}=1 may provide more details"
                     );
                 }
                 Err(err) => {
-                    anyhow::bail!("Failed to inform spfs-monitor to start: {err}");
+                    miette::bail!("Failed to inform spfs-monitor to start: {err}");
                 }
             };
 
@@ -286,7 +286,7 @@ impl CmdEnter {
 
         cmd.exec()
             .map(|_| 0)
-            .context("Failed to execute runtime command")
+            .wrap_err("Failed to execute runtime command")
     }
 
     #[cfg_attr(not(feature = "sentry"), allow(unused))]

crates/spfs-cli/cmd-enter/src/cmd_enter.rs

@@ -19,12 +19,12 @@ fuse-backend-rhel-7-9 = ["spfs-vfs/fuse-backend-rhel-7-9"]
 sentry = ["spfs-cli-common/sentry"]
 
 [dependencies]
-anyhow = { workspace = true }
 clap = { workspace = true }
 dashmap = { workspace = true }
 spfs-vfs = { path = "../../spfs-vfs" }
-nix = { workspace = true, features = ["process"] }
 libc = "0.2"
+miette = { workspace = true, features = ["fancy"] }
+nix = { workspace = true, features = ["process"] }
 spfs = { path = "../../spfs", features = ["fuse-backend"] }
 spfs-cli-common = { path = "../common" }
 tokio = { version = "1.20", features = ["rt", "rt-multi-thread"] }

crates/spfs-cli/cmd-fuse/Cargo.toml

@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 // https://github.com/imageworks/spk
 
-use anyhow::{anyhow, bail, Context, Result};
 use clap::Parser;
 use fuser::MountOption;
+use miette::{bail, miette, Context, IntoDiagnostic, Result};
 use spfs::tracking::EnvSpec;
 use spfs::Error;
 use spfs_cli_common as cli;
@@ -14,13 +14,13 @@ use tokio::signal::unix::{signal, SignalKind};
 // The runtime setup process manages the current namespace
 // which operates only on the current thread. For this reason
 // we must use a single threaded async runtime, if any.
-fn main() {
+fn main() -> Result<()> {
     // because this function exits right away it does not
     // properly handle destruction of data, so we put the actual
     // logic into a separate function/scope
-    std::process::exit(main2())
+    std::process::exit(main2()?)
 }
-fn main2() -> i32 {
+fn main2() -> Result<i32> {
     let mut opt = CmdFuse::parse();
     opt.logging
         .log_file
@@ -31,7 +31,7 @@ fn main2() -> i32 {
     let config = match spfs::get_config() {
         Err(err) => {
             tracing::error!(err = ?err, "failed to load config");
-            return 1;
+            return Ok(1);
         }
         Ok(config) => config,
     };
@@ -158,19 +158,27 @@ impl CmdFuse {
         let mountpoint = self
             .mountpoint
             .canonicalize()
-            .context("Invalid mount point")?;
+            .into_diagnostic()
+            .wrap_err("Invalid mount point")?;
 
         if !opts.uid.is_root() {
-            nix::unistd::seteuid(opts.uid).context("Failed to become desired user (effective)")?;
-            nix::unistd::setegid(opts.gid).context("Failed to become desired group (effective)")?;
+            nix::unistd::seteuid(opts.uid)
+                .into_diagnostic()
+                .wrap_err("Failed to become desired user (effective)")?;
+            nix::unistd::setegid(opts.gid)
+                .into_diagnostic()
+                .wrap_err("Failed to become desired group (effective)")?;
             // unprivileged users must have write access to the directory that
             // they are trying to mount over.
             nix::unistd::access(&mountpoint, nix::unistd::AccessFlags::W_OK)
-                .context("Must have write access to mountpoint")?;
+                .into_diagnostic()
+                .wrap_err("Must have write access to mountpoint")?;
             nix::unistd::seteuid(calling_uid)
-                .context("Failed to reset calling user (effective)")?;
+                .into_diagnostic()
+                .wrap_err("Failed to reset calling user (effective)")?;
             nix::unistd::setegid(calling_gid)
-                .context("Failed to reset calling group (effective)")?;
+                .into_diagnostic()
+                .wrap_err("Failed to reset calling group (effective)")?;
         }
 
         // establish the fuse session before changing the uid/gid of this process
@@ -184,23 +192,34 @@ impl CmdFuse {
             &mountpoint,
             &mount_opts,
         )
-        .context("Failed to create a FUSE session")?;
+        .into_diagnostic()
+        .wrap_err("Failed to create a FUSE session")?;
 
         if opts.gid != calling_gid {
-            nix::unistd::setgid(opts.gid).context("Failed to set desired group (actual)")?;
-            nix::unistd::setegid(opts.gid).context("Failed to set desired group (effective)")?;
+            nix::unistd::setgid(opts.gid)
+                .into_diagnostic()
+                .wrap_err("Failed to set desired group (actual)")?;
+            nix::unistd::setegid(opts.gid)
+                .into_diagnostic()
+                .wrap_err("Failed to set desired group (effective)")?;
         }
         if opts.uid != calling_uid {
-            nix::unistd::setuid(opts.uid).context("Failed to become desired user (actual)")?;
-            nix::unistd::seteuid(opts.uid).context("Failed to become desired user (effective)")?;
+            nix::unistd::setuid(opts.uid)
+                .into_diagnostic()
+                .wrap_err("Failed to become desired user (actual)")?;
+            nix::unistd::seteuid(opts.uid)
+                .into_diagnostic()
+                .wrap_err("Failed to become desired user (effective)")?;
         }
 
         if !self.foreground {
             tracing::debug!("Moving into background...");
             // We cannot daemonize until the session is established above,
             // otherwise initial use of the filesystem may not show any mount
             // at all.
-            nix::unistd::daemon(false, self.log_foreground)?;
+            nix::unistd::daemon(false, self.log_foreground)
+                .into_diagnostic()
+                .wrap_err("Failed to daemonize")?;
         }
 
         // We also cannot go multi-thread until the daemonization process above
@@ -213,12 +232,13 @@ impl CmdFuse {
             .max_blocking_threads(config.fuse.max_blocking_threads.get())
             .enable_all()
             .build()
-            .context("Failed to establish runtime")?;
+            .into_diagnostic()
+            .wrap_err("Failed to establish runtime")?;
 
         let result = rt.block_on(async move {
-            let mut interrupt = signal(SignalKind::interrupt()).context("interrupt signal handler")?;
-            let mut quit = signal(SignalKind::quit()).context("quit signal handler")?;
-            let mut terminate = signal(SignalKind::terminate()).context("terminate signal handler")?;
+            let mut interrupt = signal(SignalKind::interrupt()).into_diagnostic().wrap_err("interrupt signal handler")?;
+            let mut quit = signal(SignalKind::quit()).into_diagnostic().wrap_err("quit signal handler")?;
+            let mut terminate = signal(SignalKind::terminate()).into_diagnostic().wrap_err("terminate signal handler")?;
 
             tracing::info!("Starting FUSE filesystem");
             // Although the filesystem could run in the current thread, we prefer to
@@ -230,13 +250,13 @@ impl CmdFuse {
             let res = tokio::select!{
                 res = join_handle => {
                     tracing::info!("Filesystem shutting down");
-                    res.context("FUSE session failed")
+                    res.into_diagnostic().wrap_err("FUSE session failed")
                 }
                 // we explicitly catch any signal related to interruption
                 // and will act by shutting down the filesystem early
-                _ = terminate.recv() => Err(anyhow!("Terminate signal received, filesystem shutting down")),
-                _ = interrupt.recv() => Err(anyhow!("Interrupt signal received, filesystem shutting down")),
-                _ = quit.recv() => Err(anyhow!("Quit signal received, filesystem shutting down")),
+                _ = terminate.recv() => Err(miette!("Terminate signal received, filesystem shutting down")),
+                _ = interrupt.recv() => Err(miette!("Interrupt signal received, filesystem shutting down")),
+                _ = quit.recv() => Err(miette!("Quit signal received, filesystem shutting down")),
             };
             // the filesystem task must be fully terminated in order for the subsequent unmount
             // process to function. Otherwise, the background task will keep this process alive
@@ -251,7 +271,7 @@ impl CmdFuse {
         // events which will never come and so we don't want to block forever
         // when the runtime is dropped.
         rt.shutdown_timeout(std::time::Duration::from_secs(2));
-        result??;
+        result?.into_diagnostic()?;
         Ok(0)
     }
 }

crates/spfs-cli/cmd-fuse/src/cmd_fuse.rs

@@ -12,9 +12,9 @@ path = "src/cmd_join.rs"
 sentry = ["spfs-cli-common/sentry"]
 
 [dependencies]
-anyhow = { workspace = true }
 clap = { workspace = true }
 futures = { workspace = true }
+miette = { workspace = true, features = ["fancy"] }
 spfs = { path = "../../spfs" }
 spfs-cli-common = { path = "../common" }
 tokio = { version = "1.20", features = ["rt", "rt-multi-thread"] }

crates/spfs-cli/cmd-join/Cargo.toml

@@ -7,9 +7,9 @@
 
 use std::ffi::OsString;
 
-use anyhow::{anyhow, bail, Context, Result};
 use clap::{ArgGroup, Parser};
 use futures::StreamExt;
+use miette::{bail, miette, Context, Result};
 use spfs::Error;
 use spfs_cli_common as cli;
 use spfs_cli_common::CommandName;
@@ -62,12 +62,12 @@ impl CmdJoin {
                 storage
                     .read_runtime(runtime)
                     .await
-                    .map_err(Into::<anyhow::Error>::into)
+                    .map_err(Into::<miette::Error>::into)
             } else if let Some(pid) = self.pid {
                 let mount_ns = spfs::monitor::identify_mount_namespace_of_process(pid)
                     .await
-                    .context("identify mount namespace of pid")?
-                    .ok_or(anyhow!("pid not found"))?;
+                    .wrap_err("identify mount namespace of pid")?
+                    .ok_or(miette!("pid not found"))?;
                 let mut runtimes = storage.iter_runtimes().await;
                 while let Some(runtime) = runtimes.next().await {
                     let Ok(runtime) = runtime else {

crates/spfs-cli/cmd-join/src/cmd_join.rs

@@ -12,8 +12,8 @@ path = "src/cmd_monitor.rs"
 sentry = ["spfs/sentry", "spfs-cli-common/sentry"]
 
 [dependencies]
-anyhow = { workspace = true }
 clap = { workspace = true }
+miette = { workspace = true, features = ["fancy"] }
 nix = { workspace = true }
 spfs = { path = "../../spfs", features = ["fuse-backend"] }
 spfs-cli-common = { path = "../common" }

crates/spfs-cli/cmd-monitor/Cargo.toml

@@ -7,24 +7,24 @@
 
 use std::time::Duration;
 
-use anyhow::{Context, Result};
 use clap::Parser;
 #[cfg(feature = "sentry")]
 use cli::configure_sentry;
+use miette::{Context, IntoDiagnostic, Result};
 use spfs::Error;
 use spfs_cli_common as cli;
 use spfs_cli_common::CommandName;
 use tokio::io::AsyncReadExt;
 use tokio::signal::unix::{signal, SignalKind};
 use tokio::time::timeout;
 
-fn main() {
+fn main() -> Result<()> {
     // because this function exits right away it does not
     // properly handle destruction of data, so we put the actual
     // logic into a separate function/scope
-    std::process::exit(main2())
+    std::process::exit(main2()?);
 }
-fn main2() -> i32 {
+fn main2() -> Result<i32> {
     let mut opt = CmdMonitor::parse();
     opt.logging
         .log_file
@@ -84,13 +84,15 @@ impl CmdMonitor {
             .max_blocking_threads(1)
             .enable_all()
             .build()
-            .context("Failed to establish async runtime")?;
+            .into_diagnostic()
+            .wrap_err("Failed to establish async runtime")?;
         rt.block_on(self.wait_for_ready());
         // clean up this runtime and all other threads before detaching
         drop(rt);
 
         nix::unistd::daemon(self.no_chdir, self.no_close)
-            .context("Failed to daemonize the monitor process")?;
+            .into_diagnostic()
+            .wrap_err("Failed to daemonize the monitor process")?;
 
         #[cfg(feature = "sentry")]
         {
@@ -106,7 +108,8 @@ impl CmdMonitor {
             .max_blocking_threads(config.monitor.max_blocking_threads.get())
             .enable_all()
             .build()
-            .context("Failed to establish async runtime")?;
+            .into_diagnostic()
+            .wrap_err("Failed to establish async runtime")?;
         let code = rt.block_on(self.run_async())?;
         // the monitor is running in the background and, although not expected,
         // can take extra time to shutdown if needed

crates/spfs-cli/cmd-monitor/src/cmd_monitor.rs

@@ -12,10 +12,10 @@ path = "src/cmd_render.rs"
 sentry = ["spfs-cli-common/sentry"]
 
 [dependencies]
-anyhow = { workspace = true }
 clap = { workspace = true }
 dunce = { workspace = true }
 futures = { workspace = true }
+miette = { workspace = true, features = ["fancy"] }
 serde_json = { workspace = true }
 spfs = { path = "../../spfs" }
 spfs-cli-common = { path = "../common" }