refactor(markdown): extract components and make them display

Author: tembleking

src/app/markdown/markdown_data.rs

@@ -0,0 +1,46 @@
+use std::fmt::{Display, Formatter};
+
+use crate::domain::scanresult::scan_result::ScanResult;
+
+use super::{
+    markdown_fixable_package_table::FixablePackageTable,
+    markdown_policy_evaluated_table::PolicyEvaluatedTable, markdown_summary::MarkdownSummary,
+    markdown_vulnerability_evaluated_table::VulnerabilityEvaluatedTable,
+};
+
+#[derive(Clone, Debug, Default)]
+pub struct MarkdownData {
+    pub summary: MarkdownSummary,
+    pub fixable_packages: FixablePackageTable,
+    pub policies: PolicyEvaluatedTable,
+    pub vulnerabilities: VulnerabilityEvaluatedTable,
+}
+
+impl From<ScanResult> for MarkdownData {
+    fn from(value: ScanResult) -> Self {
+        Self {
+            summary: MarkdownSummary::from(&value),
+            fixable_packages: FixablePackageTable::from(&value),
+            policies: PolicyEvaluatedTable::from(&value),
+            vulnerabilities: VulnerabilityEvaluatedTable::from(&value),
+        }
+    }
+}
+
+impl Display for MarkdownData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let summary_section = self.summary.to_string();
+        let fixable_packages_section = self.fixable_packages.to_string();
+        let policy_evaluation_section = self.policies.to_string();
+        let vulnerability_detail_section = self.vulnerabilities.to_string();
+
+        write!(
+            f,
+            "## Sysdig Scan Result\n{}\n{}\n{}\n{}",
+            summary_section,
+            fixable_packages_section,
+            policy_evaluation_section,
+            vulnerability_detail_section
+        )
+    }
+}

src/app/markdown/markdown_fixable_package_table.rs

@@ -0,0 +1,142 @@
+use std::fmt::{Display, Formatter};
+
+use markdown_table::{Heading, HeadingAlignment, MarkdownTable};
+
+use crate::domain::scanresult::{scan_result::ScanResult, severity::Severity};
+
+#[derive(Clone, Debug, Default)]
+pub struct FixablePackage {
+    pub name: String,
+    pub package_type: String,
+    pub version: String,
+    pub suggested_fix: Option<String>,
+    pub vulnerabilities: FixablePackageVulnerabilities,
+    pub exploits: u32,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct FixablePackageVulnerabilities {
+    pub critical: u32,
+    pub high: u32,
+    pub medium: u32,
+    pub low: u32,
+    pub negligible: u32,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct FixablePackageTable(pub Vec<FixablePackage>);
+
+impl From<&ScanResult> for FixablePackageTable {
+    fn from(value: &ScanResult) -> Self {
+        FixablePackageTable(
+            value
+                .packages()
+                .into_iter()
+                .filter(|p| p.vulnerabilities().iter().any(|v| v.fixable()))
+                .map(|p| {
+                    let mut vulns = FixablePackageVulnerabilities::default();
+                    let mut exploits = 0;
+                    for v in p.vulnerabilities() {
+                        if v.exploitable() {
+                            exploits += 1;
+                        }
+                        match v.severity() {
+                            Severity::Critical => vulns.critical += 1,
+                            Severity::High => vulns.high += 1,
+                            Severity::Medium => vulns.medium += 1,
+                            Severity::Low => vulns.low += 1,
+                            Severity::Negligible => vulns.negligible += 1,
+                            Severity::Unknown => {}
+                        }
+                    }
+
+                    FixablePackage {
+                        name: p.name().to_string(),
+                        package_type: p.package_type().to_string(),
+                        version: p.version().to_string(),
+                        suggested_fix: p
+                            .vulnerabilities()
+                            .iter()
+                            .find_map(|v| v.fix_version().map(|s| s.to_string())),
+                        vulnerabilities: vulns,
+                        exploits,
+                    }
+                })
+                .collect(),
+        )
+    }
+}
+
+impl Display for FixablePackageTable {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        if self.0.is_empty() {
+            return f.write_str("");
+        }
+
+        let headers = vec![
+            Heading::new("PACKAGE".to_string(), Some(HeadingAlignment::Left)),
+            Heading::new("TYPE".to_string(), Some(HeadingAlignment::Center)),
+            Heading::new("VERSION".to_string(), Some(HeadingAlignment::Left)),
+            Heading::new("SUGGESTED FIX".to_string(), Some(HeadingAlignment::Left)),
+            Heading::new("CRITICAL".to_string(), Some(HeadingAlignment::Center)),
+            Heading::new("HIGH".to_string(), Some(HeadingAlignment::Center)),
+            Heading::new("MEDIUM".to_string(), Some(HeadingAlignment::Center)),
+            Heading::new("LOW".to_string(), Some(HeadingAlignment::Center)),
+            Heading::new("NEGLIGIBLE".to_string(), Some(HeadingAlignment::Center)),
+            Heading::new("EXPLOIT".to_string(), Some(HeadingAlignment::Center)),
+        ];
+
+        let data = self
+            .0
+            .iter()
+            .map(|p| {
+                vec![
+                    p.name.clone(),
+                    p.package_type.clone(),
+                    p.version.clone(),
+                    p.suggested_fix.clone().unwrap_or_default(),
+                    if p.vulnerabilities.critical > 0 {
+                        p.vulnerabilities.critical.to_string()
+                    } else {
+                        "-".to_string()
+                    },
+                    if p.vulnerabilities.high > 0 {
+                        p.vulnerabilities.high.to_string()
+                    } else {
+                        "-".to_string()
+                    },
+                    if p.vulnerabilities.medium > 0 {
+                        p.vulnerabilities.medium.to_string()
+                    } else {
+                        "-".to_string()
+                    },
+                    if p.vulnerabilities.low > 0 {
+                        p.vulnerabilities.low.to_string()
+                    } else {
+                        "-".to_string()
+                    },
+                    if p.vulnerabilities.negligible > 0 {
+                        p.vulnerabilities.negligible.to_string()
+                    } else {
+                        "-".to_string()
+                    },
+                    if p.exploits > 0 {
+                        p.exploits.to_string()
+                    } else {
+                        "-".to_string()
+                    },
+                ]
+            })
+            .collect();
+
+        let mut table = MarkdownTable::new(data);
+        table.with_headings(headers);
+
+        let format = format!(
+            "\n### Fixable Packages\n{}",
+            table.as_markdown().unwrap_or_default()
+        );
+
+        f.write_str(&format)
+    }
+}

src/app/markdown/markdown_policy_evaluated_table.rs

@@ -0,0 +1,74 @@
+use std::fmt::{Display, Formatter};
+
+use itertools::Itertools;
+use markdown_table::{Heading, HeadingAlignment, MarkdownTable};
+
+use crate::domain::scanresult::scan_result::ScanResult;
+
+#[derive(Clone, Debug, Default)]
+pub struct PolicyEvaluated {
+    pub name: String,
+    pub passed: bool,
+    pub failures: u32,
+    pub risks_accepted: u32,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct PolicyEvaluatedTable(pub Vec<PolicyEvaluated>);
+
+impl Display for PolicyEvaluatedTable {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        if self.0.is_empty() {
+            return f.write_str("");
+        }
+
+        let headers = vec![
+            Heading::new("POLICY".to_string(), Some(HeadingAlignment::Left)),
+            Heading::new("STATUS".to_string(), Some(HeadingAlignment::Center)),
+            Heading::new("FAILURES".to_string(), Some(HeadingAlignment::Center)),
+            Heading::new("RISKS ACCEPTED".to_string(), Some(HeadingAlignment::Center)),
+        ];
+
+        let data = self
+            .0
+            .iter()
+            .map(|p| {
+                vec![
+                    p.name.clone(),
+                    if p.passed { "✅" } else { "❌" }.to_string(),
+                    p.failures.to_string(),
+                    p.risks_accepted.to_string(),
+                ]
+            })
+            .collect();
+
+        let mut table = MarkdownTable::new(data);
+        table.with_headings(headers);
+
+        let format = format!(
+            "\n### Policy Evaluation\n\n{}",
+            table.as_markdown().unwrap_or_default()
+        );
+
+        f.write_str(&format)
+    }
+}
+
+impl From<&ScanResult> for PolicyEvaluatedTable {
+    fn from(value: &ScanResult) -> Self {
+        PolicyEvaluatedTable(
+            value
+                .policies()
+                .iter()
+                .map(|p| PolicyEvaluated {
+                    name: p.name().to_string(),
+                    passed: p.evaluation_result().is_passed(),
+                    failures: p.bundles().iter().map(|b| b.rules().len()).sum::<usize>() as u32,
+                    risks_accepted: 0, // FIXME(fede): Cannot determine this from the current data model
+                })
+                .sorted_by(|a, b| b.failures.cmp(&a.failures))
+                .sorted_by_key(|p| p.passed)
+                .collect(),
+        )
+    }
+}

src/app/markdown/markdown_summary.rs

@@ -0,0 +1,37 @@
+use std::fmt::{Display, Formatter};
+
+use crate::domain::scanresult::scan_result::ScanResult;
+
+use super::markdown_summary_table::MarkdownSummaryTable;
+
+#[derive(Clone, Debug, Default)]
+pub struct MarkdownSummary {
+    pub pull_string: String,
+    pub image_id: String,
+    pub digest: String,
+    pub base_os: String,
+    pub total_vulns_found: MarkdownSummaryTable,
+}
+
+impl From<&ScanResult> for MarkdownSummary {
+    fn from(value: &ScanResult) -> Self {
+        MarkdownSummary {
+            pull_string: value.metadata().pull_string().to_string(),
+            image_id: value.metadata().image_id().to_string(),
+            digest: value.metadata().digest().unwrap_or("").to_string(),
+            base_os: value.metadata().base_os().name().to_string(),
+            total_vulns_found: MarkdownSummaryTable::from(value),
+        }
+    }
+}
+
+impl Display for MarkdownSummary {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let format = format!(
+            "### Summary\n* **PullString**: {}\n* **ImageID**: `{}`\n* **Digest**: `{}`\n* **BaseOS**: {}\n\n{}",
+            &self.pull_string, &self.image_id, &self.digest, &self.base_os, &self.total_vulns_found
+        );
+
+        f.write_str(&format)
+    }
+}