feat(enterprise): implement cluster manager settings commands (#164) (#292)

- Add Get command to retrieve all or specific settings
- Add Set and SetValue commands to update settings
- Add Reset command to restore defaults
- Add Export/Import for backup and migration
- Add Validate command to check settings before applying
- Add ListCategories and GetCategory for organized access
- Support for nested settings using dot notation
- Comprehensive mdBook documentation with examples
- Successfully tested against Docker environment

Author: joshrotenberg

crates/redisctl/src/cli.rs

@@ -968,6 +968,9 @@ pub enum EnterpriseCommands {
     /// Cluster operations
     #[command(subcommand)]
     Cluster(EnterpriseClusterCommands),
+    /// Cluster manager settings
+    #[command(subcommand, name = "cm-settings")]
+    CmSettings(crate::commands::enterprise::cm_settings::CmSettingsCommands),
 
     /// Database operations
     #[command(subcommand)]

crates/redisctl/src/commands/enterprise/cm_settings.rs

@@ -0,0 +1,337 @@
+use anyhow::Context;
+use clap::Subcommand;
+
+use crate::cli::OutputFormat;
+use crate::connection::ConnectionManager;
+use crate::error::Result as CliResult;
+
+#[derive(Debug, Clone, Subcommand)]
+pub enum CmSettingsCommands {
+    /// Get all cluster manager settings
+    Get {
+        /// Get specific setting by path using JMESPath
+        #[arg(long)]
+        setting: Option<String>,
+    },
+
+    /// Update cluster manager settings
+    Set {
+        /// Settings data (JSON file or inline, use @filename or - for stdin)
+        #[arg(short, long)]
+        data: String,
+
+        /// Force update without confirmation
+        #[arg(short, long)]
+        force: bool,
+    },
+
+    /// Update a specific setting
+    #[command(name = "set-value")]
+    SetValue {
+        /// Setting name/path
+        name: String,
+
+        /// New value for the setting
+        #[arg(long)]
+        value: String,
+
+        /// Force update without confirmation
+        #[arg(short, long)]
+        force: bool,
+    },
+
+    /// Reset settings to defaults
+    Reset {
+        /// Force reset without confirmation
+        #[arg(short, long)]
+        force: bool,
+    },
+
+    /// Export settings to file
+    Export {
+        /// Output file path (use - for stdout)
+        #[arg(short, long, default_value = "-")]
+        output: String,
+    },
+
+    /// Import settings from file
+    Import {
+        /// Input file path (use @filename or - for stdin)
+        #[arg(short, long)]
+        file: String,
+
+        /// Force import without confirmation
+        #[arg(short, long)]
+        force: bool,
+    },
+
+    /// Validate settings without applying
+    Validate {
+        /// Settings file to validate (use @filename or - for stdin)
+        #[arg(short, long)]
+        file: String,
+    },
+
+    /// List all setting categories
+    #[command(name = "list-categories")]
+    ListCategories,
+
+    /// Get settings by category
+    #[command(name = "get-category")]
+    GetCategory {
+        /// Category name
+        category: String,
+    },
+}
+
+impl CmSettingsCommands {
+    #[allow(dead_code)]
+    pub async fn execute(
+        &self,
+        conn_mgr: &ConnectionManager,
+        profile_name: Option<&str>,
+        output_format: OutputFormat,
+        query: Option<&str>,
+    ) -> CliResult<()> {
+        let client = conn_mgr.create_enterprise_client(profile_name).await?;
+
+        match self {
+            CmSettingsCommands::Get { setting } => {
+                let response: serde_json::Value = client
+                    .get("/v1/cm_settings")
+                    .await
+                    .context("Failed to get cluster manager settings")?;
+
+                let output_data = if let Some(s) = setting {
+                    // Use the setting parameter as a JMESPath query
+                    super::utils::apply_jmespath(&response, s)?
+                } else if let Some(q) = query {
+                    super::utils::apply_jmespath(&response, q)?
+                } else {
+                    response
+                };
+                super::utils::print_formatted_output(output_data, output_format)?;
+            }
+
+            CmSettingsCommands::Set { data, force } => {
+                if !force && !super::utils::confirm_action("Update cluster manager settings?")? {
+                    return Ok(());
+                }
+
+                let json_data = super::utils::read_json_data(data)?;
+
+                let response: serde_json::Value =
+                    client
+                        .put("/v1/cm_settings", &json_data)
+                        .await
+                        .context("Failed to update cluster manager settings")?;
+
+                println!("Cluster manager settings updated successfully");
+
+                let output_data = if let Some(q) = query {
+                    super::utils::apply_jmespath(&response, q)?
+                } else {
+                    response
+                };
+                super::utils::print_formatted_output(output_data, output_format)?;
+            }
+
+            CmSettingsCommands::SetValue { name, value, force } => {
+                if !force && !super::utils::confirm_action(&format!("Update setting '{}'?", name))?
+                {
+                    return Ok(());
+                }
+
+                // Get current settings
+                let mut settings: serde_json::Value = client
+                    .get("/v1/cm_settings")
+                    .await
+                    .context("Failed to get current settings")?;
+
+                // Parse value as JSON if possible, otherwise as string
+                let parsed_value: serde_json::Value =
+                    serde_json::from_str(value).unwrap_or_else(|_| serde_json::json!(value));
+
+                // Update the specific setting
+                if name.contains('.') {
+                    // Handle nested settings
+                    let parts: Vec<&str> = name.split('.').collect();
+                    let mut current = &mut settings;
+
+                    for (i, part) in parts.iter().enumerate() {
+                        if i == parts.len() - 1 {
+                            current[part] = parsed_value.clone();
+                        } else {
+                            current = &mut current[part];
+                        }
+                    }
+                } else {
+                    settings[name] = parsed_value;
+                }
+
+                // Update settings
+                let response: serde_json::Value = client
+                    .put("/v1/cm_settings", &settings)
+                    .await
+                    .context("Failed to update setting")?;
+
+                println!("Setting '{}' updated to: {}", name, value);
+
+                let output_data = if let Some(q) = query {
+                    super::utils::apply_jmespath(&response, q)?
+                } else {
+                    response
+                };
+                super::utils::print_formatted_output(output_data, output_format)?;
+            }
+
+            CmSettingsCommands::Reset { force } => {
+                if !force
+                    && !super::utils::confirm_action(
+                        "Reset all cluster manager settings to defaults?",
+                    )?
+                {
+                    return Ok(());
+                }
+
+                // Reset by sending empty object
+                let response: serde_json::Value = client
+                    .put("/v1/cm_settings", &serde_json::json!({}))
+                    .await
+                    .context("Failed to reset settings")?;
+
+                println!("Cluster manager settings reset to defaults");
+
+                let output_data = if let Some(q) = query {
+                    super::utils::apply_jmespath(&response, q)?
+                } else {
+                    response
+                };
+                super::utils::print_formatted_output(output_data, output_format)?;
+            }
+
+            CmSettingsCommands::Export { output } => {
+                let settings: serde_json::Value = client
+                    .get("/v1/cm_settings")
+                    .await
+                    .context("Failed to get settings for export")?;
+
+                if output == "-" {
+                    // Output to stdout
+                    super::utils::print_formatted_output(settings, output_format)?;
+                } else {
+                    // Write to file
+                    let json_str = serde_json::to_string_pretty(&settings)
+                        .context("Failed to serialize settings")?;
+                    std::fs::write(output, json_str).context("Failed to write settings to file")?;
+                    println!("Settings exported to: {}", output);
+                }
+            }
+
+            CmSettingsCommands::Import { file, force } => {
+                if !force
+                    && !super::utils::confirm_action("Import cluster manager settings from file?")?
+                {
+                    return Ok(());
+                }
+
+                let json_data = super::utils::read_json_data(file)?;
+
+                let response: serde_json::Value = client
+                    .put("/v1/cm_settings", &json_data)
+                    .await
+                    .context("Failed to import settings")?;
+
+                println!("Settings imported successfully");
+
+                let output_data = if let Some(q) = query {
+                    super::utils::apply_jmespath(&response, q)?
+                } else {
+                    response
+                };
+                super::utils::print_formatted_output(output_data, output_format)?;
+            }
+
+            CmSettingsCommands::Validate { file } => {
+                let json_data = super::utils::read_json_data(file)?;
+
+                // Try to validate by doing a dry-run (if supported)
+                // For now, just validate JSON structure
+                if json_data.is_object() {
+                    println!("Settings file is valid JSON");
+
+                    // Check for known required fields if any
+                    let obj = json_data.as_object().unwrap();
+
+                    // List known categories/fields for informational purposes
+                    println!("\nFound settings categories:");
+                    for key in obj.keys() {
+                        println!("  - {}", key);
+                    }
+                } else {
+                    return Err(
+                        anyhow::anyhow!("Invalid settings format: expected JSON object").into(),
+                    );
+                }
+            }
+
+            CmSettingsCommands::ListCategories => {
+                let settings: serde_json::Value = client
+                    .get("/v1/cm_settings")
+                    .await
+                    .context("Failed to get settings")?;
+
+                // Extract top-level keys as categories
+                let categories = if let Some(obj) = settings.as_object() {
+                    let cats: Vec<String> = obj.keys().cloned().collect();
+                    serde_json::json!(cats)
+                } else {
+                    serde_json::json!([])
+                };
+
+                let output_data = if let Some(q) = query {
+                    super::utils::apply_jmespath(&categories, q)?
+                } else {
+                    categories
+                };
+                super::utils::print_formatted_output(output_data, output_format)?;
+            }
+
+            CmSettingsCommands::GetCategory { category } => {
+                let settings: serde_json::Value = client
+                    .get("/v1/cm_settings")
+                    .await
+                    .context("Failed to get settings")?;
+
+                // Extract specific category
+                let category_data = &settings[category];
+
+                if category_data.is_null() {
+                    return Err(anyhow::anyhow!("Category '{}' not found", category).into());
+                }
+
+                let output_data = if let Some(q) = query {
+                    super::utils::apply_jmespath(category_data, q)?
+                } else {
+                    category_data.clone()
+                };
+                super::utils::print_formatted_output(output_data, output_format)?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[allow(dead_code)]
+pub async fn handle_cm_settings_command(
+    conn_mgr: &ConnectionManager,
+    profile_name: Option<&str>,
+    cm_settings_cmd: CmSettingsCommands,
+    output_format: OutputFormat,
+    query: Option<&str>,
+) -> CliResult<()> {
+    cm_settings_cmd
+        .execute(conn_mgr, profile_name, output_format, query)
+        .await
+}

crates/redisctl/src/commands/enterprise/mod.rs

@@ -4,6 +4,7 @@ pub mod actions;
 pub mod bdb_group;
 pub mod cluster;
 pub mod cluster_impl;
+pub mod cm_settings;
 pub mod crdb;
 pub mod crdb_impl;
 pub mod crdb_task;

crates/redisctl/src/main.rs

@@ -216,6 +216,16 @@ async fn execute_enterprise_command(
             )
             .await
         }
+        CmSettings(cm_settings_cmd) => {
+            commands::enterprise::cm_settings::handle_cm_settings_command(
+                conn_mgr,
+                profile,
+                cm_settings_cmd.clone(),
+                output,
+                query,
+            )
+            .await
+        }
         Database(db_cmd) => {
             commands::enterprise::database::handle_database_command(
                 conn_mgr, profile, db_cmd, output, query,

docs/src/SUMMARY.md

@@ -28,6 +28,7 @@
 
 - [Overview](./enterprise/overview.md)
 - [Cluster](./enterprise/cluster.md)
+- [CM Settings](./enterprise/cm-settings.md)
 - [Databases](./enterprise/databases.md)
 - [Database Groups](./enterprise/bdb-groups.md)
 - [Shards](./enterprise/shards.md)