9eecfc8eef
All checks were successful
PR build (required check) / changes (pull_request) Successful in 6s
secrets-guard / encrypted (pull_request) Successful in 7s
PR build (required check) / build-backend (pull_request) Has been skipped
shell-lint / shellcheck (pull_request) Successful in 7s
PR build (required check) / validate-observability (pull_request) Has been skipped
PR build (required check) / build-frontend (pull_request) Successful in 1m0s
PR build (required check) / gate (pull_request) Successful in 2s
Ports frontend/ (Jinja2/FastAPI, ~1180 LOC) to Go with html/template. No climate math, no DB, no auth here -- every route fetches from the backend's /content/* API, so this is I/O-bound glue with no hard-porting wall; the risk was always in reproducing the rendering exactly, not the language. Verified with a golden-HTML diff, not just unit tests: both the Python original and the Go rewrite were run against the same committed fixtures (frontend/tests/fixtures/) and every one of the 11 routes compared byte-for-byte. The only surviving differences after that process are insignificant inter-tag whitespace and one attribute where Go's stricter escaper HTML-encodes an apostrophe Jinja left literal (functionally identical in every browser) -- confirmed programmatically by normalizing whitespace and unescaping before diffing, not by eyeballing. That process caught defects unit tests alone would have missed, because map[string]any has no compile-time field check: - Render-context keys were snake_case throughout (content.py's Jinja convention, ported verbatim) while the templates -- written independently -- read PascalCase fields. A missing map key doesn't error in html/template, it silently renders empty, so this was invisible in every status code and every "it built" signal: title, meta description, canonical URL, OpenGraph tags, the homepage's entire ranked list, and the brand-tag/nav-active state were all blank across every page. Fixed by renaming every key to match each template's own header comment (the authoritative per-page field contract) and, where an API struct's exported fields already matched what a template needed (contentapi.CityInfo, Crumb, HomeRanked, HubCountry, ...), passing the struct straight through instead of hand-rewrapping it in a map -- removes a whole layer of future drift risk, not just this instance of it. - Three pages 500'd outright: `.ToolHref` needed a fully-composed href string, not the bare "lat,lon" fragment the handlers were building; the all-time-records table needed the raw contentapi.AllTimeRecords struct, not a re-wrapped map. - JSON-LD was being double-encoded: `<script type="application/ld+json">` is JAVASCRIPT context to html/template's contextual escaper regardless of the script's `type` attribute, so a template.HTML-typed value placed there gets re-escaped as a quoted JS string instead of emitted raw -- the entire structured-data payload shipped as a JSON string containing JSON, which no crawler would parse as the intended object. Needed template.JS instead, the type that actually means "trusted JS source." The glossary term page's JSON-LD was simply never built at all (the Jinja original assembled it inline in the template rather than through content.py's context dict, and that got lost in translation) -- added. - html/template silently strips literal HTML comments AND JavaScript comments from the parsed output (verified in isolation, zero template actions involved) -- confirmed as real engine behavior, not a bug in either port, so both need a FuncMap function returning template.HTML / template.JS respectively to survive parsing rather than a literal `<!-- -->` or `//` in the template source. Packaging: multi-stage Go build, final image alpine (not distroless -- the Swarm stack's env-entrypoint.sh shim needs bash), 187MB -> 22.6MB. Two defects caught before they reached a host: - The Swarm stack overrides `entrypoint:` with no `command:`, which drops the image's own CMD entirely (Docker/Swarm semantics, not merged) -- env-entrypoint.sh then fell through to its hardcoded `exec uvicorn app:app` fallback, which doesn't exist in this image. Every deploy would have exited 127. Fixed with an explicit `command:` on the stack's frontend service, and corrected the shim's stale comment claiming CMD passes through automatically. - `COPY --chown=thermograph` resolves the group by NAME at copy time; Alpine's `adduser -S` with no `-G` doesn't create a same-named group, so the classic (non-BuildKit) Docker builder -- which this CI runner falls back to, since it installs plain `docker.io` with no buildx plugin -- failed outright. Fixed with an explicit group and numeric --chown. Verification: go build/vet/test -race clean across all packages; the Docker image builds and passes its embedded go test step under both BuildKit and the classic builder; shellcheck 0 findings on the one script touched; rebased onto current main (the ERA5 lake stack landed on both main and dev during this work -- confirmed additive, no overlap with frontend/daemon).
91 lines
4.2 KiB
Docker
91 lines
4.2 KiB
Docker
# Thermograph frontend: server-rendered content pages, the interactive tool's
|
|
# SPA shells, and every static asset. Split from the monorepo (repo-split
|
|
# Stage 7), rewritten as a Go service (server/). No migrations, no DB, no
|
|
# pre-boot logic -- a plain exec-form CMD is enough (unlike backend, no
|
|
# separate entrypoint script needed).
|
|
#
|
|
# Multi-stage: the golang builder runs vet + the full Go test suite before
|
|
# building, so every published image provably passed the hermetic tier with
|
|
# the exact toolchain that compiled the shipping binary (this replaces the
|
|
# old in-image pytest step in .forgejo/workflows/build.yml -- the runtime
|
|
# image carries no toolchain to test with). The final stage is Alpine, not
|
|
# distroless: the Swarm stack (infra/deploy/stack/thermograph-stack.yml)
|
|
# bind-mounts a bash entrypoint shim (env-entrypoint.sh) over this image's
|
|
# entrypoint, so bash must exist inside the container; curl serves the
|
|
# HEALTHCHECK, same line as ever.
|
|
FROM golang:1.26 AS builder
|
|
|
|
WORKDIR /src
|
|
|
|
# Module graph first so the download layer caches across source-only changes.
|
|
COPY server/go.mod server/go.sum ./
|
|
RUN go mod download
|
|
|
|
COPY server/ ./
|
|
|
|
# internal/content's tests read two directories the same three-levels-up
|
|
# relative path away from the test file's own package dir (go test always
|
|
# runs with cwd set there): the committed golden fixtures (frontend/tests/
|
|
# fixtures/*.json — the same set the Python golden-diff comparison used) and
|
|
# the SSR copy (frontend/content/*.yaml, content_loader.go's LoadGlossary
|
|
# etc.). This stage only copies server/ into /src (so /src has no "frontend/"
|
|
# parent to climb to), which is why both land at container-root paths here
|
|
# instead — same three-levels-up relationship the tests' relative paths
|
|
# expect, just anchored differently.
|
|
COPY tests/fixtures /tests/fixtures
|
|
COPY content /content
|
|
|
|
RUN test -z "$(gofmt -l .)" && go vet ./... && go test ./...
|
|
|
|
# Static binary: CGO off (no libc dependency on Alpine), -trimpath for
|
|
# reproducible paths, -s -w to strip debug info the container never uses.
|
|
RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" \
|
|
-o /out/thermograph-frontend .
|
|
|
|
FROM alpine:3.22
|
|
|
|
# bash: required by the Swarm stack's env-entrypoint.sh shim (see above).
|
|
# curl: the HEALTHCHECK below (pulls in ca-certificates as a dependency).
|
|
RUN apk add --no-cache bash curl
|
|
|
|
# Same uid as the Python image: 10001 is the uid infra provisions readable
|
|
# secrets for (deploy-stack.sh installs /etc/thermograph/stack.env
|
|
# uid-10001-readable) -- do not change it. Explicit group (Alpine's `adduser
|
|
# -S` with no -G falls back to an existing system group, not a same-named
|
|
# one -- a bare `--chown=thermograph` below then has no "thermograph" group
|
|
# to resolve, which the classic (non-BuildKit) builder rejects outright).
|
|
RUN addgroup -S -g 10001 thermograph \
|
|
&& adduser -S -u 10001 -G thermograph -h /home/thermograph thermograph
|
|
|
|
COPY --from=builder /out/thermograph-frontend /usr/local/bin/thermograph-frontend
|
|
|
|
# The binary embeds its HTML templates (server/internal/render); static/ and
|
|
# content/ stay on disk, resolved relative to the working directory (see
|
|
# server/internal/config: StaticDir="static", ContentDir="content"), so /app
|
|
# mirrors the repo layout the config expects. Read-only at runtime -- the
|
|
# service is stateless and holds no data of its own.
|
|
#
|
|
# Numeric --chown, not the name: needs no /etc/passwd|group lookup at COPY
|
|
# time, so it works identically under BuildKit and the classic builder (the
|
|
# CI runner installs plain `docker.io`, no buildx plugin, so a build there
|
|
# silently uses the classic builder unless BuildKit is forced).
|
|
COPY --chown=10001:10001 static/ /app/static/
|
|
COPY --chown=10001:10001 content/ /app/content/
|
|
|
|
USER thermograph
|
|
WORKDIR /app
|
|
|
|
# No WORKERS knob anymore: uvicorn needed a process count, the Go server
|
|
# handles concurrency in one process. (The stack/compose files never set it
|
|
# for frontend, so nothing references it.)
|
|
ENV PORT=8080 \
|
|
THERMOGRAPH_BASE=/
|
|
|
|
EXPOSE 8080
|
|
|
|
HEALTHCHECK --interval=30s --timeout=5s --start-period=40s --retries=3 \
|
|
CMD curl -fsS http://127.0.0.1:${PORT}/healthz || exit 1
|
|
|
|
# Exec form, no shell wrapper: the Swarm shim receives this CMD as $@ and
|
|
# execs the binary directly; PID 1 gets SIGTERM and shuts down gracefully.
|
|
CMD ["/usr/local/bin/thermograph-frontend"]
|