add omdb reconfigurator history (#7600)

Author: davepacheco

dev-tools/omdb/src/bin/omdb/reconfigurator.rs

@@ -8,17 +8,28 @@ use crate::Omdb;
 use crate::check_allow_destructive::DestructiveOperationToken;
 use crate::db::DbUrlOptions;
 use anyhow::Context as _;
+use async_bb8_diesel::AsyncRunQueryDsl;
 use camino::Utf8PathBuf;
 use clap::Args;
 use clap::Subcommand;
+use diesel::ExpressionMethods;
+use diesel::QueryDsl;
+use diesel::SelectableHelper;
+use nexus_db_model::BpTarget;
 use nexus_db_queries::authz;
 use nexus_db_queries::context::OpContext;
 use nexus_db_queries::db::DataStore;
+use nexus_db_queries::db::datastore::SQL_BATCH_SIZE;
+use nexus_db_queries::db::pagination::Paginator;
+use nexus_types::deployment::Blueprint;
+use nexus_types::deployment::BlueprintMetadata;
 use nexus_types::deployment::UnstableReconfiguratorState;
 use omicron_common::api::external::Error;
 use omicron_common::api::external::LookupType;
+use omicron_uuid_kinds::BlueprintUuid;
 use omicron_uuid_kinds::GenericUuid;
 use slog::Logger;
+use std::collections::BTreeMap;
 
 /// Arguments to the "omdb reconfigurator" subcommand
 #[derive(Debug, Args)]
@@ -40,6 +51,8 @@ enum ReconfiguratorCommands {
     /// Save the current Reconfigurator state to a file and remove historical
     /// artifacts from the live system (e.g., non-target blueprints)
     Archive(ExportArgs),
+    /// Show recent history of blueprints
+    History(HistoryArgs),
 }
 
 #[derive(Debug, Args, Clone)]
@@ -48,6 +61,17 @@ struct ExportArgs {
     output_file: Utf8PathBuf,
 }
 
+#[derive(Debug, Args, Clone)]
+struct HistoryArgs {
+    /// how far back in the history to show (number of targets)
+    #[clap(long, default_value_t = 128)]
+    limit: u32,
+
+    /// also attempt to diff blueprints
+    #[clap(long, default_value_t = false)]
+    diff: bool,
+}
+
 impl ReconfiguratorArgs {
     /// Run a `omdb reconfigurator` subcommand.
     pub(crate) async fn run_cmd(
@@ -77,6 +101,14 @@ impl ReconfiguratorArgs {
                         )
                         .await
                     }
+                    ReconfiguratorCommands::History(history_args) => {
+                        cmd_reconfigurator_history(
+                            &opctx,
+                            &datastore,
+                            history_args,
+                        )
+                        .await
+                    }
                 }
             })
             .await
@@ -192,3 +224,142 @@ async fn cmd_reconfigurator_archive(
 
     Ok(())
 }
+
+/// Show recent history of blueprints
+async fn cmd_reconfigurator_history(
+    opctx: &OpContext,
+    datastore: &DataStore,
+    history_args: &HistoryArgs,
+) -> anyhow::Result<()> {
+    // Select recent targets.
+    let limit = history_args.limit;
+    let mut targets: Vec<_> = {
+        use nexus_db_queries::db::schema::bp_target::dsl;
+        let conn = datastore
+            .pool_connection_for_tests()
+            .await
+            .context("obtaining connection")?;
+        dsl::bp_target
+            .select(BpTarget::as_select())
+            .order_by(dsl::version.desc())
+            .limit(i64::from(limit))
+            .get_results_async(&*conn)
+            .await
+            .context("listing targets")?
+    };
+
+    // Select everything from the blueprint table.
+    // This shouldn't be very large.
+    let mut all_blueprints: BTreeMap<BlueprintUuid, BlueprintMetadata> =
+        BTreeMap::new();
+    let mut paginator = Paginator::new(SQL_BATCH_SIZE);
+    while let Some(p) = paginator.next() {
+        let records_batch = datastore
+            .blueprints_list(opctx, &p.current_pagparams())
+            .await
+            .context("batch of blueprints")?;
+        paginator = p.found_batch(&records_batch, &|b| *b.id.as_untyped_uuid());
+        all_blueprints.extend(records_batch.into_iter().map(|b| (b.id, b)));
+    }
+
+    // Sort the target list in increasing order.
+    // (This should be the same as reversing it.)
+    targets.sort_by_key(|b| b.version);
+
+    // Now, print the history.
+    println!("{:>5} {:24} {:36}", "VERSN", "TIME", "BLUEPRINT");
+    if targets.len() == usize::try_from(limit).unwrap() {
+        println!("... (earlier history omitted)");
+    }
+
+    // prev_blueprint_id is `None` only during the first iteration.
+    let mut prev_blueprint_id: Option<BlueprintUuid> = None;
+
+    // prev_blueprint is `None` if any of these is true:
+    // - if we're not printing diffs
+    // - if this is the first iteration of the loop
+    // - if the previous blueprint was missing from the database or we didn't
+    //   load it because _it_ was the first iteration of the loop or _its_
+    //   parent was missing from the database
+    let mut prev_blueprint: Option<Blueprint> = None;
+
+    for t in targets {
+        let target_id = BlueprintUuid::from(t.blueprint_id);
+
+        print!(
+            "{:>5} {} {} {:>8}",
+            t.version,
+            humantime::format_rfc3339_millis(t.time_made_target.into()),
+            target_id,
+            if t.enabled { "enabled" } else { "disabled" },
+        );
+
+        if prev_blueprint_id == Some(target_id) {
+            // The only change here could be to the enable/disable bit.
+            // There's nothing else to say.
+            println!();
+        } else {
+            // The blueprint id changed.
+            let comment = match all_blueprints.get(&target_id) {
+                Some(b) => &b.comment,
+                None => "blueprint details no longer available",
+            };
+            println!(": {}", comment);
+
+            match (
+                // are we printing diffs?
+                history_args.diff,
+                // was the previous blueprint (if any) in the database?
+                prev_blueprint_id
+                    .and_then(|prev_id| all_blueprints.get(&prev_id)),
+                // is this blueprint in the database?
+                all_blueprints.get(&target_id),
+            ) {
+                (true, Some(previous), Some(_)) => {
+                    // In this case, we are printing diffs and both the previous
+                    // and current blueprints are in the database.
+                    //
+                    // We might already have loaded the full previous blueprint,
+                    // if we took this branch on the last iteration.  But we
+                    // might not have, if that blueprint's parent was absent
+                    // from the database.
+                    let previous_blueprint = match prev_blueprint {
+                        Some(p) => p,
+                        None => {
+                            blueprint_load(opctx, datastore, previous.id)
+                                .await?
+                        }
+                    };
+                    assert_eq!(previous_blueprint.id, previous.id);
+                    let current_blueprint =
+                        blueprint_load(opctx, datastore, target_id).await?;
+                    let diff = current_blueprint
+                        .diff_since_blueprint(&previous_blueprint);
+                    println!("{}", diff.display());
+                    prev_blueprint = Some(current_blueprint);
+                }
+                _ => {
+                    prev_blueprint = None;
+                }
+            };
+        }
+
+        prev_blueprint_id = Some(target_id);
+    }
+
+    Ok(())
+}
+
+async fn blueprint_load(
+    opctx: &OpContext,
+    datastore: &DataStore,
+    id: BlueprintUuid,
+) -> anyhow::Result<Blueprint> {
+    let id = *id.as_untyped_uuid();
+    let authz_blueprint =
+        authz::Blueprint::new(authz::FLEET, id, LookupType::ById(id));
+    datastore
+        .blueprint_read(opctx, &authz_blueprint)
+        .await
+        .with_context(|| format!("read blueprint {}", id))
+}

dev-tools/omdb/tests/usage_errors.out

@@ -842,6 +842,7 @@ Commands:
   export   Save the current Reconfigurator state to a file
   archive  Save the current Reconfigurator state to a file and remove historical artifacts from the
            live system (e.g., non-target blueprints)
+  history  Show recent history of blueprints
   help     Print this message or the help of the given subcommand(s)
 
 Options: