consistent test rng thingy

Author: hawkw

Cargo.lock

@@ -12,10 +12,12 @@ chrono.workspace = true
 iddqd.workspace = true
 nexus-types.workspace = true
 omicron-uuid-kinds.workspace = true
+rand.workspace = true
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 slog.workspace = true
+typed-rng.workspace = true
 
 omicron-workspace-hack.workspace = true
 

nexus/fm/Cargo.toml

@@ -12,6 +12,8 @@ use slog::Logger;
 
 mod case;
 pub use case::{AllCases, CaseBuilder};
+pub(crate) mod rng;
+pub use rng::SitrepBuilderRng;
 
 #[derive(Debug)]
 pub struct SitrepBuilder<'a> {
@@ -30,15 +32,29 @@ impl<'a> SitrepBuilder<'a> {
         inventory: &'a inventory::Collection,
         parent_sitrep: Option<&'a fm::Sitrep>,
     ) -> Self {
-        let sitrep_id = SitrepUuid::new_v4();
+        Self::new_with_rng(
+            log,
+            inventory,
+            parent_sitrep,
+            SitrepBuilderRng::from_entropy(),
+        )
+    }
+
+    pub fn new_with_rng(
+        log: &Logger,
+        inventory: &'a inventory::Collection,
+        parent_sitrep: Option<&'a fm::Sitrep>,
+        mut rng: SitrepBuilderRng,
+    ) -> Self {
+        let sitrep_id = rng.sitrep_id();
         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),
         ));
 
         let (cases, impact_lists) =
-            case::AllCases::new(log.clone(), sitrep_id, parent_sitrep);
+            case::AllCases::new(log.clone(), sitrep_id, parent_sitrep, rng);
 
         slog::info!(
             &log,

nexus/fm/src/builder.rs

@@ -2,13 +2,13 @@
 // 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 super::rng;
 use crate::alert;
 use anyhow::Context;
 use chrono::Utc;
 use iddqd::id_ord_map::{self, IdOrdMap};
 use nexus_types::fm;
 use nexus_types::inventory::SpType;
-use omicron_uuid_kinds::AlertUuid;
 use omicron_uuid_kinds::CaseUuid;
 use omicron_uuid_kinds::SitrepUuid;
 use std::collections::{HashMap, HashSet};
@@ -19,20 +19,23 @@ pub struct CaseBuilder {
     pub log: slog::Logger,
     pub case: fm::Case,
     pub sitrep_id: SitrepUuid,
+    rng: rng::CaseBuilderRng,
 }
 
 #[derive(Debug)]
 pub struct AllCases {
     log: slog::Logger,
     sitrep_id: SitrepUuid,
     pub cases: IdOrdMap<CaseBuilder>,
+    rng: rng::SitrepBuilderRng,
 }
 
 impl AllCases {
-    pub fn new(
+    pub(super) fn new(
         log: slog::Logger,
         sitrep_id: SitrepUuid,
         parent_sitrep: Option<&fm::Sitrep>,
+        mut rng: rng::SitrepBuilderRng,
     ) -> (Self, ImpactLists) {
         // Copy forward any open cases from the parent sitrep.
         // If a case was closed in the parent sitrep, skip it.
@@ -48,11 +51,12 @@ impl AllCases {
                         .or_default()
                         .insert(case.id);
                 }
-                CaseBuilder::new(&log, sitrep_id, case.clone())
+                let rng = rng::CaseBuilderRng::new(case.id, &mut rng);
+                CaseBuilder::new(&log, sitrep_id, case.clone(), rng)
             })
             .collect();
 
-        let cases = Self { log, sitrep_id, cases };
+        let cases = Self { log, sitrep_id, cases, rng };
         let impact_lists = ImpactLists { cases_by_sp: cases_by_location };
         (cases, impact_lists)
     }
@@ -61,7 +65,7 @@ impl AllCases {
         &mut self,
         de: fm::DiagnosisEngineKind,
     ) -> anyhow::Result<iddqd::id_ord_map::RefMut<'_, CaseBuilder>> {
-        let id = CaseUuid::new_v4();
+        let (id, case_rng) = self.rng.next_case();
         let sitrep_id = self.sitrep_id;
         let case = match self.cases.entry(&id) {
             iddqd::id_ord_map::Entry::Occupied(_) => {
@@ -80,7 +84,9 @@ impl AllCases {
                     alerts_requested: Default::default(),
                     impacted_locations: Default::default(),
                 };
-                entry.insert(CaseBuilder::new(&self.log, sitrep_id, case))
+                entry.insert(CaseBuilder::new(
+                    &self.log, sitrep_id, case, case_rng,
+                ))
             }
         };
 
@@ -107,20 +113,25 @@ impl AllCases {
 }
 
 impl CaseBuilder {
-    fn new(log: &slog::Logger, sitrep_id: SitrepUuid, case: fm::Case) -> Self {
+    fn new(
+        log: &slog::Logger,
+        sitrep_id: SitrepUuid,
+        case: fm::Case,
+        rng: rng::CaseBuilderRng,
+    ) -> Self {
         let log = log.new(slog::o!(
             "case_id" => format!("{:?}", case.id),
             "de" => case.de.to_string(),
             "created_sitrep_id" => format!("{:?}", case.created_sitrep_id),
         ));
-        Self { log, case, sitrep_id }
+        Self { log, case, sitrep_id, rng }
     }
 
     pub fn request_alert<A: alert::Alert>(
         &mut self,
         alert: &A,
     ) -> anyhow::Result<()> {
-        let id = AlertUuid::new_v4();
+        let id = self.rng.next_alert();
         let class = A::CLASS;
         let req = fm::AlertRequest {
             id,

nexus/fm/src/builder/case.rs

@@ -0,0 +1,78 @@
+// 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/.
+
+//! RNGs for sitrep generation to allow reproduceable UUID generation
+//! (particularly for tests).
+//!
+//! This is similar to the `nexus_reconfigurator_planning::planner::rng`
+//! module.
+
+use omicron_uuid_kinds::AlertKind;
+use omicron_uuid_kinds::AlertUuid;
+use omicron_uuid_kinds::CaseKind;
+use omicron_uuid_kinds::CaseUuid;
+use omicron_uuid_kinds::SitrepUuid;
+use rand::SeedableRng as _;
+use rand::rngs::StdRng;
+use std::hash::Hash;
+use typed_rng::TypedUuidRng;
+
+#[derive(Clone, Debug)]
+pub struct SitrepBuilderRng {
+    parent: StdRng,
+    case_rng: TypedUuidRng<CaseKind>,
+}
+
+impl SitrepBuilderRng {
+    pub fn from_entropy() -> Self {
+        Self::new_from_parent(StdRng::from_os_rng())
+    }
+
+    pub fn from_seed<H: Hash>(seed: H) -> Self {
+        // Important to add some more bytes here, so that builders with the
+        // same seed but different purposes don't end up with the same UUIDs.
+        const SEED_EXTRA: &str = "sitrep-builder";
+        Self::new_from_parent(typed_rng::from_seed(seed, SEED_EXTRA))
+    }
+
+    pub fn new_from_parent(mut parent: StdRng) -> Self {
+        let case_rng = TypedUuidRng::from_parent_rng(&mut parent, "case");
+
+        Self { parent, case_rng }
+    }
+
+    pub(super) fn sitrep_id(&mut self) -> SitrepUuid {
+        // we only need a single sitrep UUID, so no sense storing a whole RNG
+        // for it in the builder RNGs...
+        TypedUuidRng::from_parent_rng(&mut self.parent, "sitrep").next()
+    }
+
+    pub(super) fn next_case(&mut self) -> (CaseUuid, CaseBuilderRng) {
+        let case_id = self.case_rng.next();
+        let rng = CaseBuilderRng::new(case_id, self);
+        (case_id, rng)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct CaseBuilderRng {
+    alert_rng: TypedUuidRng<AlertKind>,
+}
+
+impl CaseBuilderRng {
+    pub(super) fn new(
+        case_id: CaseUuid,
+        sitrep: &mut SitrepBuilderRng,
+    ) -> Self {
+        let alert_rng = TypedUuidRng::from_parent_rng(
+            &mut sitrep.parent,
+            (case_id, "alert"),
+        );
+        Self { alert_rng }
+    }
+
+    pub(super) fn next_alert(&mut self) -> AlertUuid {
+        self.alert_rng.next()
+    }
+}

nexus/fm/src/builder/rng.rs

@@ -498,8 +498,12 @@ mod test {
             .nsleds(2)
             .build();
         let mut de = PowerShelfDiagnosis::new(&logctx.log);
-        let mut sitrep =
-            SitrepBuilder::new(&logctx.log, &example_system.collection, None);
+        let mut sitrep = SitrepBuilder::new_with_rng(
+            &logctx.log,
+            &example_system.collection,
+            None,
+            crate::builder::SitrepBuilderRng::from_seed(TEST_NAME),
+        );
 
         de.analyze_ereport(
             &mut sitrep,