meta_srv/service/admin/
procedure.rs1use 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#[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#[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#[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 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 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#[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}