Plumb disks into inventory

Author: smklein

clients/sled-agent-client/src/lib.rs

@@ -165,6 +165,16 @@ impl omicron_common::api::external::ClientError for types::Error {
     }
 }
 
+impl From<types::DiskIdentity> for omicron_common::disk::DiskIdentity {
+    fn from(identity: types::DiskIdentity) -> Self {
+        Self {
+            vendor: identity.vendor,
+            serial: identity.serial,
+            model: identity.model,
+        }
+    }
+}
+
 impl From<omicron_common::api::internal::nexus::InstanceRuntimeState>
     for types::InstanceRuntimeState
 {

nexus/db-model/src/inventory.rs

@@ -7,10 +7,11 @@
 use crate::omicron_zone_config::{OmicronZone, OmicronZoneNic};
 use crate::schema::{
     hw_baseboard_id, inv_caboose, inv_collection, inv_collection_error,
-    inv_omicron_zone, inv_omicron_zone_nic, inv_root_of_trust,
-    inv_root_of_trust_page, inv_service_processor, inv_sled_agent,
-    inv_sled_omicron_zones, sw_caboose, sw_root_of_trust_page,
+    inv_omicron_zone, inv_omicron_zone_nic, inv_physical_disk,
+    inv_root_of_trust, inv_root_of_trust_page, inv_service_processor,
+    inv_sled_agent, inv_sled_omicron_zones, sw_caboose, sw_root_of_trust_page,
 };
+use crate::PhysicalDiskKind;
 use crate::{
     impl_enum_type, ipv6, ByteCount, Generation, MacAddr, Name, SqlU16, SqlU32,
     SqlU8,
@@ -652,6 +653,48 @@ impl InvSledAgent {
     }
 }
 
+/// See [`nexus_types::inventory::PhysicalDisk`].
+#[derive(Queryable, Clone, Debug, Selectable, Insertable)]
+#[diesel(table_name = inv_physical_disk)]
+pub struct InvPhysicalDisk {
+    pub inv_collection_id: Uuid,
+    pub sled_id: Uuid,
+    pub vendor: String,
+    pub serial: String,
+    pub model: String,
+    pub variant: PhysicalDiskKind,
+}
+
+impl InvPhysicalDisk {
+    pub fn new(
+        inv_collection_id: Uuid,
+        sled_id: Uuid,
+        disk: nexus_types::inventory::PhysicalDisk,
+    ) -> Self {
+        Self {
+            inv_collection_id,
+            sled_id,
+            vendor: disk.identity.vendor,
+            serial: disk.identity.serial,
+            model: disk.identity.model,
+            variant: disk.variant.into(),
+        }
+    }
+}
+
+impl From<InvPhysicalDisk> for nexus_types::inventory::PhysicalDisk {
+    fn from(disk: InvPhysicalDisk) -> Self {
+        Self {
+            identity: omicron_common::disk::DiskIdentity {
+                vendor: disk.vendor,
+                serial: disk.serial,
+                model: disk.model,
+            },
+            variant: disk.variant.into(),
+        }
+    }
+}
+
 /// See [`nexus_types::inventory::OmicronZonesFound`].
 #[derive(Queryable, Clone, Debug, Selectable, Insertable)]
 #[diesel(table_name = inv_sled_omicron_zones)]

nexus/db-model/src/schema.rs

@@ -1358,6 +1358,19 @@ table! {
     }
 }
 
+table! {
+    inv_physical_disk (inv_collection_id, sled_id, vendor, serial, model) {
+        inv_collection_id -> Uuid,
+        sled_id -> Uuid,
+
+        vendor -> Text,
+        serial -> Text,
+        model -> Text,
+
+        variant -> crate::PhysicalDiskKindEnum,
+    }
+}
+
 table! {
     inv_sled_omicron_zones (inv_collection_id, sled_id) {
         inv_collection_id -> Uuid,

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

@@ -39,6 +39,7 @@ use nexus_db_model::InvCollection;
 use nexus_db_model::InvCollectionError;
 use nexus_db_model::InvOmicronZone;
 use nexus_db_model::InvOmicronZoneNic;
+use nexus_db_model::InvPhysicalDisk;
 use nexus_db_model::InvRootOfTrust;
 use nexus_db_model::InvRotPage;
 use nexus_db_model::InvServiceProcessor;
@@ -125,6 +126,25 @@ impl DataStore {
                 ))
             })
             .collect::<Result<Vec<_>, Error>>()?;
+        // Pull disks out of all sled agents
+        let disks: Vec<_> = collection
+            .sled_agents
+            .iter()
+            .flat_map(|(sled_id, sled_agent)| {
+                sled_agent
+                    .disks
+                    .iter()
+                    .map(|disk| {
+                        InvPhysicalDisk::new(
+                            collection_id,
+                            *sled_id,
+                            disk.clone(),
+                        )
+                    })
+                    .collect::<Vec<_>>()
+            })
+            .collect();
+
         // Partition the sled agents into those with an associated baseboard id
         // and those without one.  We handle these pretty differently.
         let (sled_agents_baseboards, sled_agents_no_baseboards): (
@@ -639,6 +659,20 @@ impl DataStore {
                 }
             }
 
+            // Insert rows for all the physical disks we found.
+            {
+                use db::schema::inv_physical_disk::dsl;
+
+                let mut iter =
+                    disks.chunks(SQL_BATCH_SIZE.get().try_into().unwrap());
+                while let Some(some_disks) = iter.next() {
+                    let _ = diesel::insert_into(dsl::inv_physical_disk)
+                        .values(some_disks.to_vec())
+                        .execute_async(&conn)
+                        .await?;
+                }
+            }
+
             // Insert rows for the sled agents that we found.  In practice, we'd
             // expect these to all have baseboards (if using Oxide hardware) or
             // none have baseboards (if not).
@@ -1391,6 +1425,83 @@ impl DataStore {
             rows
         };
 
+        // Mapping of "Sled ID" -> "All disks reported by that sled"
+        let physical_disks: BTreeMap<
+            Uuid,
+            Vec<nexus_types::inventory::PhysicalDisk>,
+        > = {
+            use db::schema::inv_physical_disk::dsl;
+
+            let mut disks = BTreeMap::<
+                Uuid,
+                Vec<nexus_types::inventory::PhysicalDisk>,
+            >::new();
+            let mut paginator = Paginator::new(batch_size);
+            while let Some(p) = paginator.next() {
+                // The primary key of physical disks is more than two columns,
+                // which complicates a bit of the pagination query. This
+                // code below is effectively an implementation of
+                // "paginated_multicolumn" for these four columns (sled_id,
+                // vendor, model, serial).
+                type PK = (Uuid, String, String, String);
+
+                let pagparams = &p.current_pagparams();
+                let mut query = dsl::inv_physical_disk
+                    .into_boxed()
+                    .limit(pagparams.limit.get().into())
+                    .filter(dsl::inv_collection_id.eq(id));
+                let marker = pagparams.marker.map(|m: &PK| m.clone());
+                if let Some((sled_id, vendor, serial, model)) = marker {
+                    query = query.filter(
+                        dsl::sled_id
+                            .eq(sled_id)
+                            .and(dsl::vendor.eq(vendor.clone()))
+                            .and(dsl::model.eq(model.clone()))
+                            .and(dsl::serial.gt(serial.clone())),
+                    );
+                    query = query.or_filter(
+                        dsl::sled_id
+                            .eq(sled_id)
+                            .and(dsl::vendor.eq(vendor.clone()))
+                            .and(dsl::model.gt(model.clone())),
+                    );
+                    query = query.or_filter(
+                        dsl::sled_id
+                            .eq(sled_id)
+                            .and(dsl::vendor.gt(vendor.clone())),
+                    );
+                    query = query.or_filter(dsl::sled_id.gt(sled_id));
+                }
+                query = query
+                    .order(dsl::sled_id.asc())
+                    .then_order_by(dsl::vendor.asc())
+                    .then_order_by(dsl::model.asc())
+                    .then_order_by(dsl::serial.asc());
+
+                let batch: Vec<_> = query
+                    .select(InvPhysicalDisk::as_select())
+                    .load_async(&*conn)
+                    .await
+                    .map_err(|e| {
+                        public_error_from_diesel(e, ErrorHandler::Server)
+                    })?;
+                paginator = p.found_batch(&batch, &|row| {
+                    (
+                        row.sled_id,
+                        row.vendor.clone(),
+                        row.serial.clone(),
+                        row.model.clone(),
+                    )
+                });
+
+                for disk in batch {
+                    disks.entry(disk.sled_id).or_default().push(disk.into());
+                }
+            }
+
+            disks
+        };
+
         // Collect the unique baseboard ids referenced by SPs, RoTs, and Sled
         // Agents.
         let baseboard_id_ids: BTreeSet<_> = sps
@@ -1494,6 +1605,10 @@ impl DataStore {
                         ),
                         usable_physical_ram: s.usable_physical_ram.into(),
                         reservoir_size: s.reservoir_size.into(),
+                        disks: physical_disks
+                            .get(&sled_id)
+                            .map(|disks| disks.to_vec())
+                            .unwrap_or_default(),
                     };
                     Ok((sled_id, sled_agent))
                 })

nexus/deployment/src/blueprint_builder.rs

@@ -806,6 +806,7 @@ pub mod test {
                         sled_id,
                         usable_hardware_threads: 10,
                         usable_physical_ram: ByteCount::from(1024 * 1024),
+                        disks: vec![],
                     },
                 )
                 .unwrap();

nexus/inventory/src/builder.rs

@@ -458,6 +458,7 @@ impl CollectionBuilder {
             reservoir_size: inventory.reservoir_size,
             time_collected: now_db_precision(),
             sled_id,
+            disks: inventory.disks.into_iter().map(|d| d.into()).collect(),
         };
 
         if let Some(previous) = self.sleds.get(&sled_id) {

nexus/inventory/src/examples.rs

@@ -448,5 +448,6 @@ pub fn sled_agent(
         sled_id,
         usable_hardware_threads: 10,
         usable_physical_ram: ByteCount::from(1024 * 1024),
+        disks: vec![],
     }
 }

nexus/types/src/external_api/params.rs

@@ -1319,6 +1319,16 @@ pub enum PhysicalDiskKind {
     U2,
 }
 
+impl From<sled_agent_client::types::DiskVariant> for PhysicalDiskKind {
+    fn from(variant: sled_agent_client::types::DiskVariant) -> Self {
+        use sled_agent_client::types::DiskVariant;
+        match variant {
+            DiskVariant::U2 => Self::U2,
+            DiskVariant::M2 => Self::M2,
+        }
+    }
+}
+
 /// Different sources for a disk
 #[derive(Clone, Debug, Deserialize, Serialize, JsonSchema)]
 #[serde(tag = "type", rename_all = "snake_case")]

nexus/types/src/inventory.rs

@@ -9,6 +9,7 @@
 //! nexus/inventory does not currently know about nexus/db-model and it's
 //! convenient to separate these concerns.)
 
+use crate::external_api::params::PhysicalDiskKind;
 use crate::external_api::params::UninitializedSledId;
 use crate::external_api::shared::Baseboard;
 use chrono::DateTime;
@@ -301,6 +302,26 @@ impl IntoRotPage for gateway_client::types::RotCfpa {
     }
 }
 
+/// A physical disk reported by a sled agent.
+///
+/// This identifies that a physical disk appears in a Sled.
+/// The existence of this object does not necessarily imply that
+/// the disk is being actively managed by the control plane.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PhysicalDisk {
+    pub identity: omicron_common::disk::DiskIdentity,
+    pub variant: PhysicalDiskKind,
+}
+
+impl From<sled_agent_client::types::InventoryDisk> for PhysicalDisk {
+    fn from(disk: sled_agent_client::types::InventoryDisk) -> PhysicalDisk {
+        PhysicalDisk {
+            identity: disk.identity.into(),
+            variant: disk.variant.into(),
+        }
+    }
+}
+
 /// Inventory reported by sled agent
 ///
 /// This is a software notion of a sled, distinct from an underlying baseboard.
@@ -318,6 +339,7 @@ pub struct SledAgent {
     pub usable_hardware_threads: u32,
     pub usable_physical_ram: ByteCount,
     pub reservoir_size: ByteCount,
+    pub disks: Vec<PhysicalDisk>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]