bootspec: use our own error type

This makes it much less painful for consumers of the bootspec crate to
handle any errors that may occur.

Author: cole-h

Cargo.lock

@@ -13,6 +13,7 @@ authors = ["Graham Christensen <[email protected]>", "Cole Helbling <co
 [dependencies]
 serde = { version = "1.0.152", features = ["derive"] }
 serde_json = "1.0.91"
+thiserror = "1.0.40"
 
 [dev-dependencies]
 tempfile = "3.5.0"

bootspec/Cargo.toml

@@ -0,0 +1,33 @@
+use std::path::PathBuf;
+
+#[derive(Debug, thiserror::Error)]
+pub enum BootspecError {
+    #[error("failed to synthesize: {0}")]
+    Synthesize(#[from] SynthesizeError),
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+    #[error("{0} had an invalid file name")]
+    InvalidFileName(PathBuf),
+    #[error("{0} contained invalid UTF8")]
+    InvalidUtf8(PathBuf),
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum SynthesizeError {
+    #[error("unsupported schema version {0}")]
+    UnsupportedVersion(u64),
+    #[error("failed to canonicalize {path}: {err}")]
+    Canonicalize {
+        path: PathBuf,
+        #[source]
+        err: std::io::Error,
+    },
+    #[error("failed to read {path}: {err}")]
+    ReadPath {
+        path: PathBuf,
+        #[source]
+        err: std::io::Error,
+    },
+    #[error("could not find kernel version dir in {0}")]
+    MissingKernelVersionDir(PathBuf),
+}

bootspec/src/error.rs

@@ -1,18 +1,19 @@
 mod deser;
+pub mod error;
 pub mod generation;
 pub mod v1;
 
 use std::collections::HashMap;
-use std::error::Error;
 use std::fmt;
 use std::path::{Path, PathBuf};
 
 use serde::{Deserialize, Serialize};
 
+use crate::error::{BootspecError, SynthesizeError};
 use crate::generation::Generation;
 
 #[doc(hidden)]
-pub type Result<T, E = Box<dyn Error + Send + Sync + 'static>> = core::result::Result<T, E>;
+pub(crate) type Result<T, E = BootspecError> = core::result::Result<T, E>;
 
 /// A wrapper type describing the name of a NixOS specialisation.
 #[derive(Debug, Default, Clone, Deserialize, Serialize, PartialEq, Eq, Hash)]
@@ -85,9 +86,9 @@ impl BootJson {
                 Generation::V1(generation)
             }
             v => {
-                return Err(
-                    format!("Cannot synthesize for unsupported schema version {}", v).into(),
-                )
+                return Err(BootspecError::Synthesize(
+                    SynthesizeError::UnsupportedVersion(v),
+                ))
             }
         };
 

bootspec/src/lib.rs

@@ -5,6 +5,7 @@ use std::path::{Path, PathBuf};
 
 use serde::{Deserialize, Serialize};
 
+use crate::error::{BootspecError, SynthesizeError};
 use crate::{Result, SpecialisationName, SystemConfigurationRoot};
 
 /// The V1 bootspec schema version.
@@ -40,9 +41,9 @@ impl GenerationV1 {
                 let specialisation = specialisation?;
                 let name = specialisation
                     .file_name()
-                    .ok_or("Could not get name of specialisation dir")?
+                    .ok_or(BootspecError::InvalidFileName(specialisation.clone()))?
                     .to_str()
-                    .ok_or("Specialisation dir name was invalid UTF8")?;
+                    .ok_or(BootspecError::InvalidUtf8(specialisation.clone()))?;
                 let toplevel = fs::canonicalize(generation_path.join("specialisation").join(name))?;
 
                 specialisations.insert(
@@ -92,29 +93,54 @@ impl BootSpecV1 {
     pub(crate) fn synthesize(generation: &Path) -> Result<Self> {
         let generation = generation
             .canonicalize()
-            .map_err(|e| format!("Failed to canonicalize generation dir:\n{}", e))?;
-
-        let system_version = fs::read_to_string(generation.join("nixos-version"))
-            .map_err(|e| format!("Failed to read system version:\n{}", e))?;
-
-        let system = fs::read_to_string(generation.join("system"))
-            .map_err(|e| format!("Failed to read system double:\n{}", e))?;
-
-        let kernel = fs::canonicalize(generation.join("kernel-modules/bzImage"))
-            .map_err(|e| format!("Failed to canonicalize the kernel:\n{}", e))?;
-
-        let kernel_modules = fs::canonicalize(generation.join("kernel-modules/lib/modules"))
-            .map_err(|e| format!("Failed to canonicalize the kernel modules dir:\n{}", e))?;
-        let versioned_kernel_modules = fs::read_dir(kernel_modules)
-            .map_err(|e| format!("Failed to read kernel modules dir:\n{}", e))?
+            .map_err(|e| SynthesizeError::Canonicalize {
+                path: generation.to_path_buf(),
+                err: e,
+            })?;
+
+        let version_file = generation.join("nixos-version");
+        let system_version =
+            fs::read_to_string(version_file.clone()).map_err(|e| SynthesizeError::ReadPath {
+                path: version_file,
+                err: e,
+            })?;
+
+        let system_file = generation.join("system");
+        let system =
+            fs::read_to_string(system_file.clone()).map_err(|e| SynthesizeError::ReadPath {
+                path: system_file,
+                err: e,
+            })?;
+
+        let kernel_file = generation.join("kernel-modules/bzImage");
+        let kernel =
+            fs::canonicalize(kernel_file.clone()).map_err(|e| SynthesizeError::Canonicalize {
+                path: kernel_file,
+                err: e,
+            })?;
+
+        let kernel_modules_path = generation.join("kernel-modules/lib/modules");
+        let kernel_modules = fs::canonicalize(kernel_modules_path.clone()).map_err(|e| {
+            SynthesizeError::Canonicalize {
+                path: kernel_modules_path,
+                err: e,
+            }
+        })?;
+        let versioned_kernel_modules = fs::read_dir(kernel_modules.clone())
+            .map_err(|e| SynthesizeError::ReadPath {
+                path: kernel_modules.clone(),
+                err: e,
+            })?
             .map(|res| res.map(|e| e.path()))
             .next()
-            .ok_or("Could not find kernel version dir")??;
+            .ok_or(SynthesizeError::MissingKernelVersionDir(kernel_modules))??;
         let kernel_version = versioned_kernel_modules
             .file_name()
-            .ok_or("Could not get name of kernel version dir")?
+            .ok_or(BootspecError::InvalidFileName(
+                versioned_kernel_modules.clone(),
+            ))?
             .to_str()
-            .ok_or("Kernel version dir name was invalid UTF8")?;
+            .ok_or(BootspecError::InvalidUtf8(versioned_kernel_modules.clone()))?;
 
         let kernel_params: Vec<String> = fs::read_to_string(generation.join("kernel-params"))?
             .split(' ')
@@ -125,10 +151,12 @@ impl BootSpecV1 {
 
         let initrd_path = generation.join("initrd");
         let initrd = if initrd_path.exists() {
-            Some(
-                fs::canonicalize(initrd_path)
-                    .map_err(|e| format!("Failed to canonicalize the initrd:\n{}", e))?,
-            )
+            Some(fs::canonicalize(initrd_path.clone()).map_err(|e| {
+                SynthesizeError::Canonicalize {
+                    path: initrd_path,
+                    err: e,
+                }
+            })?)
         } else {
             None
         };

bootspec/src/v1.rs

@@ -2,7 +2,7 @@ use std::fs;
 use std::io::{self, Write};
 use std::path::PathBuf;
 
-use bootspec::{BootJson, Result};
+use bootspec::BootJson;
 
 #[derive(clap::Parser)]
 struct Cli {
@@ -12,7 +12,7 @@ struct Cli {
     version: u64,
 }
 
-fn main() -> Result<()> {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     if let Err(e) = self::cli() {
         writeln!(io::stderr(), "{}", e)?;
 
@@ -22,7 +22,7 @@ fn main() -> Result<()> {
     Ok(())
 }
 
-fn cli() -> Result<()> {
+fn cli() -> Result<(), Box<dyn std::error::Error>> {
     let args: Cli = clap::Parser::parse();
     let generation_dir = args.generation_dir;
     let out_path = args.out_path;

synthesize/src/main.rs

@@ -2,9 +2,9 @@ use std::fs;
 use std::io::{self, Write};
 use std::path::PathBuf;
 
-use bootspec::{BootJson, Result};
+use bootspec::BootJson;
 
-fn main() -> Result<()> {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     if let Err(e) = self::cli() {
         writeln!(io::stderr(), "{}", e)?;
 
@@ -14,7 +14,7 @@ fn main() -> Result<()> {
     Ok(())
 }
 
-fn cli() -> Result<()> {
+fn cli() -> Result<(), Box<dyn std::error::Error>> {
     let Args { bootspec_path } = parse_args()?;
 
     let contents = fs::read_to_string(&bootspec_path)?;
@@ -46,7 +46,7 @@ pub struct Args {
     pub bootspec_path: PathBuf,
 }
 
-fn parse_args() -> Result<Args> {
+fn parse_args() -> Result<Args, Box<dyn std::error::Error>> {
     let mut args = std::env::args().skip(1);
 
     if args.len() != 1 {