reticulating

Author: hawkw

nexus/fm/src/de/power_shelf.rs

@@ -11,20 +11,42 @@ use crate::alert;
 use crate::ereport_analysis;
 use nexus_types::fm::DiagnosisEngineKind;
 use nexus_types::fm::Ereport;
+use nexus_types::fm::case::CaseEreport;
+use nexus_types::fm::case::ImpactedSpSlot;
 use nexus_types::fm::ereport;
 use nexus_types::inventory::SpType;
+use omicron_uuid_kinds::CaseUuid;
 use serde::de::DeserializeOwned;
 use serde_json::Value;
+use std::collections::HashMap;
 use std::sync::Arc;
 
 pub struct PowerShelfDiagnosis {
     log: slog::Logger,
-    // TODO(eliza): does this need/want any internal state?
+    cases_by_shelf: [HashMap<CaseUuid, PscCase>; 2],
 }
 
+#[derive(Default)]
+struct PscCase {
+    psus_impacted: PsuSet,
+}
+
+type PsuSet = [bool; N_PSUS];
+const N_PSUS: usize = 6;
+
+const KNOWN_EREPORT_CLASSES: &[&str] = &[
+    "hw.remove.psu",
+    "hw.insert.psu",
+    "hw.pwr.pwr_good.good",
+    "hw.pwr.pwr_good.bad",
+];
+
 impl PowerShelfDiagnosis {
     pub fn new(log: &slog::Logger) -> Self {
-        Self { log: log.new(slog::o!("de" => "power_shelf")) }
+        Self {
+            log: log.new(slog::o!("de" => "power_shelf")),
+            cases_by_shelf: [HashMap::new(), HashMap::new()],
+        }
     }
 }
 
@@ -38,7 +60,126 @@ impl DiagnosisEngine for PowerShelfDiagnosis {
         sitrep: &mut SitrepBuilder<'_>,
         case: &mut CaseBuilder,
     ) -> anyhow::Result<()> {
-        todo!()
+        slog::debug!(
+            self.log,
+            "analyzing open case from parent sitrep...";
+            "case_id" => %case.id
+        );
+
+        // ooh, a case we alerady opened! let's figure out what its deal is...
+        for &ImpactedSpSlot { sp_type, slot, ref comment, .. } in
+            &case.impacted_sp_slots
+        {
+            // skip non-PSC impacts
+            if sp_type != SpType::Power {
+                continue;
+            }
+
+            if matches!(slot, 0 | 1) {
+                slog::debug!(
+                    &self.log,
+                    "open case impacts power shelf {slot}";
+                    "case_id" => %case.id,
+                    "power_shelf" => slot,
+                    "comment" => %comment,
+                );
+                // make sure it's tracked.
+                self.cases_by_shelf[slot as usize].entry(case.id).or_default();
+            } else {
+                slog::warn!(
+                    &self.log,
+                    "this is weird: I only know about power shelves numbered \
+                     1 and 0, but found a case that claims to impact power \
+                     shelf {slot}";
+                    "case_id" => %case.id,
+                    "power_shelf" => slot,
+                    "comment" => %comment,
+                );
+            }
+        }
+
+        for CaseEreport { ereport, comment, assigned_sitrep_id } in
+            &case.ereports
+        {
+            let class = match &ereport.class {
+                // This is one we care about
+                Some(ref class)
+                    if KNOWN_EREPORT_CLASSES.contains(&class.as_ref()) =>
+                {
+                    slog::debug!(
+                        self.log,
+                        "analyzing ereport assigned to open case...";
+                        "case_id" => %case.id,
+                        "ereport_id" => %ereport.id,
+                        "ereport_class" => %class,
+                        "comment" => %comment,
+                        "assigned_sitrep_id" => %assigned_sitrep_id,
+                    );
+                    class
+                }
+                class => {
+                    slog::debug!(
+                        &self.log,
+                        "an ereport with an unknown or missing class was \
+                         assigned to this case (presumably by another DE); \
+                         skipping it...";
+                        "case_id" => %case.id,
+                        "ereport_id" => %ereport.id,
+                        "ereport_class" => ?class,
+                        "comment" => %comment,
+                    );
+                    continue;
+                }
+            };
+
+            let ereport::Reporter::Sp { sp_type: SpType::Power, slot: shelf } =
+                ereport.reporter
+            else {
+                slog::debug!(
+                    self.log,
+                    "skipping ereport that was not reported by a power shelf";
+                    "case_id" => %case.id,
+                    "ereport_id" => %ereport.id,
+                    "ereport_class" => %class,
+                    "ereport_id" => %ereport.id,
+                    "reporter" => %ereport.reporter,
+                );
+                continue;
+            };
+
+            let tracked_case =
+                self.cases_by_shelf[shelf as usize].entry(case.id).or_default();
+
+            // Does the ereport include a PSU slot?
+            if let Some(slot) = ereport.report["slot"].as_u64() {
+                let slot = slot as usize;
+                if slot >= N_PSUS {
+                    slog::warn!(
+                        &self.log,
+                        "this is weird: I only know about power shelves with \
+                         {N_PSUS} PSU SLOTS, but this ereport claims to \
+                         involve slot {slot}";
+                        "case_id" => %case.id,
+                        "ereport_id" => %ereport.id,
+                        "ereport_class" => %class,
+                        "slot" => slot,
+                    )
+                } else {
+                    slog::debug!(
+                        &self.log,
+                        "found an ereport associated with PSU slot {slot}";
+                        "case_id" => %case.id,
+                        "ereport_id" => %ereport.id,
+                        "ereport_class" => %class,
+                        "shelf" => shelf,
+                        "slot" => slot,
+                    );
+                    tracked_case.psus_impacted[slot] = true;
+                }
+            }
+        }
+
+        Ok(())
     }
 
     fn analyze_ereport(
@@ -204,6 +345,9 @@ fn grab_json_value<T: DeserializeOwned>(
 struct PscEreport {
     #[serde(flatten)]
     metadata: ereport_analysis::HubrisMetadata,
+
+    #[serde(flatten)]
+    psu: PsuId,
     #[serde(flatten)]
     class: EreportClass,
 }
@@ -212,37 +356,21 @@ struct PscEreport {
 #[serde(tag = "k")]
 enum EreportClass {
     #[serde(rename = "hw.insert.psu")]
-    PsuInserted {
-        #[serde(flatten)]
-        ereport: PsuInsertedEreport,
-    },
+    PsuInserted,
     #[serde(rename = "hw.remove.psu")]
-    PsuRemoved {
-        #[serde(flatten)]
-        ereport: PsuInsertedEreport,
-    },
+    PsuRemoved,
     #[serde(rename = "hw.pwr.pwr_good.bad")]
-    PwrBad {
-        #[serde(flatten)]
-        ereport: PwrGoodEreport,
-    },
-}
-
-#[derive(Debug, Eq, PartialEq, serde::Deserialize)]
-struct PsuInsertedEreport {
-    refdes: String,
-    rail: String,
-    slot: u8,
-    fruid: PsuFruid,
+    PwrBad { pmbus_status: PmbusStatus },
+    #[serde(rename = "hw.pwr.pwr_good.good")]
+    PwrGood { pmbus_status: PmbusStatus },
 }
 
 #[derive(Debug, Eq, PartialEq, serde::Deserialize)]
-struct PwrGoodEreport {
+struct PsuId {
     refdes: String,
     rail: String,
     slot: u8,
     fruid: PsuFruid,
-    pmbus_status: PmbusStatus,
 }
 
 // These are the same field names that Hubris uses in the ereport. See: