Implement 'definitions export_from_vhost'

Author: michaelklishin

CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## v0.24.0 (in development)
 
+### Enhancements
+
+ * `definitions export_from_vhost` is a new command that exports definitions from a single virtual host
+   instead of the entire cluster
+
+
 ## v0.23.0 (Feb 2, 2025)
 
 ### Enhancements

Cargo.lock

@@ -17,7 +17,7 @@ reqwest = { version = "0.12.12", features = [
     "__rustls",
     "rustls-tls-native-roots"
 ]}
-rabbitmq_http_client = { version = "0.20.0", features = [
+rabbitmq_http_client = { version = "0.21.0", features = [
     "core",
     "blocking",
     "tabled"

Cargo.toml

@@ -253,7 +253,7 @@ pub fn parser() -> Command {
                 .subcommand_value_name("queues")
                 .subcommands(rebalance_subcommands()),
             Command::new("definitions")
-                .about("operations on definitions")
+                .about("operations on definitions (everything except for messages: virtual hosts, queues, streams, exchanges, bindings, users, etc)")
                 .after_long_help(color_print::cformat!(
                     "<bold>Doc guide</bold>: {}",
                     DEFINITION_GUIDE_URL
@@ -1130,33 +1130,67 @@ fn close_subcommands() -> [Command; 2] {
     [close_connection, close_user_connections]
 }
 
-fn definitions_subcommands() -> [Command; 2] {
+fn definitions_subcommands() -> [Command; 4] {
     let export_cmd = Command::new("export")
-        .about("export cluster-wide definitions (everything except for messages: virtual hosts, queues, streams, exchanges, bindings, users, etc)")
+        .about("export cluster-wide definitions")
         .after_long_help(color_print::cformat!(
-            "<bold>Doc guide</bold>: {}", DEFINITION_GUIDE_URL
+            "<bold>Doc guide</bold>: {}",
+            DEFINITION_GUIDE_URL
+        ))
+        .arg(
+            Arg::new("file")
+                .long("file")
+                .help("output file path or '-' for standard output")
+                .required(false)
+                .default_value("-"),
+        );
+
+    let export_from_vhost_cmd = Command::new("export_from_vhost")
+        .about("export definitions of a specific virtual host")
+        .after_long_help(color_print::cformat!(
+            "<bold>Doc guide</bold>: {}",
+            DEFINITION_GUIDE_URL
         ))
         .arg(
             Arg::new("file")
                 .long("file")
-                .help("output path or '-' for standard output")
+                .help("output file path or '-' for standard output")
                 .required(false)
                 .default_value("-"),
         );
 
     let import_cmd = Command::new("import")
-        .about("import definitions (everything except for messages: virtual hosts, queues, streams, exchanges, bindings, users, etc")
+        .about("import cluster-wide definitions (of multiple virtual hosts)")
+        .after_long_help(color_print::cformat!(
+            "<bold>Doc guide</bold>: {}",
+            DEFINITION_GUIDE_URL
+        ))
+        .arg(
+            Arg::new("file")
+                .long("file")
+                .help("JSON file with cluster-wide definitions")
+                .required(true),
+        );
+
+    let import_into_vhost_cmd = Command::new("import_into_vhost")
+        .about("import a virtual host-specific definitions file into a virtual host")
         .after_long_help(color_print::cformat!(
-            "<bold>Doc guide</bold>: {}", DEFINITION_GUIDE_URL
+            "<bold>Doc guide</bold>: {}",
+            DEFINITION_GUIDE_URL
         ))
         .arg(
             Arg::new("file")
                 .long("file")
-                .help("JSON file with definitions")
+                .help("JSON file with virtual host-specific definitions")
                 .required(true),
         );
 
-    [export_cmd, import_cmd]
+    [
+        export_cmd,
+        export_from_vhost_cmd,
+        import_cmd,
+        import_into_vhost_cmd,
+    ]
 }
 
 fn export_subcommands() -> [Command; 1] {

src/cli.rs

@@ -682,8 +682,34 @@ pub fn rebalance_queues(client: APIClient) -> ClientResult<()> {
     client.rebalance_queue_leaders()
 }
 
-pub fn export_definitions(client: APIClient, command_args: &ArgMatches) -> ClientResult<()> {
-    match client.export_definitions() {
+pub fn export_cluster_wide_definitions(
+    client: APIClient,
+    command_args: &ArgMatches,
+) -> ClientResult<()> {
+    match client.export_cluster_wide_definitions() {
+        Ok(definitions) => {
+            let path = command_args.get_one::<String>("file").unwrap();
+            match path.as_str() {
+                "-" => {
+                    println!("{}", &definitions);
+                    Ok(())
+                }
+                file => {
+                    _ = fs::write(file, &definitions);
+                    Ok(())
+                }
+            }
+        }
+        Err(err) => Err(err),
+    }
+}
+
+pub fn export_vhost_definitions(
+    client: APIClient,
+    vhost: &str,
+    command_args: &ArgMatches,
+) -> ClientResult<()> {
+    match client.export_vhost_definitions(vhost) {
         Ok(definitions) => {
             let path = command_args.get_one::<String>("file").unwrap();
             match path.as_str() {

src/commands.rs

@@ -498,15 +498,20 @@ fn dispatch_common_subcommand(
             res_handler.no_output_on_success(result);
         }
         ("definitions", "export") => {
-            let result = commands::export_definitions(client, second_level_args);
+            let result = commands::export_cluster_wide_definitions(client, second_level_args);
             res_handler.no_output_on_success(result);
         }
+        ("definitions", "export_from_vhost") => {
+            let result = commands::export_vhost_definitions(client, &vhost, second_level_args);
+            res_handler.no_output_on_success(result);
+        }
+
         ("definitions", "import") => {
             let result = commands::import_definitions(client, second_level_args);
             res_handler.no_output_on_success(result);
         }
         ("export", "definitions") => {
-            let result = commands::export_definitions(client, second_level_args);
+            let result = commands::export_cluster_wide_definitions(client, second_level_args);
             res_handler.no_output_on_success(result);
         }
         ("import", "definitions") => {

src/main.rs

@@ -15,11 +15,33 @@
 use predicates::prelude::*;
 
 mod test_helpers;
+use crate::test_helpers::delete_vhost;
 use test_helpers::run_succeeds;
 
 #[test]
-fn test_export_definitions() -> Result<(), Box<dyn std::error::Error>> {
+fn test_export_cluster_wide_definitions() -> Result<(), Box<dyn std::error::Error>> {
     run_succeeds(["definitions", "export"]).stdout(predicate::str::contains("guest"));
 
     Ok(())
 }
+
+#[test]
+fn test_export_vhost_definitions() -> Result<(), Box<dyn std::error::Error>> {
+    let vh = "test_export_vhost_definitions.1";
+    delete_vhost(vh).expect("failed to delete a virtual host");
+    run_succeeds(["declare", "vhost", "--name", vh]);
+
+    let q = "qq.test_export_vhost_definitions.1";
+    run_succeeds([
+        "-V", vh, "declare", "queue", "--name", q, "--type", "quorum",
+    ]);
+
+    run_succeeds(["--vhost", vh, "definitions", "export_from_vhost"])
+        .stdout(predicate::str::contains(q));
+    run_succeeds(["--vhost", "/", "definitions", "export_from_vhost"])
+        .stdout(predicate::str::contains(q).not());
+
+    delete_vhost(vh).expect("failed to delete a virtual host");
+
+    Ok(())
+}