rustploy-gui 0.1.70

Rustploy — desktop client (glacier-ui) for the Rustploy PaaS daemon
--!strict
--!nolint FunctionUnused
-- handlers/jobs.luau — ações da tela global "Schedules" (sidebar) e da aba
-- "Jobs" do projeto: rodar agora, aquecer, pausar/ativar, remover, abrir a
-- janela "Novo job".

local State = require("../state")
local Stream = require("stream")
local format = require("../format")

-- Fecha o painel "Ações do job" (`JobActions`) de todas as linhas: cada painel
-- guarda o aberto/fechado numa chave `job_actions_open_<job_id>` e fechar é
-- zerá-la. Zera todos, em vez de um, porque `job_run_cancel` e
-- `open_job_logs_window` só recebem o id da execução, não o do job.
local function close_job_actions(): ()
    for job_id in State.jobs_by_id do
        ctx["job_actions_open_" .. job_id] = ""
    end
end

-- Bloqueia o botão IMEDIATAMENTE ao clicar (antes de qualquer resposta do
-- backend chegar) e trava double-click: `State.jobs_inflight[id] = true` +
-- os dois recomputos locais (sem RPC) fazem `j.running` virar `true` na
-- HORA em ambas as telas (sidebar Schedules e aba Jobs do projeto) — sem
-- isso o botão só desabilitava quando `refresh_now()` (rede) terminava,
-- alguns segundos depois do click. Só desbloqueia em erro (na hora, sem
-- esperar `refresh_now()`) ou depois que `refresh_now()` confirma o
-- `job_run` criado (dali em diante `j.running` já vem do snapshot real).
function job_run_now(job_id: string): ()
    close_job_actions()
    local api = State.api
    if not api then
        return
    end
    if State.jobs_inflight[job_id] then
        return
    end
    State.jobs_inflight[job_id] = true
    Stream.update_open_project()
    Stream.refresh_jobs_summary_local()

    local job_run_now_ok, job_run_now_response = api:rpc_checked {
        JobRunNow = { id = job_id },
    }
    if not job_run_now_ok then
        toast { message = tostring(job_run_now_response), kind = "error" }
        State.jobs_inflight[job_id] = nil
        Stream.update_open_project()
        Stream.refresh_jobs_summary_local()
        return
    end
    toast { message = tostring(i18n.tr("Job disparado")), kind = "success" }
    Stream.refresh_now()
    State.jobs_inflight[job_id] = nil
end

-- Cancela um job_run em execução (ver docs/plano-cancelamento-de-jobs.md):
-- mata o processo `docker compose up` de verdade no daemon, não só a UI.
-- `job_run_id` vem de `j.last_run_id` — enquanto `j.running` só reflete o
-- estado otimista (ver `job_run_now`, antes do primeiro refresh confirmar o
-- job_run novo), pode ainda apontar pro run ANTERIOR; o daemon devolve
-- NotFound nesse caso (inofensivo, só o toast de erro).
function job_run_cancel(job_run_id: string): ()
    close_job_actions()
    local api = State.api
    if not api or not job_run_id or job_run_id == "" then
        return
    end
    local job_run_cancel_ok, job_run_cancel_response = api:rpc_checked {
        JobRunCancel = { job_run_id = job_run_id },
    }
    if job_run_cancel_ok then
        toast {
            message = tostring(i18n.tr("Cancelamento solicitado")),
            kind = "success",
        }
    else
        toast { message = tostring(job_run_cancel_response), kind = "error" }
    end
    Stream.refresh_now()
end

-- Pausa/ativa um job: `JobUpdate` substitui o registro inteiro, então
-- reenviamos os campos como estão (só invertendo `enabled`) — o Job cru vem
-- de `State.jobs_by_id`, preenchido pelo `stream.luau` a cada snapshot.
function job_toggle(job_id: string): ()
    close_job_actions()
    local api = State.api
    if not api then
        return
    end
    local job = State.jobs_by_id[job_id]
    if not job then
        toast {
            message = tostring(
                i18n.tr("job não encontrado (tela desatualizada — tenta de novo)")
            ),
            kind = "error",
        }
        return
    end
    local job_update_ok, job_update_response = api:rpc_checked {
        JobUpdate = {
            id = job_id,
            name = job.name,
            compose = job.compose,
            git_source = job.git_source,
            main_service = job.main_service,
            env_vars = job.env_vars,
            env_comments = job.env_comments,
            enabled = not job.enabled,
            recurrence = job.recurrence,
        },
    }
    if job_update_ok then
        toast {
            message = tostring(job.enabled and i18n.tr("Job pausado") or i18n.tr("Job ativado")),
            kind = "success",
        }
    else
        toast {
            message = tostring(job_update_response),
            kind = "error",
        }
    end
    Stream.refresh_now()
end

-- Abre a janela de cadastro de job (motor Glacier próprio, isolado). Passa a
-- conexão atual + os catálogos de projetos/serviços JÁ BUSCADOS pelo snapshot
-- (a janela filha não pode buscar no init — só ações despachadas rodam o
-- fetch). Ao concluir, ela emite broadcast("job_created"), recebido por
-- on_broadcast em handlers/projects.luau. Ver views/new_job_window.screen.gv.
function open_new_job_window(): ()
    local snap = State.snap
    local projects = {}
    for _, project in ipairs((snap and snap.projects) or {}) do
        table.insert(projects, { id = project.id, name = project.name })
    end
    local services = {}
    for _, service in ipairs((snap and snap.services) or {}) do
        local service_record = service.service
        if service_record then
            table.insert(services, {
                id = service_record.id,
                name = service_record.spec.name,
                project_id = service_record.spec.project_id,
            })
        end
    end
    open_window {
        component = "new_job",
        size = "560 700",
        decorations = false,
        resizable = false,
        data = {
            api_url = ctx.api_url or "",
            api_token = ctx.api_token or "",
            new_job_projects = json.encode(projects),
            new_job_services = json.encode(services),
        },
    }
end

-- Abre a MESMA janela em modo edição: pula os passos 1/2 (projeto/serviço
-- gatilho não são editáveis via JobUpdate) e semeia o passo 3 já preenchido.
-- Se o job for git-sourced, resolve conta/repo/branch ANTES de abrir (a
-- janela filha não pode buscar no init — mesma restrição de
-- open_new_job_window) pra o picker já vir com a seleção certa, sem forçar
-- o usuário a escolher de novo só pra editar outra coisa (ex.: env vars).
function open_edit_job_window(job_id: string): ()
    close_job_actions()
    local job = State.jobs_by_id[job_id]
    if not job then
        toast {
            message = tostring(
                i18n.tr("job não encontrado (tela desatualizada — tenta de novo)")
            ),
            kind = "error",
        }
        return
    end
    local api = State.api

    local new_job_git_providers = json.array({})
    local new_job_git_repos = json.array({})
    local new_job_git_repo = ""
    local new_job_git_branches = json.array({})
    if job.git_source and api then
        local provider_id = job.git_source.provider_id
        if provider_id and provider_id ~= "" then
            -- Essa cascata de RPCs (conta → repos → branches) roda ANTES de
            -- `open_window` — a janela filha não pode buscar no próprio
            -- init (mesma restrição de `open_new_job_window`), então até ela
            -- abrir o clique em "Editar" fica sem NENHUM feedback visual.
            -- Só o toast avisa que algo está acontecendo nesse intervalo.
            toast {
                message = tostring(i18n.tr("Carregando dados do repositório…")),
                kind = "info",
            }
            local git_provider_list_ok, git_provider_list_response =
                api:rpc("GitProviderList")
            if
                git_provider_list_ok
                and git_provider_list_response.GitProviders
            then
                new_job_git_providers = format.git_providers(
                    git_provider_list_response.GitProviders
                )
            end
            local git_repo_list_ok, git_repo_list_response = api:rpc {
                GitRepoList = {
                    provider_id = provider_id,
                },
            }
            if git_repo_list_ok and git_repo_list_response.GitRepos then
                new_job_git_repos =
                    format.git_repos(git_repo_list_response.GitRepos)
                for _, git_repo in ipairs(git_repo_list_response.GitRepos) do
                    if git_repo.clone_url == job.git_source.url then
                        new_job_git_repo = git_repo.full_name
                        break
                    end
                end
                if new_job_git_repo ~= "" then
                    local git_branch_list_ok, git_branch_list_response =
                        api:rpc {
                            GitBranchList = {
                                provider_id = provider_id,
                                repo_full_name = new_job_git_repo,
                            },
                        }
                    if
                        git_branch_list_ok
                        and git_branch_list_response.GitBranches
                    then
                        new_job_git_branches = format.git_branches(
                            git_branch_list_response.GitBranches
                        )
                    end
                end
            end
        end
    end

    open_window {
        component = "new_job",
        size = "560 700",
        decorations = false,
        -- Sobrepõe o `title` do <screen> ("Novo job"): só quem abre sabe que
        -- desta vez é edição.
        title = i18n.tr("Editar job — Rustploy"),
        resizable = false,
        data = {
            api_url = ctx.api_url or "",
            api_token = ctx.api_token or "",
            new_job_edit_job = json.encode(job),
            new_job_git_providers = new_job_git_providers,
            new_job_git_repos = new_job_git_repos,
            new_job_git_repo = new_job_git_repo,
            new_job_git_branches = new_job_git_branches,
        },
    }
end

-- Logs da última execução de um job — mesma janela genérica de logs
-- (log_window.gv/.luau) usada por runtime/build, agora apontando pro SSE
-- dedicado `/api/jobs/runs/<id>/logs` (ver Event::JobLogLine).
function open_job_logs_window(job_run_id: string): ()
    close_job_actions()
    if not job_run_id or job_run_id == "" then
        return
    end
    local seed = json.array({})
    local api = State.api
    if api then
        local get_job_logs_ok, get_job_logs_response = api:rpc {
            GetJobLogs = {
                job_run_id = job_run_id,
            },
        }
        if get_job_logs_ok and get_job_logs_response.JobLogs then
            seed = json.array(get_job_logs_response.JobLogs)
        end
    end
    open_window {
        component = "log",
        size = "900 560",
        decorations = false,
        title = i18n.tr("Job — ") .. string.sub(job_run_id, 1, 12),
        resizable = true,
        data = {
            api_url = ctx.api_url or "",
            api_token = ctx.api_token or "",
            log_window_title = i18n.tr("Job · ") .. string.sub(job_run_id, 1, 12),
            log_window_stream_url = "/api/jobs/runs/" .. job_run_id .. "/logs",
            log_window_seed = seed,
        },
    }
end

function job_delete(job_id: string): ()
    local api = State.api
    if not api then
        return
    end
    -- Confirma antes de apagar, como a webui ("Remover este job? Ação
    -- irreversível.") e como os demais botões destrutivos do app. O painel ⋯
    -- fecha ANTES: ele é uma camada flutuante e ficava por cima da confirmação,
    -- escondendo-a (a janela só aparecia ao clicar fora do painel).
    local job = State.jobs_by_id[job_id]
    local job_name = job and job.name or job_id
    close_job_actions()
    local confirmed = confirm {
        title = i18n.tr("Remover job?"),
        message = i18n.tr("O job \"")
            .. tostring(job_name)
            .. i18n.tr("\" será removido e não poderá ser recuperado."),
        confirm_label = i18n.tr("Remover"),
        destructive = true,
    }
    if not confirmed then
        return
    end
    local job_delete_ok, job_delete_response = api:rpc_checked {
        JobDelete = {
            id = job_id,
        },
    }
    if job_delete_ok then
        toast { message = tostring(i18n.tr("Job removido")), kind = "success" }
    else
        toast { message = tostring(job_delete_response), kind = "error" }
    end
    Stream.refresh_now()
end

-- Reconstrói o job do zero (`JobWarm` com `force`): rebaixa as imagens e refaz
-- o build sem cache, mesmo com o job quente. Leva minutos e segura a vaga
-- única da fila de jobs, então pede confirmação antes. O fim chega em
-- `Event::JobWarmChanged`.
function job_rebuild(job_id: string): ()
    local api = State.api
    if not api then
        return
    end
    local job = State.jobs_by_id[job_id]
    local job_name = job and job.name or job_id
    -- O painel ⋯ fecha antes da confirmação (ficava por cima dela; ver `job_delete`).
    close_job_actions()
    local confirmed = confirm {
        title = i18n.tr("Reconstruir sem cache?"),
        message = i18n.tr("O job \"")
            .. tostring(job_name)
            .. i18n.tr("\" será reconstruído do zero (sem cache e com as imagens base rebaixadas). Isso pode levar vários minutos e ocupa a fila de jobs enquanto roda."),
        confirm_label = i18n.tr("Reconstruir"),
    }
    if not confirmed then
        return
    end
    local job_rebuild_ok, job_rebuild_response = api:rpc_checked {
        JobWarm = { job_id = job_id, force = true },
    }
    if not job_rebuild_ok then
        toast { message = tostring(job_rebuild_response), kind = "error" }
        return
    end
    toast { message = tostring(i18n.tr("Reconstrução iniciada")), kind = "success" }
    Stream.refresh_now()
end

-- Aquece o job (baixa as imagens que faltam e popula o cache de build) sem
-- executá-lo. Já quente: o daemon não dispara nada e só avisa. O painel fica
-- aberto, para o estado mudar ao vivo; o fim do aquecimento chega depois, em
-- `Event::JobWarmChanged` (handlers/stream.luau).
function job_warm(job_id: string): ()
    local api = State.api
    if not api then
        return
    end
    local job_warm_ok, job_warm_response = api:rpc_checked {
        JobWarm = { job_id = job_id },
    }
    if not job_warm_ok then
        toast { message = tostring(job_warm_response), kind = "error" }
        return
    end
    if job_warm_response.JobWarmRequested.already_warm then
        toast { message = tostring(i18n.tr("Job já está aquecido")), kind = "success" }
    else
        toast { message = tostring(i18n.tr("Aquecimento iniciado")), kind = "success" }
    end
    Stream.refresh_now()
end