plane 0.5.5

Session backend orchestrator for ambitious browser-based apps.
Documentation 
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

use super::{core::Controller, error::IntoApiError};
use axum::{
    extract::{Path, State},
    response::Response,
    Json,
};
use plane_common::{
    names::BackendName,
    protocol::BackendAction,
    types::{TerminationKind, TerminationReason},
};

async fn terminate(
    controller: &Controller,
    backend_id: &BackendName,
    hard: bool,
) -> Result<(), Response> {
    let backend = controller
        .db
        .backend()
        .backend(backend_id)
        .await
        .or_internal_error("Database error")?
        .or_not_found("Backend does not exist")?;

    let kind = if hard {
        TerminationKind::Hard
    } else {
        TerminationKind::Soft
    };
    controller
        .db
        .backend_actions()
        .create_pending_action(
            backend_id,
            backend.drone_id,
            &BackendAction::Terminate {
                kind,
                reason: TerminationReason::External,
            },
        )
        .await
        .or_internal_error("Database error")?;

    Ok(())
}

pub async fn handle_soft_terminate(
    Path(backend_id): Path<BackendName>,
    State(controller): State<Controller>,
) -> Result<Json<()>, Response> {
    terminate(&controller, &backend_id, false).await?;
    Ok(Json(()))
}

pub async fn handle_hard_terminate(
    Path(backend_id): Path<BackendName>,
    State(controller): State<Controller>,
) -> Result<Json<()>, Response> {
    terminate(&controller, &backend_id, true).await?;
    Ok(Json(()))
}