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
// Copyright 2023 The RocketMQ Rust Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use std::collections::HashMap;
use serde::Deserialize;
use serde::Serialize;
use crate::protocol::body::producer_info::ProducerInfo;
/// Producer information table
///
/// A collection of producer information organized by group.
/// This structure maps producer group names to lists of producer information objects.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProducerTableInfo {
/// Mapping from producer group names to lists of producer information
data: HashMap<String, Vec<ProducerInfo>>,
}
impl ProducerTableInfo {
/// Create a new ProducerTableInfo
///
/// # Parameters
/// * `data` - Map of producer groups to lists of producer information
pub fn new(data: HashMap<String, Vec<ProducerInfo>>) -> Self {
Self { data }
}
/// Get the producer table data
///
/// # Returns
/// Reference to the internal map of producer groups to producer information
pub fn data(&self) -> &HashMap<String, Vec<ProducerInfo>> {
&self.data
}
/// Get mutable access to the producer table data
///
/// # Returns
/// Mutable reference to the internal map of producer groups to producer information
pub fn data_mut(&mut self) -> &mut HashMap<String, Vec<ProducerInfo>> {
&mut self.data
}
/// Set the producer table data
///
/// # Parameters
/// * `data` - New map of producer groups to lists of producer information
pub fn set_data(&mut self, data: HashMap<String, Vec<ProducerInfo>>) {
self.data = data;
}
}
/// Default implementation that creates an empty producer table
impl Default for ProducerTableInfo {
fn default() -> Self {
Self { data: HashMap::new() }
}
}
/// Implementation of the From trait to convert from a HashMap
impl From<HashMap<String, Vec<ProducerInfo>>> for ProducerTableInfo {
fn from(data: HashMap<String, Vec<ProducerInfo>>) -> Self {
Self::new(data)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::protocol::LanguageCode;
use crate::protocol::RemotingDeserializable;
use crate::protocol::RemotingSerializable;
#[test]
fn test_producer_table_info() {
let mut table = ProducerTableInfo::default();
assert!(table.data().is_empty());
// Create some test data
let producer1 = ProducerInfo::new("producer1", "192.168.1.1", LanguageCode::RUST, 1, 100);
let producer2 = ProducerInfo::new("producer2", "192.168.1.2", LanguageCode::JAVA, 2, 200);
let mut data = HashMap::new();
data.insert("group1".to_string(), vec![producer1.clone()]);
data.insert("group2".to_string(), vec![producer2.clone()]);
// Test setters
table.set_data(data);
assert_eq!(table.data().len(), 2);
assert!(table.data().contains_key("group1"));
assert!(table.data().contains_key("group2"));
// Test JSON serialization/deserialization
let json = table.serialize_json().unwrap();
let deserialized = ProducerTableInfo::decode(json.as_bytes()).unwrap();
assert_eq!(deserialized.data().len(), 2);
assert!(deserialized.data().contains_key("group1"));
assert!(deserialized.data().contains_key("group2"));
// Verify producer info was preserved
let group1_producers = &deserialized.data()["group1"];
assert_eq!(group1_producers.len(), 1);
assert_eq!(group1_producers[0].client_id(), "producer1");
// Test the From trait implementation
let mut new_data = HashMap::new();
new_data.insert("group3".to_string(), vec![producer1.clone(), producer2.clone()]);
let from_table = ProducerTableInfo::from(new_data);
assert_eq!(from_table.data().len(), 1);
assert_eq!(from_table.data()["group3"].len(), 2);
}
}