1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use crate::api::_generic::{handle_empty_response, handle_response};
use crate::errors::RabbitMqClientError;
use crate::RabbitMqClient;
use async_trait::async_trait;
use serde::{Deserialize, Serialize};

#[async_trait]
pub trait OverviewApi {
    async fn get_overview(&self) -> Result<RabbitMqOverview, RabbitMqClientError>;

    async fn get_cluster_name(&self) -> Result<RabbitMqClusterName, RabbitMqClientError>;

    async fn set_cluster_name(
        &self,
        request: RabbitMqClusterName,
    ) -> Result<(), RabbitMqClientError>;
}

#[async_trait]
impl OverviewApi for RabbitMqClient {
    async fn get_overview(&self) -> Result<RabbitMqOverview, RabbitMqClientError> {
        let response = self
            .client
            .request(
                reqwest::Method::GET,
                format!("{}/api/overview", self.api_url),
            )
            .send()
            .await?;

        handle_response(response).await
    }

    async fn get_cluster_name(&self) -> Result<RabbitMqClusterName, RabbitMqClientError> {
        let response = self
            .client
            .request(
                reqwest::Method::GET,
                format!("{}/api/cluster-name", self.api_url),
            )
            .send()
            .await?;

        handle_response(response).await
    }

    async fn set_cluster_name(
        &self,
        request: RabbitMqClusterName,
    ) -> Result<(), RabbitMqClientError> {
        let response = self
            .client
            .request(
                reqwest::Method::PUT,
                format!("{}/api/cluster-name", self.api_url),
            )
            .json(&request)
            .send()
            .await?;

        handle_empty_response(response).await
    }
}

#[derive(Debug, Deserialize)]
pub struct RabbitMqOverview {
    pub management_version: String,
    pub rates_mode: String,
    pub exchange_types: Vec<RabbitMqExchangeType>,
    pub product_version: String,
    pub product_name: String,
    pub rabbitmq_version: String,
    pub cluster_name: String,
    pub erlang_version: String,
    pub erlang_full_version: String,
    pub release_series_support_status: String,
    pub disable_stats: bool,
    pub is_op_policy_updating_enabled: bool,
    pub enable_queue_totals: bool,
    pub churn_rates: RabbitMqChurnRates,
    pub object_totals: RabbitMqObjectTotals,
    pub listeners: Vec<RabbitMqListener>,
    pub contexts: Vec<RabbitMqContext>,
}

#[derive(Debug, Deserialize)]
pub struct RabbitMqExchangeType {
    pub name: String,
    pub description: String,
    pub enabled: bool,
}

#[derive(Debug, Deserialize)]
pub struct RabbitMqContext {
    pub node: Option<String>,
    pub description: String,
    pub path: String,
    pub cowboy_opts: String,
    pub port: String,
    pub protocol: Option<String>,
}

#[derive(Debug, Deserialize)]
pub struct RabbitMqListener {
    pub node: String,
    pub protocol: String,
    pub ip_address: String,
    pub port: i64,
}

#[derive(Debug, Deserialize)]
pub struct RabbitMqChurnRates {
    pub channel_closed: i64,
    pub channel_created: i64,
    pub connection_closed: i64,
    pub connection_created: i64,
    pub queue_created: i64,
    pub queue_declared: i64,
    pub queue_deleted: i64,
}

#[derive(Debug, Deserialize)]
pub struct RabbitMqObjectTotals {
    pub channels: i64,
    pub connections: i64,
    pub consumers: i64,
    pub exchanges: i64,
    pub queues: i64,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct RabbitMqClusterName {
    pub name: String,
}