1use api::v1::meta::{HeartbeatRequest, Role};
16use common_meta::region_registry::{LeaderRegion, LeaderRegionManifestInfo};
17use store_api::region_engine::RegionRole;
18
19use crate::error::Result;
20use crate::handler::{HandleControl, HeartbeatAccumulator, HeartbeatHandler};
21use crate::metasrv::Context;
22
23pub struct CollectLeaderRegionHandler;
24
25#[async_trait::async_trait]
26impl HeartbeatHandler for CollectLeaderRegionHandler {
27 fn is_acceptable(&self, role: Role) -> bool {
28 role == Role::Datanode
29 }
30
31 async fn handle(
32 &self,
33 _req: &HeartbeatRequest,
34 ctx: &mut Context,
35 acc: &mut HeartbeatAccumulator,
36 ) -> Result<HandleControl> {
37 let Some(current_stat) = acc.stat.as_ref() else {
38 return Ok(HandleControl::Continue);
39 };
40
41 let mut key_values = Vec::with_capacity(current_stat.region_stats.len());
42 for stat in current_stat.region_stats.iter() {
43 if !matches!(stat.role, RegionRole::Leader | RegionRole::StagingLeader) {
44 continue;
45 }
46
47 let manifest = LeaderRegionManifestInfo::from_region_stat(stat);
48 let value = LeaderRegion {
49 datanode_id: current_stat.id,
50 manifest,
51 has_pending_tails: stat.has_pending_tails,
52 };
53 key_values.push((stat.id, value));
54 }
55 ctx.leader_region_registry.batch_put(key_values);
56
57 Ok(HandleControl::Continue)
58 }
59}
60
61#[cfg(test)]
62mod tests {
63 use common_meta::datanode::{RegionManifestInfo, RegionStat, Stat};
64 use common_meta::region_registry::LeaderRegionManifestInfo;
65 use store_api::region_engine::RegionRole;
66 use store_api::storage::RegionId;
67
68 use super::*;
69 use crate::handler::test_utils::TestEnv;
70
71 fn new_region_stat(id: RegionId, manifest_version: u64, role: RegionRole) -> RegionStat {
72 RegionStat {
73 id,
74 region_manifest: RegionManifestInfo::Mito {
75 manifest_version,
76 flushed_entry_id: 0,
77 file_removed_cnt: 0,
78 },
79 rcus: 0,
80 wcus: 0,
81 approximate_bytes: 0,
82 engine: "mito".to_string(),
83 role,
84 num_rows: 0,
85 memtable_size: 0,
86 manifest_size: 0,
87 sst_size: 0,
88 sst_num: 0,
89 index_size: 0,
90 data_topic_latest_entry_id: 0,
91 metadata_topic_latest_entry_id: 0,
92 min_timestamp: None,
93 max_timestamp: None,
94 written_bytes: 0,
95 ingested_parquet_bytes: 0,
96 query_cpu_time: 0,
97 query_scanned_bytes: 0,
98 has_pending_tails: false,
99 }
100 }
101
102 #[tokio::test]
103 async fn test_handle_collect_leader_region() {
104 let env = TestEnv::new();
105 let mut ctx = env.ctx();
106
107 let mut acc = HeartbeatAccumulator {
108 stat: Some(Stat {
109 id: 1,
110 region_stats: vec![
111 RegionStat {
112 has_pending_tails: true,
113 ..new_region_stat(RegionId::new(1, 1), 1, RegionRole::Leader)
114 },
115 new_region_stat(RegionId::new(1, 2), 2, RegionRole::Follower),
116 ],
117 addr: "127.0.0.1:0000".to_string(),
118 region_num: 2,
119 ..Default::default()
120 }),
121 ..Default::default()
122 };
123
124 let handler = CollectLeaderRegionHandler;
125 let control = handler
126 .handle(&HeartbeatRequest::default(), &mut ctx, &mut acc)
127 .await
128 .unwrap();
129
130 assert_eq!(control, HandleControl::Continue);
131 let regions = ctx
132 .leader_region_registry
133 .batch_get(vec![RegionId::new(1, 1), RegionId::new(1, 2)].into_iter());
134 assert_eq!(regions.len(), 1);
135 assert_eq!(
136 regions.get(&RegionId::new(1, 1)),
137 Some(&LeaderRegion {
138 datanode_id: 1,
139 manifest: LeaderRegionManifestInfo::Mito {
140 manifest_version: 1,
141 flushed_entry_id: 0,
142 topic_latest_entry_id: 0,
143 },
144 has_pending_tails: true,
145 })
146 );
147
148 acc.stat = Some(Stat {
150 id: 1,
151 region_stats: vec![new_region_stat(RegionId::new(1, 1), 2, RegionRole::Leader)],
152 timestamp_millis: 0,
153 addr: "127.0.0.1:0000".to_string(),
154 region_num: 1,
155 node_epoch: 0,
156 ..Default::default()
157 });
158 let control = handler
159 .handle(&HeartbeatRequest::default(), &mut ctx, &mut acc)
160 .await
161 .unwrap();
162
163 assert_eq!(control, HandleControl::Continue);
164 let regions = ctx
165 .leader_region_registry
166 .batch_get(vec![RegionId::new(1, 1)].into_iter());
167 assert_eq!(regions.len(), 1);
168 assert_eq!(
169 regions.get(&RegionId::new(1, 1)),
170 Some(&LeaderRegion {
171 datanode_id: 1,
172 manifest: LeaderRegionManifestInfo::Mito {
173 manifest_version: 2,
174 flushed_entry_id: 0,
175 topic_latest_entry_id: 0,
176 },
177 has_pending_tails: false,
178 })
179 );
180
181 acc.stat = Some(Stat {
183 id: 1,
184 region_stats: vec![new_region_stat(RegionId::new(1, 1), 1, RegionRole::Leader)],
185 timestamp_millis: 0,
186 addr: "127.0.0.1:0000".to_string(),
187 region_num: 1,
188 node_epoch: 0,
189 ..Default::default()
190 });
191 let control = handler
192 .handle(&HeartbeatRequest::default(), &mut ctx, &mut acc)
193 .await
194 .unwrap();
195
196 assert_eq!(control, HandleControl::Continue);
197 let regions = ctx
198 .leader_region_registry
199 .batch_get(vec![RegionId::new(1, 1)].into_iter());
200 assert_eq!(regions.len(), 1);
201 assert_eq!(
202 regions.get(&RegionId::new(1, 1)),
203 Some(&LeaderRegion {
205 datanode_id: 1,
206 manifest: LeaderRegionManifestInfo::Mito {
207 manifest_version: 2,
208 flushed_entry_id: 0,
209 topic_latest_entry_id: 0,
210 },
211 has_pending_tails: false,
212 })
213 );
214 }
215}