manta-server 2.0.0-beta.61

Manta HTTP server — single API that proxies to CSM / Ochami backends.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! Template + post_template_session handlers.

use axum::{
  Json,
  extract::{Path, Query},
  http::StatusCode,
  response::IntoResponse,
};

use super::{
  ErrorResponse, RequestCtx, SiteHeader, serialize_or_500, to_handler_error,
};
use crate::service;

// ---------------------------------------------------------------------------
// GET /api/v1/templates
// ---------------------------------------------------------------------------

pub use manta_shared::types::api::queries::TemplateQuery;

/// GET /templates — list BOS session templates with optional filters.
#[utoipa::path(get, path = "/templates", tag = "templates",
  params(TemplateQuery, SiteHeader),
  security(("bearerAuth" = [])),
  responses(
    // BosSessionTemplate lives in manta-backend-dispatcher (third-party,
    // no ToSchema) — kept as Value until upstream derives it.
    (status = 200, description = "List of session templates", body = serde_json::Value),
    (status = 401, description = "Unauthorized",              body = ErrorResponse),
    (status = 500, description = "Internal error",            body = ErrorResponse),
  )
)]
#[tracing::instrument(skip_all)]
pub async fn get_templates(
  ctx: RequestCtx,
  Query(q): Query<TemplateQuery>,
) -> Result<impl IntoResponse, (StatusCode, Json<ErrorResponse>)> {
  let infra = ctx.infra();

  let params = service::template::GetTemplateParams {
    name: q.name,
    group_name: q.hsm_group,
    settings_group_name: None,
    limit: q.limit,
  };

  let templates = service::template::get_templates(&infra, &ctx.token, &params)
    .await
    .map_err(to_handler_error)?;

  Ok(Json(templates))
}

// ---------------------------------------------------------------------------
// POST /api/v1/templates/{name}/sessions — Create BOS session from template
// ---------------------------------------------------------------------------

pub use manta_shared::types::api::template::{
  BosOperation, PostTemplateSessionRequest,
};

/// `POST /api/v1/templates/{name}/sessions` — create a BOS session from a session template.
#[utoipa::path(post, path = "/templates/{name}/sessions", tag = "templates",
  params(("name" = String, Path, description = "Template name"), SiteHeader),
  request_body = PostTemplateSessionRequest,
  security(("bearerAuth" = [])),
  responses(
    // dry_run/real result union — kept as Value until the union shape is formalised
    (status = 200, description = "Dry run preview",  body = serde_json::Value),
    // BosSession lives in manta-backend-dispatcher (third-party, no
    // ToSchema) — kept as Value until upstream derives it.
    (status = 201, description = "Session created",  body = serde_json::Value),
    (status = 400, description = "Bad request",      body = ErrorResponse),
    (status = 401, description = "Unauthorized",     body = ErrorResponse),
    (status = 500, description = "Internal error",   body = ErrorResponse),
  )
)]
#[tracing::instrument(skip_all)]
pub async fn post_template_session(
  ctx: RequestCtx,
  Path(name): Path<String>,
  Json(body): Json<PostTemplateSessionRequest>,
) -> Result<impl IntoResponse, (StatusCode, Json<ErrorResponse>)> {
  tracing::info!(
    "post_template_session template={} op={:?} dry_run={}",
    name,
    body.operation,
    body.dry_run
  );
  let infra = ctx.infra();

  let params = service::template::ApplyTemplateParams {
    bos_session_name: body.session_name,
    bos_sessiontemplate_name: name,
    bos_session_operation: body.operation.as_str().to_string(),
    limit: body.limit,
    include_disabled: body.include_disabled,
  };

  let (bos_session, _) =
    service::template::validate_and_prepare_template_session(
      &infra, &ctx.token, &params,
    )
    .await
    .map_err(to_handler_error)?;

  if body.dry_run {
    return Ok((StatusCode::OK, Json(serialize_or_500(&bos_session)?)));
  }

  let created =
    service::template::create_bos_session(&infra, &ctx.token, bos_session)
      .await
      .map_err(to_handler_error)?;

  Ok((StatusCode::CREATED, Json(serialize_or_500(&created)?)))
}