lint: Add --skip

This allows people to explicitly skip individual lints; especially
useful for warnings. But maybe people have a legitimate reason
to skip ones we're calling fatal too.

Prep especially for supporting `--fix --skip`.

Signed-off-by: Colin Walters <[email protected]>

Author: cgwalters

lib/src/cli.rs

@@ -257,6 +257,13 @@ pub(crate) enum ContainerOpts {
         /// maintaining this exact format; do not parse it via code or scripts.
         #[clap(long)]
         list: bool,
+
+        /// Skip checking the targeted lints, by name. Use `--list` to discover the set
+        /// of available lints.
+        ///
+        /// Example: --skip nonempty-boot --skip baseimage-root
+        #[clap(long)]
+        skip: Vec<String>,
     },
 }
 
@@ -1044,6 +1051,7 @@ async fn run_from_opt(opt: Opt) -> Result<()> {
                 rootfs,
                 fatal_warnings,
                 list,
+                skip,
             } => {
                 if list {
                     return lints::lint_list(std::io::stdout().lock());
@@ -1060,7 +1068,8 @@ async fn run_from_opt(opt: Opt) -> Result<()> {
                 };
 
                 let root = &Dir::open_ambient_dir(rootfs, cap_std::ambient_authority())?;
-                lints::lint(root, warnings, root_type, std::io::stdout().lock())?;
+                let skip = skip.iter().map(|s| s.as_str());
+                lints::lint(root, warnings, root_type, skip, std::io::stdout().lock())?;
                 Ok(())
             }
         },

lib/src/lints.rs

@@ -140,18 +140,25 @@ struct LintExecutionResult {
     fatal: usize,
 }
 
-fn lint_inner(
+fn lint_inner<'skip>(
     root: &Dir,
     root_type: RootType,
+    skip: impl IntoIterator<Item = &'skip str>,
     mut output: impl std::io::Write,
 ) -> Result<LintExecutionResult> {
     let mut fatal = 0usize;
     let mut warnings = 0usize;
     let mut passed = 0usize;
     let mut skipped = 0usize;
+    let skip: std::collections::HashSet<_> = skip.into_iter().collect();
     for lint in LINTS {
         let name = lint.name;
 
+        if skip.contains(name) {
+            skipped += 1;
+            continue;
+        }
+
         if let Some(lint_root_type) = lint.root_type {
             if lint_root_type != root_type {
                 skipped += 1;
@@ -194,13 +201,14 @@ fn lint_inner(
 /// if it exists we need to check that it links to /run if not error
 /// if it does not exist error.
 #[context("Linting")]
-pub(crate) fn lint(
+pub(crate) fn lint<'skip>(
     root: &Dir,
     warning_disposition: WarningDisposition,
     root_type: RootType,
+    skip: impl IntoIterator<Item = &'skip str>,
     mut output: impl std::io::Write,
 ) -> Result<()> {
-    let r = lint_inner(root, root_type, &mut output)?;
+    let r = lint_inner(root, root_type, skip, &mut output)?;
     writeln!(output, "Checks passed: {}", r.passed)?;
     if r.skipped > 0 {
         writeln!(output, "Checks skipped: {}", r.skipped)?;
@@ -534,31 +542,43 @@ mod tests {
         let mut out = Vec::new();
         let warnings = WarningDisposition::FatalWarnings;
         let root_type = RootType::Running;
-        lint(root, warnings, root_type, &mut out).unwrap();
+        lint(root, warnings, root_type, [], &mut out).unwrap();
         root.create_dir_all("var/run/foo")?;
         let mut out = Vec::new();
-        assert!(lint(root, warnings, root_type, &mut out).is_err());
+        assert!(lint(root, warnings, root_type, [], &mut out).is_err());
         Ok(())
     }
 
     #[test]
     fn test_lint_inner() -> Result<()> {
         let root = &passing_fixture()?;
+
+        // Verify that all lints run except one which is skipped for non-running roots
         let mut out = Vec::new();
         let root_type = RootType::Running;
-        let r = lint_inner(root, root_type, &mut out).unwrap();
+        let r = lint_inner(root, root_type, [], &mut out).unwrap();
         let allbut_one = LINTS.len().checked_sub(1).unwrap();
         assert_eq!(r.passed, allbut_one);
         assert_eq!(r.fatal, 0);
         assert_eq!(r.skipped, 1);
         assert_eq!(r.warnings, 0);
-        root.create_dir_all("var/run/foo")?;
+
+        let r = lint_inner(root, root_type, ["var-log"], &mut out).unwrap();
+        // Trigger a failure in var-log
+        root.create_dir_all("var/log/dnf")?;
+        root.write("var/log/dnf/dnf.log", b"dummy dnf log")?;
+        assert_eq!(r.passed, allbut_one.checked_sub(1).unwrap());
+        assert_eq!(r.fatal, 0);
+        assert_eq!(r.skipped, 2);
+        assert_eq!(r.warnings, 0);
+
+        // But verify that not skipping it results in an error
         let mut out = Vec::new();
-        let r = lint_inner(root, root_type, &mut out).unwrap();
+        let r = lint_inner(root, root_type, [], &mut out).unwrap();
         assert_eq!(r.passed, allbut_one.checked_sub(1).unwrap());
-        assert_eq!(r.fatal, 1);
+        assert_eq!(r.fatal, 0);
         assert_eq!(r.skipped, 1);
-        assert_eq!(r.warnings, 0);
+        assert_eq!(r.warnings, 1);
         Ok(())
     }