Add omdb,db,nexus api support for chicken switches (#8449)

This is an initial commit to support chicken switches that allow runtime
reconfigurator configuration.

There is only one initial chicken switch which can be used to enable the
planner background task to run.

A follow up PR will be made to add a background task that reads the
chicken switch DB table and makes it available to nexus via a watcher.
This PR will complete
#8253 .

Support for listing history was added at the datastore level, but not
made available yet in OMDB, because of the way pagination works. This
will likely come in a follow up.

Author: andrewjstone

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

@@ -4,6 +4,8 @@
 
 //! omdb commands that query or update specific Nexus instances
 
+mod chicken_switches;
+
 use crate::Omdb;
 use crate::check_allow_destructive::DestructiveOperationToken;
 use crate::db::DbUrlOptions;
@@ -15,6 +17,8 @@ use crate::helpers::should_colorize;
 use anyhow::Context as _;
 use anyhow::bail;
 use camino::Utf8PathBuf;
+use chicken_switches::ChickenSwitchesArgs;
+use chicken_switches::cmd_nexus_chicken_switches;
 use chrono::DateTime;
 use chrono::SecondsFormat;
 use chrono::Utc;
@@ -123,6 +127,8 @@ enum NexusCommands {
     BackgroundTasks(BackgroundTasksArgs),
     /// interact with blueprints
     Blueprints(BlueprintsArgs),
+    /// interact with reconfigurator chicken switches
+    ChickenSwitches(ChickenSwitchesArgs),
     /// interact with clickhouse policy
     ClickhousePolicy(ClickhousePolicyArgs),
     /// print information about pending MGS updates
@@ -678,6 +684,10 @@ impl NexusArgs {
                 cmd_nexus_blueprints_import(&client, token, args).await
             }
 
+            NexusCommands::ChickenSwitches(args) => {
+                cmd_nexus_chicken_switches(&omdb, &client, args).await
+            }
+
             NexusCommands::ClickhousePolicy(ClickhousePolicyArgs {
                 command,
             }) => match command {

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

@@ -0,0 +1,164 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+//! omdb commands for reconfigurator chicken switches
+
+use crate::Omdb;
+use crate::check_allow_destructive::DestructiveOperationToken;
+use clap::Args;
+use clap::Subcommand;
+use http::StatusCode;
+use nexus_client::types::{
+    ReconfiguratorChickenSwitches, ReconfiguratorChickenSwitchesParam,
+};
+use std::num::ParseIntError;
+use std::str::FromStr;
+
+#[derive(Debug, Args)]
+pub struct ChickenSwitchesArgs {
+    #[command(subcommand)]
+    command: ChickenSwitchesCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum ChickenSwitchesCommands {
+    /// Show a chicken switch at a given version
+    Show(ChickenSwitchesShowArgs),
+
+    /// Set the value of all chicken switches for the latest version
+    /// Values carry over from the latest version if unset on the CLI.
+    Set(ChickenSwitchesSetArgs),
+}
+
+#[derive(Debug, Clone, Args)]
+pub struct ChickenSwitchesSetArgs {
+    planner_enabled: bool,
+}
+
+#[derive(Debug, Clone, Copy, Args)]
+pub struct ChickenSwitchesShowArgs {
+    version: ChickenSwitchesVersionOrCurrent,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum ChickenSwitchesVersionOrCurrent {
+    Current,
+    Version(u32),
+}
+
+impl FromStr for ChickenSwitchesVersionOrCurrent {
+    type Err = ParseIntError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if matches!(s, "current" | "latest") {
+            Ok(Self::Current)
+        } else {
+            let version = s.parse()?;
+            Ok(Self::Version(version))
+        }
+    }
+}
+
+pub async fn cmd_nexus_chicken_switches(
+    omdb: &Omdb,
+    client: &nexus_client::Client,
+    args: &ChickenSwitchesArgs,
+) -> Result<(), anyhow::Error> {
+    match &args.command {
+        ChickenSwitchesCommands::Show(version) => {
+            chicken_switches_show(&client, version).await
+        }
+        ChickenSwitchesCommands::Set(args) => {
+            let token = omdb.check_allow_destructive()?;
+            chicken_switches_set(&client, args, token).await
+        }
+    }
+}
+async fn chicken_switches_show(
+    client: &nexus_client::Client,
+    args: &ChickenSwitchesShowArgs,
+) -> Result<(), anyhow::Error> {
+    let res = match args.version {
+        ChickenSwitchesVersionOrCurrent::Current => {
+            client.reconfigurator_chicken_switches_show_current().await
+        }
+        ChickenSwitchesVersionOrCurrent::Version(version) => {
+            client.reconfigurator_chicken_switches_show(version).await
+        }
+    };
+
+    match res {
+        Ok(switches) => {
+            let ReconfiguratorChickenSwitches {
+                version,
+                planner_enabled,
+                time_modified,
+            } = switches.into_inner();
+            println!("Reconfigurator Chicken Switches: ");
+            println!("    version: {version}");
+            println!("    modified time: {time_modified}");
+            println!("    planner enabled: {planner_enabled}");
+        }
+        Err(err) => eprintln!("error: {:#}", err),
+    }
+
+    Ok(())
+}
+
+async fn chicken_switches_set(
+    client: &nexus_client::Client,
+    args: &ChickenSwitchesSetArgs,
+    _destruction_token: DestructiveOperationToken,
+) -> Result<(), anyhow::Error> {
+    let switches = match client
+        .reconfigurator_chicken_switches_show_current()
+        .await
+    {
+        Ok(switches) => {
+            let Some(version) = switches.version.checked_add(1) else {
+                eprintln!(
+                    "ERROR: Failed to update chicken switches. Max version reached."
+                );
+                return Ok(());
+            };
+            let switches = switches.into_inner();
+            // Future switches should use the following pattern, and only update
+            // the current switch values if a setting changed.
+            //
+            // We may want to use `Options` in `args` to allow defaulting to
+            // the current setting rather than forcing the user to update all
+            // settings if the number of switches grows significantly. However,
+            // this will not play nice with the `NOT_FOUND` case below.
+            let mut modified = false;
+            if args.planner_enabled != switches.planner_enabled {
+                modified = true;
+            }
+            if modified {
+                ReconfiguratorChickenSwitchesParam {
+                    version,
+                    planner_enabled: args.planner_enabled,
+                }
+            } else {
+                println!("No modifications made to current switch values");
+                return Ok(());
+            }
+        }
+        Err(err) => {
+            if err.status() == Some(StatusCode::NOT_FOUND) {
+                ReconfiguratorChickenSwitchesParam {
+                    version: 1,
+                    planner_enabled: args.planner_enabled,
+                }
+            } else {
+                eprintln!("error: {:#}", err);
+                return Ok(());
+            }
+        }
+    };
+
+    client.reconfigurator_chicken_switches_set(&switches).await?;
+    println!("Chicken switches updated at version {}", switches.version);
+
+    Ok(())
+}

dev-tools/omdb/tests/usage_errors.out

@@ -841,6 +841,7 @@ Usage: omdb nexus [OPTIONS] <COMMAND>
 Commands:
   background-tasks      print information about background tasks
   blueprints            interact with blueprints
+  chicken-switches      interact with reconfigurator chicken switches
   clickhouse-policy     interact with clickhouse policy
   mgs-updates           print information about pending MGS updates
   oximeter-read-policy  interact with oximeter read policy

nexus/db-model/src/lib.rs

@@ -66,6 +66,7 @@ mod physical_disk_state;
 mod probe;
 mod producer_endpoint;
 mod project;
+mod reconfigurator_chicken_switches;
 mod rendezvous_debug_dataset;
 mod semver_version;
 mod serde_time_delta;
@@ -203,6 +204,7 @@ pub use producer_endpoint::*;
 pub use project::*;
 pub use quota::*;
 pub use rack::*;
+pub use reconfigurator_chicken_switches::*;
 pub use region::*;
 pub use region_replacement::*;
 pub use region_replacement_step::*;

nexus/db-model/src/reconfigurator_chicken_switches.rs

@@ -0,0 +1,52 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+//! Types representing runtime configuration for reconfigurator
+
+use crate::SqlU32;
+use chrono::{DateTime, Utc};
+use nexus_db_schema::schema::reconfigurator_chicken_switches;
+use nexus_types::deployment;
+
+#[derive(Queryable, Clone, Debug, Selectable, Insertable)]
+#[diesel(table_name = reconfigurator_chicken_switches)]
+pub struct ReconfiguratorChickenSwitches {
+    pub version: SqlU32,
+    pub planner_enabled: bool,
+    pub time_modified: DateTime<Utc>,
+}
+
+impl ReconfiguratorChickenSwitches {
+    pub fn new(version: u32, planner_enabled: bool) -> Self {
+        Self {
+            version: version.into(),
+            planner_enabled,
+            time_modified: Utc::now(),
+        }
+    }
+}
+
+impl From<deployment::ReconfiguratorChickenSwitches>
+    for ReconfiguratorChickenSwitches
+{
+    fn from(value: deployment::ReconfiguratorChickenSwitches) -> Self {
+        Self {
+            version: value.version.into(),
+            planner_enabled: value.planner_enabled,
+            time_modified: value.time_modified,
+        }
+    }
+}
+
+impl From<ReconfiguratorChickenSwitches>
+    for deployment::ReconfiguratorChickenSwitches
+{
+    fn from(value: ReconfiguratorChickenSwitches) -> Self {
+        Self {
+            version: value.version.into(),
+            planner_enabled: value.planner_enabled,
+            time_modified: value.time_modified,
+        }
+    }
+}

nexus/db-model/src/schema_versions.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(152, 0, 0);
+pub const SCHEMA_VERSION: Version = Version::new(153, 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(153, "chicken-switches"),
         KnownVersion::new(152, "ereports"),
         KnownVersion::new(151, "zone-image-resolver-inventory"),
         KnownVersion::new(150, "add-last-reconciliation-orphaned-datasets"),

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

@@ -83,6 +83,7 @@ mod probe;
 mod project;
 mod quota;
 mod rack;
+mod reconfigurator_chicken_switches;
 mod region;
 mod region_replacement;
 mod region_snapshot;