rabbitmq_management_client/api/
user.rs

1use crate::api::_generic::{handle_empty_response, handle_response};
2use crate::api::permission::{RabbitMqPermission, RabbitMqTopicPermission};
3use crate::errors::RabbitMqClientError;
4use crate::RabbitMqClient;
5use async_trait::async_trait;
6use serde::{Deserialize, Serialize};
7
8#[async_trait]
9pub trait UserApi {
10    async fn who_am_i(&self) -> Result<RabbitMqWhoAmI, RabbitMqClientError>;
11
12    async fn list_users(&self) -> Result<Vec<RabbitMqUser>, RabbitMqClientError>;
13
14    async fn get_user(&self, name: String) -> Result<RabbitMqUser, RabbitMqClientError>;
15
16    async fn create_user(&self, user: RabbitMqUserCreateRequest)
17        -> Result<(), RabbitMqClientError>;
18
19    async fn delete_user(&self, name: String) -> Result<(), RabbitMqClientError>;
20
21    async fn list_users_without_permissions(
22        &self,
23    ) -> Result<Vec<RabbitMqUser>, RabbitMqClientError>;
24
25    async fn bulk_delete_users(
26        &self,
27        users: RabbitMqUsersBulkDeleteRequest,
28    ) -> Result<(), RabbitMqClientError>;
29
30    async fn list_user_permissions(
31        &self,
32        user: String,
33    ) -> Result<Vec<RabbitMqPermission>, RabbitMqClientError>;
34
35    async fn list_user_topic_permissions(
36        &self,
37        user: String,
38    ) -> Result<Vec<RabbitMqTopicPermission>, RabbitMqClientError>;
39}
40
41#[async_trait]
42impl UserApi for RabbitMqClient {
43    #[tracing::instrument(skip(self))]
44    async fn who_am_i(&self) -> Result<RabbitMqWhoAmI, RabbitMqClientError> {
45        let response = self
46            .client
47            .request(reqwest::Method::GET, format!("{}/api/whoami", self.api_url))
48            .send()
49            .await?;
50
51        handle_response(response).await
52    }
53
54    #[tracing::instrument(skip(self))]
55    async fn list_users(&self) -> Result<Vec<RabbitMqUser>, RabbitMqClientError> {
56        let response = self
57            .client
58            .request(reqwest::Method::GET, format!("{}/api/users", self.api_url))
59            .send()
60            .await?;
61
62        handle_response(response).await
63    }
64
65    #[tracing::instrument(skip(self))]
66    async fn get_user(&self, name: String) -> Result<RabbitMqUser, RabbitMqClientError> {
67        let response = self
68            .client
69            .request(
70                reqwest::Method::GET,
71                format!("{}/api/users/{}", self.api_url, name),
72            )
73            .send()
74            .await?;
75
76        handle_response(response).await
77    }
78
79    async fn create_user(
80        &self,
81        user: RabbitMqUserCreateRequest,
82    ) -> Result<(), RabbitMqClientError> {
83        let response = self
84            .client
85            .request(
86                reqwest::Method::PUT,
87                format!("{}/api/users/{}", self.api_url, user.name),
88            )
89            .json(&user)
90            .send()
91            .await?;
92
93        handle_empty_response(response).await
94    }
95
96    async fn delete_user(&self, name: String) -> Result<(), RabbitMqClientError> {
97        let response = self
98            .client
99            .request(
100                reqwest::Method::DELETE,
101                format!("{}/api/users/{}", self.api_url, name),
102            )
103            .send()
104            .await?;
105
106        handle_empty_response(response).await
107    }
108
109    #[tracing::instrument(skip(self))]
110    async fn list_users_without_permissions(
111        &self,
112    ) -> Result<Vec<RabbitMqUser>, RabbitMqClientError> {
113        let response = self
114            .client
115            .request(
116                reqwest::Method::GET,
117                format!("{}/api/users/without-permissions", self.api_url),
118            )
119            .send()
120            .await?;
121
122        handle_response(response).await
123    }
124
125    #[tracing::instrument(skip(self))]
126    async fn bulk_delete_users(
127        &self,
128        users: RabbitMqUsersBulkDeleteRequest,
129    ) -> Result<(), RabbitMqClientError> {
130        let response = self
131            .client
132            .request(
133                reqwest::Method::POST,
134                format!("{}/api/users/bulk-delete", self.api_url),
135            )
136            .json(&users)
137            .send()
138            .await?;
139
140        handle_empty_response(response).await
141    }
142
143    #[tracing::instrument(skip(self))]
144    async fn list_user_permissions(
145        &self,
146        user: String,
147    ) -> Result<Vec<RabbitMqPermission>, RabbitMqClientError> {
148        let response = self
149            .client
150            .request(
151                reqwest::Method::DELETE,
152                format!("{}/api/users/{}/permissions", self.api_url, user),
153            )
154            .send()
155            .await?;
156
157        handle_response(response).await
158    }
159
160    #[tracing::instrument(skip(self))]
161    async fn list_user_topic_permissions(
162        &self,
163        user: String,
164    ) -> Result<Vec<RabbitMqTopicPermission>, RabbitMqClientError> {
165        let response = self
166            .client
167            .request(
168                reqwest::Method::DELETE,
169                format!("{}/api/users/{}/topic-permissions", self.api_url, user),
170            )
171            .send()
172            .await?;
173
174        handle_response(response).await
175    }
176}
177
178#[derive(Debug, Deserialize)]
179pub struct RabbitMqWhoAmI {
180    pub name: String,
181    pub tags: Vec<RabbitMqUserTag>,
182}
183
184#[derive(Debug, Deserialize)]
185pub struct RabbitMqUser {
186    pub name: String,
187    pub password_hash: String,
188    pub hashing_algorithm: RabbitMqHashingAlgorithm,
189    pub tags: Vec<RabbitMqUserTag>,
190}
191
192#[derive(Debug, Deserialize, Serialize, PartialEq)]
193#[serde(rename_all = "snake_case")]
194pub enum RabbitMqUserTag {
195    Administrator,
196    Management,
197    Monitoring,
198}
199
200#[derive(Debug, Serialize)]
201pub struct RabbitMqUserCreateRequest {
202    #[serde(skip_serializing)]
203    pub name: String,
204    #[serde(skip_serializing_if = "Option::is_none")]
205    pub password: Option<String>,
206    #[serde(skip_serializing_if = "Option::is_none")]
207    pub password_hash: Option<String>,
208    #[serde(skip_serializing_if = "Option::is_none")]
209    pub hashing_algorithm: Option<RabbitMqHashingAlgorithm>,
210    pub tags: Vec<RabbitMqUserTag>,
211}
212
213#[derive(Debug, Serialize)]
214pub struct RabbitMqUsersBulkDeleteRequest {
215    pub users: Vec<String>,
216}
217
218#[derive(Debug, Deserialize, Serialize)]
219pub enum RabbitMqHashingAlgorithm {
220    #[serde(rename = "rabbit_password_hashing_sha256")]
221    RabbitPasswordHashingSha256,
222    #[serde(rename = "rabbit_password_hashing_sha512")]
223    RabbitPasswordHashingSha512,
224    #[serde(rename = "rabbit_password_hashing_md5")]
225    RabbitPasswordHashingMd5,
226}
rabbitmq_management_client/api/user.rs

rabbitmq_management_client/api/
user.rs
