rustploy 0.1.3

Rustploy PaaS daemon — lightweight self-hosted deployment platform
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

//! `Command::ServiceReload`: reinicia o container live de um serviço (stop
//! gracioso + start) sem redeployar.

use crate::{bootstrap::state::AppState, engine::containers};
use chrono::Utc;
use shared::{DeployState, Event, Response as RpResponse, ServiceStatus};

pub async fn handle(state: AppState, service_id: String) -> RpResponse {
    let svc = match crate::store::services::get(&state.db, &service_id).await {
        Ok(Some(s)) => s,
        Ok(None) => return RpResponse::err("NotFound", "serviço não encontrado"),
        Err(e) => return RpResponse::err("DatabaseError", e.to_string()),
    };

    let container_id = match &svc.live_container_id {
        Some(id) => id.clone(),
        None => return RpResponse::err("NotRunning", "serviço não possui container ativo"),
    };

    if let Err(e) = containers::stop_graceful(&state.docker.inner, &container_id, 10).await {
        return RpResponse::err("DockerError", format!("falha ao parar: {e}"));
    }

    if let Err(e) = containers::start(&state.docker.inner, &container_id).await {
        return RpResponse::err("DockerError", format!("falha ao iniciar: {e}"));
    }

    if let Err(e) = crate::store::services::update_status(
        &state.db,
        &service_id,
        &ServiceStatus::Running,
        Some(&container_id),
    )
    .await
    {
        return RpResponse::err("DatabaseError", e.to_string());
    }

    // Se o deployment estava Stopped, volta para Live.
    if let Ok(history) =
        crate::store::deployments::list_for_service(&state.db, &service_id, 1).await
        && let Some(dep) = history
            .into_iter()
            .find(|d| d.state == DeployState::Stopped)
    {
        let _ = crate::store::deployments::transition(
            &state.db,
            &dep.id,
            &DeployState::Stopped,
            DeployState::Live,
            None,
        )
        .await;
        state.bus.publish(Event::DeployStateChanged {
            deployment_id: dep.id,
            service_id: service_id.clone(),
            state: DeployState::Live,
            timestamp: Utc::now(),
            message: None,
        });
    }

    state.bus.publish(Event::ServiceStatusChanged {
        service_id,
        status: ServiceStatus::Running,
    });

    RpResponse::Ok
}