Collect internal DNS generation in inventory

Author: smklein

Cargo.lock

@@ -30,7 +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_last_reconciliation_dataset_result,
+    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,
@@ -60,8 +61,9 @@ use nexus_sled_agent_shared::inventory::{
     OmicronZoneDataset, OmicronZoneImageSource, OmicronZoneType,
 };
 use nexus_types::inventory::{
-    BaseboardId, Caboose, CockroachStatus, Collection, NvmeFirmware,
-    PowerState, RotPage, RotSlot, TimeSync,
+    BaseboardId, Caboose, CockroachStatus, Collection,
+    InternalDnsGenerationStatus, NvmeFirmware, PowerState, RotPage, RotSlot,
+    TimeSync,
 };
 use omicron_common::api::external;
 use omicron_common::api::internal::shared::NetworkInterface;
@@ -2860,6 +2862,36 @@ impl From<InvNtpTimesync> for nexus_types::inventory::TimeSync {
     }
 }
 
+#[derive(Queryable, Clone, Debug, Selectable, Insertable)]
+#[diesel(table_name = inv_internal_dns)]
+pub struct InvInternalDns {
+    pub inv_collection_id: DbTypedUuid<CollectionKind>,
+    pub zone_id: DbTypedUuid<OmicronZoneKind>,
+    pub generation: Generation,
+}
+
+impl InvInternalDns {
+    pub fn new(
+        inv_collection_id: CollectionUuid,
+        status: &InternalDnsGenerationStatus,
+    ) -> Result<Self, anyhow::Error> {
+        Ok(Self {
+            inv_collection_id: inv_collection_id.into(),
+            zone_id: status.zone_id.into(),
+            generation: Generation(status.generation),
+        })
+    }
+}
+
+impl From<InvInternalDns> for InternalDnsGenerationStatus {
+    fn from(value: InvInternalDns) -> Self {
+        Self {
+            zone_id: value.zone_id.into(),
+            generation: value.generation.into(),
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use nexus_types::inventory::NvmeFirmware;

nexus/db-model/src/inventory.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(169, 0, 0);
+pub const SCHEMA_VERSION: Version = Version::new(170, 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(170, "inv-internal-dns"),
         KnownVersion::new(169, "inv-ntp-timesync"),
         KnownVersion::new(168, "add-inv-host-phase-1-flash-hash"),
         KnownVersion::new(167, "add-pending-mgs-updates-rot"),

nexus/db-model/src/schema_versions.rs

@@ -41,6 +41,7 @@ use nexus_db_model::InvConfigReconcilerStatus;
 use nexus_db_model::InvConfigReconcilerStatusKind;
 use nexus_db_model::InvDataset;
 use nexus_db_model::InvHostPhase1FlashHash;
+use nexus_db_model::InvInternalDns;
 use nexus_db_model::InvLastReconciliationDatasetResult;
 use nexus_db_model::InvLastReconciliationDiskResult;
 use nexus_db_model::InvLastReconciliationOrphanedDataset;
@@ -96,6 +97,7 @@ use nexus_sled_agent_shared::inventory::ZoneManifestNonBootInventory;
 use nexus_types::inventory::BaseboardId;
 use nexus_types::inventory::CockroachStatus;
 use nexus_types::inventory::Collection;
+use nexus_types::inventory::InternalDnsGenerationStatus;
 use nexus_types::inventory::PhysicalDiskFirmware;
 use nexus_types::inventory::SledAgent;
 use nexus_types::inventory::TimeSync;
@@ -398,6 +400,13 @@ impl DataStore {
             .collect::<Result<Vec<_>, _>>()
             .map_err(|e| Error::internal_error(&e.to_string()))?;
 
+        let inv_internal_dns_records: Vec<InvInternalDns> = collection
+            .internal_dns_generation_status
+            .iter()
+            .map(|status| InvInternalDns::new(collection_id, status))
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| Error::internal_error(&e.to_string()))?;
+
         // This implementation inserts all records associated with the
         // collection in one transaction.  This is primarily for simplicity.  It
         // means we don't have to worry about other readers seeing a
@@ -1516,6 +1525,15 @@ impl DataStore {
                     .await?;
             }
 
+            // Insert the internal DNS generation status we've observed
+            if !inv_internal_dns_records.is_empty() {
+                use nexus_db_schema::schema::inv_internal_dns::dsl;
+                diesel::insert_into(dsl::inv_internal_dns)
+                    .values(inv_internal_dns_records)
+                    .execute_async(&conn)
+                    .await?;
+            }
+
             // Finally, insert the list of errors.
             {
                 use nexus_db_schema::schema::inv_collection_error::dsl as errors_dsl;
@@ -1807,6 +1825,7 @@ impl DataStore {
             nclickhouse_keeper_membership: usize,
             ncockroach_status: usize,
             nntp_timesync: usize,
+            ninternal_dns: usize,
         }
 
         let NumRowsDeleted {
@@ -1839,6 +1858,7 @@ impl DataStore {
             nclickhouse_keeper_membership,
             ncockroach_status,
             nntp_timesync,
+            ninternal_dns,
         } =
             self.transaction_retry_wrapper("inventory_delete_collection")
                 .transaction(&conn, |conn| async move {
@@ -2117,6 +2137,18 @@ impl DataStore {
                         .await?
                     };
 
+                    // Remove rows for internal DNS
+                    let ninternal_dns = {
+                        use nexus_db_schema::schema::inv_internal_dns::dsl;
+                        diesel::delete(
+                            dsl::inv_internal_dns.filter(
+                                dsl::inv_collection_id.eq(db_collection_id),
+                            ),
+                        )
+                        .execute_async(&conn)
+                        .await?
+                    };
+
                     Ok(NumRowsDeleted {
                         ncollections,
                         nsps,
@@ -2147,6 +2179,7 @@ impl DataStore {
                         nclickhouse_keeper_membership,
                         ncockroach_status,
                         nntp_timesync,
+                        ninternal_dns,
                     })
                 })
                 .await
@@ -2189,6 +2222,7 @@ impl DataStore {
             "nclickhouse_keeper_membership" => nclickhouse_keeper_membership,
             "ncockroach_status" => ncockroach_status,
             "nntp_timesync" => nntp_timesync,
+            "ninternal_dns" => ninternal_dns,
         );
 
         Ok(())
@@ -3638,6 +3672,27 @@ impl DataStore {
                 .collect::<IdOrdMap<_>>()
         };
 
+        // Load internal DNS generation status
+        let internal_dns_generation_status: IdOrdMap<
+            InternalDnsGenerationStatus,
+        > = {
+            use nexus_db_schema::schema::inv_internal_dns::dsl;
+
+            let records: Vec<InvInternalDns> = dsl::inv_internal_dns
+                .filter(dsl::inv_collection_id.eq(db_id))
+                .select(InvInternalDns::as_select())
+                .load_async(&*conn)
+                .await
+                .map_err(|e| {
+                    public_error_from_diesel(e, ErrorHandler::Server)
+                })?;
+
+            records
+                .into_iter()
+                .map(|record| InternalDnsGenerationStatus::from(record))
+                .collect::<IdOrdMap<_>>()
+        };
+
         // Finally, build up the sled-agent map using the sled agent and
         // omicron zone rows. A for loop is easier to understand than into_iter
         // + filter_map + return Result + collect.
@@ -3886,6 +3941,7 @@ impl DataStore {
             clickhouse_keeper_cluster_membership,
             cockroach_status,
             ntp_timesync,
+            internal_dns_generation_status,
         })
     }
 }

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

@@ -1920,6 +1920,14 @@ table! {
     }
 }
 
+table! {
+    inv_internal_dns (inv_collection_id, zone_id) {
+        inv_collection_id -> Uuid,
+        zone_id -> Uuid,
+        generation -> Int8,
+    }
+}
+
 /* blueprints */
 
 table! {

nexus/db-schema/src/schema.rs

@@ -13,6 +13,7 @@ base64.workspace = true
 camino.workspace = true
 chrono.workspace = true
 clickhouse-admin-keeper-client.workspace = true
+dns-service-client.workspace = true
 clickhouse-admin-server-client.workspace = true
 clickhouse-admin-types.workspace = true
 futures.workspace = true

nexus/inventory/Cargo.toml

@@ -26,6 +26,7 @@ use nexus_types::inventory::CabooseWhich;
 use nexus_types::inventory::CockroachStatus;
 use nexus_types::inventory::Collection;
 use nexus_types::inventory::HostPhase1FlashHash;
+use nexus_types::inventory::InternalDnsGenerationStatus;
 use nexus_types::inventory::RotPage;
 use nexus_types::inventory::RotPageFound;
 use nexus_types::inventory::RotPageWhich;
@@ -127,6 +128,7 @@ pub struct CollectionBuilder {
         BTreeSet<ClickhouseKeeperClusterMembership>,
     cockroach_status: BTreeMap<NodeId, CockroachStatus>,
     ntp_timesync: IdOrdMap<TimeSync>,
+    internal_dns_generation_status: IdOrdMap<InternalDnsGenerationStatus>,
     // CollectionBuilderRng is taken by value, rather than passed in as a
     // mutable ref, to encourage a tree-like structure where each RNG is
     // generally independent.
@@ -159,6 +161,7 @@ impl CollectionBuilder {
             clickhouse_keeper_cluster_membership: BTreeSet::new(),
             cockroach_status: BTreeMap::new(),
             ntp_timesync: IdOrdMap::new(),
+            internal_dns_generation_status: IdOrdMap::new(),
             rng: CollectionBuilderRng::from_entropy(),
         }
     }
@@ -184,6 +187,7 @@ impl CollectionBuilder {
                 .clickhouse_keeper_cluster_membership,
             cockroach_status: self.cockroach_status,
             ntp_timesync: self.ntp_timesync,
+            internal_dns_generation_status: self.internal_dns_generation_status,
         }
     }
 
@@ -652,6 +656,19 @@ impl CollectionBuilder {
             metrics.get_metric_unsigned(CockroachMetric::LivenessLiveNodes);
         self.cockroach_status.insert(node_id, status);
     }
+
+    /// Record information about internal DNS generation status
+    pub fn found_internal_dns_generation_status(
+        &mut self,
+        status: InternalDnsGenerationStatus,
+    ) -> Result<(), anyhow::Error> {
+        self.internal_dns_generation_status
+            .insert_unique(status)
+            .map_err(|err| err.into_owned())
+            .context(
+                "Internal DNS server reported generation status multiple times",
+            )
+    }
 }
 
 /// Returns the current time, truncated to the previous microsecond.
@@ -712,6 +729,7 @@ mod test {
         assert!(collection.clickhouse_keeper_cluster_membership.is_empty());
         assert!(collection.cockroach_status.is_empty());
         assert!(collection.ntp_timesync.is_empty());
+        assert!(collection.internal_dns_generation_status.is_empty());
     }
 
     // Simple test of a single, fairly typical collection that contains just