utils: Make filter_errno a method on the result instead of a function

I.e. instead of `filter(open(), ENOENT)`, you do `open().filter(ENOENT)`.

Signed-off-by: Alexander Larsson <[email protected]>

Author: alexlarsson

crates/composefs/src/repository.rs

@@ -26,7 +26,7 @@ use crate::{
     },
     mount::{composefs_fsmount, mount_at},
     splitstream::{DigestMap, SplitStreamReader, SplitStreamWriter},
-    util::{filter_errno, proc_self_fd, replace_symlinkat, Sha256Digest},
+    util::{proc_self_fd, replace_symlinkat, ErrnoFilter, Sha256Digest},
 };
 
 /// Call openat() on the named subdirectory of "dirfd", possibly creating it first.
@@ -550,24 +550,21 @@ impl<ObjectID: FsVerityHashValue> Repository<ObjectID> {
     fn gc_category(&self, category: &str) -> Result<HashSet<ObjectID>> {
         let mut objects = HashSet::new();
 
-        let Some(category_fd) = filter_errno(
-            self.openat(category, OFlags::RDONLY | OFlags::DIRECTORY),
-            Errno::NOENT,
-        )
-        .context("Opening {category} dir in repository")?
+        let Some(category_fd) = self
+            .openat(category, OFlags::RDONLY | OFlags::DIRECTORY)
+            .filter_errno(Errno::NOENT)
+            .context("Opening {category} dir in repository")?
         else {
             return Ok(objects);
         };
 
-        if let Some(refs) = filter_errno(
-            openat(
-                &category_fd,
-                "refs",
-                OFlags::RDONLY | OFlags::DIRECTORY,
-                Mode::empty(),
-            ),
-            Errno::NOENT,
+        if let Some(refs) = openat(
+            &category_fd,
+            "refs",
+            OFlags::RDONLY | OFlags::DIRECTORY,
+            Mode::empty(),
         )
+        .filter_errno(Errno::NOENT)
         .context("Opening {category}/refs dir in repository")?
         {
             Self::walk_symlinkdir(refs, &mut objects)?;

crates/composefs/src/util.rs

@@ -106,14 +106,17 @@ pub fn parse_sha256(string: impl AsRef<str>) -> Result<Sha256Digest> {
     Ok(value)
 }
 
-pub(crate) fn filter_errno<T>(
-    result: rustix::io::Result<T>,
-    ignored: Errno,
-) -> ErrnoResult<Option<T>> {
-    match result {
-        Ok(result) => Ok(Some(result)),
-        Err(err) if err == ignored => Ok(None),
-        Err(err) => Err(err),
+pub(crate) trait ErrnoFilter<T> {
+    fn filter_errno(self, ignored: Errno) -> ErrnoResult<Option<T>>;
+}
+
+impl<T> ErrnoFilter<T> for ErrnoResult<T> {
+    fn filter_errno(self, ignored: Errno) -> ErrnoResult<Option<T>> {
+        match self {
+            Ok(result) => Ok(Some(result)),
+            Err(err) if err == ignored => Ok(None),
+            Err(err) => Err(err),
+        }
     }
 }
 
@@ -135,12 +138,15 @@ pub(crate) fn replace_symlinkat(
     let target = target.as_ref();
 
     // Step 1: try to create the symlink
-    if filter_errno(symlinkat(target, dirfd, name), Errno::EXIST)?.is_some() {
+    if symlinkat(target, dirfd, name)
+        .filter_errno(Errno::EXIST)?
+        .is_some()
+    {
         return Ok(());
     };
 
     // Step 2: the symlink already exists.  Maybe it already has the correct target?
-    if let Some(current_target) = filter_errno(readlinkat(dirfd, name, []), Errno::NOENT)? {
+    if let Some(current_target) = readlinkat(dirfd, name, []).filter_errno(Errno::NOENT)? {
         if current_target.into_bytes() == target.as_os_str().as_bytes() {
             return Ok(());
         }
@@ -149,7 +155,10 @@ pub(crate) fn replace_symlinkat(
     // Step 3: full atomic replace path
     for _ in 0..16 {
         let tmp_name = generate_tmpname(".symlink-");
-        if filter_errno(symlinkat(target, dirfd, &tmp_name), Errno::EXIST)?.is_none() {
+        if symlinkat(target, dirfd, &tmp_name)
+            .filter_errno(Errno::EXIST)?
+            .is_none()
+        {
             // This temporary filename already exists, try another
             continue;
         }