[omdb] print out chicken switch diff when setting switches (#8694)

Nice quality of life improvement.

Author: sunshowers

Cargo.lock

@@ -22,6 +22,7 @@ crossterm.workspace = true
 crucible-agent-client.workspace = true
 crucible-pantry-client.workspace = true
 csv.workspace = true
+daft.workspace = true
 diesel.workspace = true
 dropshot.workspace = true
 dyn-clone.workspace = true

dev-tools/omdb/Cargo.toml

@@ -9,6 +9,7 @@ use crate::check_allow_destructive::DestructiveOperationToken;
 use clap::ArgAction;
 use clap::Args;
 use clap::Subcommand;
+use daft::Diffable;
 use http::StatusCode;
 use indent_write::io::IndentWriter;
 use nexus_types::deployment::PlannerChickenSwitches;
@@ -169,7 +170,7 @@ async fn chicken_switches_set(
     args: &ChickenSwitchesSetArgs,
     _destruction_token: DestructiveOperationToken,
 ) -> Result<(), anyhow::Error> {
-    let switches = match client
+    let (current_switches, new_switches) = match client
         .reconfigurator_chicken_switches_show_current()
         .await
     {
@@ -183,33 +184,57 @@ async fn chicken_switches_set(
             let switches = switches.into_inner();
             // Future switches should use the following pattern, and only update
             // the current switch values if a setting changed.
-            let Some(switches) = args
+            let Some(new_switches) = args
                 .switches
                 .update_if_modified(&switches.switches, next_version)
             else {
-                println!("No modifications made to current switch values");
+                println!("no modifications made to current switch values:");
+                let stdout = io::stdout();
+                let mut indented = IndentWriter::new("    ", stdout.lock());
+                // No need for writeln! here because .display() adds its own
+                // newlines.
+                write!(indented, "{}", switches.display()).unwrap();
                 return Ok(());
             };
-            switches
+            (Some(switches), new_switches)
         }
         Err(err) => {
             if err.status() == Some(StatusCode::NOT_FOUND) {
                 let default_switches = ReconfiguratorChickenSwitches::default();
                 // In this initial case, the operator expects that we always set
                 // switches.
-                ReconfiguratorChickenSwitchesParam {
+                let new_switches = ReconfiguratorChickenSwitchesParam {
                     version: 1,
                     switches: args.switches.update(&default_switches),
-                }
+                };
+                (None, new_switches)
             } else {
                 eprintln!("error: {:#}", err);
                 return Ok(());
             }
         }
     };
 
-    client.reconfigurator_chicken_switches_set(&switches).await?;
-    println!("Chicken switches updated at version {}", switches.version);
+    client.reconfigurator_chicken_switches_set(&new_switches).await?;
+    println!("chicken switches updated to version {}:", new_switches.version);
+    match current_switches {
+        Some(current_switches) => {
+            // ReconfiguratorChickenSwitchesDiffDisplay does its own
+            // indentation, so more isn't required.
+            print!(
+                "{}",
+                current_switches
+                    .switches
+                    .diff(&new_switches.switches)
+                    .display(),
+            );
+        }
+        None => {
+            let stdout = io::stdout();
+            let mut indented = IndentWriter::new("    ", stdout.lock());
+            write!(indented, "{}", new_switches.switches.display()).unwrap();
+        }
+    }
 
     Ok(())
 }

dev-tools/omdb/src/bin/omdb/nexus/chicken_switches.rs

@@ -1411,7 +1411,10 @@ EXECUTING COMMAND: omdb ["-w", "nexus", "chicken-switches", "set", "--planner-en
 termination: Exited(0)
 ---------------------------------------------
 stdout:
-Chicken switches updated at version 1
+chicken switches updated to version 1:
+    planner enabled: true
+    planner switches:
+        add zones with mupdate override:   true
 ---------------------------------------------
 stderr:
 note: using Nexus URL http://127.0.0.1:REDACTED_PORT/
@@ -1420,7 +1423,10 @@ EXECUTING COMMAND: omdb ["-w", "nexus", "chicken-switches", "set", "--add-zones-
 termination: Exited(0)
 ---------------------------------------------
 stdout:
-Chicken switches updated at version 2
+chicken switches updated to version 2:
+    planner enabled:   true (unchanged)
+    planner switches:
+    *   add zones with mupdate override:   true -> false
 ---------------------------------------------
 stderr:
 note: using Nexus URL http://127.0.0.1:REDACTED_PORT/

dev-tools/omdb/tests/successes.out

@@ -79,6 +79,8 @@ pub use chicken_switches::PlannerChickenSwitches;
 pub use chicken_switches::PlannerChickenSwitchesDiff;
 pub use chicken_switches::PlannerChickenSwitchesDisplay;
 pub use chicken_switches::ReconfiguratorChickenSwitches;
+pub use chicken_switches::ReconfiguratorChickenSwitchesDiff;
+pub use chicken_switches::ReconfiguratorChickenSwitchesDiffDisplay;
 pub use chicken_switches::ReconfiguratorChickenSwitchesDisplay;
 pub use chicken_switches::ReconfiguratorChickenSwitchesParam;
 pub use chicken_switches::ReconfiguratorChickenSwitchesView;

nexus/types/src/deployment.rs

@@ -3,16 +3,38 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 //! Runtime configuration for reconfigurator
-//!
-use std::fmt;
+
+use std::fmt::{self, Write};
 
 use chrono::{DateTime, TimeZone, Utc};
 use daft::Diffable;
+use indent_write::fmt::IndentWriter;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use crate::deployment::blueprint_display::{BpDiffState, KvList, KvPair};
 
+macro_rules! diff_row {
+    ($diff:expr, $label:expr) => {
+        if $diff.before == $diff.after {
+            KvPair::new(
+                BpDiffState::Unchanged,
+                $label,
+                super::blueprint_display::linear_table_unchanged(&$diff.after),
+            )
+        } else {
+            KvPair::new(
+                BpDiffState::Modified,
+                $label,
+                super::blueprint_display::linear_table_modified(
+                    &$diff.before,
+                    &$diff.after,
+                ),
+            )
+        }
+    };
+}
+
 #[derive(
     Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema,
 )]
@@ -87,7 +109,15 @@ impl fmt::Display for ReconfiguratorChickenSwitchesViewDisplay<'_> {
 }
 
 #[derive(
-    Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema,
+    Clone,
+    Copy,
+    Debug,
+    Diffable,
+    PartialEq,
+    Eq,
+    Serialize,
+    Deserialize,
+    JsonSchema,
 )]
 pub struct ReconfiguratorChickenSwitches {
     pub planner_enabled: bool,
@@ -134,6 +164,38 @@ impl fmt::Display for ReconfiguratorChickenSwitchesDisplay<'_> {
     }
 }
 
+impl<'a> ReconfiguratorChickenSwitchesDiff<'a> {
+    pub fn display(&self) -> ReconfiguratorChickenSwitchesDiffDisplay<'a, '_> {
+        ReconfiguratorChickenSwitchesDiffDisplay { diff: self }
+    }
+}
+
+pub struct ReconfiguratorChickenSwitchesDiffDisplay<'a, 'b> {
+    diff: &'b ReconfiguratorChickenSwitchesDiff<'a>,
+}
+
+impl fmt::Display for ReconfiguratorChickenSwitchesDiffDisplay<'_, '_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let ReconfiguratorChickenSwitchesDiff {
+            planner_enabled,
+            planner_switches,
+        } = self.diff;
+
+        let list = KvList::new(
+            None,
+            vec![diff_row!(planner_enabled, "planner enabled")],
+        );
+        // No need for writeln! here because KvList adds its own newlines.
+        write!(f, "{list}")?;
+
+        let mut indented = IndentWriter::new("    ", f);
+        writeln!(indented, "planner switches:")?;
+        write!(indented, "{}", planner_switches.display())?;
+
+        Ok(())
+    }
+}
+
 #[derive(
     Clone,
     Copy,
@@ -229,28 +291,8 @@ pub struct PlannerChickenSwitchesDiffDisplay<'a, 'b> {
 
 impl fmt::Display for PlannerChickenSwitchesDiffDisplay<'_, '_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        macro_rules! diff_row {
-            ($member:ident, $label:expr) => {
-                if self.diff.$member.before == self.diff.$member.after {
-                    KvPair::new(
-                        BpDiffState::Unchanged,
-                        $label,
-                        super::blueprint_display::linear_table_unchanged(
-                            &self.diff.$member.after,
-                        ),
-                    )
-                } else {
-                    KvPair::new(
-                        BpDiffState::Modified,
-                        $label,
-                        super::blueprint_display::linear_table_modified(
-                            &self.diff.$member.before,
-                            &self.diff.$member.after,
-                        ),
-                    )
-                }
-            };
-        }
+        let PlannerChickenSwitchesDiff { add_zones_with_mupdate_override } =
+            self.diff;
 
         let list = KvList::new(
             None,