rustploy-gui 0.1.74

Rustploy — desktop client (glacier-ui) for the Rustploy PaaS daemon
--!strict
--!nolint FunctionUnused
-- handlers/recover.luau — Settings → Recuperar: recuperar este servidor a
-- partir do git + chave de recuperação + backups no S3
-- (docs/plano-backup-de-dados-para-s3.md, Fase 4). A webui faz o mesmo em
-- `webui/app.js` (`recover*`): mude os dois juntos.
--
-- A chave e o token só vivem no campo: somem ao enviar, deem certo ou não, e
-- nunca ficam em outro lugar do `ctx`.

local State = require("../state")
local Helpers = require("../helpers")
local RecoveryKit = require("../recovery_kit")

local M = {}

local POLL_MS = 3000
local poll_timer: any = nil

local STEP_LABELS: { [string]: string } = {
    pending = "aguardando",
    restoring = "restaurando dados",
    starting = "subindo",
    ready = "pronto",
    blocked = "bloqueado",
    failed = "falhou",
}

--- O rótulo de uma etapa. A tradução acontece aqui, no ponto de uso (e não
--- numa tabela de módulo).
function M.step_label(step: string): string
    local source = STEP_LABELS[step]
    if source == nil then
        return step
    end
    return i18n.tr(source)
end

--- A linha de um serviço na tela, a partir do que o daemon devolveu. Pura
--- (recebe o rótulo de cada coisa).
function M.service_row(service: any): { [string]: string }
    local backup = if service.latest_backup ~= nil
        then i18n.tr("backup de ") .. tostring(service.latest_backup)
        else i18n.tr("sem backup: sobe vazio")
    local step = M.step_label(tostring(service.step))
    if service.error ~= nil then
        step = step .. ": " .. tostring(service.error)
    end
    return {
        kind = if service.kind == "database" then "BD" else "VOL",
        who = tostring(service.project) .. " / " .. tostring(service.name),
        backup = backup,
        step = step,
    }
end

local function apply(info: any): ()
    ctx.recover_phase = tostring(info.phase or "idle")
    ctx.recover_projects = tostring(info.projects or 0)
    ctx.recover_destination_error = info.destination_error or ""
    ctx.recover_message = info.message or ""
    local rows = json.array {}
    for _, service in ipairs(info.services or {}) do
        table.insert(rows, M.service_row(service))
    end
    ctx.recover_services = rows
    ctx.recover_services_count = tostring(#rows)
end

--- Lê em que ponto a recuperação está e, enquanto roda, repolla.
function M.load(): ()
    if poll_timer then
        poll_timer:cancel()
        poll_timer = nil
    end
    local api = State.api
    if not api then
        return
    end
    local ok, response = api:rpc_checked("ServerRecoverStatus")
    if ok and type(response) == "table" and response.ServerRecover ~= nil then
        apply(response.ServerRecover)
    end
    if ctx.recover_phase == "running" and ctx.settings_tab == "recover" then
        poll_timer = after(POLL_MS, function(): ()
            poll_timer = nil
            M.load()
        end)
    end
end

function recover_refresh(): ()
    M.load()
end

--- Preenche os quatro campos a partir de um kit já lido. Pura (só escreve no
--- `ctx`), para os testes.
function M.fill_from_kit(kit: RecoveryKit.Kit): ()
    ctx.recover_remote = kit.infra_remote
    ctx.recover_branch = kit.infra_branch
    ctx.recover_token = kit.infra_token
    ctx.recover_key = kit.private_key
    local origin = if kit.server ~= "" then kit.server else "?"
    ctx.recover_message = string.format(
        i18n.tr(
            "arquivo de recuperação de %s (%s) carregado: confira e restaure"
        ),
        origin,
        string.sub(kit.created_at, 1, 10)
    )
end

--- "Carregar arquivo de recuperação": lê o `.rpkit` gerado junto com a chave
--- e preenche repositório, branch, token e chave.
function recover_load_kit(): ()
    local path = open_file {
        title = i18n.tr("Arquivo de recuperação"),
        filters = {
            {
                name = i18n.tr("Arquivo de recuperação"),
                extensions = { "rpkit" },
            },
        },
    }
    if not path then
        return
    end
    local bytes, read_error = read_file(path)
    if bytes == nil then
        ctx.recover_message = i18n.tr("erro ao ler o arquivo: ")
            .. tostring(read_error)
        toast { message = ctx.recover_message, kind = "error" }
        return
    end
    local kit, decode_error = RecoveryKit.decode(bytes)
    if kit == nil then
        ctx.recover_message = tostring(decode_error)
        toast { message = ctx.recover_message, kind = "error" }
        return
    end
    M.fill_from_kit(kit)
    toast { message = ctx.recover_message, kind = "success" }
end

--- Passo 1: traz a infra do git, recifra os segredos e lista o que foi achado.
--- Não toca em dado.
function recover_start(): ()
    local api = State.api
    if not api then
        return
    end
    local branch = Helpers.trim(ctx.recover_branch)
    local ok, response = api:rpc_checked {
        ServerRecoverStart = {
            remote = Helpers.trim(ctx.recover_remote),
            token = Helpers.trim(ctx.recover_token),
            branch = if branch ~= "" then branch else nil,
            recovery_key = Helpers.trim(ctx.recover_key),
        },
    }
    -- a chave e o token saem da tela, deu certo ou não
    ctx.recover_key = ""
    ctx.recover_token = ""
    if ok and type(response) == "table" and response.ServerRecover ~= nil then
        apply(response.ServerRecover)
        toast {
            message = tostring(
                i18n.tr("infraestrutura restaurada; confira o resumo")
            ),
            kind = "success",
        }
    else
        toast { message = tostring(response), kind = "error" }
    end
end

--- Passo 2: restaura os dados e sobe os serviços na ordem das dependências (em
--- segundo plano).
function recover_run(): ()
    local api = State.api
    if not api then
        return
    end
    local confirmed = confirm {
        title = i18n.tr("Restaurar os dados e subir?"),
        message = i18n.tr(
            "Cada serviço tem os dados restaurados do S3 (volumes antes de "
                .. "subir, bancos depois) e sobe na ordem das dependências."
        ),
        confirm_label = i18n.tr("Restaurar"),
        destructive = true,
    }
    if not confirmed then
        return
    end
    local ok, response = api:rpc_checked("ServerRecoverRun")
    if ok then
        toast {
            message = tostring(i18n.tr("recuperação iniciada")),
            kind = "success",
        }
        M.load()
    else
        toast { message = tostring(response), kind = "error" }
    end
end

function recover_cancel(): ()
    local api = State.api
    if not api then
        return
    end
    local ok, response = api:rpc_checked("ServerRecoverCancel")
    if ok and type(response) == "table" and response.ServerRecover ~= nil then
        apply(response.ServerRecover)
        toast {
            message = tostring(i18n.tr("recuperação cancelada")),
            kind = "success",
        }
    else
        toast { message = tostring(response), kind = "error" }
    end
end

return M