image: wrap LeafContent::Regular{Inline,External}

Create a new LeafContent::Regular which covers both cases and contains
another enum which can be either RegularFile::Inline or ::External.

This is a bit more typing in some cases but lets us consolidate a couple
of match statements and also introduces the possibility of APIs which
can access regular files in uniform ways.

Signed-off-by: Allison Karlitskaya <[email protected]>

Author: allisonkarlitskaya

src/dumpfile.rs

@@ -13,7 +13,7 @@ use rustix::fs::FileType;
 
 use crate::{
     fsverity::Sha256HashValue,
-    image::{DirEnt, Directory, FileSystem, Inode, Leaf, LeafContent, Stat},
+    image::{DirEnt, Directory, FileSystem, Inode, Leaf, LeafContent, RegularFile, Stat},
 };
 
 fn write_empty(writer: &mut impl fmt::Write) -> fmt::Result {
@@ -109,7 +109,7 @@ pub fn write_leaf(
     nlink: usize,
 ) -> fmt::Result {
     match content {
-        LeafContent::InlineFile(ref data) => write_entry(
+        LeafContent::Regular(RegularFile::Inline(ref data)) => write_entry(
             writer,
             path,
             stat,
@@ -121,7 +121,7 @@ pub fn write_leaf(
             data,
             None,
         ),
-        LeafContent::ExternalFile(id, size) => write_entry(
+        LeafContent::Regular(RegularFile::External(id, size)) => write_entry(
             writer,
             path,
             stat,

src/erofs/writer.rs

@@ -265,14 +265,14 @@ impl<'a> Directory<'a> {
 impl Leaf<'_> {
     fn inode_meta(&self) -> (format::DataLayout, u32, u64, usize) {
         let (layout, u, size) = match &self.content {
-            image::LeafContent::InlineFile(data) => {
+            image::LeafContent::Regular(image::RegularFile::Inline(data)) => {
                 if data.is_empty() {
                     (format::DataLayout::FlatPlain, 0, data.len() as u64)
                 } else {
                     (format::DataLayout::FlatInline, 0, data.len() as u64)
                 }
             }
-            image::LeafContent::ExternalFile(.., size) => {
+            image::LeafContent::Regular(image::RegularFile::External(.., size)) => {
                 (format::DataLayout::ChunkBased, 31, *size)
             }
             image::LeafContent::CharacterDevice(rdev) | image::LeafContent::BlockDevice(rdev) => {
@@ -290,8 +290,8 @@ impl Leaf<'_> {
 
     fn write_inline(&self, output: &mut impl Output) {
         output.write(match self.content {
-            image::LeafContent::InlineFile(data) => data,
-            image::LeafContent::ExternalFile(..) => b"\xff\xff\xff\xff", // null chunk
+            image::LeafContent::Regular(image::RegularFile::Inline(data)) => data,
+            image::LeafContent::Regular(image::RegularFile::External(..)) => b"\xff\xff\xff\xff", // null chunk
             image::LeafContent::Symlink(target) => target.as_bytes(),
             _ => &[],
         });
@@ -303,9 +303,7 @@ impl Inode<'_> {
         match &self.content {
             InodeContent::Directory(..) => format::FileType::Directory,
             InodeContent::Leaf(leaf) => match &leaf.content {
-                image::LeafContent::ExternalFile(..) | image::LeafContent::InlineFile(..) => {
-                    format::FileType::RegularFile
-                }
+                image::LeafContent::Regular(..) => format::FileType::RegularFile,
                 image::LeafContent::CharacterDevice(..) => format::FileType::CharacterDevice,
                 image::LeafContent::BlockDevice(..) => format::FileType::BlockDevice,
                 image::LeafContent::Fifo => format::FileType::Fifo,
@@ -407,7 +405,7 @@ impl<'a> InodeCollector<'a> {
 
         // We need to record extra xattrs for some files.  These come first.
         if let InodeContent::Leaf(Leaf {
-            content: image::LeafContent::ExternalFile(id, ..),
+            content: image::LeafContent::Regular(image::RegularFile::External(id, ..)),
             ..
         }) = content
         {

src/fs.rs

@@ -24,7 +24,7 @@ use zerocopy::IntoBytes;
 
 use crate::{
     fsverity::{digest::FsVerityHasher, Sha256HashValue},
-    image::{DirEnt, Directory, FileSystem, Inode, Leaf, LeafContent, Stat},
+    image::{DirEnt, Directory, FileSystem, Inode, Leaf, LeafContent, RegularFile, Stat},
     repository::Repository,
     selabel::selabel,
     util::proc_self_fd,
@@ -88,8 +88,10 @@ fn write_leaf(leaf: &Leaf, dirfd: &OwnedFd, name: &OsStr, repo: &Repository) ->
     let mode = leaf.stat.st_mode.into();
 
     match leaf.content {
-        LeafContent::InlineFile(ref data) => set_file_contents(dirfd, name, &leaf.stat, data)?,
-        LeafContent::ExternalFile(ref id, size) => {
+        LeafContent::Regular(RegularFile::Inline(ref data)) => {
+            set_file_contents(dirfd, name, &leaf.stat, data)?
+        }
+        LeafContent::Regular(RegularFile::External(ref id, size)) => {
             let object = repo.open_object(id)?;
             // TODO: make this better.  At least needs to be EINTR-safe.  Could even do reflink in some cases...
             let mut buffer = vec![MaybeUninit::uninit(); size as usize];
@@ -191,9 +193,9 @@ impl FilesystemReader<'_> {
                     } else {
                         FsVerityHasher::hash(data)
                     };
-                    LeafContent::ExternalFile(id, buf.st_size as u64)
+                    LeafContent::Regular(RegularFile::External(id, buf.st_size as u64))
                 } else {
-                    LeafContent::InlineFile(Vec::from(data))
+                    LeafContent::Regular(RegularFile::Inline(Vec::from(data)))
                 }
             }
             FileType::Symlink => {

src/image.rs

@@ -20,10 +20,15 @@ pub struct Stat {
     pub xattrs: RefCell<BTreeMap<Box<OsStr>, Box<[u8]>>>,
 }
 
+#[derive(Debug)]
+pub enum RegularFile {
+    Inline(Vec<u8>),
+    External(Sha256HashValue, u64),
+}
+
 #[derive(Debug)]
 pub enum LeafContent {
-    InlineFile(Vec<u8>),
-    ExternalFile(Sha256HashValue, u64),
+    Regular(RegularFile),
     BlockDevice(u64),
     CharacterDevice(u64),
     Fifo,

src/oci/image.rs

@@ -107,7 +107,7 @@ pub fn create_image(
 }
 
 #[cfg(test)]
-use crate::image::{LeafContent, Stat};
+use crate::image::{LeafContent, RegularFile, Stat};
 #[cfg(test)]
 use std::{cell::RefCell, collections::BTreeMap, io::BufRead, path::PathBuf};
 
@@ -122,7 +122,7 @@ fn file_entry(path: &str) -> oci::tar::TarEntry {
             st_mtim_sec: 0,
             xattrs: RefCell::new(BTreeMap::new()),
         },
-        item: oci::tar::TarItem::Leaf(LeafContent::InlineFile(vec![])),
+        item: oci::tar::TarItem::Leaf(LeafContent::Regular(RegularFile::Inline(vec![]))),
     }
 }
 

src/oci/tar.rs

@@ -15,7 +15,7 @@ use tokio::io::{AsyncRead, AsyncReadExt};
 
 use crate::{
     dumpfile,
-    image::{LeafContent, Stat},
+    image::{LeafContent, RegularFile, Stat},
     splitstream::{SplitStreamData, SplitStreamReader, SplitStreamWriter},
     util::{read_exactish, read_exactish_async},
     INLINE_CONTENT_MAX,
@@ -181,7 +181,7 @@ pub fn get_entry<R: Read>(reader: &mut SplitStreamReader<R>) -> Result<Option<Ta
                         size as usize > INLINE_CONTENT_MAX,
                         "Splitstream incorrectly stored a small ({size} byte) file external"
                     );
-                    TarItem::Leaf(LeafContent::ExternalFile(id, size))
+                    TarItem::Leaf(LeafContent::Regular(RegularFile::External(id, size)))
                 }
                 _ => bail!(
                     "Unsupported external-chunked entry {:?} {}",
@@ -224,7 +224,7 @@ pub fn get_entry<R: Read>(reader: &mut SplitStreamReader<R>) -> Result<Option<Ta
                         "Splitstream incorrectly stored a large ({} byte) file inline",
                         content.len()
                     );
-                    TarItem::Leaf(LeafContent::InlineFile(content))
+                    TarItem::Leaf(LeafContent::Regular(RegularFile::Inline(content)))
                 }
                 EntryType::Link => TarItem::Hardlink({
                     let Some(link_name) = header.link_name_bytes() else {

src/selabel.rs

@@ -11,7 +11,7 @@ use anyhow::{bail, ensure, Context, Result};
 use regex_automata::{hybrid::dfa, util::syntax, Anchored, Input};
 
 use crate::{
-    image::{DirEnt, Directory, FileSystem, Inode, Leaf, LeafContent, Stat},
+    image::{DirEnt, Directory, FileSystem, Inode, Leaf, LeafContent, RegularFile, Stat},
     repository::Repository,
 };
 
@@ -116,8 +116,8 @@ pub fn openat<'a>(
 
     match &dir.entries[idx].inode {
         Inode::Leaf(leaf) => match &leaf.content {
-            LeafContent::InlineFile(data) => Ok(Some(Box::new(data.as_slice()))),
-            LeafContent::ExternalFile(id, ..) => {
+            LeafContent::Regular(RegularFile::Inline(data)) => Ok(Some(Box::new(data.as_slice()))),
+            LeafContent::Regular(RegularFile::External(id, ..)) => {
                 Ok(Some(Box::new(File::from(repo.open_object(id)?))))
             }
             _ => bail!("Invalid file type"),
@@ -211,7 +211,7 @@ fn relabel(stat: &Stat, path: &Path, ifmt: u8, policy: &mut Policy) {
 
 fn relabel_leaf(leaf: &Leaf, path: &Path, policy: &mut Policy) {
     let ifmt = match leaf.content {
-        LeafContent::InlineFile(..) | LeafContent::ExternalFile(..) => b'-',
+        LeafContent::Regular(..) => b'-',
         LeafContent::Fifo => b'p', // NB: 'pipe', not 'fifo'
         LeafContent::Socket => b's',
         LeafContent::Symlink(..) => b'l',

tests/mkfs.rs

@@ -13,7 +13,7 @@ use tempfile::NamedTempFile;
 use composefs::{
     dumpfile::write_dumpfile,
     erofs::{debug::debug_img, writer::mkfs_erofs},
-    image::{Directory, FileSystem, Inode, Leaf, LeafContent, Stat},
+    image::{Directory, FileSystem, Inode, Leaf, LeafContent, RegularFile, Stat},
 };
 
 fn debug_fs(mut fs: FileSystem) -> String {
@@ -54,12 +54,12 @@ fn simple(fs: &mut FileSystem) {
     add_leaf(
         &mut fs.root,
         "regular-inline",
-        LeafContent::InlineFile(b"hihi".to_vec()),
+        LeafContent::Regular(RegularFile::Inline(b"hihi".to_vec())),
     );
     add_leaf(
         &mut fs.root,
         "regular-external",
-        LeafContent::ExternalFile([0x5a; 32], 1234),
+        LeafContent::Regular(RegularFile::External([0x5a; 32], 1234)),
     );
     add_leaf(&mut fs.root, "chrdev", LeafContent::CharacterDevice(123));
     add_leaf(&mut fs.root, "blkdev", LeafContent::BlockDevice(123));