Bridge the gap between the "verb" command groups and "noun" ones

Author: michaelklishin

CHANGELOG.md

@@ -2,7 +2,41 @@
 
 ## v2.15.0 (in development)
 
-No changes yet.
+### Enhancements
+
+* `permissions` is a new command group for operations on user permissions:
+
+  ```shell
+  rabbitmqadmin permissions list
+
+  rabbitmqadmin permissions declare --user "user1" --configure ".*" --read ".*" --write ".*"
+
+  rabbitmqadmin permissions delete --user "user1"
+  ```
+
+* `user_limits` is a new command group for operations on per-user limits:
+
+  ```shell
+  rabbitmqadmin user_limits list
+
+  rabbitmqadmin user_limits declare --user "user1" --name "max-connections" --value "100"
+
+  rabbitmqadmin user_limits delete --user "user1" --name "max-connections"
+  ```
+
+* `vhost_limits` is a new command group for operations on virtual host limits:
+
+  ```shell
+  rabbitmqadmin vhost_limits list
+
+  rabbitmqadmin vhost_limits declare --name "max-connections" --value "1000"
+
+  rabbitmqadmin vhost_limits delete --name "max-connections"
+  ```
+
+### Deprecations
+
+* "Verb" command groups (`list [object]`, `declare [object]`, `delete [object]`) are now deprecated in favor of the "noun" group commands (such as `users [operation]` or `permissions [operation]`).
 
 
 ## v2.14.0 (Sep 30, 2025)

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rabbitmqadmin"
-version = "2.14.0"
+version = "2.15.0"
 edition = "2024"
 
 description = "rabbitmqadmin v2 is a modern CLI tool for the RabbitMQ HTTP API"

Cargo.toml

@@ -220,6 +220,16 @@ pub fn parser(pre_flight_settings: PreFlightSettings) -> Command {
             PASSWORD_GUIDE_URL
         ))
         .subcommands(passwords_subcommands(pre_flight_settings.clone()));
+    let permissions_group = Command::new("permissions")
+        .about("Operations on user permissions")
+        .infer_subcommands(pre_flight_settings.infer_subcommands)
+        .infer_long_args(pre_flight_settings.infer_long_options)
+        .after_help(color_print::cformat!(
+            "<bold>Doc guide</bold>: {}",
+            ACCESS_CONTROL_GUIDE_URL
+        ))
+        .subcommand_value_name("permission")
+        .subcommands(permissions_subcommands(pre_flight_settings.clone()));
     let policies_group = Command::new("policies")
         .about("Operations on policies")
         .infer_subcommands(pre_flight_settings.infer_subcommands)
@@ -304,11 +314,31 @@ pub fn parser(pre_flight_settings: PreFlightSettings) -> Command {
         ))
         .subcommand_value_name("subcommand")
         .subcommands(users_subcommands(pre_flight_settings.clone()));
+    let user_limits_group = Command::new("user_limits")
+        .about("Operations on per-user (resource) limits")
+        .infer_subcommands(pre_flight_settings.infer_subcommands)
+        .infer_long_args(pre_flight_settings.infer_long_options)
+        .after_help(color_print::cformat!(
+            "<bold>Doc guide</bold>: {}",
+            USER_LIMIT_GUIDE_URL
+        ))
+        .subcommand_value_name("user_limit")
+        .subcommands(user_limits_subcommands(pre_flight_settings.clone()));
     let vhosts_group = Command::new("vhosts")
         .about("Virtual host operations")
         .infer_subcommands(pre_flight_settings.infer_subcommands)
         .infer_long_args(pre_flight_settings.infer_long_options)
         .subcommands(vhosts_subcommands(pre_flight_settings.clone()));
+    let vhost_limits_group = Command::new("vhost_limits")
+        .about("Operations on virtual host (resource) limits")
+        .infer_subcommands(pre_flight_settings.infer_subcommands)
+        .infer_long_args(pre_flight_settings.infer_long_options)
+        .after_help(color_print::cformat!(
+            "<bold>Doc guide</bold>: {}",
+            VIRTUAL_HOST_LIMIT_GUIDE_URL
+        ))
+        .subcommand_value_name("vhost_limit")
+        .subcommands(vhost_limits_subcommands(pre_flight_settings.clone()));
 
     let command_groups = [
         bindings_group,
@@ -332,6 +362,7 @@ pub fn parser(pre_flight_settings: PreFlightSettings) -> Command {
         operator_policies_group,
         parameters_group,
         passwords_group,
+        permissions_group,
         policies_group,
         publish_group,
         purge_group,
@@ -342,7 +373,9 @@ pub fn parser(pre_flight_settings: PreFlightSettings) -> Command {
         streams_group,
         tanzu_group,
         users_group,
+        user_limits_group,
         vhosts_group,
+        vhost_limits_group,
     ];
 
     Command::new("rabbitmqadmin")
@@ -2948,6 +2981,162 @@ pub fn passwords_subcommands(pre_flight_settings: PreFlightSettings) -> [Command
     [hash_password].map(|cmd| cmd.infer_long_args(pre_flight_settings.infer_long_options))
 }
 
+pub fn permissions_subcommands(pre_flight_settings: PreFlightSettings) -> [Command; 3] {
+    let idempotently_arg = Arg::new("idempotently")
+        .long("idempotently")
+        .value_parser(value_parser!(bool))
+        .action(ArgAction::SetTrue)
+        .help("do not consider 404 Not Found API responses to be errors")
+        .required(false);
+
+    let list_cmd = Command::new("list")
+        .long_about("Lists user permissions")
+        .after_help(color_print::cformat!(
+            "<bold>Doc guide</bold>: {}",
+            ACCESS_CONTROL_GUIDE_URL
+        ));
+
+    let declare_cmd = Command::new("declare")
+        .about("grants permissions to a user")
+        .after_help(color_print::cformat!(
+            "<bold>Doc guide:</bold>: {}",
+            ACCESS_CONTROL_GUIDE_URL
+        ))
+        .arg(
+            Arg::new("user")
+                .long("user")
+                .help("username")
+                .required(true),
+        )
+        .arg(
+            Arg::new("configure")
+                .long("configure")
+                .help("name pattern for configuration access")
+                .required(true),
+        )
+        .arg(
+            Arg::new("read")
+                .long("read")
+                .help("name pattern for read access")
+                .required(true),
+        )
+        .arg(
+            Arg::new("write")
+                .long("write")
+                .help("name pattern for write access")
+                .required(true),
+        );
+
+    let delete_cmd = Command::new("delete")
+        .about("Revokes user permissions to a given vhost")
+        .arg(
+            Arg::new("user")
+                .long("user")
+                .help("username")
+                .required(true),
+        )
+        .arg(idempotently_arg.clone());
+
+    [list_cmd, declare_cmd, delete_cmd]
+        .map(|cmd| cmd.infer_long_args(pre_flight_settings.infer_long_options))
+}
+
+pub fn user_limits_subcommands(pre_flight_settings: PreFlightSettings) -> [Command; 3] {
+    let list_cmd = Command::new("list")
+        .long_about("Lists per-user (resource) limits")
+        .after_help(color_print::cformat!(
+            "<bold>Doc guide</bold>: {}",
+            USER_LIMIT_GUIDE_URL
+        ))
+        .arg(
+            Arg::new("user")
+                .long("user")
+                .help("username")
+                .required(false),
+        );
+
+    let declare_cmd = Command::new("declare")
+        .about("Set a user limit")
+        .after_help(color_print::cformat!(
+            "<bold>Doc guide:</bold>: {}",
+            USER_LIMIT_GUIDE_URL
+        ))
+        .arg(
+            Arg::new("user")
+                .long("user")
+                .help("username")
+                .required(true),
+        )
+        .arg(
+            Arg::new("name")
+                .long("name")
+                .help("limit name (eg. max-connections, max-queues)")
+                .required(true),
+        )
+        .arg(
+            Arg::new("value")
+                .long("value")
+                .help("limit value")
+                .required(true),
+        );
+
+    let delete_cmd = Command::new("delete")
+        .about("Clears a user limit")
+        .arg(
+            Arg::new("user")
+                .long("user")
+                .help("username")
+                .required(true),
+        )
+        .arg(
+            Arg::new("name")
+                .long("name")
+                .help("limit name (eg. max-connections, max-queues)")
+                .required(true),
+        );
+
+    [list_cmd, declare_cmd, delete_cmd]
+        .map(|cmd| cmd.infer_long_args(pre_flight_settings.infer_long_options))
+}
+
+pub fn vhost_limits_subcommands(pre_flight_settings: PreFlightSettings) -> [Command; 3] {
+    let list_cmd = Command::new("list")
+        .long_about("Lists virtual host (resource) limits")
+        .after_help(color_print::cformat!(
+            "<bold>Doc guide</bold>: {}",
+            VIRTUAL_HOST_GUIDE_URL
+        ));
+
+    let declare_cmd = Command::new("declare")
+        .about("Set a vhost limit")
+        .after_help(color_print::cformat!(
+            "<bold>Doc guide:</bold>: {}",
+            VIRTUAL_HOST_LIMIT_GUIDE_URL
+        ))
+        .arg(
+            Arg::new("name")
+                .long("name")
+                .help("limit name (eg. max-connections, max-queues)")
+                .required(true),
+        )
+        .arg(
+            Arg::new("value")
+                .long("value")
+                .help("limit value")
+                .required(true),
+        );
+
+    let delete_cmd = Command::new("delete").about("delete a vhost limit").arg(
+        Arg::new("name")
+            .long("name")
+            .help("limit name (eg. max-connections, max-queues)")
+            .required(true),
+    );
+
+    [list_cmd, declare_cmd, delete_cmd]
+        .map(|cmd| cmd.infer_long_args(pre_flight_settings.infer_long_options))
+}
+
 pub fn publish_subcommands(pre_flight_settings: PreFlightSettings) -> [Command; 1] {
     [Command::new("message")
         .about(color_print::cstr!("Publishes (<red>inefficiently</red>) message(s) to a queue or a stream. <bold><red>Only suitable for development and test environments</red></bold>. Prefer messaging or streaming protocol clients!"))

src/cli.rs

@@ -910,6 +910,20 @@ fn dispatch_common_subcommand(
             let result = commands::salt_and_hash_password(second_level_args);
             res_handler.show_salted_and_hashed_value(result)
         }
+        ("permissions", "list") => {
+            let result = commands::list_permissions(client);
+            res_handler.tabular_result(result)
+        }
+        ("permissions", "declare") => {
+            let result = commands::declare_permissions(client, &vhost, second_level_args)
+                .map_err(Into::into);
+            res_handler.no_output_on_success(result);
+        }
+        ("permissions", "delete") => {
+            let result =
+                commands::delete_permissions(client, &vhost, second_level_args).map_err(Into::into);
+            res_handler.no_output_on_success(result);
+        }
         ("policies", "declare") => {
             let result = commands::declare_policy(client, &vhost, second_level_args);
             res_handler.no_output_on_success(result);
@@ -1153,6 +1167,19 @@ fn dispatch_common_subcommand(
             let result = commands::list_permissions(client);
             res_handler.tabular_result(result)
         }
+        ("user_limits", "list") => {
+            let result = commands::list_user_limits(client, second_level_args);
+            res_handler.tabular_result(result)
+        }
+        ("user_limits", "declare") => {
+            let result =
+                commands::declare_user_limit(client, second_level_args).map_err(Into::into);
+            res_handler.no_output_on_success(result);
+        }
+        ("user_limits", "delete") => {
+            let result = commands::delete_user_limit(client, second_level_args).map_err(Into::into);
+            res_handler.no_output_on_success(result);
+        }
         ("vhosts", "declare") => {
             let result = commands::declare_vhost(client, second_level_args).map_err(Into::into);
             res_handler.no_output_on_success(result);
@@ -1191,6 +1218,20 @@ fn dispatch_common_subcommand(
                 .map_err(Into::into);
             res_handler.no_output_on_success(result);
         }
+        ("vhost_limits", "list") => {
+            let result = commands::list_vhost_limits(client, &vhost);
+            res_handler.tabular_result(result)
+        }
+        ("vhost_limits", "declare") => {
+            let result = commands::declare_vhost_limit(client, &vhost, second_level_args)
+                .map_err(Into::into);
+            res_handler.no_output_on_success(result);
+        }
+        ("vhost_limits", "delete") => {
+            let result =
+                commands::delete_vhost_limit(client, &vhost, second_level_args).map_err(Into::into);
+            res_handler.no_output_on_success(result);
+        }
         _ => {
             let error = CommandRunError::UnknownCommandTarget {
                 command: pair.0.into(),

src/main.rs

@@ -31,8 +31,8 @@ fn test_list_permissions() -> Result<(), Box<dyn Error>> {
     ]);
 
     run_succeeds([
-        "declare",
         "permissions",
+        "declare",
         "--user",
         username,
         "--configure",
@@ -43,14 +43,14 @@ fn test_list_permissions() -> Result<(), Box<dyn Error>> {
         "baz",
     ]);
 
-    run_succeeds(["list", "permissions"]).stdout(
+    run_succeeds(["permissions", "list"]).stdout(
         output_includes("foo")
             .and(output_includes("bar"))
             .and(output_includes("baz")),
     );
 
-    run_succeeds(["delete", "permissions", "--user", username]);
-    run_succeeds(["list", "permissions"]).stdout(output_includes(username).not());
+    run_succeeds(["permissions", "delete", "--user", username]);
+    run_succeeds(["permissions", "list"]).stdout(output_includes(username).not());
     run_succeeds(["delete", "user", "--name", username]);
 
     Ok(())