Skip to main content

meta_srv/handler/
collect_leader_region_handler.rs

1// Copyright 2023 Greptime Team
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 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        // New heartbeat with new manifest version
149        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        // New heartbeat with old manifest version
182        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            // The manifest version is not updated
204            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}