start throwing together some kind of DE stuff

Author: hawkw

Cargo.lock

@@ -249,7 +249,7 @@ async fn cmd_db_sitrep_show(
         }
     };
 
-    let fm::Sitrep { metadata } = sitrep;
+    let fm::Sitrep { metadata, cases, alerts_requested } = sitrep;
     let fm::SitrepMetadata {
         id,
         creator_id,

dev-tools/omdb/src/bin/omdb/db/sitrep.rs

@@ -102,7 +102,9 @@ impl TryFrom<i64> for Ena {
 }
 
 /// Unique identifier for an ereport.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord,
+)]
 pub struct EreportId {
     pub restart_id: EreporterRestartUuid,
     pub ena: Ena,

ereport/types/src/lib.rs

@@ -143,7 +143,12 @@ impl DataStore {
         // TODO(eliza): this is where we would read all the other sitrep data,
         // if there was any.
 
-        Ok(Sitrep { metadata })
+        Ok(Sitrep {
+            metadata,
+            // TODO(eliza) read these
+            alerts_requested: Default::default(),
+            cases: Default::default(),
+        })
     }
 
     /// Insert the provided [`Sitrep`] into the database, and attempt to mark it

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

@@ -7,8 +7,11 @@ edition = "2021"
 workspace = true
 
 [dependencies]
-nexus-types.workspace = true
+anyhow.workspace = true
 chrono.workspace = true
+iddqd.workspace = true
+nexus-types.workspace = true
 omicron-uuid-kinds.workspace = true
+slog.workspace = true
 
 omicron-workspace-hack.workspace = true

nexus/fm/Cargo.toml

@@ -0,0 +1,7 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+//! Diagnosis engines
+
+pub mod power_shelf;

nexus/fm/src/de.rs

@@ -0,0 +1,10 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+//! Power shelf diagnosis
+use crate::SitrepBuilder;
+
+pub fn diagnose(sitrep: &mut SitrepBuilder<'_>) -> anyhow::Result<()> {
+    Ok(())
+}

nexus/fm/src/de/power_shelf.rs

@@ -6,37 +6,116 @@
 
 use nexus_types::fm;
 use nexus_types::inventory;
+use omicron_uuid_kinds::CaseUuid;
 use omicron_uuid_kinds::OmicronZoneUuid;
 use omicron_uuid_kinds::SitrepUuid;
+use slog::Logger;
+use std::fmt::Write;
+
+pub mod de;
 
 #[derive(Debug)]
 pub struct SitrepBuilder<'a> {
-    inventory: &'a inventory::Collection,
-    parent_sitrep: Option<&'a fm::Sitrep>,
+    pub log: Logger,
+    pub inventory: &'a inventory::Collection,
+    pub parent_sitrep: Option<&'a fm::Sitrep>,
+    pub sitrep_id: SitrepUuid,
+    pub cases: iddqd::IdOrdMap<fm::Case>,
     comment: String,
 }
 
 impl<'a> SitrepBuilder<'a> {
     pub fn new(
+        log: &Logger,
         inventory: &'a inventory::Collection,
         parent_sitrep: Option<&'a fm::Sitrep>,
     ) -> Self {
-        SitrepBuilder { inventory, parent_sitrep, comment: String::new() }
+        let sitrep_id = SitrepUuid::new_v4();
+        let log = log.new(slog::o!(
+            "sitrep_id" => format!("{sitrep_id:?}"),
+            "parent_sitrep_id" => format!("{:?}", parent_sitrep.as_ref().map(|s| s.id())),
+            "inv_collection_id" => format!("{:?}", inventory.id),
+        ));
+        SitrepBuilder {
+            log,
+            sitrep_id,
+            inventory,
+            parent_sitrep,
+            comment: String::new(),
+            cases: Default::default(),
+        }
+    }
+
+    pub fn open_case(&mut self, case: fm::Case) -> anyhow::Result<CaseUuid> {
+        let case_id = case.id;
+        if self.cases.contains_key(&case_id) {
+            anyhow::bail!("case with ID {case_id:?} already exists");
+        }
+
+        slog::info!(
+            self.log,
+            "opened case {case_id:?}";
+            "case_id" => ?case_id,
+            "de" => %case.de
+        );
+
+        writeln!(&mut self.comment, "* de {} opened case {case_id:?}", case.de)
+            .unwrap();
+
+        self.cases
+            .insert_unique(case)
+            .expect("we just checked that it doesn't exist");
+        Ok(case_id)
+    }
+
+    pub fn request_alert(
+        &mut self,
+        case_id: CaseUuid,
+        req: fm::AlertRequest,
+    ) -> anyhow::Result<()> {
+        let mut case = self.cases
+            .get_mut(&case_id)
+            .ok_or_else(|| anyhow::anyhow!(
+                "cannot create an alert request for non-existent case ID {case_id:?}",
+            ))?;
+        let alert_id = req.id;
+        let alert_class = req.class;
+
+        case.alerts_requested.insert_unique(req).map_err(|_| {
+            anyhow::anyhow!("an alert with ID {alert_id:?} already exists")
+        })?;
+
+        writeln!(
+            &mut self.comment,
+            "* de {} requested {alert_class:?} alert {alert_id:?} for case \
+             {case_id:?}",
+            case.de
+        )
+        .unwrap();
+
+        slog::info!(
+            self.log,
+            "requested an alert for case {case_id:?}";
+            "case_id" => ?case_id,
+            "de" => %case.de,
+            "alert_id" => ?alert_id,
+            "alert_class" => ?alert_class,
+        );
+
+        Ok(())
     }
-    
-    
 
     pub fn build(self, creator_id: OmicronZoneUuid) -> fm::Sitrep {
         fm::Sitrep {
             metadata: fm::SitrepMetadata {
-                id: SitrepUuid::new_v4(),
+                id: self.sitrep_id,
                 parent_sitrep_id: self.parent_sitrep.map(|s| s.metadata.id),
                 inv_collection_id: self.inventory.id,
                 creator_id,
                 comment: self.comment,
                 time_created: chrono::Utc::now(),
             },
-            // TODO(eliza): draw the rest of the owl...
+            cases: self.cases,
         }
     }
 }

nexus/fm/src/lib.rs

@@ -8,13 +8,19 @@
 //! structure containing fault management state.
 
 use chrono::{DateTime, Utc};
-use omicron_uuid_kinds::{CollectionUuid, OmicronZoneUuid, SitrepUuid};
-use schemars::JsonSchema;
+use iddqd::{IdOrdItem, IdOrdMap};
+use omicron_uuid_kinds::{
+    CaseUuid, CollectionUuid, OmicronZoneUuid, SitrepUuid,
+};
 use serde::{Deserialize, Serialize};
+use std::collections::BTreeSet;
 
-pub use ereport::Ereport;
+pub use ereport::{Ereport, EreportId};
 pub mod ereport;
 
+mod alert;
+pub use alert::*;
+
 /// A fault management situation report, or _sitrep_.
 ///
 /// The sitrep is a data structure that represents a snapshot of the state of
@@ -30,12 +36,12 @@ pub mod ereport;
 /// The sitrep, how it is represented in the database, and how the fault
 /// management subsystem creates and interacts with sitreps, is described in
 /// detail in [RFD 603](https://rfd.shared.oxide.computer/rfd/0603).
-#[derive(Clone, Debug, Eq, PartialEq, JsonSchema, Deserialize, Serialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
 pub struct Sitrep {
     /// Metadata describing this sitrep, when it was created, its parent sitrep
     /// ID, and which Nexus produced it.
     pub metadata: SitrepMetadata,
-    // TODO(eliza): draw the rest of the sitrep
+    pub cases: IdOrdMap<Case>,
 }
 
 impl Sitrep {
@@ -46,12 +52,22 @@ impl Sitrep {
     pub fn parent_id(&self) -> Option<SitrepUuid> {
         self.metadata.parent_sitrep_id
     }
+
+    /// Iterate over all alerts requested by cases in this sitrep.
+    pub fn alerts_requested(
+        &self,
+    ) -> impl Iterator<Item = (CaseUuid, &'_ AlertRequest)> + '_ {
+        self.cases.iter().flat_map(|case| {
+            let case_id = case.id;
+            case.alerts_requested.iter().map(move |alert| (case_id, alert))
+        })
+    }
 }
 
 /// Metadata describing a sitrep.
 ///
 /// This corresponds to the records stored in the `fm_sitrep` database table.
-#[derive(Clone, Debug, Eq, PartialEq, JsonSchema, Deserialize, Serialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
 pub struct SitrepMetadata {
     /// The ID of this sitrep.
     pub id: SitrepUuid,
@@ -91,9 +107,28 @@ pub struct SitrepMetadata {
 }
 
 /// An entry in the sitrep version history.
-#[derive(Clone, Debug, Eq, PartialEq, JsonSchema, Deserialize, Serialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
 pub struct SitrepVersion {
     pub id: SitrepUuid,
     pub version: u32,
     pub time_made_current: DateTime<Utc>,
 }
+
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
+pub struct Case {
+    pub id: CaseUuid,
+    pub created_sitrep_id: SitrepUuid,
+    pub de: String,
+    pub ereports: BTreeSet<EreportId>,
+    // TODO(eliza) what else?
+    pub alerts_requested: IdOrdMap<AlertRequest>, // TODO(eliza): draw the rest of the sitrep
+}
+
+impl IdOrdItem for Case {
+    type Key<'a> = &'a CaseUuid;
+    fn key(&self) -> Self::Key<'_> {
+        &self.id
+    }
+
+    iddqd::id_upcast!();
+}

nexus/types/src/fm.rs

@@ -0,0 +1,29 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use omicron_uuid_kinds::AlertUuid;
+use omicron_uuid_kinds::SitrepUuid;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+pub struct AlertRequest {
+    pub id: AlertUuid,
+    pub class: AlertClass,
+    pub payload: serde_json::Value,
+    pub requested_sitrep_id: SitrepUuid,
+}
+
+impl iddqd::IdOrdItem for AlertRequest {
+    type Key<'a> = &'a AlertUuid;
+    fn key(&self) -> Self::Key<'_> {
+        &self.id
+    }
+
+    iddqd::id_upcast!();
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+pub enum AlertClass {
+    // TODO
+}