Skip to main content

rocketmq_protocol/protocol/header/namesrv/
query_data_version_header.rs

1// Copyright 2023 The RocketMQ Rust Authors
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use cheetah_string::CheetahString;
16use rocketmq_macros::RequestHeaderCodec;
17use serde::Deserialize;
18use serde::Serialize;
19
20#[derive(Debug, Clone, Deserialize, Serialize, Default, RequestHeaderCodec)]
21#[serde(rename_all = "camelCase")]
22#[header(
23    type_id = "rocketmq_protocol::protocol::header::namesrv::query_data_version_header::QueryDataVersionRequestHeader",
24    java_class = "org.apache.rocketmq.remoting.protocol.header.namesrv.QueryDataVersionRequestHeader"
25)]
26pub struct QueryDataVersionRequestHeader {
27    #[header(required)]
28    pub broker_name: CheetahString,
29
30    #[header(required)]
31    pub broker_addr: CheetahString,
32
33    #[header(required)]
34    pub cluster_name: CheetahString,
35
36    #[header(required, range = "i64")]
37    pub broker_id: u64,
38}
39
40impl QueryDataVersionRequestHeader {
41    pub fn new(
42        broker_name: impl Into<CheetahString>,
43        broker_addr: impl Into<CheetahString>,
44        cluster_name: impl Into<CheetahString>,
45        broker_id: u64,
46    ) -> Self {
47        Self {
48            broker_name: broker_name.into(),
49            broker_addr: broker_addr.into(),
50            cluster_name: cluster_name.into(),
51            broker_id,
52        }
53    }
54}
55
56#[derive(Debug, Clone, Deserialize, Serialize, Default, RequestHeaderCodec)]
57#[header(
58    type_id = "rocketmq_protocol::protocol::header::namesrv::query_data_version_header::QueryDataVersionResponseHeader",
59    java_class = "org.apache.rocketmq.remoting.protocol.header.namesrv.QueryDataVersionResponseHeader"
60)]
61pub struct QueryDataVersionResponseHeader {
62    #[header(required)]
63    changed: bool,
64}
65
66impl QueryDataVersionResponseHeader {
67    pub fn new(changed: bool) -> Self {
68        Self { changed }
69    }
70
71    pub fn changed(&self) -> bool {
72        self.changed
73    }
74}
75
76#[cfg(test)]
77mod tests {
78    use cheetah_string::CheetahString;
79
80    use super::*;
81
82    #[test]
83    fn query_data_version_request_header_serialization() {
84        let header = QueryDataVersionRequestHeader::new("broker1", "127.0.0.1", "cluster1", 1);
85        let serialized = serde_json::to_string(&header).unwrap();
86        assert_eq!(
87            serialized,
88            r#"{"brokerName":"broker1","brokerAddr":"127.0.0.1","clusterName":"cluster1","brokerId":1}"#
89        );
90    }
91
92    #[test]
93    fn query_data_version_request_header_deserialization() {
94        let json = r#"{"brokerName":"broker1","brokerAddr":"127.0.0.1","clusterName":"cluster1","brokerId":1}"#;
95        let deserialized: QueryDataVersionRequestHeader = serde_json::from_str(json).unwrap();
96        assert_eq!(deserialized.broker_name, CheetahString::from("broker1"));
97        assert_eq!(deserialized.broker_addr, CheetahString::from("127.0.0.1"));
98        assert_eq!(deserialized.cluster_name, CheetahString::from("cluster1"));
99        assert_eq!(deserialized.broker_id, 1);
100    }
101
102    #[test]
103    fn query_data_version_response_header_serialization() {
104        let header = QueryDataVersionResponseHeader::new(true);
105        let serialized = serde_json::to_string(&header).unwrap();
106        assert_eq!(serialized, r#"{"changed":true}"#);
107    }
108
109    #[test]
110    fn query_data_version_response_header_deserialization() {
111        let json = r#"{"changed":true}"#;
112        let deserialized: QueryDataVersionResponseHeader = serde_json::from_str(json).unwrap();
113        assert!(deserialized.changed);
114    }
115}