nexus-types: add SupportBundleRequest type and Case field

Add SupportBundleRequest to fm::case with data_selection support. Add
support_bundles_requested field to Case and iterator to Sitrep. Add
Serialize/Deserialize derives to support_bundle types (needed because
Case derives Serialize). Add BundleDataSelection::iter() for per-variant
decomposition.

Author: mergeconflict

nexus/db-model/src/fm/case.rs

@@ -58,6 +58,7 @@ impl CaseMetadata {
             de,
             comment,
             alerts_requested: _,
+            support_bundles_requested: _,
             ereports: _,
         } = case;
         Self {

nexus/db-queries/src/db/datastore/fm.rs

@@ -385,6 +385,7 @@ impl DataStore {
                         comment,
                         ereports,
                         alerts_requested,
+                        support_bundles_requested: iddqd::IdOrdMap::new(),
                     }
                 }));
             }

nexus/types/src/fm.rs

@@ -81,6 +81,17 @@ impl Sitrep {
             case.alerts_requested.iter().map(move |alert| (case_id, alert))
         })
     }
+
+    /// Iterate over all support bundles requested by cases in this sitrep.
+    pub fn support_bundles_requested(
+        &self,
+    ) -> impl Iterator<Item = (CaseUuid, &'_ case::SupportBundleRequest)> + '_
+    {
+        self.cases.iter().flat_map(|case| {
+            let case_id = case.id;
+            case.support_bundles_requested.iter().map(move |req| (case_id, req))
+        })
+    }
 }
 
 /// Metadata describing a sitrep.

nexus/types/src/fm/case.rs

@@ -5,8 +5,11 @@
 use crate::alert::AlertClass;
 use crate::fm::DiagnosisEngineKind;
 use crate::fm::Ereport;
+use crate::support_bundle::BundleDataSelection;
 use iddqd::{IdOrdItem, IdOrdMap};
-use omicron_uuid_kinds::{AlertUuid, CaseEreportUuid, CaseUuid, SitrepUuid};
+use omicron_uuid_kinds::{
+    AlertUuid, CaseEreportUuid, CaseUuid, SitrepUuid, SupportBundleUuid,
+};
 use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::sync::Arc;
@@ -21,6 +24,7 @@ pub struct Case {
 
     pub ereports: IdOrdMap<CaseEreport>,
     pub alerts_requested: IdOrdMap<AlertRequest>,
+    pub support_bundles_requested: IdOrdMap<SupportBundleRequest>,
 
     pub comment: String,
 }
@@ -88,6 +92,23 @@ impl iddqd::IdOrdItem for AlertRequest {
     iddqd::id_upcast!();
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+pub struct SupportBundleRequest {
+    pub id: SupportBundleUuid,
+    pub requested_sitrep_id: SitrepUuid,
+    pub reason: String,
+    pub data_selection: Option<BundleDataSelection>,
+}
+
+impl iddqd::IdOrdItem for SupportBundleRequest {
+    type Key<'a> = &'a SupportBundleUuid;
+    fn key(&self) -> Self::Key<'_> {
+        &self.id
+    }
+
+    iddqd::id_upcast!();
+}
+
 struct DisplayCase<'a> {
     case: &'a Case,
     indent: usize,
@@ -120,6 +141,7 @@ impl fmt::Display for DisplayCase<'_> {
                     ereports,
                     comment,
                     alerts_requested,
+                    support_bundles_requested,
                 },
             indent,
             sitrep_id,
@@ -234,6 +256,34 @@ impl fmt::Display for DisplayCase<'_> {
             }
         }
 
+        if !support_bundles_requested.is_empty() {
+            writeln!(f, "\n{:>indent$}support bundles requested:", "")?;
+            writeln!(f, "{:>indent$}-------------------------", "")?;
+
+            let indent = indent + 2;
+            for SupportBundleRequest {
+                id,
+                requested_sitrep_id,
+                reason,
+                data_selection: _,
+            } in support_bundles_requested.iter()
+            {
+                const REASON: &str = "reason:";
+                const REQUESTED_IN: &str = "requested in:";
+
+                const WIDTH: usize = const_max_len(&[REASON, REQUESTED_IN]);
+
+                writeln!(f, "{BULLET:>indent$}bundle {id}",)?;
+                writeln!(f, "{:>indent$}{REASON:<WIDTH$} {reason}", "",)?;
+                writeln!(
+                    f,
+                    "{:>indent$}{REQUESTED_IN:<WIDTH$} {requested_sitrep_id}{}\n",
+                    "",
+                    this_sitrep(*requested_sitrep_id)
+                )?;
+            }
+        }
+
         writeln!(f)?;
 
         Ok(())
@@ -357,6 +407,7 @@ mod tests {
             de: DiagnosisEngineKind::PowerShelf,
             ereports,
             alerts_requested,
+            support_bundles_requested: IdOrdMap::new(),
             comment: "Power shelf rectifier added and removed here :-)"
                 .to_string(),
         };

nexus/types/src/support_bundle.rs

@@ -10,11 +10,12 @@
 use chrono::{DateTime, Utc};
 use omicron_common::api::external::Error;
 use omicron_uuid_kinds::SledUuid;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::collections::HashSet;
 
 /// A set of filters for fetching ereports.
-#[derive(Clone, Debug, Default, Eq, PartialEq)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
 pub struct EreportFilters {
     /// If present, include only ereports that were collected at the specified
     /// timestamp or later.
@@ -52,7 +53,7 @@ impl EreportFilters {
 }
 
 /// Describes the category of support bundle data.
-#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq, Serialize, Deserialize)]
 pub enum BundleDataCategory {
     /// Collects reconfigurator state (some of the latest blueprints,
     /// information about the target blueprint).
@@ -74,7 +75,7 @@ pub enum BundleDataCategory {
 /// For categories without additional parameters, the variant is a unit variant.
 /// For categories that can be filtered or configured, the variant contains
 /// that configuration data.
-#[derive(Debug, Clone, Eq, PartialEq)]
+#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
 pub enum BundleData {
     Reconfigurator,
     HostInfo(HashSet<SledSelection>),
@@ -100,7 +101,7 @@ impl BundleData {
 /// This wrapper ensures that categories and data always match - you can't
 /// insert (BundleDataCategory::Reconfigurator, BundleData::SpDumps)
 /// because each BundleData determines its own category.
-#[derive(Debug, Clone, Eq, PartialEq)]
+#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
 pub struct BundleDataSelection {
     data: HashMap<BundleDataCategory, BundleData>,
 }
@@ -131,6 +132,11 @@ impl BundleDataSelection {
     pub fn get(&self, category: BundleDataCategory) -> Option<&BundleData> {
         self.data.get(&category)
     }
+
+    /// Iterate over all data entries in this selection.
+    pub fn iter(&self) -> impl Iterator<Item = &BundleData> {
+        self.data.values()
+    }
 }
 
 impl FromIterator<BundleData> for BundleDataSelection {
@@ -167,7 +173,7 @@ impl Default for BundleDataSelection {
 ///
 /// Multiple values of this enum are joined together into a HashSet.
 /// Therefore "SledSelection::All" overrides specific sleds.
-#[derive(Debug, Clone, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
 pub enum SledSelection {
     All,
     Specific(SledUuid),