mbrkit 1.0.1

A CLI for building, inspecting, extracting, and verifying MBR-backed disk images
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

//! Error types shared by all `mbrkit` modules.

use std::fmt;
use std::io;
use std::path::PathBuf;

use thiserror::Error;

/// The crate-wide result type.
pub type Result<T> = std::result::Result<T, MbrkitError>;

/// The unified application error type.
#[derive(Debug, Error)]
pub enum MbrkitError {
    /// A wrapped I/O error with optional path context.
    #[error("{message}{path_suffix}")]
    Io {
        /// The path associated with the I/O operation.
        path: Option<PathBuf>,
        /// The high-level error message.
        message: String,
        /// The underlying I/O error.
        #[source]
        source: io::Error,
        /// The rendered path suffix used by the display implementation.
        path_suffix: PathSuffix,
    },
    /// A generic validation error.
    #[error("{0}")]
    InvalidArgument(String),
    /// A partition specification could not be parsed.
    #[error("invalid partition spec `{spec}`: {message}")]
    InvalidPartitionSpec {
        /// The original partition specification string.
        spec: String,
        /// The specific parsing failure.
        message: String,
    },
    /// A user-provided size string is invalid.
    #[error("invalid size `{value}`")]
    InvalidSize {
        /// The original size string.
        value: String,
    },
    /// A user-provided partition type string is invalid.
    #[error("invalid partition type `{value}`")]
    InvalidPartitionType {
        /// The original partition type string.
        value: String,
    },
    /// The disk image does not contain a valid or complete MBR sector.
    #[error("{0}")]
    InvalidMbr(String),
    /// The command already emitted a report and only needs a process exit code.
    #[error("")]
    SilentFailure(i32),
    /// Serialization failed while writing JSON output.
    #[error("failed to serialize report: {0}")]
    Serialize(#[from] serde_json::Error),
    /// TOML manifest parsing failed.
    #[error("failed to parse manifest `{path}`: {source}")]
    Manifest {
        /// The manifest path string used in the error message.
        path: String,
        /// The underlying parse error.
        #[source]
        source: toml::de::Error,
    },
}

/// A tiny helper wrapper keeps the main error enum concise.
#[derive(Clone, Debug)]
pub struct PathSuffix(pub String);

impl fmt::Display for PathSuffix {
    /// Render the suffix appended to I/O errors.
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(&self.0)
    }
}

impl MbrkitError {
    /// Build an I/O error with optional path context.
    pub fn io(path: Option<PathBuf>, message: impl Into<String>, source: io::Error) -> Self {
        let path_suffix = match &path {
            Some(value) => PathSuffix(format!(" ({})", value.display())),
            None => PathSuffix(String::new()),
        };

        Self::Io {
            path,
            message: message.into(),
            source,
            path_suffix,
        }
    }

    /// Return the exit code that should be used by the binary.
    pub fn exit_code(&self) -> i32 {
        match self {
            Self::SilentFailure(code) => *code,
            Self::InvalidArgument(_)
            | Self::InvalidPartitionSpec { .. }
            | Self::InvalidSize { .. }
            | Self::InvalidPartitionType { .. } => 2,
            _ => 1,
        }
    }

    /// Tell the binary whether the error should be printed to stderr.
    pub fn should_print(&self) -> bool {
        !matches!(self, Self::SilentFailure(_))
    }
}