Introduce 'vhosts delete_multiple'

Author: michaelklishin

.config/nextest.toml

@@ -15,6 +15,8 @@ read_only = { max-threads = 16 }
 isolated_vhosts = { max-threads = 8 }
 # Tests that modify users/permissions (global state)
 user_management = { max-threads = 1 }
+# Tests that modify virtual hosts (global state)
+vhost_management = { max-threads = 1 }
 # Tests that modify runtime parameters
 runtime_params = { max-threads = 1 }
 # Tests requiring complete isolation
@@ -103,7 +105,13 @@ test-group = 'runtime_params'
 [[profile.default.overrides]]
 filter = 'binary(vhosts_tests)'
 priority = 62
-test-group = 'user_management'
+test-group = 'vhost_management'
+
+# Virtual host delete_multiple tests (global vhost operations, can be flaky due to race conditions)
+[[profile.default.overrides]]
+filter = 'binary(vhosts_delete_multiple_tests)'
+priority = 61
+test-group = 'vhost_management'
 
 # Combined integration tests (creates global users)
 [[profile.default.overrides]]

CHANGELOG.md

@@ -6,6 +6,24 @@
 
 * Several commands now have minimalistic progress indicators: `federation disable_tls_peer_verification_for_all_upstreams`, `federation enable_tls_peer_verification_for_all_upstreams`, `shovels disable_tls_peer_verification_for_all_source_uris`, `shovels disable_tls_peer_verification_for_all_destination_uris`, `shovels enable_tls_peer_verification_for_all_source_uris`, and `shovels enable_tls_peer_verification_for_all_destination_uris`
 
+* `vhosts delete_multiple` is a new command that deletes multiple virtual hosts matching a regular expression pattern:
+
+  ```shell
+  # Delete all virtual hosts matching a pattern (requires explicit approval)
+  rabbitmqadmin vhosts delete_multiple --name-pattern "test-.*" --approve
+
+  # Dry-run to see what would be deleted without actually deleting
+  rabbitmqadmin vhosts delete_multiple --name-pattern "staging-.*" --dry-run
+
+  # Non-interactive mode (no --approve flag needed)
+  rabbitmqadmin --non-interactive vhosts delete_multiple --name-pattern "temp-.*"
+  ```
+
+  One virtual host — named `/`, that is, the default one — is always skipped to preserve
+  at least one functional virtual host at all times.
+
+  **Important**: this command is **very destructive** and should be used with caution. Always test with `--dry-run` first.
+
 ## v2.13.0 (Sep 26, 2025)
 
 ### Enhancements

Cargo.lock

@@ -28,6 +28,7 @@ toml = "0.9"
 color-print = "0.3"
 thiserror = "2"
 shellexpand = "3.1"
+regex = "1"
 
 log = "0.4"
 rustls = { version = "0.23", features = ["aws_lc_rs"] }

Cargo.toml

@@ -2711,7 +2711,7 @@ pub fn nodes_subcommands(pre_flight_settings: PreFlightSettings) -> [Command; 3]
     .map(|cmd| cmd.infer_long_args(pre_flight_settings.infer_long_options))
 }
 
-pub fn vhosts_subcommands(pre_flight_settings: PreFlightSettings) -> [Command; 3] {
+pub fn vhosts_subcommands(pre_flight_settings: PreFlightSettings) -> [Command; 4] {
     let list_cmd = Command::new("list")
         .long_about("Lists virtual hosts")
         .after_help(color_print::cformat!(
@@ -2764,7 +2764,32 @@ pub fn vhosts_subcommands(pre_flight_settings: PreFlightSettings) -> [Command; 3
         )
         .arg(idempotently_arg.clone());
 
-    [list_cmd, declare_cmd, delete_cmd]
+    let bulk_delete_cmd = Command::new("delete_multiple")
+        .about(color_print::cstr!("<bold><red>DANGER ZONE.</red></bold> Deletes multiple virtual hosts at once using a name matching pattern"))
+        .after_help(color_print::cformat!("<bold>Doc guide:</bold>: {}", VIRTUAL_HOST_GUIDE_URL))
+        .arg(
+            Arg::new("name_pattern")
+                .long("name-pattern")
+                .help("a regular expression that will be used to match virtual host names")
+                .required(true),
+        )
+        .arg(
+            Arg::new("approve")
+                .long("approve")
+                .action(ArgAction::SetTrue)
+                .help("this operation is very destructive and requires an explicit approval")
+                .required(false),
+        )
+        .arg(
+            Arg::new("dry_run")
+                .long("dry-run")
+                .action(ArgAction::SetTrue)
+                .help("show what would be deleted without performing the actual deletion")
+                .required(false),
+        )
+        .arg(idempotently_arg.clone());
+
+    [list_cmd, declare_cmd, delete_cmd, bulk_delete_cmd]
         .map(|cmd| cmd.infer_long_args(pre_flight_settings.infer_long_options))
 }
 

src/cli.rs

@@ -13,9 +13,10 @@
 // limitations under the License.
 #![allow(clippy::result_large_err)]
 
-use crate::constants::DEFAULT_BLANKET_POLICY_PRIORITY;
+use crate::constants::{DEFAULT_BLANKET_POLICY_PRIORITY, DEFAULT_VHOST};
 use crate::errors::CommandRunError;
 use crate::output::ProgressReporter;
+use crate::pre_flight;
 use clap::ArgMatches;
 use rabbitmq_http_client::blocking_api::Client;
 use rabbitmq_http_client::blocking_api::Result as ClientResult;
@@ -39,6 +40,7 @@ use rabbitmq_http_client::requests::{
 
 use rabbitmq_http_client::transformers::{TransformationChain, VirtualHostTransformationChain};
 use rabbitmq_http_client::{password_hashing, requests, responses};
+use regex::Regex;
 use serde::de::DeserializeOwned;
 use serde_json::Value;
 use std::fs;
@@ -1265,6 +1267,88 @@ pub fn delete_vhost(client: APIClient, command_args: &ArgMatches) -> ClientResul
     client.delete_vhost(name, idempotently)
 }
 
+pub fn delete_multiple_vhosts(
+    client: APIClient,
+    command_args: &ArgMatches,
+    prog_rep: &mut dyn ProgressReporter,
+) -> Result<Option<Vec<responses::VirtualHost>>, CommandRunError> {
+    let name_pattern = command_args.get_one::<String>("name_pattern").unwrap();
+    let approve = command_args
+        .get_one::<bool>("approve")
+        .cloned()
+        .unwrap_or(false);
+    let dry_run = command_args
+        .get_one::<bool>("dry_run")
+        .cloned()
+        .unwrap_or(false);
+    let idempotently = command_args
+        .get_one::<bool>("idempotently")
+        .cloned()
+        .unwrap_or(false);
+    let non_interactive_cli = command_args
+        .get_one::<bool>("non_interactive")
+        .cloned()
+        .unwrap_or_else(|| pre_flight::InteractivityMode::from_env().is_non_interactive());
+
+    let regex =
+        Regex::new(name_pattern).map_err(|_| CommandRunError::UnsupportedArgumentValue {
+            property: "name_pattern".to_string(),
+        })?;
+
+    let vhosts = client.list_vhosts()?;
+
+    let matching_vhosts: Vec<responses::VirtualHost> = vhosts
+        .into_iter()
+        .filter(|vhost| regex.is_match(&vhost.name))
+        .filter(|vhost| vhost.name != DEFAULT_VHOST)
+        .collect();
+
+    if dry_run {
+        return Ok(Some(matching_vhosts));
+    }
+
+    if !approve && !pre_flight::is_non_interactive() && !non_interactive_cli {
+        return Err(CommandRunError::FailureDuringExecution {
+            message: "This operation is destructive and requires the --approve flag".to_string(),
+        });
+    }
+
+    let total = matching_vhosts.len();
+
+    if total == 0 {
+        return Ok(None);
+    }
+
+    prog_rep.start_operation(total, "Deleting virtual hosts");
+
+    let mut successes = 0;
+    let mut failures = 0;
+
+    for (index, vhost) in matching_vhosts.iter().enumerate() {
+        let vhost_name = &vhost.name;
+        match client.delete_vhost(vhost_name, idempotently) {
+            Ok(_) => {
+                prog_rep.report_progress(index + 1, total, vhost_name);
+                successes += 1;
+            }
+            Err(error) => {
+                prog_rep.report_failure(vhost_name, &error.to_string());
+                failures += 1;
+            }
+        }
+    }
+
+    prog_rep.finish_operation(total);
+
+    if failures > 0 && successes == 0 {
+        return Err(CommandRunError::FailureDuringExecution {
+            message: format!("Failed to delete all {} virtual hosts", failures),
+        });
+    }
+
+    Ok(None)
+}
+
 pub fn delete_user(client: APIClient, command_args: &ArgMatches) -> ClientResult<()> {
     // the flag is required
     let name = command_args.get_one::<String>("name").unwrap();

src/commands.rs

@@ -1161,6 +1161,22 @@ fn dispatch_common_subcommand(
             let result = commands::delete_vhost(client, second_level_args);
             res_handler.delete_operation_result(result);
         }
+        ("vhosts", "delete_multiple") => {
+            let mut prog_rep = res_handler.instantiate_progress_reporter();
+            let result =
+                commands::delete_multiple_vhosts(client, second_level_args, &mut *prog_rep);
+            match result {
+                Ok(Some(vhosts)) => {
+                    res_handler.tabular_result(Ok(vhosts));
+                }
+                Ok(None) => {
+                    res_handler.no_output_on_success(Ok(()));
+                }
+                Err(e) => {
+                    res_handler.no_output_on_success::<()>(Err(e));
+                }
+            }
+        }
         ("vhosts", "list") => {
             let result = commands::list_vhosts(client);
             res_handler.tabular_result(result)

src/main.rs

@@ -461,42 +461,53 @@ pub trait ProgressReporter {
     fn report_progress(&mut self, current: usize, total: usize, item_name: &str);
     fn report_success(&mut self, item_name: &str);
     fn report_skip(&mut self, item_name: &str, reason: &str);
+    fn report_failure(&mut self, item_name: &str, error: &str);
     fn finish_operation(&mut self, total: usize);
 }
 
 #[allow(dead_code)]
 pub struct InteractiveProgressReporter {
     operation_name: String,
+    failures: usize,
+    current_position: usize,
+    total: usize,
+    results: Vec<char>,
 }
 
 #[allow(dead_code)]
 impl InteractiveProgressReporter {
     pub fn new() -> Self {
         Self {
             operation_name: String::new(),
+            failures: 0,
+            current_position: 0,
+            total: 0,
+            results: Vec::new(),
         }
     }
 }
 
 impl ProgressReporter for InteractiveProgressReporter {
-    fn start_operation(&mut self, _total: usize, operation_name: &str) {
+    fn start_operation(&mut self, total: usize, operation_name: &str) {
         self.operation_name = operation_name.to_string();
+        self.failures = 0;
+        self.current_position = 0;
+        self.total = total;
+        self.results = vec!['.'; total];
         println!("{}...", operation_name);
     }
 
-    fn report_progress(&mut self, current: usize, total: usize, _item_name: &str) {
-        let percentage = if total > 0 {
-            (current * 100) / total
-        } else {
-            0
-        };
-        let bar_width = 50;
-        let filled = if total > 0 {
-            (current * bar_width) / total
+    fn report_progress(&mut self, _current: usize, _total: usize, _item_name: &str) {
+        if self.current_position < self.results.len() {
+            self.results[self.current_position] = '#';
+        }
+        self.current_position += 1;
+        let percentage = if self.total > 0 {
+            (self.current_position * 100) / self.total
         } else {
             0
         };
-        let bar = format!("{}{}", "#".repeat(filled), ".".repeat(bar_width - filled));
+        let bar: String = self.results.iter().collect();
         print!("\rProgress: [{:3}%] [{}]", percentage, bar);
         io::stdout().flush().unwrap();
     }
@@ -509,8 +520,34 @@ impl ProgressReporter for InteractiveProgressReporter {
         // No-op: progress bar already shows the advancement
     }
 
+    fn report_failure(&mut self, _item_name: &str, _error: &str) {
+        self.failures += 1;
+        if self.current_position < self.results.len() {
+            self.results[self.current_position] = 'X';
+        }
+        self.current_position += 1;
+        let percentage = if self.total > 0 {
+            (self.current_position * 100) / self.total
+        } else {
+            0
+        };
+        let bar: String = self.results.iter().collect();
+        print!("\rProgress: [{:3}%] [{}]", percentage, bar);
+        io::stdout().flush().unwrap();
+    }
+
     fn finish_operation(&mut self, total: usize) {
-        println!("\n✅ Completed: {} items processed", total);
+        let successes = total - self.failures;
+        if self.failures == 0 {
+            println!("\n✅ Completed: {} items processed successfully", total);
+        } else if successes == 0 {
+            println!("\n❌ Failed: All {} items failed to process", total);
+        } else {
+            println!(
+                "\n⚠️  Completed with failures: {} succeeded, {} failed out of {} total",
+                successes, self.failures, total
+            );
+        }
     }
 }
 
@@ -536,16 +573,21 @@ impl ProgressReporter for NonInteractiveProgressReporter {
     }
 
     fn report_progress(&mut self, _current: usize, _total: usize, _item_name: &str) {
-        print!(".");
+        print!("#");
         io::stdout().flush().unwrap();
     }
 
     fn report_success(&mut self, _item_name: &str) {
-        // Dot already printed in report_progress
+        // Hash already printed in report_progress
     }
 
     fn report_skip(&mut self, _item_name: &str, _reason: &str) {
-        // Dot already printed in report_progress
+        // Hash already printed in report_progress
+    }
+
+    fn report_failure(&mut self, _item_name: &str, _error: &str) {
+        print!("X");
+        io::stdout().flush().unwrap();
     }
 
     fn finish_operation(&mut self, total: usize) {
@@ -580,6 +622,10 @@ impl ProgressReporter for QuietProgressReporter {
         // Silent
     }
 
+    fn report_failure(&mut self, _item_name: &str, _error: &str) {
+        // Silent
+    }
+
     fn finish_operation(&mut self, total: usize) {
         println!("Completed: {} items processed", total);
     }