Skip to main content

meta_srv/service/admin/
procedure.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 std::collections::HashMap;
16use std::sync::Arc;
17
18use axum::Json;
19use axum::extract::{Query, State};
20use axum::response::{IntoResponse, Response};
21use common_meta::key::runtime_switch::RuntimeSwitchManagerRef;
22use common_meta::rpc::procedure;
23use common_procedure::ProcedureId;
24use common_telemetry::info;
25use serde::{Deserialize, Serialize};
26use servers::http::result::error_result::ErrorResponse;
27use snafu::{OptionExt, ResultExt};
28use tonic::codegen::http;
29
30use crate::error::{self, RuntimeSwitchManagerSnafu};
31use crate::metasrv::Metasrv;
32use crate::service::admin::HttpHandler;
33use crate::service::admin::util;
34use crate::service::admin::util::{ErrorHandler, to_json_response, to_not_found_response};
35
36#[derive(Clone)]
37pub struct ProcedureManagerHandler {
38    pub manager: RuntimeSwitchManagerRef,
39}
40
41#[derive(Debug, Serialize, Deserialize)]
42pub(crate) struct ProcedureManagerStatusResponse {
43    status: ProcedureManagerStatus,
44}
45
46#[derive(Debug, Serialize, Deserialize)]
47#[serde(rename_all = "snake_case")]
48enum ProcedureManagerStatus {
49    Paused,
50    Running,
51}
52
53/// Get the procedure manager status.
54#[axum_macros::debug_handler]
55pub(crate) async fn status(State(handler): State<ProcedureManagerHandler>) -> Response {
56    handler
57        .get_procedure_manager_status()
58        .await
59        .map(Json)
60        .map_err(ErrorHandler::new)
61        .into_response()
62}
63
64/// Pause the procedure manager.
65#[axum_macros::debug_handler]
66pub(crate) async fn pause(State(handler): State<ProcedureManagerHandler>) -> Response {
67    handler
68        .pause_procedure_manager()
69        .await
70        .map(Json)
71        .map_err(ErrorHandler::new)
72        .into_response()
73}
74
75/// Resume the procedure manager.
76#[axum_macros::debug_handler]
77pub(crate) async fn resume(State(handler): State<ProcedureManagerHandler>) -> Response {
78    handler
79        .resume_procedure_manager()
80        .await
81        .map(Json)
82        .map_err(ErrorHandler::new)
83        .into_response()
84}
85
86impl ProcedureManagerHandler {
87    pub(crate) async fn pause_procedure_manager(
88        &self,
89    ) -> crate::Result<ProcedureManagerStatusResponse> {
90        self.manager
91            .pasue_procedure()
92            .await
93            .context(RuntimeSwitchManagerSnafu)?;
94        // TODO(weny): Add a record to the system events.
95        info!("Pause the procedure manager.");
96        Ok(ProcedureManagerStatusResponse {
97            status: ProcedureManagerStatus::Paused,
98        })
99    }
100
101    pub(crate) async fn resume_procedure_manager(
102        &self,
103    ) -> crate::Result<ProcedureManagerStatusResponse> {
104        self.manager
105            .resume_procedure()
106            .await
107            .context(RuntimeSwitchManagerSnafu)?;
108        // TODO(weny): Add a record to the system events.
109        info!("Resume the procedure manager.");
110        Ok(ProcedureManagerStatusResponse {
111            status: ProcedureManagerStatus::Running,
112        })
113    }
114
115    pub(crate) async fn get_procedure_manager_status(
116        &self,
117    ) -> crate::Result<ProcedureManagerStatusResponse> {
118        let is_paused = self
119            .manager
120            .is_procedure_paused()
121            .await
122            .context(RuntimeSwitchManagerSnafu)?;
123        let response = ProcedureManagerStatusResponse {
124            status: if is_paused {
125                ProcedureManagerStatus::Paused
126            } else {
127                ProcedureManagerStatus::Running
128            },
129        };
130
131        Ok(response)
132    }
133}
134
135#[async_trait::async_trait]
136impl HttpHandler for ProcedureManagerHandler {
137    async fn handle(
138        &self,
139        path: &str,
140        method: http::Method,
141        _: &HashMap<String, String>,
142    ) -> crate::Result<http::Response<String>> {
143        match method {
144            http::Method::GET => {
145                if path.ends_with("status") {
146                    let response = self.get_procedure_manager_status().await?;
147                    to_json_response(response)
148                } else {
149                    to_not_found_response()
150                }
151            }
152            http::Method::POST => {
153                if path.ends_with("pause") {
154                    let response = self.pause_procedure_manager().await?;
155                    to_json_response(response)
156                } else if path.ends_with("resume") {
157                    let response = self.resume_procedure_manager().await?;
158                    to_json_response(response)
159                } else {
160                    to_not_found_response()
161                }
162            }
163            _ => to_not_found_response(),
164        }
165    }
166}
167
168#[derive(Debug, Deserialize)]
169pub(crate) struct ProcedureStatusRequest {
170    procedure_id: String,
171}
172
173#[derive(Debug, Serialize)]
174pub(crate) struct ProcedureStatusResponse {
175    procedure_id: String,
176    status: String,
177    error: Option<String>,
178}
179
180/// Queries a submitted procedure, independently of the procedure-manager switch.
181#[axum_macros::debug_handler]
182pub(crate) async fn procedure_status(
183    State(metasrv): State<Arc<Metasrv>>,
184    Query(request): Query<ProcedureStatusRequest>,
185) -> Response {
186    async {
187        util::ensure_leader(&metasrv)?;
188        let pid = request.procedure_id.parse::<ProcedureId>().map_err(|_| {
189            error::InvalidArgumentsSnafu {
190                err_msg: format!("invalid procedure id: {}", request.procedure_id),
191            }
192            .build()
193        })?;
194        let state = metasrv
195            .procedure_manager()
196            .procedure_state(pid)
197            .await
198            .context(error::QueryProcedureSnafu)?
199            .with_context(|| error::ProcedureNotFoundSnafu {
200                pid: request.procedure_id,
201            })?;
202        let (_, error) = procedure::procedure_state_to_pb_state(&state);
203        Ok::<_, error::Error>(ProcedureStatusResponse {
204            procedure_id: pid.to_string(),
205            status: state.as_str_name().to_string(),
206            error: (!error.is_empty()).then_some(error),
207        })
208    }
209    .await
210    .map(Json)
211    .map_err(ErrorResponse::from_error)
212    .into_response()
213}