Skip to main content

rocketmq_model/common/tools/
message_track.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
15#[allow(deprecated)]
16use crate::common::tools::track_type::TrackType;
17use serde::Deserialize;
18use serde::Serialize;
19
20#[deprecated(
21    since = "0.7.0",
22    note = "This type has been moved to rocketmq_model::common::tools::message_track::MessageTrack"
23)]
24#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(rename_all = "camelCase")]
26#[allow(deprecated)]
27pub struct MessageTrack {
28    pub consumer_group: String,
29    pub track_type: Option<TrackType>,
30    pub exception_desc: String,
31}
32
33#[allow(dead_code)]
34#[allow(deprecated)]
35impl MessageTrack {
36    pub fn get_consumer_group(&self) -> String {
37        self.consumer_group.clone()
38    }
39
40    pub fn set_consumer_group(&mut self, consumer_group: String) {
41        self.consumer_group = consumer_group;
42    }
43
44    pub fn get_track_type(&self) -> Option<TrackType> {
45        self.track_type
46    }
47
48    pub fn set_track_type(&mut self, track_type: TrackType) {
49        self.track_type = Some(track_type);
50    }
51
52    pub fn get_exception_desc(&self) -> String {
53        self.exception_desc.clone()
54    }
55
56    pub fn set_exception_desc(&mut self, exception_desc: String) {
57        self.exception_desc = exception_desc;
58    }
59}
60#[allow(deprecated)]
61impl std::fmt::Display for MessageTrack {
62    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
63        let track_type_str = self
64            .track_type
65            .as_ref()
66            .map_or("None".to_string(), |tt| format!("{tt}"));
67        write!(
68            f,
69            "MessageTrack [consumerGroup={}, trackType={}, exceptionDesc={}]",
70            self.consumer_group, track_type_str, self.exception_desc
71        )
72    }
73}
74
75#[cfg(test)]
76mod tests {
77
78    use super::*;
79
80    #[test]
81    #[allow(deprecated)]
82    pub fn test_message_track() {
83        let mut message_track = MessageTrack {
84            consumer_group: "test_consumer_group".to_string(),
85            track_type: Some(TrackType::Consumed),
86            exception_desc: "test_exception_desc".to_string(),
87        };
88
89        assert_eq!(message_track.get_consumer_group(), "test_consumer_group");
90        assert_eq!(message_track.get_exception_desc(), "test_exception_desc");
91        assert_eq!(message_track.get_track_type(), Some(TrackType::Consumed));
92
93        let display = format!("{}", message_track);
94        println!("{}", display);
95        assert_eq!(
96            display,
97            "MessageTrack [consumerGroup=test_consumer_group, trackType=CONSUMED, exceptionDesc=test_exception_desc]"
98        );
99
100        message_track.set_consumer_group("test_consumer_group2".to_string());
101        message_track.set_track_type(TrackType::Pull);
102        message_track.set_exception_desc("test_exception_desc2".to_string());
103
104        assert_eq!(message_track.get_consumer_group(), "test_consumer_group2");
105        assert_eq!(message_track.get_exception_desc(), "test_exception_desc2");
106    }
107}