[inventory] Add active host phase 1 slot (#8793)

This was an oversight; we're already collecting the host phase 1 hashes;
we also need to know which slot is active (for host OS updates).

Author: jgallagher

dev-tools/reconfigurator-cli/tests/output/cmds-example-stdout

@@ -1030,8 +1030,9 @@ Sled serial0
     part number: model0
     power:    A2
     revision: 0
-    MGS slot: Sled 0 (cubby 0)
+    MGS slot: Sled 0
     found at: <REDACTED_TIMESTAMP> from fake MGS 1
+    host phase 1 active slot: A
     host phase 1 hashes:
         SLOT HASH                                                             
         A    0101010101010101010101010101010101010101010101010101010101010101 
@@ -1053,8 +1054,9 @@ Sled serial1
     part number: model1
     power:    A2
     revision: 0
-    MGS slot: Sled 1 (cubby 1)
+    MGS slot: Sled 1
     found at: <REDACTED_TIMESTAMP> from fake MGS 1
+    host phase 1 active slot: A
     host phase 1 hashes:
         SLOT HASH                                                             
         A    0101010101010101010101010101010101010101010101010101010101010101 
@@ -1076,8 +1078,9 @@ Sled serial2
     part number: model2
     power:    A2
     revision: 0
-    MGS slot: Sled 2 (cubby 2)
+    MGS slot: Sled 2
     found at: <REDACTED_TIMESTAMP> from fake MGS 1
+    host phase 1 active slot: A
     host phase 1 hashes:
         SLOT HASH                                                             
         A    0101010101010101010101010101010101010101010101010101010101010101 

nexus/db-model/src/inventory.rs

@@ -30,8 +30,8 @@ use nexus_db_schema::schema::inv_zone_manifest_zone;
 use nexus_db_schema::schema::{
     hw_baseboard_id, inv_caboose, inv_clickhouse_keeper_membership,
     inv_cockroachdb_status, inv_collection, inv_collection_error, inv_dataset,
-    inv_host_phase_1_flash_hash, inv_internal_dns,
-    inv_last_reconciliation_dataset_result,
+    inv_host_phase_1_active_slot, inv_host_phase_1_flash_hash,
+    inv_internal_dns, inv_last_reconciliation_dataset_result,
     inv_last_reconciliation_disk_result,
     inv_last_reconciliation_orphaned_dataset,
     inv_last_reconciliation_zone_result, inv_mupdate_override_non_boot,
@@ -62,6 +62,7 @@ use nexus_sled_agent_shared::inventory::{
     ConfigReconcilerInventoryResult, OmicronSledConfig, OmicronZoneConfig,
     OmicronZoneDataset, OmicronZoneImageSource, OmicronZoneType,
 };
+use nexus_types::inventory::HostPhase1ActiveSlot;
 use nexus_types::inventory::{
     BaseboardId, Caboose, CockroachStatus, Collection,
     InternalDnsGenerationStatus, NvmeFirmware, PowerState, RotPage, RotSlot,
@@ -786,6 +787,28 @@ impl From<InvRootOfTrust> for nexus_types::inventory::RotState {
     }
 }
 
+/// See [`nexus_types::inventory::HostPhase1ActiveSlot`].
+#[derive(Queryable, Clone, Debug, Selectable)]
+#[diesel(table_name = inv_host_phase_1_active_slot)]
+pub struct InvHostPhase1ActiveSlot {
+    pub inv_collection_id: Uuid,
+    pub hw_baseboard_id: Uuid,
+    pub time_collected: DateTime<Utc>,
+    pub source: String,
+
+    pub slot: HwM2Slot,
+}
+
+impl From<InvHostPhase1ActiveSlot> for HostPhase1ActiveSlot {
+    fn from(value: InvHostPhase1ActiveSlot) -> Self {
+        Self {
+            time_collected: value.time_collected,
+            source: value.source,
+            slot: value.slot.into(),
+        }
+    }
+}
+
 /// See [`nexus_types::inventory::HostPhase1FlashHash`].
 #[derive(Queryable, Clone, Debug, Selectable)]
 #[diesel(table_name = inv_host_phase_1_flash_hash)]

nexus/db-model/src/schema_versions.rs

@@ -16,7 +16,7 @@ use std::{collections::BTreeMap, sync::LazyLock};
 ///
 /// This must be updated when you change the database schema.  Refer to
 /// schema/crdb/README.adoc in the root of this repository for details.
-pub const SCHEMA_VERSION: Version = Version::new(174, 0, 0);
+pub const SCHEMA_VERSION: Version = Version::new(175, 0, 0);
 
 /// List of all past database schema versions, in *reverse* order
 ///
@@ -28,6 +28,7 @@ static KNOWN_VERSIONS: LazyLock<Vec<KnownVersion>> = LazyLock::new(|| {
         // |  leaving the first copy as an example for the next person.
         // v
         // KnownVersion::new(next_int, "unique-dirname-with-the-sql-files"),
+        KnownVersion::new(175, "inv-host-phase-1-active-slot"),
         KnownVersion::new(174, "add-tuf-rot-by-sign"),
         KnownVersion::new(173, "inv-internal-dns"),
         KnownVersion::new(172, "add-zones-with-mupdate-override"),

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

@@ -39,6 +39,7 @@ use nexus_db_model::InvCollectionError;
 use nexus_db_model::InvConfigReconcilerStatus;
 use nexus_db_model::InvConfigReconcilerStatusKind;
 use nexus_db_model::InvDataset;
+use nexus_db_model::InvHostPhase1ActiveSlot;
 use nexus_db_model::InvHostPhase1FlashHash;
 use nexus_db_model::InvInternalDns;
 use nexus_db_model::InvLastReconciliationDatasetResult;
@@ -690,6 +691,64 @@ impl DataStore {
                 }
             }
 
+            // Insert rows for the host phase 1 active slots that we found.
+            // Like service processors, we do this using INSERT INTO ... SELECT.
+            {
+                use nexus_db_schema::schema::hw_baseboard_id::dsl as baseboard_dsl;
+                use nexus_db_schema::schema::inv_host_phase_1_active_slot::dsl as phase1_dsl;
+
+                for (baseboard_id, phase1) in
+                    &collection.host_phase_1_active_slots
+                {
+                    let selection = nexus_db_schema::schema::hw_baseboard_id::table
+                        .select((
+                            db_collection_id
+                                .into_sql::<diesel::sql_types::Uuid>(),
+                            baseboard_dsl::id,
+                            phase1.time_collected
+                                .into_sql::<diesel::sql_types::Timestamptz>(),
+                            phase1.source
+                                .clone()
+                                .into_sql::<diesel::sql_types::Text>(),
+                            HwM2Slot::from(phase1.slot)
+                                .into_sql::<HwM2SlotEnum>(),
+                        ))
+                        .filter(
+                            baseboard_dsl::part_number
+                                .eq(baseboard_id.part_number.clone()),
+                        )
+                        .filter(
+                            baseboard_dsl::serial_number
+                                .eq(baseboard_id.serial_number.clone()),
+                        );
+
+                    let _ = diesel::insert_into(
+                        nexus_db_schema::schema::inv_host_phase_1_active_slot::table,
+                    )
+                    .values(selection)
+                    .into_columns((
+                        phase1_dsl::inv_collection_id,
+                        phase1_dsl::hw_baseboard_id,
+                        phase1_dsl::time_collected,
+                        phase1_dsl::source,
+                        phase1_dsl::slot,
+                    ))
+                    .execute_async(&conn)
+                    .await?;
+
+                    // See the comment in the above block (where we use
+                    // `inv_service_processor::all_columns()`).  The same
+                    // applies here.
+                    let (
+                        _inv_collection_id,
+                        _hw_baseboard_id,
+                        _time_collected,
+                        _source,
+                        _slot,
+                    ) = phase1_dsl::inv_host_phase_1_active_slot::all_columns();
+                }
+            }
+
             // Insert rows for the host phase 1 flash hashes that we found.
             // Like service processors, we do this using INSERT INTO ... SELECT.
             {
@@ -1798,6 +1857,7 @@ impl DataStore {
         struct NumRowsDeleted {
             ncollections: usize,
             nsps: usize,
+            nhost_phase1_active_slots: usize,
             nhost_phase1_flash_hashes: usize,
             nrots: usize,
             ncabooses: usize,
@@ -1831,6 +1891,7 @@ impl DataStore {
         let NumRowsDeleted {
             ncollections,
             nsps,
+            nhost_phase1_active_slots,
             nhost_phase1_flash_hashes,
             nrots,
             ncabooses,
@@ -1883,6 +1944,16 @@ impl DataStore {
                         .await?
                     };
 
+                    // Remove rows for host phase 1 active slots.
+                    let nhost_phase1_active_slots = {
+                        use nexus_db_schema::schema::inv_host_phase_1_active_slot::dsl;
+                        diesel::delete(dsl::inv_host_phase_1_active_slot.filter(
+                            dsl::inv_collection_id.eq(db_collection_id),
+                        ))
+                        .execute_async(&conn)
+                        .await?
+                    };
+
                     // Remove rows for host phase 1 flash hashes.
                     let nhost_phase1_flash_hashes = {
                         use nexus_db_schema::schema::inv_host_phase_1_flash_hash::dsl;
@@ -2152,6 +2223,7 @@ impl DataStore {
                     Ok(NumRowsDeleted {
                         ncollections,
                         nsps,
+                        nhost_phase1_active_slots,
                         nhost_phase1_flash_hashes,
                         nrots,
                         ncabooses,
@@ -2191,6 +2263,7 @@ impl DataStore {
             "collection_id" => collection_id.to_string(),
             "ncollections" => ncollections,
             "nsps" => nsps,
+            "nhost_phase1_active_slots" => nhost_phase1_active_slots,
             "nhost_phase1_flash_hashes" => nhost_phase1_flash_hashes,
             "nrots" => nrots,
             "ncabooses" => ncabooses,
@@ -2698,6 +2771,45 @@ impl DataStore {
             })
             .collect::<Result<BTreeMap<_, _>, _>>()?;
 
+        // Fetch the host phase 1 active slots found.
+        let host_phase_1_active_slots = {
+            use nexus_db_schema::schema::inv_host_phase_1_active_slot::dsl;
+
+            let mut slots = BTreeMap::new();
+
+            let mut paginator = Paginator::new(
+                batch_size,
+                dropshot::PaginationOrder::Ascending,
+            );
+            while let Some(p) = paginator.next() {
+                let batch = paginated(
+                    dsl::inv_host_phase_1_active_slot,
+                    dsl::hw_baseboard_id,
+                    &p.current_pagparams(),
+                )
+                .filter(dsl::inv_collection_id.eq(db_id))
+                .select(InvHostPhase1ActiveSlot::as_select())
+                .load_async(&*conn)
+                .await
+                .map_err(|e| {
+                    public_error_from_diesel(e, ErrorHandler::Server)
+                })?;
+                paginator = p.found_batch(&batch, &|row| row.hw_baseboard_id);
+                for row in batch {
+                    let bb = baseboards_by_id
+                        .get(&row.hw_baseboard_id)
+                        .ok_or_else(|| {
+                            Error::internal_error(
+                                "missing baseboard that we should have fetched",
+                            )
+                        })?;
+                    slots.insert(Arc::clone(bb), row.into());
+                }
+            }
+
+            slots
+        };
+
         // Fetch records of host phase 1 flash hashes found.
         let inv_host_phase_1_flash_hash_rows = {
             use nexus_db_schema::schema::inv_host_phase_1_flash_hash::dsl;
@@ -3941,6 +4053,7 @@ impl DataStore {
             cabooses: cabooses_by_id.values().cloned().collect(),
             rot_pages: rot_pages_by_id.values().cloned().collect(),
             sps,
+            host_phase_1_active_slots,
             host_phase_1_flash_hashes,
             rots,
             cabooses_found,

nexus/db-schema/src/schema.rs

@@ -1559,6 +1559,17 @@ table! {
     }
 }
 
+table! {
+    inv_host_phase_1_active_slot (inv_collection_id, hw_baseboard_id) {
+        inv_collection_id -> Uuid,
+        hw_baseboard_id -> Uuid,
+        time_collected -> Timestamptz,
+        source -> Text,
+
+        slot -> crate::enums::HwM2SlotEnum,
+    }
+}
+
 table! {
     inv_host_phase_1_flash_hash (inv_collection_id, hw_baseboard_id, slot) {
         inv_collection_id -> Uuid,

nexus/inventory/src/builder.rs

@@ -25,6 +25,7 @@ use nexus_types::inventory::CabooseFound;
 use nexus_types::inventory::CabooseWhich;
 use nexus_types::inventory::CockroachStatus;
 use nexus_types::inventory::Collection;
+use nexus_types::inventory::HostPhase1ActiveSlot;
 use nexus_types::inventory::HostPhase1FlashHash;
 use nexus_types::inventory::InternalDnsGenerationStatus;
 use nexus_types::inventory::RotPage;
@@ -116,6 +117,7 @@ pub struct CollectionBuilder {
     cabooses: BTreeSet<Arc<Caboose>>,
     rot_pages: BTreeSet<Arc<RotPage>>,
     sps: BTreeMap<Arc<BaseboardId>, ServiceProcessor>,
+    host_phase_1_active_slots: BTreeMap<Arc<BaseboardId>, HostPhase1ActiveSlot>,
     host_phase_1_flash_hashes:
         BTreeMap<M2Slot, BTreeMap<Arc<BaseboardId>, HostPhase1FlashHash>>,
     rots: BTreeMap<Arc<BaseboardId>, RotState>,
@@ -153,6 +155,7 @@ impl CollectionBuilder {
             cabooses: BTreeSet::new(),
             rot_pages: BTreeSet::new(),
             sps: BTreeMap::new(),
+            host_phase_1_active_slots: BTreeMap::new(),
             host_phase_1_flash_hashes: BTreeMap::new(),
             rots: BTreeMap::new(),
             cabooses_found: BTreeMap::new(),
@@ -178,6 +181,7 @@ impl CollectionBuilder {
             cabooses: self.cabooses,
             rot_pages: self.rot_pages,
             sps: self.sps,
+            host_phase_1_active_slots: self.host_phase_1_active_slots,
             host_phase_1_flash_hashes: self.host_phase_1_flash_hashes,
             rots: self.rots,
             cabooses_found: self.cabooses_found,
@@ -318,6 +322,63 @@ impl CollectionBuilder {
         Some(baseboard)
     }
 
+    /// Returns true if we already found the active host phase 1 flash slot for
+    /// baseboard `baseboard`
+    ///
+    /// This is used to avoid requesting it multiple times (from multiple MGS
+    /// instances).
+    pub fn found_host_phase_1_active_slot_already(
+        &self,
+        baseboard: &BaseboardId,
+    ) -> bool {
+        self.host_phase_1_active_slots.contains_key(baseboard)
+    }
+
+    /// Record the given host phase 1 active slot found for the given baseboard
+    ///
+    /// The baseboard must previously have been reported using
+    /// `found_sp_state()`.
+    ///
+    /// `source` is an arbitrary string for debugging that describes the MGS
+    /// that reported this data (generally a URL string).
+    pub fn found_host_phase_1_active_slot(
+        &mut self,
+        baseboard: &BaseboardId,
+        source: &str,
+        slot: M2Slot,
+    ) -> Result<(), CollectorBug> {
+        let (baseboard, _) =
+            self.sps.get_key_value(baseboard).ok_or_else(|| {
+                anyhow!(
+                    "reporting host phase 1 active slot for unknown baseboard: \
+                    {baseboard:?} ({slot:?})",
+                )
+            })?;
+        if let Some(previous) = self.host_phase_1_active_slots.insert(
+            baseboard.clone(),
+            HostPhase1ActiveSlot {
+                time_collected: now_db_precision(),
+                source: source.to_owned(),
+                slot,
+            },
+        ) {
+            let error = if previous.slot == slot {
+                anyhow!("reported multiple times (same value)")
+            } else {
+                anyhow!(
+                    "reported host phase 1 flash hash \
+                     (previously {}, now {slot})",
+                    previous.slot,
+                )
+            };
+            Err(CollectorBug::from(
+                error.context(format!("baseboard {baseboard:?}")),
+            ))
+        } else {
+            Ok(())
+        }
+    }
+
     /// Returns true if we already found the host phase 1 flash hash for `slot`
     /// for baseboard `baseboard`
     ///