fn remove_item()

in src/client/trash_cleaner/src/main.rs [254:355]
96 lines of code
3 McCabe index (conditional complexity)

    fn remove_item(&self, entry: &nix::dir::Entry) -> nix::Result<()> {
        match Self::check_item(entry) {
            Ok(true) => (),
            Ok(false) => {
                error!(
                    "trash directory {:?} try clean unexpired item {:?}",
                    self.path,
                    entry.file_name()
                );
                std::process::abort();
            }
            Err(msg) => {
                error!(
                    "trash directory {:?} try clean unknown item {:?}, {}",
                    self.path,
                    entry.file_name(),
                    msg
                );
                std::process::abort();
            }
        }
        assert_eq!(Self::check_item(entry), Ok(true));
        const ROOT: Uid = Uid::from_raw(0);
        assert_ne!(geteuid(), ROOT);
        assert_eq!(geteuid(), self.user);

        if entry.file_name().len() > NAME_MAX {
            return Err(nix::errno::Errno::ENAMETOOLONG);
        }

        // record trash item entries before remove
        let sub_entries = Dir::openat(
            Some(self.dir.as_raw_fd()),
            entry.file_name(),
            OFlag::O_RDONLY | OFlag::O_DIRECTORY,
            Mode::empty(),
        )
        .and_then(|mut subdir| {
            let mut sub_entries = Vec::new();
            for sub_entry in subdir.iter() {
                match sub_entry {
                    Ok(sub_entry) => sub_entries.push(DirEntry::new(sub_entry)),
                    Err(errno) => return Err(errno),
                }
            }
            Ok(sub_entries)
        });

        match sub_entries {
            Ok(sub_entries) => {
                info!(
                    target: "event",
                    user = self.user.as_raw(),
                    user_name = self.user_name,
                    op = "list",
                    item = format!("{:?}", entry.file_name()),
                    sub_entries = serde_json::to_string(&sub_entries).unwrap_or("null".to_string()),
                    errno = 0
                );
            }
            Err(err) => {
                info!(
                    target: "event",
                    user = self.user.as_raw(),
                    user_name = self.user_name,
                    op = "list",
                    item = format!("{:?}", entry.file_name()),
                    sub_entries = "",
                    errno = err as i32
                );
            }
        }

        let mut remove_arg = Hf3fsIoctlRemove {
            parent: self.dir_stat.st_ino,
            name: [0 as libc::c_char; NAME_MAX + 1],
            recursive: true,
        };
        let ret = unsafe {
            let file_name = entry.file_name();
            assert!(file_name.len() <= NAME_MAX);
            std::ptr::copy(
                file_name.as_ptr(),
                remove_arg.name.as_mut_ptr(),
                file_name.len(),
            );
            hf3fs_ioctl_remove(self.dir.as_raw_fd(), &mut remove_arg)
        };
        info!(
            target: "event",
            user = self.user.as_raw(),
            user_name = self.user_name,
            op = "remove",
            item = format!("{:?}", entry.file_name()),
            errno = match ret {
                Ok(_) => 0,
                Err(errno) => errno as i32
            }
        );

        return ret.map(|_| ());
    }