[2/n] [reconfigurator-sim] rename state uuid type (#9364)

We're going to introduce another kind of reconfigurator sim UUID called
`ReconfiguratorSimOpUuid`.

Author: sunshowers

dev-tools/reconfigurator-cli/src/lib.rs

@@ -63,7 +63,7 @@ use omicron_repl_utils::run_repl_from_file;
 use omicron_repl_utils::run_repl_on_stdin;
 use omicron_uuid_kinds::GenericUuid;
 use omicron_uuid_kinds::OmicronZoneUuid;
-use omicron_uuid_kinds::ReconfiguratorSimUuid;
+use omicron_uuid_kinds::ReconfiguratorSimStateUuid;
 use omicron_uuid_kinds::SledUuid;
 use omicron_uuid_kinds::VnicUuid;
 use omicron_uuid_kinds::{BlueprintUuid, MupdateOverrideUuid};
@@ -92,7 +92,7 @@ struct ReconfiguratorSim {
     // The simulator currently being used.
     sim: Simulator,
     // The current state.
-    current: ReconfiguratorSimUuid,
+    current: ReconfiguratorSimStateUuid,
     // The current system state
     log: slog::Logger,
 }
@@ -1024,38 +1024,38 @@ impl From<CollectionIdOpt> for CollectionId {
 }
 
 #[derive(Clone, Debug)]
-enum ReconfiguratorSimIdOpt {
+enum ReconfiguratorSimStateIdOpt {
     /// use a specific reconfigurator sim state by full UUID
-    Id(ReconfiguratorSimUuid),
+    Id(ReconfiguratorSimStateUuid),
     /// use a reconfigurator sim state by UUID prefix
     Prefix(String),
 }
 
-impl FromStr for ReconfiguratorSimIdOpt {
+impl FromStr for ReconfiguratorSimStateIdOpt {
     type Err = Infallible;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.parse::<ReconfiguratorSimUuid>() {
-            Ok(id) => Ok(ReconfiguratorSimIdOpt::Id(id)),
-            Err(_) => Ok(ReconfiguratorSimIdOpt::Prefix(s.to_owned())),
+        match s.parse::<ReconfiguratorSimStateUuid>() {
+            Ok(id) => Ok(ReconfiguratorSimStateIdOpt::Id(id)),
+            Err(_) => Ok(ReconfiguratorSimStateIdOpt::Prefix(s.to_owned())),
         }
     }
 }
 
-impl fmt::Display for ReconfiguratorSimIdOpt {
+impl fmt::Display for ReconfiguratorSimStateIdOpt {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            ReconfiguratorSimIdOpt::Id(id) => id.fmt(f),
-            ReconfiguratorSimIdOpt::Prefix(prefix) => prefix.fmt(f),
+            ReconfiguratorSimStateIdOpt::Id(id) => id.fmt(f),
+            ReconfiguratorSimStateIdOpt::Prefix(prefix) => prefix.fmt(f),
         }
     }
 }
 
-impl From<ReconfiguratorSimIdOpt> for ReconfiguratorSimId {
-    fn from(value: ReconfiguratorSimIdOpt) -> Self {
+impl From<ReconfiguratorSimStateIdOpt> for ReconfiguratorSimId {
+    fn from(value: ReconfiguratorSimStateIdOpt) -> Self {
         match value {
-            ReconfiguratorSimIdOpt::Id(id) => ReconfiguratorSimId::Id(id),
-            ReconfiguratorSimIdOpt::Prefix(prefix) => {
+            ReconfiguratorSimStateIdOpt::Id(id) => ReconfiguratorSimId::Id(id),
+            ReconfiguratorSimStateIdOpt::Prefix(prefix) => {
                 ReconfiguratorSimId::Prefix(prefix)
             }
         }
@@ -1519,7 +1519,7 @@ enum StateArgs {
 struct StateLogArgs {
     /// Starting state ID (defaults to current state)
     #[clap(long)]
-    from: Option<ReconfiguratorSimUuid>,
+    from: Option<ReconfiguratorSimStateUuid>,
 
     /// Limit number of states to display
     #[clap(long, short = 'n', requires = "from")]
@@ -1533,7 +1533,7 @@ struct StateLogArgs {
 #[derive(Debug, Args)]
 struct StateSwitchArgs {
     /// The state ID or unique prefix to switch to
-    state_id: ReconfiguratorSimIdOpt,
+    state_id: ReconfiguratorSimStateIdOpt,
 }
 
 #[derive(Debug, Args)]

nexus/reconfigurator/simulation/src/errors.rs

@@ -7,7 +7,7 @@ use std::collections::BTreeSet;
 use indent_write::indentable::Indentable as _;
 use itertools::Itertools;
 use omicron_common::api::external::{Generation, Name};
-use omicron_uuid_kinds::ReconfiguratorSimUuid;
+use omicron_uuid_kinds::ReconfiguratorSimStateUuid;
 use swrite::{SWrite, swriteln};
 use thiserror::Error;
 
@@ -166,7 +166,7 @@ impl UnknownZoneNamesError {
 #[derive(Clone, Debug)]
 pub struct StateMatch {
     /// The state ID.
-    pub id: ReconfiguratorSimUuid,
+    pub id: ReconfiguratorSimStateUuid,
     /// The state generation.
     pub generation: Generation,
     /// The state description.
@@ -186,7 +186,7 @@ pub enum StateIdResolveError {
 
     /// State not found by ID.
     #[error("state not found: {0}")]
-    NotFound(ReconfiguratorSimUuid),
+    NotFound(ReconfiguratorSimStateUuid),
 }
 
 fn format_matches(matches: &[StateMatch]) -> String {

nexus/reconfigurator/simulation/src/render_graph.rs

@@ -6,7 +6,7 @@
 
 use std::collections::{HashMap, HashSet};
 
-use omicron_uuid_kinds::ReconfiguratorSimUuid;
+use omicron_uuid_kinds::ReconfiguratorSimStateUuid;
 use renderdag::{Ancestor, GraphRowRenderer, Renderer};
 use swrite::{SWrite, swrite, swriteln};
 
@@ -17,12 +17,12 @@ use crate::{SimState, Simulator, utils::DisplayUuidPrefix};
 pub struct GraphRenderOptions {
     verbose: bool,
     starting_state: GraphStartingState,
-    current: ReconfiguratorSimUuid,
+    current: ReconfiguratorSimStateUuid,
 }
 
 impl GraphRenderOptions {
     /// Create new render options with the current state.
-    pub fn new(current: ReconfiguratorSimUuid) -> Self {
+    pub fn new(current: ReconfiguratorSimStateUuid) -> Self {
         Self {
             verbose: false,
             starting_state: GraphStartingState::None,
@@ -51,7 +51,7 @@ pub enum GraphStartingState {
     None,
     State {
         /// The starting state.
-        start: ReconfiguratorSimUuid,
+        start: ReconfiguratorSimStateUuid,
         /// The maximum number of states to render.
         ///
         /// We do not allow a limit to be set without a starting state, because
@@ -74,7 +74,7 @@ impl Simulator {
         &self,
         options: &GraphRenderOptions,
     ) -> Vec<&SimState> {
-        let mut remaining_heads: Vec<ReconfiguratorSimUuid> =
+        let mut remaining_heads: Vec<ReconfiguratorSimStateUuid> =
             if let GraphStartingState::State { start, .. } =
                 options.starting_state
             {
@@ -123,10 +123,10 @@ impl Simulator {
     /// Recursively walk a branch, processing merge points along the way.
     fn walk_branch_recursive<'a>(
         &'a self,
-        mut current_id: ReconfiguratorSimUuid,
+        mut current_id: ReconfiguratorSimStateUuid,
         node_to_heads: &HashMap<
-            ReconfiguratorSimUuid,
-            Vec<ReconfiguratorSimUuid>,
+            ReconfiguratorSimStateUuid,
+            Vec<ReconfiguratorSimStateUuid>,
         >,
         walk_state: &mut WalkState<'a>,
     ) {
@@ -168,12 +168,12 @@ impl Simulator {
 /// State accumulated during graph traversal.
 struct WalkState<'a> {
     states: Vec<&'a SimState>,
-    visited: HashSet<ReconfiguratorSimUuid>,
-    remaining_heads: Vec<ReconfiguratorSimUuid>,
+    visited: HashSet<ReconfiguratorSimStateUuid>,
+    remaining_heads: Vec<ReconfiguratorSimStateUuid>,
 }
 
 impl<'a> WalkState<'a> {
-    fn new(heads: Vec<ReconfiguratorSimUuid>) -> Self {
+    fn new(heads: Vec<ReconfiguratorSimStateUuid>) -> Self {
         Self {
             states: Vec::new(),
             visited: HashSet::new(),

nexus/reconfigurator/simulation/src/sim.rs

@@ -8,7 +8,9 @@
 use std::{collections::HashMap, sync::Arc};
 
 use indexmap::IndexSet;
-use omicron_uuid_kinds::{ReconfiguratorSimKind, ReconfiguratorSimUuid};
+use omicron_uuid_kinds::{
+    ReconfiguratorSimStateKind, ReconfiguratorSimStateUuid,
+};
 use typed_rng::TypedUuidRng;
 
 use crate::{
@@ -48,8 +50,8 @@ pub struct Simulator {
     // In the future, it would be interesting to store a chain of every set of
     // heads over time, similar to `jj op log`. That would let us implement undo
     // and restore operations.
-    heads: IndexSet<ReconfiguratorSimUuid>,
-    states: HashMap<ReconfiguratorSimUuid, Arc<SimState>>,
+    heads: IndexSet<ReconfiguratorSimStateUuid>,
+    states: HashMap<ReconfiguratorSimStateUuid, Arc<SimState>>,
     // This state corresponds to `ROOT_ID`.
     //
     // Storing it in the Arc is extremely important! `SimStateBuilder` stores a
@@ -59,15 +61,16 @@ pub struct Simulator {
     // points to the same memory address.
     root_state: Arc<SimState>,
     // Top-level (unversioned) RNG.
-    sim_uuid_rng: TypedUuidRng<ReconfiguratorSimKind>,
+    sim_uuid_rng: TypedUuidRng<ReconfiguratorSimStateKind>,
 }
 
 impl Simulator {
     /// The root ID of the store.
     ///
     /// This is always defined to be the nil UUID, and if queried will always
     /// have a state associated with it.
-    pub const ROOT_ID: ReconfiguratorSimUuid = ReconfiguratorSimUuid::nil();
+    pub const ROOT_ID: ReconfiguratorSimStateUuid =
+        ReconfiguratorSimStateUuid::nil();
 
     /// Create a new simulator with the given initial seed.
     pub fn new(log: &slog::Logger, seed: Option<String>) -> Self {
@@ -77,6 +80,8 @@ impl Simulator {
 
     fn new_inner(log: &slog::Logger, seed: String) -> Self {
         let log = log.new(slog::o!("component" => "SimStore"));
+        // The ReconfiguratorSimStateUuid type used to be ReconfiguratorSimUuid.
+        // Retain the old name in the seed for generated ID compatibility.
         let sim_uuid_rng =
             TypedUuidRng::from_seed(&seed, "ReconfiguratorSimUuid");
         let root_state = SimState::new_root(seed);
@@ -99,12 +104,15 @@ impl Simulator {
 
     /// Get the current heads of the store.
     #[inline]
-    pub fn heads(&self) -> &IndexSet<ReconfiguratorSimUuid> {
+    pub fn heads(&self) -> &IndexSet<ReconfiguratorSimStateUuid> {
         &self.heads
     }
 
     /// Get the state for the given UUID.
-    pub fn get_state(&self, id: ReconfiguratorSimUuid) -> Option<&SimState> {
+    pub fn get_state(
+        &self,
+        id: ReconfiguratorSimStateUuid,
+    ) -> Option<&SimState> {
         if id == Self::ROOT_ID {
             return Some(&self.root_state);
         }
@@ -126,7 +134,7 @@ impl Simulator {
     fn get_state_by_prefix(
         &self,
         prefix: &str,
-    ) -> Result<ReconfiguratorSimUuid, StateIdResolveError> {
+    ) -> Result<ReconfiguratorSimStateUuid, StateIdResolveError> {
         let mut matching_ids = Vec::new();
 
         if Self::ROOT_ID.to_string().starts_with(prefix) {
@@ -169,11 +177,11 @@ impl Simulator {
         }
     }
 
-    /// Resolve a [`ReconfiguratorSimId`] to a [`ReconfiguratorSimUuid`].
+    /// Resolve a [`ReconfiguratorSimId`] to a [`ReconfiguratorSimStateUuid`].
     pub fn resolve_state_id(
         &self,
         id: ReconfiguratorSimId,
-    ) -> Result<ReconfiguratorSimUuid, StateIdResolveError> {
+    ) -> Result<ReconfiguratorSimStateUuid, StateIdResolveError> {
         match id {
             ReconfiguratorSimId::Id(id) => Ok(id),
             ReconfiguratorSimId::Prefix(prefix) => {
@@ -192,7 +200,7 @@ impl Simulator {
     }
 
     #[inline]
-    pub(crate) fn next_sim_uuid(&mut self) -> ReconfiguratorSimUuid {
+    pub(crate) fn next_sim_uuid(&mut self) -> ReconfiguratorSimStateUuid {
         self.sim_uuid_rng.next()
     }
 

nexus/reconfigurator/simulation/src/state.rs

@@ -8,7 +8,7 @@ use anyhow::{Context, anyhow, bail};
 use nexus_inventory::CollectionBuilder;
 use nexus_types::deployment::UnstableReconfiguratorState;
 use omicron_common::api::external::Generation;
-use omicron_uuid_kinds::{CollectionUuid, ReconfiguratorSimUuid};
+use omicron_uuid_kinds::{CollectionUuid, ReconfiguratorSimStateUuid};
 use sync_ptr::SyncConstPtr;
 
 use crate::{
@@ -31,9 +31,9 @@ pub struct SimState {
     // is stored behind an `Arc`. This means that the address stays stable even
     // if the `Simulator` struct is cloned or moved in memory.
     root_state: SyncConstPtr<SimState>,
-    id: ReconfiguratorSimUuid,
+    id: ReconfiguratorSimStateUuid,
     // The parent state that this state was derived from.
-    parent: Option<ReconfiguratorSimUuid>,
+    parent: Option<ReconfiguratorSimStateUuid>,
     // The state's generation, starting from 0.
     //
     // TODO: Should this be its own type to avoid confusion with other
@@ -79,13 +79,13 @@ impl SimState {
 
     #[inline]
     #[must_use]
-    pub fn id(&self) -> ReconfiguratorSimUuid {
+    pub fn id(&self) -> ReconfiguratorSimStateUuid {
         self.id
     }
 
     #[inline]
     #[must_use]
-    pub fn parent(&self) -> Option<ReconfiguratorSimUuid> {
+    pub fn parent(&self) -> Option<ReconfiguratorSimStateUuid> {
         self.parent
     }
 
@@ -185,7 +185,7 @@ pub struct SimStateBuilder {
     // Used to check that the simulator is the same as the one that created
     // this state.
     root_state: SyncConstPtr<SimState>,
-    parent: ReconfiguratorSimUuid,
+    parent: ReconfiguratorSimStateUuid,
     parent_gen: Generation,
     system: SimSystemBuilder,
     config: SimConfigBuilder,
@@ -195,7 +195,7 @@ pub struct SimStateBuilder {
 impl SimStateBuilder {
     #[inline]
     #[must_use]
-    pub fn parent(&self) -> ReconfiguratorSimUuid {
+    pub fn parent(&self) -> ReconfiguratorSimStateUuid {
         self.parent
     }
 
@@ -271,7 +271,7 @@ impl SimStateBuilder {
         self,
         description: String,
         sim: &mut Simulator,
-    ) -> ReconfiguratorSimUuid {
+    ) -> ReconfiguratorSimStateUuid {
         // Check for unrelated histories.
         if !std::ptr::eq(sim.root_state(), self.root_state.inner()) {
             panic!(

nexus/reconfigurator/simulation/src/system.rs

@@ -24,7 +24,7 @@ use nexus_types::{
 };
 use omicron_common::{api::external::Generation, disk::M2Slot};
 use omicron_uuid_kinds::{
-    BlueprintUuid, CollectionUuid, ReconfiguratorSimUuid, SledUuid,
+    BlueprintUuid, CollectionUuid, ReconfiguratorSimStateUuid, SledUuid,
 };
 use strum::IntoEnumIterator as _;
 
@@ -677,7 +677,7 @@ impl fmt::Display for ResolvedCollectionId {
 #[derive(Clone, Debug)]
 pub enum ReconfiguratorSimId {
     /// The specified state by full UUID.
-    Id(ReconfiguratorSimUuid),
+    Id(ReconfiguratorSimStateUuid),
 
     /// The specified state by UUID prefix.
     Prefix(String),

uuid-kinds/src/lib.rs

@@ -72,7 +72,7 @@ impl_typed_uuid_kinds! {
         Rack = {},
         RackInit = {},
         RackReset = {},
-        ReconfiguratorSim = {},
+        ReconfiguratorSimState = {},
         Region = {},
         SiloGroup = {},
         SiloUser = {},