Jaroslav BenešandClaude Opus 5
ddad585e4b
The button cannot do the work, and that is the whole design. The service runs as an unprivileged account, cannot restart itself, and should not be able to: a web application that can restart its own service is one whose worst day is much worse. So /admin/updates writes a file, and an opt-in systemd .path unit runs deploy/update.sh as root. Three properties hold it up, and each is a thing that could have been got wrong. The request file carries nothing that reaches a command line -- no branch, no ref, no arguments -- because the branch is baked into the unit at install time, so pressing the button is always "deploy the branch this host was configured with" and can never be "deploy something else". It is off unless somebody passes INSTALL_UPDATE_HELPER=1, and re-running the installer without it removes both units and the marker. And without the helper the page says so and prints the manual command rather than writing a file nothing is watching, which would be a button that reports success and does nothing. The card that says all of this is rendered whether or not there is anything to apply. It was inside the "there is an update" branch first, so an administrator could not discover the helper was missing until the day they needed it, which is the worst possible moment. Opening the page makes no network request; Check is the one thing that fetches. And it shows the log between, not a count: "3 behind" is a number somebody has to go and look up, while the subjects are what decides whether this is worth restarting for right now. Docker is one stage, because there is nothing to build -- no Node, no compiled assets. It bakes no secret key (one in an image is one every copy shares, and rotating it makes stored API keys unreadable), no data, and no .git, so /admin/updates inside a container correctly reports that it was not installed from a checkout. Compose publishes on loopback and refuses to start without a key. TLS in front is a constraint rather than a recommendation: the service worker and the microphone both require HTTPS or localhost. The image was built and run before this was committed, which is how the missing COPY of LICENSE was found -- pyproject declares it and the build backend reads it, so the failure reads like a packaging problem and is one line. deploy/lxc-install.sh creates an unprivileged Debian container and runs the existing installer inside it. A wrapper, not a second install path: a parallel installer is two things to keep correct and one of them rots. /healthz opens the database rather than only proving the socket is listening -- a process that is up with a database it cannot open answers every page with a 500 -- and says nothing about what is here, being reachable without signing in. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
81 lines
2.7 KiB
Python
81 lines
2.7 KiB
Python
"""What is running here, and getting to what is not.
|
|
|
|
Read `services/updates.py` first — the reason the button writes a file rather
|
|
than doing the work is there, and it is the whole design.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
|
|
from fastapi import APIRouter, Request, Response, status
|
|
from fastapi.responses import RedirectResponse
|
|
|
|
from lembas.api.deps import AdminUser, Db
|
|
from lembas.services import updates as updates_service
|
|
from lembas.web.templating import render
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
router = APIRouter(prefix="/admin/updates", tags=["admin-updates"])
|
|
|
|
|
|
def _page(request: Request, state, saved: str = "") -> Response:
|
|
return render(
|
|
request,
|
|
"admin/updates.html",
|
|
{
|
|
"state": state,
|
|
"command": updates_service.manual_command(),
|
|
"saved": saved,
|
|
},
|
|
)
|
|
|
|
|
|
@router.get("")
|
|
async def updates_page(request: Request, db: Db, user: AdminUser, saved: str = ""):
|
|
"""No network on a page load.
|
|
|
|
`read(fetch=False)` compares against whatever the last fetch left behind, so
|
|
opening this is a few git reads off the local disk. A page that reached the
|
|
remote every time it was rendered would be one somebody stops opening.
|
|
"""
|
|
return _page(request, updates_service.read(), saved)
|
|
|
|
|
|
@router.post("/check")
|
|
async def check(request: Request, db: Db, user: AdminUser) -> Response:
|
|
"""Ask the remote what is there. The one place this touches the network."""
|
|
state = updates_service.read(fetch=True)
|
|
log.info("%s checked for updates", user.email)
|
|
return _page(request, state)
|
|
|
|
|
|
@router.post("/apply")
|
|
async def apply(db: Db, user: AdminUser) -> Response:
|
|
"""Write the request the helper is watching for.
|
|
|
|
Refused when the helper is not installed rather than written and left to sit
|
|
there: a file nothing is watching is a button that reports success and does
|
|
nothing, which is the failure this codebase keeps cataloguing.
|
|
"""
|
|
if not updates_service.helper_installed():
|
|
return RedirectResponse(
|
|
"/admin/updates?saved=The+update+helper+is+not+installed+on+this+host.",
|
|
status_code=status.HTTP_303_SEE_OTHER,
|
|
)
|
|
problem = updates_service.request_update(user.email)
|
|
message = problem or "Update requested. The service will restart in a moment."
|
|
return RedirectResponse(
|
|
f"/admin/updates?saved={message.replace(' ', '+')}",
|
|
status_code=status.HTTP_303_SEE_OTHER,
|
|
)
|
|
|
|
|
|
@router.post("/cancel")
|
|
async def cancel(db: Db, user: AdminUser) -> Response:
|
|
updates_service.clear_request()
|
|
return RedirectResponse(
|
|
"/admin/updates?saved=Request+withdrawn.", status_code=status.HTTP_303_SEE_OTHER
|
|
)
|