Line data Source code
1 : use crate::reconciler::ReconcileError;
2 : use crate::service::{Service, STARTUP_RECONCILE_TIMEOUT};
3 : use hyper::{Body, Request, Response};
4 : use hyper::{StatusCode, Uri};
5 : use pageserver_api::models::{
6 : TenantCreateRequest, TenantLocationConfigRequest, TenantShardSplitRequest,
7 : TenantTimeTravelRequest, TimelineCreateRequest,
8 : };
9 : use pageserver_api::shard::TenantShardId;
10 : use pageserver_client::mgmt_api;
11 : use std::sync::Arc;
12 : use std::time::{Duration, Instant};
13 : use utils::auth::{Scope, SwappableJwtAuth};
14 : use utils::http::endpoint::{auth_middleware, check_permission_with, request_span};
15 : use utils::http::request::{must_get_query_param, parse_request_param};
16 : use utils::id::{TenantId, TimelineId};
17 :
18 : use utils::{
19 : http::{
20 : endpoint::{self},
21 : error::ApiError,
22 : json::{json_request, json_response},
23 : RequestExt, RouterBuilder,
24 : },
25 : id::NodeId,
26 : };
27 :
28 : use pageserver_api::controller_api::{
29 : NodeConfigureRequest, NodeRegisterRequest, TenantShardMigrateRequest,
30 : };
31 : use pageserver_api::upcall_api::{ReAttachRequest, ValidateRequest};
32 :
33 : use control_plane::attachment_service::{AttachHookRequest, InspectRequest};
34 :
35 : /// State available to HTTP request handlers
36 0 : #[derive(Clone)]
37 : pub struct HttpState {
38 : service: Arc<crate::service::Service>,
39 : auth: Option<Arc<SwappableJwtAuth>>,
40 : allowlist_routes: Vec<Uri>,
41 : }
42 :
43 : impl HttpState {
44 0 : pub fn new(service: Arc<crate::service::Service>, auth: Option<Arc<SwappableJwtAuth>>) -> Self {
45 0 : let allowlist_routes = ["/status", "/ready", "/metrics"]
46 0 : .iter()
47 0 : .map(|v| v.parse().unwrap())
48 0 : .collect::<Vec<_>>();
49 0 : Self {
50 0 : service,
51 0 : auth,
52 0 : allowlist_routes,
53 0 : }
54 0 : }
55 : }
56 :
57 : #[inline(always)]
58 0 : fn get_state(request: &Request<Body>) -> &HttpState {
59 0 : request
60 0 : .data::<Arc<HttpState>>()
61 0 : .expect("unknown state type")
62 0 : .as_ref()
63 0 : }
64 :
65 : /// Pageserver calls into this on startup, to learn which tenants it should attach
66 0 : async fn handle_re_attach(mut req: Request<Body>) -> Result<Response<Body>, ApiError> {
67 0 : check_permissions(&req, Scope::GenerationsApi)?;
68 :
69 0 : let reattach_req = json_request::<ReAttachRequest>(&mut req).await?;
70 0 : let state = get_state(&req);
71 0 : json_response(StatusCode::OK, state.service.re_attach(reattach_req).await?)
72 0 : }
73 :
74 : /// Pageserver calls into this before doing deletions, to confirm that it still
75 : /// holds the latest generation for the tenants with deletions enqueued
76 0 : async fn handle_validate(mut req: Request<Body>) -> Result<Response<Body>, ApiError> {
77 0 : check_permissions(&req, Scope::GenerationsApi)?;
78 :
79 0 : let validate_req = json_request::<ValidateRequest>(&mut req).await?;
80 0 : let state = get_state(&req);
81 0 : json_response(StatusCode::OK, state.service.validate(validate_req))
82 0 : }
83 :
84 : /// Call into this before attaching a tenant to a pageserver, to acquire a generation number
85 : /// (in the real control plane this is unnecessary, because the same program is managing
86 : /// generation numbers and doing attachments).
87 0 : async fn handle_attach_hook(mut req: Request<Body>) -> Result<Response<Body>, ApiError> {
88 0 : check_permissions(&req, Scope::Admin)?;
89 :
90 0 : let attach_req = json_request::<AttachHookRequest>(&mut req).await?;
91 0 : let state = get_state(&req);
92 0 :
93 0 : json_response(
94 0 : StatusCode::OK,
95 0 : state
96 0 : .service
97 0 : .attach_hook(attach_req)
98 0 : .await
99 0 : .map_err(ApiError::InternalServerError)?,
100 : )
101 0 : }
102 :
103 0 : async fn handle_inspect(mut req: Request<Body>) -> Result<Response<Body>, ApiError> {
104 0 : check_permissions(&req, Scope::Admin)?;
105 :
106 0 : let inspect_req = json_request::<InspectRequest>(&mut req).await?;
107 :
108 0 : let state = get_state(&req);
109 0 :
110 0 : json_response(StatusCode::OK, state.service.inspect(inspect_req))
111 0 : }
112 :
113 0 : async fn handle_tenant_create(
114 0 : service: Arc<Service>,
115 0 : mut req: Request<Body>,
116 0 : ) -> Result<Response<Body>, ApiError> {
117 0 : check_permissions(&req, Scope::PageServerApi)?;
118 :
119 0 : let create_req = json_request::<TenantCreateRequest>(&mut req).await?;
120 : json_response(
121 : StatusCode::CREATED,
122 0 : service.tenant_create(create_req).await?,
123 : )
124 0 : }
125 :
126 : // For tenant and timeline deletions, which both implement an "initially return 202, then 404 once
127 : // we're done" semantic, we wrap with a retry loop to expose a simpler API upstream. This avoids
128 : // needing to track a "deleting" state for tenants.
129 0 : async fn deletion_wrapper<R, F>(service: Arc<Service>, f: F) -> Result<Response<Body>, ApiError>
130 0 : where
131 0 : R: std::future::Future<Output = Result<StatusCode, ApiError>> + Send + 'static,
132 0 : F: Fn(Arc<Service>) -> R + Send + Sync + 'static,
133 0 : {
134 0 : let started_at = Instant::now();
135 0 : // To keep deletion reasonably snappy for small tenants, initially check after 1 second if deletion
136 0 : // completed.
137 0 : let mut retry_period = Duration::from_secs(1);
138 0 : // On subsequent retries, wait longer.
139 0 : let max_retry_period = Duration::from_secs(5);
140 0 : // Enable callers with a 30 second request timeout to reliably get a response
141 0 : let max_wait = Duration::from_secs(25);
142 :
143 : loop {
144 0 : let status = f(service.clone()).await?;
145 0 : match status {
146 : StatusCode::ACCEPTED => {
147 0 : tracing::info!("Deletion accepted, waiting to try again...");
148 0 : tokio::time::sleep(retry_period).await;
149 0 : retry_period = max_retry_period;
150 : }
151 : StatusCode::NOT_FOUND => {
152 0 : tracing::info!("Deletion complete");
153 0 : return json_response(StatusCode::OK, ());
154 : }
155 : _ => {
156 0 : tracing::warn!("Unexpected status {status}");
157 0 : return json_response(status, ());
158 : }
159 : }
160 :
161 0 : let now = Instant::now();
162 0 : if now + retry_period > started_at + max_wait {
163 0 : tracing::info!("Deletion timed out waiting for 404");
164 : // REQUEST_TIMEOUT would be more appropriate, but CONFLICT is already part of
165 : // the pageserver's swagger definition for this endpoint, and has the same desired
166 : // effect of causing the control plane to retry later.
167 0 : return json_response(StatusCode::CONFLICT, ());
168 0 : }
169 : }
170 0 : }
171 :
172 0 : async fn handle_tenant_location_config(
173 0 : service: Arc<Service>,
174 0 : mut req: Request<Body>,
175 0 : ) -> Result<Response<Body>, ApiError> {
176 0 : let tenant_id: TenantId = parse_request_param(&req, "tenant_id")?;
177 0 : check_permissions(&req, Scope::PageServerApi)?;
178 :
179 0 : let config_req = json_request::<TenantLocationConfigRequest>(&mut req).await?;
180 : json_response(
181 : StatusCode::OK,
182 0 : service
183 0 : .tenant_location_config(tenant_id, config_req)
184 0 : .await?,
185 : )
186 0 : }
187 :
188 0 : async fn handle_tenant_time_travel_remote_storage(
189 0 : service: Arc<Service>,
190 0 : mut req: Request<Body>,
191 0 : ) -> Result<Response<Body>, ApiError> {
192 0 : let tenant_id: TenantId = parse_request_param(&req, "tenant_id")?;
193 0 : check_permissions(&req, Scope::PageServerApi)?;
194 :
195 0 : let time_travel_req = json_request::<TenantTimeTravelRequest>(&mut req).await?;
196 :
197 0 : let timestamp_raw = must_get_query_param(&req, "travel_to")?;
198 0 : let _timestamp = humantime::parse_rfc3339(×tamp_raw).map_err(|_e| {
199 0 : ApiError::BadRequest(anyhow::anyhow!(
200 0 : "Invalid time for travel_to: {timestamp_raw:?}"
201 0 : ))
202 0 : })?;
203 :
204 0 : let done_if_after_raw = must_get_query_param(&req, "done_if_after")?;
205 0 : let _done_if_after = humantime::parse_rfc3339(&done_if_after_raw).map_err(|_e| {
206 0 : ApiError::BadRequest(anyhow::anyhow!(
207 0 : "Invalid time for done_if_after: {done_if_after_raw:?}"
208 0 : ))
209 0 : })?;
210 :
211 0 : service
212 0 : .tenant_time_travel_remote_storage(
213 0 : &time_travel_req,
214 0 : tenant_id,
215 0 : timestamp_raw,
216 0 : done_if_after_raw,
217 0 : )
218 0 : .await?;
219 :
220 0 : json_response(StatusCode::OK, ())
221 0 : }
222 :
223 0 : async fn handle_tenant_delete(
224 0 : service: Arc<Service>,
225 0 : req: Request<Body>,
226 0 : ) -> Result<Response<Body>, ApiError> {
227 0 : let tenant_id: TenantId = parse_request_param(&req, "tenant_id")?;
228 0 : check_permissions(&req, Scope::PageServerApi)?;
229 :
230 0 : deletion_wrapper(service, move |service| async move {
231 0 : service.tenant_delete(tenant_id).await
232 0 : })
233 0 : .await
234 0 : }
235 :
236 0 : async fn handle_tenant_timeline_create(
237 0 : service: Arc<Service>,
238 0 : mut req: Request<Body>,
239 0 : ) -> Result<Response<Body>, ApiError> {
240 0 : let tenant_id: TenantId = parse_request_param(&req, "tenant_id")?;
241 0 : check_permissions(&req, Scope::PageServerApi)?;
242 :
243 0 : let create_req = json_request::<TimelineCreateRequest>(&mut req).await?;
244 : json_response(
245 : StatusCode::CREATED,
246 0 : service
247 0 : .tenant_timeline_create(tenant_id, create_req)
248 0 : .await?,
249 : )
250 0 : }
251 :
252 0 : async fn handle_tenant_timeline_delete(
253 0 : service: Arc<Service>,
254 0 : req: Request<Body>,
255 0 : ) -> Result<Response<Body>, ApiError> {
256 0 : let tenant_id: TenantId = parse_request_param(&req, "tenant_id")?;
257 0 : check_permissions(&req, Scope::PageServerApi)?;
258 :
259 0 : let timeline_id: TimelineId = parse_request_param(&req, "timeline_id")?;
260 :
261 0 : deletion_wrapper(service, move |service| async move {
262 0 : service.tenant_timeline_delete(tenant_id, timeline_id).await
263 0 : })
264 0 : .await
265 0 : }
266 :
267 0 : async fn handle_tenant_timeline_passthrough(
268 0 : service: Arc<Service>,
269 0 : req: Request<Body>,
270 0 : ) -> Result<Response<Body>, ApiError> {
271 0 : let tenant_id: TenantId = parse_request_param(&req, "tenant_id")?;
272 0 : check_permissions(&req, Scope::PageServerApi)?;
273 :
274 0 : let Some(path) = req.uri().path_and_query() else {
275 : // This should never happen, our request router only calls us if there is a path
276 0 : return Err(ApiError::BadRequest(anyhow::anyhow!("Missing path")));
277 : };
278 :
279 0 : tracing::info!("Proxying request for tenant {} ({})", tenant_id, path);
280 :
281 : // Find the node that holds shard zero
282 0 : let (base_url, tenant_shard_id) = service.tenant_shard0_baseurl(tenant_id)?;
283 :
284 : // Callers will always pass an unsharded tenant ID. Before proxying, we must
285 : // rewrite this to a shard-aware shard zero ID.
286 0 : let path = format!("{}", path);
287 0 : let tenant_str = tenant_id.to_string();
288 0 : let tenant_shard_str = format!("{}", tenant_shard_id);
289 0 : let path = path.replace(&tenant_str, &tenant_shard_str);
290 0 :
291 0 : let client = mgmt_api::Client::new(base_url, service.get_config().jwt_token.as_deref());
292 0 : let resp = client.get_raw(path).await.map_err(|_e|
293 : // FIXME: give APiError a proper Unavailable variant. We return 503 here because
294 : // if we can't successfully send a request to the pageserver, we aren't available.
295 0 : ApiError::ShuttingDown)?;
296 :
297 : // We have a reqest::Response, would like a http::Response
298 0 : let mut builder = hyper::Response::builder()
299 0 : .status(resp.status())
300 0 : .version(resp.version());
301 0 : for (k, v) in resp.headers() {
302 0 : builder = builder.header(k, v);
303 0 : }
304 :
305 0 : let response = builder
306 0 : .body(Body::wrap_stream(resp.bytes_stream()))
307 0 : .map_err(|e| ApiError::InternalServerError(e.into()))?;
308 :
309 0 : Ok(response)
310 0 : }
311 :
312 0 : async fn handle_tenant_locate(
313 0 : service: Arc<Service>,
314 0 : req: Request<Body>,
315 0 : ) -> Result<Response<Body>, ApiError> {
316 0 : check_permissions(&req, Scope::Admin)?;
317 :
318 0 : let tenant_id: TenantId = parse_request_param(&req, "tenant_id")?;
319 0 : json_response(StatusCode::OK, service.tenant_locate(tenant_id)?)
320 0 : }
321 :
322 0 : async fn handle_node_register(mut req: Request<Body>) -> Result<Response<Body>, ApiError> {
323 0 : check_permissions(&req, Scope::Admin)?;
324 :
325 0 : let register_req = json_request::<NodeRegisterRequest>(&mut req).await?;
326 0 : let state = get_state(&req);
327 0 : state.service.node_register(register_req).await?;
328 0 : json_response(StatusCode::OK, ())
329 0 : }
330 :
331 0 : async fn handle_node_list(req: Request<Body>) -> Result<Response<Body>, ApiError> {
332 0 : check_permissions(&req, Scope::Admin)?;
333 :
334 0 : let state = get_state(&req);
335 0 : json_response(StatusCode::OK, state.service.node_list().await?)
336 0 : }
337 :
338 0 : async fn handle_node_drop(req: Request<Body>) -> Result<Response<Body>, ApiError> {
339 0 : check_permissions(&req, Scope::Admin)?;
340 :
341 0 : let state = get_state(&req);
342 0 : let node_id: NodeId = parse_request_param(&req, "node_id")?;
343 0 : json_response(StatusCode::OK, state.service.node_drop(node_id).await?)
344 0 : }
345 :
346 0 : async fn handle_node_configure(mut req: Request<Body>) -> Result<Response<Body>, ApiError> {
347 0 : check_permissions(&req, Scope::Admin)?;
348 :
349 0 : let node_id: NodeId = parse_request_param(&req, "node_id")?;
350 0 : let config_req = json_request::<NodeConfigureRequest>(&mut req).await?;
351 0 : if node_id != config_req.node_id {
352 0 : return Err(ApiError::BadRequest(anyhow::anyhow!(
353 0 : "Path and body node_id differ"
354 0 : )));
355 0 : }
356 0 : let state = get_state(&req);
357 0 :
358 0 : json_response(
359 0 : StatusCode::OK,
360 0 : state.service.node_configure(config_req).await?,
361 : )
362 0 : }
363 :
364 0 : async fn handle_tenant_shard_split(
365 0 : service: Arc<Service>,
366 0 : mut req: Request<Body>,
367 0 : ) -> Result<Response<Body>, ApiError> {
368 0 : check_permissions(&req, Scope::Admin)?;
369 :
370 0 : let tenant_id: TenantId = parse_request_param(&req, "tenant_id")?;
371 0 : let split_req = json_request::<TenantShardSplitRequest>(&mut req).await?;
372 :
373 : json_response(
374 : StatusCode::OK,
375 0 : service.tenant_shard_split(tenant_id, split_req).await?,
376 : )
377 0 : }
378 :
379 0 : async fn handle_tenant_shard_migrate(
380 0 : service: Arc<Service>,
381 0 : mut req: Request<Body>,
382 0 : ) -> Result<Response<Body>, ApiError> {
383 0 : check_permissions(&req, Scope::Admin)?;
384 :
385 0 : let tenant_shard_id: TenantShardId = parse_request_param(&req, "tenant_shard_id")?;
386 0 : let migrate_req = json_request::<TenantShardMigrateRequest>(&mut req).await?;
387 : json_response(
388 : StatusCode::OK,
389 0 : service
390 0 : .tenant_shard_migrate(tenant_shard_id, migrate_req)
391 0 : .await?,
392 : )
393 0 : }
394 :
395 0 : async fn handle_tenant_drop(req: Request<Body>) -> Result<Response<Body>, ApiError> {
396 0 : let tenant_id: TenantId = parse_request_param(&req, "tenant_id")?;
397 0 : check_permissions(&req, Scope::PageServerApi)?;
398 :
399 0 : let state = get_state(&req);
400 0 :
401 0 : json_response(StatusCode::OK, state.service.tenant_drop(tenant_id).await?)
402 0 : }
403 :
404 0 : async fn handle_tenants_dump(req: Request<Body>) -> Result<Response<Body>, ApiError> {
405 0 : check_permissions(&req, Scope::Admin)?;
406 :
407 0 : let state = get_state(&req);
408 0 : state.service.tenants_dump()
409 0 : }
410 :
411 0 : async fn handle_scheduler_dump(req: Request<Body>) -> Result<Response<Body>, ApiError> {
412 0 : check_permissions(&req, Scope::Admin)?;
413 :
414 0 : let state = get_state(&req);
415 0 : state.service.scheduler_dump()
416 0 : }
417 :
418 0 : async fn handle_consistency_check(req: Request<Body>) -> Result<Response<Body>, ApiError> {
419 0 : check_permissions(&req, Scope::Admin)?;
420 :
421 0 : let state = get_state(&req);
422 0 :
423 0 : json_response(StatusCode::OK, state.service.consistency_check().await?)
424 0 : }
425 :
426 : /// Status endpoint is just used for checking that our HTTP listener is up
427 0 : async fn handle_status(_req: Request<Body>) -> Result<Response<Body>, ApiError> {
428 0 : json_response(StatusCode::OK, ())
429 0 : }
430 :
431 : /// Readiness endpoint indicates when we're done doing startup I/O (e.g. reconciling
432 : /// with remote pageserver nodes). This is intended for use as a kubernetes readiness probe.
433 0 : async fn handle_ready(req: Request<Body>) -> Result<Response<Body>, ApiError> {
434 0 : let state = get_state(&req);
435 0 : if state.service.startup_complete.is_ready() {
436 0 : json_response(StatusCode::OK, ())
437 : } else {
438 0 : json_response(StatusCode::SERVICE_UNAVAILABLE, ())
439 : }
440 0 : }
441 :
442 : impl From<ReconcileError> for ApiError {
443 0 : fn from(value: ReconcileError) -> Self {
444 0 : ApiError::Conflict(format!("Reconciliation error: {}", value))
445 0 : }
446 : }
447 :
448 : /// Common wrapper for request handlers that call into Service and will operate on tenants: they must only
449 : /// be allowed to run if Service has finished its initial reconciliation.
450 0 : async fn tenant_service_handler<R, H>(request: Request<Body>, handler: H) -> R::Output
451 0 : where
452 0 : R: std::future::Future<Output = Result<Response<Body>, ApiError>> + Send + 'static,
453 0 : H: FnOnce(Arc<Service>, Request<Body>) -> R + Send + Sync + 'static,
454 0 : {
455 0 : let state = get_state(&request);
456 0 : let service = state.service.clone();
457 0 :
458 0 : let startup_complete = service.startup_complete.clone();
459 0 : if tokio::time::timeout(STARTUP_RECONCILE_TIMEOUT, startup_complete.wait())
460 0 : .await
461 0 : .is_err()
462 : {
463 : // This shouldn't happen: it is the responsibilty of [`Service::startup_reconcile`] to use appropriate
464 : // timeouts around its remote calls, to bound its runtime.
465 0 : return Err(ApiError::Timeout(
466 0 : "Timed out waiting for service readiness".into(),
467 0 : ));
468 0 : }
469 0 :
470 0 : request_span(
471 0 : request,
472 0 : |request| async move { handler(service, request).await },
473 0 : )
474 0 : .await
475 0 : }
476 :
477 0 : fn check_permissions(request: &Request<Body>, required_scope: Scope) -> Result<(), ApiError> {
478 0 : check_permission_with(request, |claims| {
479 0 : crate::auth::check_permission(claims, required_scope)
480 0 : })
481 0 : }
482 :
483 0 : pub fn make_router(
484 0 : service: Arc<Service>,
485 0 : auth: Option<Arc<SwappableJwtAuth>>,
486 0 : ) -> RouterBuilder<hyper::Body, ApiError> {
487 0 : let mut router = endpoint::make_router();
488 0 : if auth.is_some() {
489 0 : router = router.middleware(auth_middleware(|request| {
490 0 : let state = get_state(request);
491 0 : if state.allowlist_routes.contains(request.uri()) {
492 0 : None
493 : } else {
494 0 : state.auth.as_deref()
495 : }
496 0 : }))
497 0 : }
498 :
499 0 : router
500 0 : .data(Arc::new(HttpState::new(service, auth)))
501 0 : // Non-prefixed generic endpoints (status, metrics)
502 0 : .get("/status", |r| request_span(r, handle_status))
503 0 : .get("/ready", |r| request_span(r, handle_ready))
504 0 : // Upcalls for the pageserver: point the pageserver's `control_plane_api` config to this prefix
505 0 : .post("/upcall/v1/re-attach", |r| {
506 0 : request_span(r, handle_re_attach)
507 0 : })
508 0 : .post("/upcall/v1/validate", |r| request_span(r, handle_validate))
509 0 : // Test/dev/debug endpoints
510 0 : .post("/debug/v1/attach-hook", |r| {
511 0 : request_span(r, handle_attach_hook)
512 0 : })
513 0 : .post("/debug/v1/inspect", |r| request_span(r, handle_inspect))
514 0 : .post("/debug/v1/tenant/:tenant_id/drop", |r| {
515 0 : request_span(r, handle_tenant_drop)
516 0 : })
517 0 : .post("/debug/v1/node/:node_id/drop", |r| {
518 0 : request_span(r, handle_node_drop)
519 0 : })
520 0 : .get("/debug/v1/tenant", |r| request_span(r, handle_tenants_dump))
521 0 : .get("/debug/v1/scheduler", |r| {
522 0 : request_span(r, handle_scheduler_dump)
523 0 : })
524 0 : .post("/debug/v1/consistency_check", |r| {
525 0 : request_span(r, handle_consistency_check)
526 0 : })
527 0 : .get("/control/v1/tenant/:tenant_id/locate", |r| {
528 0 : tenant_service_handler(r, handle_tenant_locate)
529 0 : })
530 0 : // Node operations
531 0 : .post("/control/v1/node", |r| {
532 0 : request_span(r, handle_node_register)
533 0 : })
534 0 : .get("/control/v1/node", |r| request_span(r, handle_node_list))
535 0 : .put("/control/v1/node/:node_id/config", |r| {
536 0 : request_span(r, handle_node_configure)
537 0 : })
538 0 : // Tenant Shard operations
539 0 : .put("/control/v1/tenant/:tenant_shard_id/migrate", |r| {
540 0 : tenant_service_handler(r, handle_tenant_shard_migrate)
541 0 : })
542 0 : .put("/control/v1/tenant/:tenant_id/shard_split", |r| {
543 0 : tenant_service_handler(r, handle_tenant_shard_split)
544 0 : })
545 0 : // Tenant operations
546 0 : // The ^/v1/ endpoints act as a "Virtual Pageserver", enabling shard-naive clients to call into
547 0 : // this service to manage tenants that actually consist of many tenant shards, as if they are a single entity.
548 0 : .post("/v1/tenant", |r| {
549 0 : tenant_service_handler(r, handle_tenant_create)
550 0 : })
551 0 : .delete("/v1/tenant/:tenant_id", |r| {
552 0 : tenant_service_handler(r, handle_tenant_delete)
553 0 : })
554 0 : .put("/v1/tenant/:tenant_id/location_config", |r| {
555 0 : tenant_service_handler(r, handle_tenant_location_config)
556 0 : })
557 0 : .put("/v1/tenant/:tenant_id/time_travel_remote_storage", |r| {
558 0 : tenant_service_handler(r, handle_tenant_time_travel_remote_storage)
559 0 : })
560 0 : // Timeline operations
561 0 : .delete("/v1/tenant/:tenant_id/timeline/:timeline_id", |r| {
562 0 : tenant_service_handler(r, handle_tenant_timeline_delete)
563 0 : })
564 0 : .post("/v1/tenant/:tenant_id/timeline", |r| {
565 0 : tenant_service_handler(r, handle_tenant_timeline_create)
566 0 : })
567 0 : // Tenant detail GET passthrough to shard zero
568 0 : .get("/v1/tenant/:tenant_id", |r| {
569 0 : tenant_service_handler(r, handle_tenant_timeline_passthrough)
570 0 : })
571 0 : // Timeline GET passthrough to shard zero. Note that the `*` in the URL is a wildcard: any future
572 0 : // timeline GET APIs will be implicitly included.
573 0 : .get("/v1/tenant/:tenant_id/timeline*", |r| {
574 0 : tenant_service_handler(r, handle_tenant_timeline_passthrough)
575 0 : })
576 0 : }
|
