tests compile

Author: jgallagher

live-tests/tests/test_nexus_add_remove.rs

@@ -30,6 +30,7 @@ use omicron_test_utils::dev::poll::CondCheckError;
 use omicron_test_utils::dev::poll::wait_for_condition;
 use slog::{debug, info};
 use std::net::SocketAddrV6;
+use std::sync::Arc;
 use std::time::Duration;
 
 // TODO-coverage This test could check other stuff:
@@ -49,15 +50,23 @@ async fn test_nexus_add_remove(lc: &LiveTestContext) {
     let opctx = lc.opctx();
     let datastore = lc.datastore();
 
+    let (_, parent_blueprint) = datastore
+        .blueprint_target_get_current_full(opctx)
+        .await
+        .expect("obtained current target blueprint");
     let planner_config = datastore
         .reconfigurator_config_get_latest(opctx)
         .await
         .expect("obtained latest reconfigurator config")
         .map_or_else(PlannerConfig::default, |c| c.config.planner_config);
-    let planning_input =
-        PlanningInputFromDb::assemble(&opctx, &datastore, planner_config)
-            .await
-            .expect("planning input");
+    let planning_input = PlanningInputFromDb::assemble(
+        &opctx,
+        &datastore,
+        planner_config,
+        Arc::new(parent_blueprint),
+    )
+    .await
+    .expect("planning input");
     let initial_nexus_clients = lc.all_internal_nexus_clients().await.unwrap();
     let nexus = initial_nexus_clients.first().expect("internal Nexus client");
 
@@ -271,17 +280,22 @@ async fn test_nexus_add_remove(lc: &LiveTestContext) {
 
     // Now run through the planner.
     info!(log, "running through planner");
-    let planning_input =
-        PlanningInputFromDb::assemble(&opctx, &datastore, planner_config)
-            .await
-            .expect("planning input");
     let (_, parent_blueprint) = datastore
         .blueprint_target_get_current_full(opctx)
         .await
         .expect("getting latest target blueprint");
+    let planning_input = PlanningInputFromDb::assemble(
+        &opctx,
+        &datastore,
+        planner_config,
+        Arc::new(parent_blueprint),
+    )
+    .await
+    .expect("planning input");
     let planner = Planner::new_based_on(
         log.clone(),
-        &parent_blueprint,
+        // TODO john remove dup arg
+        planning_input.parent_blueprint(),
         &planning_input,
         "live test suite",
         &latest_collection,

live-tests/tests/test_nexus_handoff.rs

@@ -36,6 +36,7 @@ use std::collections::BTreeMap;
 use std::collections::BTreeSet;
 use std::net::IpAddr;
 use std::net::SocketAddr;
+use std::sync::Arc;
 use std::time::Duration;
 
 #[live_test]
@@ -163,10 +164,18 @@ async fn test_nexus_handoff(lc: &LiveTestContext) {
         .await
         .expect("obtained latest reconfigurator config")
         .map_or_else(PlannerConfig::default, |cs| cs.config.planner_config);
-    let planning_input =
-        PlanningInputFromDb::assemble(opctx, datastore, planner_config)
-            .await
-            .expect("planning input");
+    let (_, parent_blueprint) = datastore
+        .blueprint_target_get_current_full(opctx)
+        .await
+        .expect("getting latest target blueprint");
+    let planning_input = PlanningInputFromDb::assemble(
+        opctx,
+        datastore,
+        planner_config,
+        Arc::new(parent_blueprint),
+    )
+    .await
+    .expect("planning input");
     let (_blueprint_initial, blueprint_new_nexus) =
         blueprint_edit_current_target(
             log,

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

@@ -1203,12 +1203,15 @@ mod test {
         system: &SystemDescription,
         test_name: &str,
     ) -> BlueprintBuilder<'static> {
-        static EMPTY_BLUEPRINT: LazyLock<Blueprint> = LazyLock::new(|| {
-            BlueprintBuilder::build_empty("EMPTY_BLUEPRINT static")
-        });
+        static EMPTY_BLUEPRINT: LazyLock<Arc<Blueprint>> =
+            LazyLock::new(|| {
+                Arc::new(BlueprintBuilder::build_empty(
+                    "EMPTY_BLUEPRINT static",
+                ))
+            });
 
         let planning_input = system
-            .to_planning_input_builder()
+            .to_planning_input_builder(Arc::clone(&EMPTY_BLUEPRINT))
             .expect("created planning input builder")
             .build();
 

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

@@ -3003,6 +3003,7 @@ mod tests {
     use slog::info;
     use std::net::Ipv4Addr;
     use std::net::Ipv6Addr;
+    use std::sync::Arc;
 
     // Test that we detect the right error condition and return None when we
     // fail to insert a VPC due to VNI exhaustion.
@@ -3283,10 +3284,6 @@ mod tests {
             datastore.sled_upsert(sled_update).await.expect("upserting sled");
         }
         sled_ids.sort_unstable();
-        let planning_input = system
-            .to_planning_input_builder()
-            .expect("creating planning builder")
-            .build();
 
         // Helper to convert a zone's nic into an insertable nic.
         let db_nic_from_zone = |zone_config: &BlueprintZoneConfig| {
@@ -3314,9 +3311,14 @@ mod tests {
         };
 
         // Create an initial, empty blueprint, and make it the target.
-        let bp0 = BlueprintBuilder::build_empty("test");
+        let bp0 = Arc::new(BlueprintBuilder::build_empty("test"));
         bp_insert_and_make_target(&opctx, &datastore, &bp0).await;
 
+        let planning_input = system
+            .to_planning_input_builder(Arc::clone(&bp0))
+            .expect("creating planning builder")
+            .build();
+
         // Our blueprint doesn't describe any services, so we shouldn't find any
         // sled IDs running services.
         assert_service_sled_ids(&datastore, &[]).await;

nexus/reconfigurator/planning/src/blueprint_builder/builder.rs

@@ -2641,7 +2641,7 @@ pub mod test {
             }
         }
 
-        let blueprint2 = builder.build(BlueprintSource::Test);
+        let blueprint2 = Arc::new(builder.build(BlueprintSource::Test));
         verify_blueprint(&blueprint2, &example.input);
         let summary = blueprint2.diff_since_blueprint(&blueprint1);
         println!(
@@ -2658,7 +2658,11 @@ pub mod test {
 
         let _ =
             example.system.sled(SledBuilder::new().id(new_sled_id)).unwrap();
-        let input = example.system.to_planning_input_builder().unwrap().build();
+        let input = example
+            .system
+            .to_planning_input_builder(Arc::clone(&blueprint2))
+            .unwrap()
+            .build();
         let mut builder = BlueprintBuilder::new_based_on(
             &logctx.log,
             &blueprint2,

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

@@ -450,10 +450,16 @@ mod test {
         // With a target blueprint having no zones, the task should trivially
         // complete and report a successful (empty) summary.
         let generation = Generation::new();
-        let blueprint = Arc::new(
-            create_blueprint(&datastore, &opctx, BTreeMap::new(), generation)
-                .await,
-        );
+        let blueprint = {
+            let (target, blueprint) = create_blueprint(
+                &datastore,
+                &opctx,
+                BTreeMap::new(),
+                generation,
+            )
+            .await;
+            (target, Arc::new(blueprint))
+        };
         let blueprint_id = blueprint.1.id;
         blueprint_tx.send(Some(blueprint)).unwrap();
         let mut value = task.activate(&opctx).await;
@@ -541,7 +547,9 @@ mod test {
                 .expect("failed to upsert zpool");
         }
 
-        blueprint_tx.send(Some(Arc::new(blueprint.clone()))).unwrap();
+        blueprint_tx
+            .send(Some((blueprint.0, Arc::new(blueprint.1.clone()))))
+            .unwrap();
 
         // Make sure that requests get made to the sled agent.
         for s in [&mut s1, &mut s2] {
@@ -584,7 +592,9 @@ mod test {
         blueprint.1.internal_dns_version =
             blueprint.1.internal_dns_version.next();
         blueprint.0.enabled = false;
-        blueprint_tx.send(Some(Arc::new(blueprint.clone()))).unwrap();
+        blueprint_tx
+            .send(Some((blueprint.0, Arc::new(blueprint.1.clone()))))
+            .unwrap();
         let value = task.activate(&opctx).await;
         println!("when disabled: {:?}", value);
         assert_eq!(
@@ -607,7 +617,9 @@ mod test {
         // Do it all again, but configure one of the servers to fail so we can
         // verify the task's returned summary of what happened.
         blueprint.0.enabled = true;
-        blueprint_tx.send(Some(Arc::new(blueprint))).unwrap();
+        blueprint_tx
+            .send(Some((blueprint.0, Arc::new(blueprint.1.clone()))))
+            .unwrap();
         s1.expect(
             Expectation::matching(match_put_omicron_config())
                 .respond_with(status_code(204)),

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

@@ -209,15 +209,15 @@ mod test {
 
     fn create_blueprint(
         parent_blueprint_id: BlueprintUuid,
-    ) -> (BlueprintTarget, Blueprint) {
+    ) -> (BlueprintTarget, Arc<Blueprint>) {
         let id = BlueprintUuid::new_v4();
         (
             BlueprintTarget {
                 target_id: id,
                 enabled: true,
                 time_made_target: now_db_precision(),
             },
-            Blueprint {
+            Arc::new(Blueprint {
                 id,
                 sleds: BTreeMap::new(),
                 pending_mgs_updates: PendingMgsUpdates::new(),
@@ -236,7 +236,7 @@ mod test {
                 creator: "test".to_string(),
                 comment: "test blueprint".to_string(),
                 source: BlueprintSource::Test,
-            },
+            }),
         )
     }
 

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

@@ -457,7 +457,7 @@ mod test {
             TargetBlueprintLoader::new(datastore.clone(), tx_loader);
         let mut rx_loader = bp_loader.watcher();
         bp_loader.activate(&opctx).await;
-        let (_initial_target, initial_blueprint) = &*rx_loader
+        let (_initial_target, initial_blueprint) = rx_loader
             .borrow_and_update()
             .clone()
             .expect("no initial blueprint");
@@ -527,14 +527,14 @@ mod test {
 
         // Load and check the new target blueprint.
         bp_loader.activate(&opctx).await;
-        let (target, blueprint) = &*rx_loader
+        let (mut target, blueprint) = rx_loader
             .borrow_and_update()
             .clone()
             .expect("failed to load blueprint");
         assert_eq!(target.target_id, blueprint.id);
         assert_eq!(target.target_id, blueprint_id);
         assert!(
-            blueprint.diff_since_blueprint(initial_blueprint).has_changes()
+            blueprint.diff_since_blueprint(&initial_blueprint).has_changes()
         );
 
         // Planning again should not change the plan, because nothing has changed.
@@ -553,7 +553,6 @@ mod test {
         );
 
         // Enable execution.
-        let mut target = *target;
         target.enabled = true;
         datastore
             .blueprint_target_set_current_enabled(&opctx, target)
@@ -562,14 +561,14 @@ mod test {
 
         // Ping the loader again so it gets the updated target.
         bp_loader.activate(&opctx).await;
-        let (target, blueprint) = &*rx_loader
+        let (target, blueprint) = rx_loader
             .borrow_and_update()
             .clone()
             .expect("failed to re-load blueprint");
         assert_eq!(target.target_id, blueprint.id);
         assert_eq!(target.target_id, blueprint_id);
         assert!(
-            blueprint.diff_since_blueprint(initial_blueprint).has_changes()
+            blueprint.diff_since_blueprint(&initial_blueprint).has_changes()
         );
 
         // Trigger an inventory collection.

nexus/src/app/quiesce.rs

@@ -882,7 +882,7 @@ mod test {
         };
         let blueprint_id = blueprint.id;
         let (_, blueprint_rx) =
-            watch::channel(Some(Arc::new((bp_target, blueprint))));
+            watch::channel(Some((bp_target, Arc::new(blueprint))));
 
         // Insert active records for the Nexus instances.
         let conn =