Implemented thiserror for libcontainer - Part 4

crates/libcontainer/src/container/container.rs

@@ -199,7 +199,9 @@ impl Container {
 
     pub fn save(&self) -> Result<()> {
         tracing::debug!("Save container status: {:?} in {:?}", self, self.root);
-        self.state.save(&self.root)
+        self.state.save(&self.root)?;
+
+        Ok(())
     }
 
     pub fn spec(&self) -> Result<YoukiConfig> {

crates/libcontainer/src/container/state.rs

@@ -6,9 +6,9 @@ use std::io::{BufReader, BufWriter, Write};
 use std::path::PathBuf;
 use std::{fs::File, path::Path};
 
-use anyhow::{Context, Result};
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
+use tracing::instrument;
 
 /// Indicates status of the container
 #[derive(Serialize, Deserialize, Debug, Copy, Clone, PartialEq, Eq)]
@@ -72,6 +72,27 @@ impl Display for ContainerStatus {
     }
 }
 
+#[derive(Debug, thiserror::Error)]
+pub enum StateError {
+    #[error("failed to open container state file {state_file_path:?}")]
+    OpenStateFile {
+        state_file_path: PathBuf,
+        source: std::io::Error,
+    },
+    #[error("failed to parse container state file {state_file_path:?}")]
+    ParseStateFile {
+        state_file_path: PathBuf,
+        source: serde_json::Error,
+    },
+    #[error("failed to write container state file {state_file_path:?}")]
+    WriteStateFile {
+        state_file_path: PathBuf,
+        source: std::io::Error,
+    },
+}
+
+type Result<T> = std::result::Result<T, StateError>;
+
 /// Stores the state information of the container
 #[derive(Serialize, Deserialize, Debug, Clone, Default)]
 #[serde(rename_all = "camelCase")]
@@ -125,6 +146,7 @@ impl State {
         }
     }
 
+    #[instrument(level = "trace")]
     pub fn save(&self, container_root: &Path) -> Result<()> {
         let state_file_path = Self::file_path(container_root);
         let file = fs::OpenOptions::new()
@@ -134,19 +156,70 @@ impl State {
             .create(true)
             .truncate(true)
             .open(&state_file_path)
-            .with_context(|| format!("failed to open {}", state_file_path.display()))?;
+            .map_err(|err| {
+                tracing::error!(
+                    state_file_path = ?state_file_path,
+                    err = %err,
+                    "failed to open container state file",
+                );
+                StateError::OpenStateFile {
+                    state_file_path: state_file_path.to_owned(),
+                    source: err,
+                }
+            })?;
         let mut writer = BufWriter::new(file);
-        serde_json::to_writer(&mut writer, self)?;
-        writer.flush()?;
+        serde_json::to_writer(&mut writer, self).map_err(|err| {
+            tracing::error!(
+                ?state_file_path,
+                %err,
+                "failed to parse container state file",
+            );
+            StateError::ParseStateFile {
+                state_file_path: state_file_path.to_owned(),
+                source: err,
+            }
+        })?;
+        writer.flush().map_err(|err| {
+            tracing::error!(
+                ?state_file_path,
+                %err,
+                "failed to write container state file",
+            );
+            StateError::WriteStateFile {
+                state_file_path: state_file_path.to_owned(),
+                source: err,
+            }
+        })?;
+
         Ok(())
     }
 
     pub fn load(container_root: &Path) -> Result<Self> {
         let state_file_path = Self::file_path(container_root);
-        let state_file = File::open(&state_file_path)
-            .with_context(|| format!("failed to open container state file {state_file_path:?}"))?;
+        let state_file = File::open(&state_file_path).map_err(|err| {
+            tracing::error!(
+                ?state_file_path,
+                %err,
+                "failed to open container state file",
+            );
+            StateError::OpenStateFile {
+                state_file_path: state_file_path.to_owned(),
+                source: err,
+            }
+        })?;
+
+        let state: Self = serde_json::from_reader(BufReader::new(state_file)).map_err(|err| {
+            tracing::error!(
+                ?state_file_path,
+                %err,
+                "failed to parse container state file",
+            );
+            StateError::ParseStateFile {
+                state_file_path: state_file_path.to_owned(),
+                source: err,
+            }
+        })?;
 
-        let state: Self = serde_json::from_reader(BufReader::new(state_file))?;
         Ok(state)
     }
 

crates/libcontainer/src/error.rs

@@ -10,3 +10,13 @@ pub enum UnifiedSyscallError {
     #[error(transparent)]
     Syscall(#[from] crate::syscall::SyscallError),
 }
+
+#[derive(Debug, thiserror::Error)]
+pub enum MissingSpecError {
+    #[error("missing process in spec")]
+    MissingProcess,
+    #[error("missing linux in spec")]
+    MissingLinux,
+    #[error("missing args in the process spec")]
+    MissingArgs,
+}