WIP: Blueprint planner test

Author: plotnick

nexus/src/app/background/tasks/blueprint_planner.rs

@@ -69,6 +69,7 @@ impl BlueprintPlanner {
             return status;
         };
         let (target, parent) = &*loaded;
+        status.unchanged = true;
         status.blueprint_id = parent.id;
 
         // Get the inventory most recently seen by the collection
@@ -162,6 +163,7 @@ impl BlueprintPlanner {
                 "parent_blueprint_id" => %parent.id,
                 "blueprint_id" => %blueprint.id,
             );
+            status.unchanged = false;
             status.blueprint_id = blueprint.id;
 
             // Save it.
@@ -218,7 +220,6 @@ impl BlueprintPlanner {
                 "blueprint unchanged from current target";
                 "parent_blueprint_id" => %parent.id,
             );
-            status.unchanged = true;
         }
 
         status
@@ -233,3 +234,193 @@ impl BackgroundTask for BlueprintPlanner {
         Box::pin(async move { json!(self.plan(opctx).await) })
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::app::background::tasks::blueprint_load::TargetBlueprintLoader;
+    use crate::app::background::tasks::inventory_collection::InventoryCollector;
+    use nexus_db_model::{
+        ByteCount, PhysicalDisk, PhysicalDiskKind, SledBaseboard,
+        SledSystemHardware, SledUpdate, Zpool,
+    };
+    use nexus_test_utils_macros::nexus_test;
+    use nexus_types::deployment::{
+        BlueprintPhysicalDiskDisposition, BlueprintZoneDisposition, SledDisk,
+    };
+    use nexus_types::external_api::views::{
+        PhysicalDiskPolicy, PhysicalDiskState,
+    };
+    use omicron_common::disk::DiskIdentity;
+    use omicron_uuid_kinds::GenericUuid as _;
+    use omicron_uuid_kinds::PhysicalDiskUuid;
+    use omicron_uuid_kinds::SledUuid;
+    use std::net::SocketAddr;
+    use uuid::Uuid;
+
+    type ControlPlaneTestContext =
+        nexus_test_utils::ControlPlaneTestContext<crate::Server>;
+
+    #[nexus_test(server = crate::Server)]
+    async fn test_blueprint_planner(cptestctx: &ControlPlaneTestContext) {
+        // Set up the test context.
+        let nexus = &cptestctx.server.server_context().nexus;
+        let datastore = nexus.datastore();
+        let opctx = OpContext::for_tests(
+            cptestctx.logctx.log.clone(),
+            datastore.clone(),
+        );
+
+        // Spin up the background tasks: blueprint loader,
+        // inventory collector, and blueprint planner.
+        let mut loader = TargetBlueprintLoader::new(datastore.clone());
+        let mut rx_loader = loader.watcher();
+        loader.activate(&opctx).await;
+        let (_target, initial_blueprint) = &*rx_loader
+            .borrow_and_update()
+            .clone()
+            .expect("no initial blueprint");
+        eprintln!("{}", initial_blueprint.display());
+
+        let resolver = internal_dns_resolver::Resolver::new_from_addrs(
+            cptestctx.logctx.log.clone(),
+            &[cptestctx.internal_dns.dns_server.local_address()],
+        )
+        .unwrap();
+        let mut collector = InventoryCollector::new(
+            datastore.clone(),
+            resolver.clone(),
+            "test_planner",
+            1,
+            false,
+        );
+        let rx_collector = collector.watcher();
+        collector.activate(&opctx).await;
+
+        let mut planner = BlueprintPlanner::new(
+            datastore.clone(),
+            false,
+            rx_collector,
+            rx_loader,
+        );
+        let mut rx_planner = planner.watcher();
+
+        // Without further setup, the planner should run but fail due
+        // to insufficient resources.
+        let status = serde_json::from_value::<BlueprintPlannerStatus>(
+            planner.activate(&opctx).await,
+        )
+        .unwrap();
+        assert!(!status.disabled);
+        assert!(status.unchanged);
+        assert_eq!(status.blueprint_id, initial_blueprint.id);
+        assert!({
+            let error = status.error.as_deref().unwrap();
+            error.starts_with("can't plan: ")
+                && error.ends_with(
+                    "no available zpools for additional InternalNtp zones",
+                )
+        });
+
+        // Set up some mock sleds.
+        let mut sled1 = httptest::Server::run();
+        let mut sled2 = httptest::Server::run();
+        let mock_server_ack_requests = |s: &mut httptest::Server| {
+            s.expect(
+                httptest::Expectation::matching(httptest::matchers::any())
+                    .times(..)
+                    .respond_with(httptest::responders::status_code(200)),
+            );
+        };
+        mock_server_ack_requests(&mut sled1);
+        mock_server_ack_requests(&mut sled2);
+
+        let sled_id1 = SledUuid::new_v4();
+        let sled_id2 = SledUuid::new_v4();
+        let rack_id = Uuid::new_v4();
+        for (i, (sled_id, server)) in
+            [(sled_id1, &sled1), (sled_id2, &sled2)].iter().enumerate()
+        {
+            let SocketAddr::V6(addr) = server.addr() else {
+                panic!("expected IPv6 address, got {}", server.addr());
+            };
+            let bogus_repo_depot_port = 0;
+            let update = SledUpdate::new(
+                sled_id.into_untyped_uuid(),
+                addr,
+                bogus_repo_depot_port,
+                SledBaseboard {
+                    serial_number: i.to_string(),
+                    part_number: "test_planner".into(),
+                    revision: 1,
+                },
+                SledSystemHardware {
+                    is_scrimlet: false,
+                    usable_hardware_threads: 4,
+                    usable_physical_ram: ByteCount(1000.into()),
+                    reservoir_size: ByteCount(999.into()),
+                },
+                rack_id,
+                nexus_db_model::Generation::new(),
+            );
+            datastore.sled_upsert(update).await.expect("failed to upsert sled");
+        }
+
+        // Add some disks & zpools for zone planning.
+        for sled_id in initial_blueprint.sleds() {
+            for i in 0..=1 {
+                let disk = PhysicalDisk::new(
+                    PhysicalDiskUuid::new_v4(),
+                    String::from("fake-vendor"),
+                    format!("serial-{i}"),
+                    String::from("fake-model"),
+                    PhysicalDiskKind::U2,
+                    sled_id.into_untyped_uuid(),
+                );
+                let zpool = Zpool::new(
+                    Uuid::new_v4(),
+                    sled_id.into_untyped_uuid(),
+                    disk.id(),
+                    ByteCount(0.into()),
+                );
+                datastore
+                    .physical_disk_and_zpool_insert(&opctx, disk, zpool)
+                    .await
+                    .unwrap();
+            }
+        }
+        collector.activate(&opctx).await;
+
+        // Planning should eventually succeed.
+        let mut blueprint_id = initial_blueprint.id;
+        for i in 0..10 {
+            let status = serde_json::from_value::<BlueprintPlannerStatus>(
+                planner.activate(&opctx).await,
+            )
+            .unwrap();
+            if let Some(error) = status.error {
+                eprintln!("planning iteration {i} failed: {error}");
+            } else {
+                assert!(!status.unchanged);
+                blueprint_id = status.blueprint_id;
+                eprintln!("planning succeeded: new blueprint {blueprint_id}");
+                break;
+            }
+        }
+
+        // Planning again should not change the plan.
+        let status = serde_json::from_value::<BlueprintPlannerStatus>(
+            planner.activate(&opctx).await,
+        )
+        .unwrap();
+        assert_eq!(
+            status,
+            BlueprintPlannerStatus {
+                disabled: false,
+                error: None,
+                unchanged: true,
+                blueprint_id,
+            }
+        );
+    }
+}