rocketmq_remoting/protocol/header/namesrv/
broker_request.rs

1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17use std::fmt::Display;
18
19use cheetah_string::CheetahString;
20use rocketmq_macros::RequestHeaderCodecV2;
21use serde::Deserialize;
22use serde::Serialize;
23
24#[derive(Debug, Clone, Deserialize, Serialize, Default, RequestHeaderCodecV2)]
25#[serde(rename_all = "camelCase")]
26pub struct UnRegisterBrokerRequestHeader {
27    #[required]
28    pub broker_name: CheetahString,
29
30    #[required]
31    pub broker_addr: CheetahString,
32
33    #[required]
34    pub cluster_name: CheetahString,
35
36    #[required]
37    pub broker_id: u64,
38}
39
40impl Display for UnRegisterBrokerRequestHeader {
41    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
42        write!(
43            f,
44            "UnRegisterBrokerRequestHeader {{ brokerName: {}, brokerAddr: {}, clusterName: {}, \
45             brokerId: {} }}",
46            self.broker_name, self.broker_addr, self.cluster_name, self.broker_id
47        )
48    }
49}
50
51#[derive(Debug, Clone, Deserialize, Serialize, Default, RequestHeaderCodecV2)]
52#[serde(rename_all = "camelCase")]
53pub struct BrokerHeartbeatRequestHeader {
54    #[required]
55    pub cluster_name: CheetahString,
56
57    #[required]
58    pub broker_addr: CheetahString,
59
60    #[required]
61    pub broker_name: CheetahString,
62    pub broker_id: Option<i64>,
63    pub epoch: Option<i32>,
64    pub max_offset: Option<i64>,
65    pub confirm_offset: Option<i64>,
66    pub heartbeat_timeout_mills: Option<i64>,
67    pub election_priority: Option<i32>,
68}
69
70#[derive(Debug, Clone, Deserialize, Serialize, Default, RequestHeaderCodecV2)]
71#[serde(rename_all = "camelCase")]
72pub struct GetBrokerMemberGroupRequestHeader {
73    #[required]
74    pub cluster_name: CheetahString,
75    #[required]
76    pub broker_name: CheetahString,
77}
78
79impl GetBrokerMemberGroupRequestHeader {
80    /* const BROKER_NAME: &'static str = "brokerName";
81    const CLUSTER_NAME: &'static str = "clusterName";*/
82
83    pub fn new(
84        cluster_name: impl Into<CheetahString>,
85        broker_name: impl Into<CheetahString>,
86    ) -> Self {
87        Self {
88            cluster_name: cluster_name.into(),
89
90            broker_name: broker_name.into(),
91        }
92    }
93}
94
95/*impl CommandCustomHeader for GetBrokerMemberGroupRequestHeader {
96    fn to_map(&self) -> Option<HashMap<CheetahString, CheetahString>> {
97        Some(HashMap::from([
98            (
99                CheetahString::from_static_str(Self::CLUSTER_NAME),
100                self.cluster_name.clone(),
101            ),
102            (
103                CheetahString::from_static_str(Self::BROKER_NAME),
104                self.broker_name.clone(),
105            ),
106        ]))
107    }
108}
109
110impl FromMap for GetBrokerMemberGroupRequestHeader {
111    type Error = rocketmq_error::RocketMQError;
112    type Target = Self;
113
114    fn from(map: &HashMap<CheetahString, CheetahString>) -> Result<Self::Target, Self::Error> {
115        Ok(GetBrokerMemberGroupRequestHeader {
116            cluster_name: map
117                .get(&CheetahString::from_static_str(Self::CLUSTER_NAME))
118                .cloned()
119                .unwrap_or_default(),
120
121            broker_name: map
122                .get(&CheetahString::from_static_str(Self::BROKER_NAME))
123                .cloned()
124                .unwrap_or_default(),
125        })
126    }
127}*/
128
129#[cfg(test)]
130mod tests {
131    use cheetah_string::CheetahString;
132
133    use super::*;
134
135    #[test]
136    fn new_creates_instance_with_correct_values() {
137        let header = GetBrokerMemberGroupRequestHeader::new("testCluster", "testBroker");
138        assert_eq!(header.cluster_name, CheetahString::from("testCluster"));
139        assert_eq!(header.broker_name, CheetahString::from("testBroker"));
140    }
141
142    #[test]
143    fn new_creates_instance_with_empty_values() {
144        let header = GetBrokerMemberGroupRequestHeader::new("", "");
145        assert_eq!(header.cluster_name, CheetahString::from(""));
146        assert_eq!(header.broker_name, CheetahString::from(""));
147    }
148
149    #[test]
150    fn new_creates_instance_with_long_values() {
151        let long_string = "a".repeat(1000);
152        let header = GetBrokerMemberGroupRequestHeader::new(&long_string, &long_string);
153        assert_eq!(header.cluster_name, CheetahString::from(&long_string));
154        assert_eq!(header.broker_name, CheetahString::from(&long_string));
155    }
156
157    #[test]
158    fn broker_heartbeat_request_header_with_required_fields() {
159        let header = BrokerHeartbeatRequestHeader {
160            cluster_name: CheetahString::from("testCluster"),
161            broker_addr: CheetahString::from("testAddr"),
162            broker_name: CheetahString::from("testBroker"),
163            broker_id: Some(1),
164            epoch: Some(1),
165            max_offset: Some(100),
166            confirm_offset: Some(50),
167            heartbeat_timeout_mills: Some(3000),
168            election_priority: Some(1),
169        };
170        assert_eq!(header.cluster_name, CheetahString::from("testCluster"));
171        assert_eq!(header.broker_addr, CheetahString::from("testAddr"));
172        assert_eq!(header.broker_name, CheetahString::from("testBroker"));
173        assert_eq!(header.broker_id, Some(1));
174        assert_eq!(header.epoch, Some(1));
175        assert_eq!(header.max_offset, Some(100));
176        assert_eq!(header.confirm_offset, Some(50));
177        assert_eq!(header.heartbeat_timeout_mills, Some(3000));
178        assert_eq!(header.election_priority, Some(1));
179    }
180
181    #[test]
182    fn broker_heartbeat_request_header_with_optional_fields() {
183        let header = BrokerHeartbeatRequestHeader {
184            cluster_name: CheetahString::from("testCluster"),
185            broker_addr: CheetahString::from("testAddr"),
186            broker_name: CheetahString::from("testBroker"),
187            broker_id: None,
188            epoch: None,
189            max_offset: None,
190            confirm_offset: None,
191            heartbeat_timeout_mills: None,
192            election_priority: None,
193        };
194        assert_eq!(header.cluster_name, CheetahString::from("testCluster"));
195        assert_eq!(header.broker_addr, CheetahString::from("testAddr"));
196        assert_eq!(header.broker_name, CheetahString::from("testBroker"));
197        assert!(header.broker_id.is_none());
198        assert!(header.epoch.is_none());
199        assert!(header.max_offset.is_none());
200        assert!(header.confirm_offset.is_none());
201        assert!(header.heartbeat_timeout_mills.is_none());
202        assert!(header.election_priority.is_none());
203    }
204
205    #[test]
206    fn broker_heartbeat_request_header_with_empty_values() {
207        let header = BrokerHeartbeatRequestHeader {
208            cluster_name: CheetahString::from(""),
209            broker_addr: CheetahString::from(""),
210            broker_name: CheetahString::from(""),
211            broker_id: None,
212            epoch: None,
213            max_offset: None,
214            confirm_offset: None,
215            heartbeat_timeout_mills: None,
216            election_priority: None,
217        };
218        assert_eq!(header.cluster_name, CheetahString::from(""));
219        assert_eq!(header.broker_addr, CheetahString::from(""));
220        assert_eq!(header.broker_name, CheetahString::from(""));
221        assert!(header.broker_id.is_none());
222        assert!(header.epoch.is_none());
223        assert!(header.max_offset.is_none());
224        assert!(header.confirm_offset.is_none());
225        assert!(header.heartbeat_timeout_mills.is_none());
226        assert!(header.election_priority.is_none());
227    }
228
229    #[test]
230    fn broker_heartbeat_request_header_with_long_values() {
231        let long_string = "a".repeat(1000);
232        let header = BrokerHeartbeatRequestHeader {
233            cluster_name: CheetahString::from(&long_string),
234            broker_addr: CheetahString::from(&long_string),
235            broker_name: CheetahString::from(&long_string),
236            broker_id: Some(1),
237            epoch: Some(1),
238            max_offset: Some(100),
239            confirm_offset: Some(50),
240            heartbeat_timeout_mills: Some(3000),
241            election_priority: Some(1),
242        };
243        assert_eq!(header.cluster_name, CheetahString::from(&long_string));
244        assert_eq!(header.broker_addr, CheetahString::from(&long_string));
245        assert_eq!(header.broker_name, CheetahString::from(&long_string));
246        assert_eq!(header.broker_id, Some(1));
247        assert_eq!(header.epoch, Some(1));
248        assert_eq!(header.max_offset, Some(100));
249        assert_eq!(header.confirm_offset, Some(50));
250        assert_eq!(header.heartbeat_timeout_mills, Some(3000));
251        assert_eq!(header.election_priority, Some(1));
252    }
253}
rocketmq_remoting/protocol/header/namesrv/broker_request.rs

rocketmq_remoting/protocol/header/namesrv/
broker_request.rs
