cfsctl: Add StatFile command

Change the previous `GetFileObjectRef` to `StatFile` which now also
outputs file metadata along with what type of file it is, eg. regular
file, symlink, socket etc

Signed-off-by: Pragyan Poudyal <[email protected]>

Author: Johan-Liebert1

crates/cfsctl/src/main.rs

@@ -24,7 +24,7 @@ use composefs::{
     fsverity::{FsVerityHashValue, Sha256HashValue, Sha512HashValue},
     generic_tree::FileSystem,
     repository::Repository,
-    tree::RegularFile,
+    tree::{Leaf, LeafContent, RegularFile, Stat},
 };
 use serde::Serialize;
 
@@ -172,7 +172,7 @@ enum OciCommand {
     },
     /// Given a file path, get the file corresponding to it in the object store
     /// If the file if stored inline, returns an empty string
-    GetFileObjectRef {
+    StatFile {
         #[clap(flatten)]
         config_opts: OCIConfigFilesystemOptions,
         /// The absolute path of the file to be found
@@ -275,7 +275,7 @@ enum Command {
     },
     /// Given a file path, get the file corresponding to it in the object store
     /// If the file if stored inline, returns an empty string
-    GetFileObjectRef {
+    StatFile {
         #[clap(flatten)]
         fs_opts: FsReadOptions,
         /// The absolute path of the file to be found
@@ -299,13 +299,39 @@ enum Command {
 
 /// The return object of GetFileObjectRef cmd
 #[derive(Debug, Serialize)]
-pub struct ObjectRef {
+pub struct ObjectRef<T: FsVerityHashValue> {
     /// Whether the file is stored inline in the EROFS image
     pub stored_inline: bool,
     /// FsVerity digest of the file
     pub digest: Option<String>,
     /// Path to the file relative to the object store
     pub path: Option<String>,
+    /// File metadata
+    pub stat: Stat,
+    /// Whether the file is a regular file, symlink, etc.
+    pub kind: LeafContent<T>,
+}
+
+impl<T: FsVerityHashValue> From<&Leaf<T>> for ObjectRef<T> {
+    fn from(leaf: &Leaf<T>) -> Self {
+        let (stored_inline, digest, path) = match &leaf.content {
+            LeafContent::Regular(file) => match file {
+                RegularFile::Inline(..) => (true, None, None),
+                RegularFile::External(id, _) => {
+                    (false, Some(id.to_hex()), Some(id.to_object_pathname()))
+                }
+            },
+            _ => (true, None, None),
+        };
+
+        Self {
+            stored_inline,
+            digest,
+            path,
+            stat: leaf.stat.clone(),
+            kind: leaf.content.clone(),
+        }
+    }
 }
 
 fn verity_opt<ObjectID>(opt: &Option<String>) -> Result<Option<ObjectID>>
@@ -385,26 +411,10 @@ fn load_filesystem_from_ondisk_fs<ObjectID: FsVerityHashValue>(
 fn get_obj_ref_for_filesystem<ObjectID: FsVerityHashValue>(
     fs: &FileSystem<RegularFile<ObjectID>>,
     file_path: &OsStr,
-) -> Result<ObjectRef> {
+) -> Result<ObjectRef<ObjectID>> {
     let (dir, file) = fs.root.split(file_path)?;
-
-    let obj_ref = dir.get_file(file)?;
-
-    let obj_ref = match obj_ref {
-        RegularFile::Inline(..) => ObjectRef {
-            stored_inline: true,
-            digest: None,
-            path: None,
-        },
-
-        RegularFile::External(id, _) => ObjectRef {
-            stored_inline: false,
-            digest: Some(id.to_hex()),
-            path: Some(id.to_object_pathname()),
-        },
-    };
-
-    Ok(obj_ref)
+    let leaf = dir.ref_leaf(file)?;
+    Ok(ObjectRef::from(leaf.as_ref()))
 }
 
 async fn run_cmd_with_repo<ObjectID>(repo: Repository<ObjectID>, args: App) -> Result<()>
@@ -443,7 +453,7 @@ where
                 let fs = load_filesystem_from_oci_image(&repo, config_opts)?;
                 fs.print_dumpfile()?;
             }
-            OciCommand::GetFileObjectRef {
+            OciCommand::StatFile {
                 config_opts,
                 file_path,
             } => {
@@ -644,7 +654,7 @@ where
             let id = fs.compute_image_id();
             println!("{}", id.to_hex());
         }
-        Command::GetFileObjectRef { fs_opts, file_path } => {
+        Command::StatFile { fs_opts, file_path } => {
             let fs = load_filesystem_from_ondisk_fs(&fs_opts, &repo)?;
             let obj_ref = get_obj_ref_for_filesystem(&fs, file_path.as_os_str())?;
             serde_json::to_writer(std::io::stdout().lock(), &obj_ref)?;

crates/composefs/Cargo.toml

@@ -31,6 +31,8 @@ xxhash-rust = { version = "0.8.2", default-features = false, features = ["xxh32"
 zerocopy = { version = "0.8.0", default-features = false, features = ["derive", "std"] }
 zstd = { version = "0.13.0", default-features = false }
 rand = { version = "0.9.1", default-features = true }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = { version = "1.0", default-features = false, features = ["std"] }
 
 [dev-dependencies]
 insta = "1.42.2"

crates/composefs/src/fsverity/hashvalue.rs

@@ -7,6 +7,7 @@
 use core::{fmt, hash::Hash};
 
 use hex::FromHexError;
+use serde::{Serialize, Serializer};
 use sha2::{digest::FixedOutputReset, digest::Output, Digest, Sha256, Sha512};
 use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout, Unaligned};
 
@@ -22,6 +23,7 @@ where
     Self: Hash + Eq,
     Self: fmt::Debug,
     Self: Send + Sync + Unpin + 'static,
+    Self: Serialize,
 {
     /// The underlying hash digest algorithm type.
     type Digest: Digest + FixedOutputReset + fmt::Debug;
@@ -177,6 +179,15 @@ impl FsVerityHashValue for Sha256HashValue {
     const ID: &str = "sha256";
 }
 
+impl Serialize for Sha256HashValue {
+    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        s.serialize_str(&self.to_hex())
+    }
+}
+
 /// A SHA-512 hash value for fs-verity operations.
 ///
 /// This is a 64-byte hash value using the SHA-512 algorithm.
@@ -190,6 +201,15 @@ impl From<Output<Sha512>> for Sha512HashValue {
     }
 }
 
+impl Serialize for Sha512HashValue {
+    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        s.serialize_str(&self.to_hex())
+    }
+}
+
 impl FsVerityHashValue for Sha512HashValue {
     type Digest = Sha512;
     const ALGORITHM: u8 = 2;

crates/composefs/src/generic_tree.rs

@@ -9,10 +9,11 @@ use std::{
     rc::Rc,
 };
 
+use serde::Serialize;
 use thiserror::Error;
 
 /// File metadata similar to `struct stat` from POSIX.
-#[derive(Debug)]
+#[derive(Debug, Clone, Serialize)]
 pub struct Stat {
     /// File mode and permissions bits.
     pub st_mode: u32,
@@ -47,7 +48,8 @@ impl Stat {
 }
 
 /// Content types for leaf nodes (non-directory files).
-#[derive(Debug)]
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
 pub enum LeafContent<T> {
     /// A regular file with content of type `T`.
     Regular(T),
@@ -60,9 +62,17 @@ pub enum LeafContent<T> {
     /// A Unix domain socket.
     Socket,
     /// A symbolic link pointing to the given target path.
+    #[serde(serialize_with = "serialize_osstr")]
     Symlink(Box<OsStr>),
 }
 
+fn serialize_osstr<S>(v: &OsStr, s: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    s.serialize_str(v.to_string_lossy().as_ref())
+}
+
 /// A leaf node representing a non-directory file.
 #[derive(Debug)]
 pub struct Leaf<T> {

crates/composefs/src/tree.rs

@@ -2,6 +2,8 @@
 //! of inlining small files, and having an external fsverity reference for
 //! larger ones.
 
+use serde::Serialize;
+
 use crate::fsverity::FsVerityHashValue;
 
 pub use crate::generic_tree::{self, ImageError, Stat};
@@ -10,7 +12,8 @@ pub use crate::generic_tree::{self, ImageError, Stat};
 ///
 /// Files can be stored inline for small content or externally referenced
 /// for larger files using fsverity hashing.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
 pub enum RegularFile<ObjectID: FsVerityHashValue> {
     /// File content stored inline as raw bytes.
     Inline(Box<[u8]>),

crates/integration-tests/src/tests/cli.rs

@@ -504,7 +504,7 @@ fn test_get_file_obj_ref() -> Result<()> {
 
     let out_json = cmd!(
         sh,
-        "{cfsctl} --insecure --repo {repo} get-file-object-ref {rootfs} --file-path usr/lib/readme.txt"
+        "{cfsctl} --insecure --repo {repo} stat-file {rootfs} --file-path usr/lib/readme.txt"
     )
     .read()?;