210 lines
8.4 KiB
Go
210 lines
8.4 KiB
Go
package updater
|
|
|
|
import (
|
|
"archive/zip"
|
|
"bufio"
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"felis.lolicon.best/internal/platform"
|
|
"felis.lolicon.best/internal/updates"
|
|
)
|
|
|
|
// This file wires the two gather seams NewSysGatherer deliberately leaves nil, for
|
|
// the one caller that can satisfy them without a cluster client: the on-host `felis
|
|
// update` CLI. Both reads are answered from the node the command runs on, which is
|
|
// exactly where bootstrap.sh installed the things being read.
|
|
//
|
|
// felis-api is answered from the RUNNING BINARY's own build stamp rather than from
|
|
// the control-plane Deployment's image tag. That is not a shortcut around the k8s
|
|
// read — it is the identity the user named ("当前版本号通过 felis version 查询"), and
|
|
// it is the same artifact: deploy/bootstrap.sh builds the felis image from the same
|
|
// checkout it installs /usr/local/bin/felis from, stamping both with one `git
|
|
// describe`. Reading the Deployment would answer a slightly different question (what
|
|
// is rolled out) and is still the right seam for the in-cluster CronJob path; it is
|
|
// left to NewSysGatherer, which keeps returning "not wired" there.
|
|
//
|
|
// The panel has no version of its own on purpose: it is compiled into the felis
|
|
// binary with //go:embed, so "the panel version" IS the felis version. The same is
|
|
// true of the plugin jars, which are built from this repo in the same bootstrap run.
|
|
// That is why the CLI's --panel and --plugins selectors both resolve here.
|
|
|
|
// DefaultVelocityJarPath is where deploy/bootstrap.sh installs the proxy. The jar is
|
|
// installed under a FIXED name with no version in it (install_velocity does
|
|
// `atomic_install_file "$tmp" "${VELOCITY_DIR}/velocity.jar"`), which is why the
|
|
// filename extractor alone cannot answer for Velocity and the manifest read below
|
|
// exists.
|
|
const DefaultVelocityJarPath = "/opt/felis/velocity/velocity.jar"
|
|
|
|
// DefaultJREReleasePath is the release file of the runtime deploy/bootstrap.sh
|
|
// installs for Velocity (install_jre unpacks Temurin into /opt/felis/jre).
|
|
const DefaultJREReleasePath = "/opt/felis/jre/release"
|
|
|
|
// NewHostGatherer builds the VersionGatherer for `felis update` running on the node.
|
|
// felisVersion is the CLI's own resolved build stamp; velocityJar is the installed
|
|
// proxy jar (empty means DefaultVelocityJarPath). k3s and cloudflared keep the
|
|
// existing exec seam — they are real binaries on this host and already answer.
|
|
func NewHostGatherer(felisVersion, velocityJar string) VersionGatherer {
|
|
if velocityJar == "" {
|
|
velocityJar = DefaultVelocityJarPath
|
|
}
|
|
return hostGatherer{
|
|
sys: sysGatherer{run: execRunner{}},
|
|
felisVersion: felisVersion,
|
|
velocityJar: velocityJar,
|
|
jreRelease: DefaultJREReleasePath,
|
|
}
|
|
}
|
|
|
|
// hostGatherer answers the two seams it can satisfy from the local filesystem and
|
|
// delegates every other component to the standard system gatherer, so the CLI and
|
|
// the (future) in-cluster runner share one dispatch table and cannot drift.
|
|
type hostGatherer struct {
|
|
sys sysGatherer
|
|
felisVersion string
|
|
velocityJar string
|
|
jreRelease string
|
|
}
|
|
|
|
// Current implements VersionGatherer.
|
|
func (g hostGatherer) Current(ctx context.Context, spec Spec) (updates.Version, error) {
|
|
switch spec.Name {
|
|
case "felis-api":
|
|
// An unstamped local `go build` reports "dev", which is not a version. Fail
|
|
// closed with an actionable message rather than inventing a 0.0.0 that would
|
|
// make every release upstream look like an upgrade.
|
|
v, err := updates.Parse(g.felisVersion)
|
|
if err != nil {
|
|
return updates.Version{}, fmt.Errorf("updater: felis build stamp %q is not a version (an unstamped build cannot be compared): %w", g.felisVersion, err)
|
|
}
|
|
return v, nil
|
|
case "velocity":
|
|
return velocityJarVersion(g.velocityJar)
|
|
case "jre":
|
|
return jreReleaseVersion(g.jreRelease)
|
|
case "postgresql":
|
|
return g.postgresVersion(ctx)
|
|
default:
|
|
return g.sys.Current(ctx, spec)
|
|
}
|
|
}
|
|
|
|
// postgresVersionArgv asks the server binary in the felis-postgres Deployment
|
|
// (internal/platform/postgres.go) for its version. The database runs from the image
|
|
// the release pins, so the answer comes from the container: a distribution package
|
|
// the move into k3s left installed on the host answers with a version nothing runs.
|
|
var postgresVersionArgv = []string{
|
|
"kubectl", "exec", "-n", platform.DefaultControlNamespace, "deploy/" + platform.PostgresName,
|
|
"-c", platform.PostgresContainer, "--", "postgres", "--version",
|
|
}
|
|
|
|
func (g hostGatherer) postgresVersion(ctx context.Context) (updates.Version, error) {
|
|
if g.sys.run == nil {
|
|
return updates.Version{}, fmt.Errorf("updater: command runner not wired for %s", platform.PostgresName)
|
|
}
|
|
out, err := g.sys.run.output(ctx, "k3s", postgresVersionArgv...)
|
|
if err != nil {
|
|
if msg := truncate(string(out), 200); msg != "" {
|
|
err = fmt.Errorf("%w: %s", err, msg)
|
|
}
|
|
return updates.Version{}, fmt.Errorf("updater: ask %s for its version: %w", platform.PostgresName, err)
|
|
}
|
|
v, err := versionFromCLI(string(out))
|
|
if err != nil {
|
|
return updates.Version{}, fmt.Errorf("updater: %s: %w", platform.PostgresName, err)
|
|
}
|
|
return v, nil
|
|
}
|
|
|
|
// jreReleaseVersion reads the runtime's version from its release file. Temurin writes
|
|
// SEMANTIC_VERSION="25.0.4.1+1"; JAVA_VERSION="25.0.4.1" is the fallback every JDK
|
|
// build writes. JAVA_RUNTIME_VERSION is avoided: its "-LTS" tail reads as a prerelease.
|
|
func jreReleaseVersion(path string) (updates.Version, error) {
|
|
raw, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return updates.Version{}, fmt.Errorf("updater: read JRE release file: %w", err)
|
|
}
|
|
fields := map[string]string{}
|
|
for _, line := range strings.Split(string(raw), "\n") {
|
|
k, v, ok := strings.Cut(line, "=")
|
|
if ok {
|
|
fields[strings.TrimSpace(k)] = strings.Trim(strings.TrimSpace(v), `"`)
|
|
}
|
|
}
|
|
for _, key := range []string{"SEMANTIC_VERSION", "JAVA_VERSION"} {
|
|
if fields[key] == "" {
|
|
continue
|
|
}
|
|
if v, err := updates.Parse(fields[key]); err == nil {
|
|
return v, nil
|
|
}
|
|
}
|
|
return updates.Version{}, fmt.Errorf("updater: no SEMANTIC_VERSION or JAVA_VERSION in %s", path)
|
|
}
|
|
|
|
// velocityJarVersion reads the installed proxy's version out of the jar itself.
|
|
//
|
|
// It reads META-INF/MANIFEST.MF's Implementation-Version, which is authoritative
|
|
// rather than incidental: Velocity reports its own version at runtime from that
|
|
// attribute (getImplementationVersion), so the value here is the same string the
|
|
// proxy prints about itself. The filename is only a fallback, and on a Felis node it
|
|
// is expected to fail — bootstrap installs the jar as a fixed "velocity.jar" — so it
|
|
// exists for the hand-placed "velocity-3.5.1.jar" case, not the normal one.
|
|
func velocityJarVersion(path string) (updates.Version, error) {
|
|
zr, err := zip.OpenReader(path)
|
|
if err != nil {
|
|
return updates.Version{}, fmt.Errorf("updater: open velocity jar %s: %w", path, err)
|
|
}
|
|
defer zr.Close()
|
|
|
|
raw, err := manifestAttr(&zr.Reader, "Implementation-Version")
|
|
if err == nil {
|
|
v, perr := updates.Parse(raw)
|
|
if perr == nil {
|
|
return v, nil
|
|
}
|
|
err = perr
|
|
}
|
|
// Fall back to the filename before surfacing the manifest failure, so a jar whose
|
|
// manifest is missing or unparseable still answers when the name carries a version.
|
|
if v, ferr := versionFromJarName(filepath.Base(path)); ferr == nil {
|
|
return v, nil
|
|
}
|
|
return updates.Version{}, fmt.Errorf("updater: no version in %s manifest or filename: %w", path, err)
|
|
}
|
|
|
|
// manifestAttr returns one attribute value from a jar's META-INF/MANIFEST.MF.
|
|
//
|
|
// This does not implement the JAR spec's 72-byte line folding (a wrapped
|
|
// value continues on the next line after a single leading space). Version values are
|
|
// far short of the wrap point, so folding cannot bite here; if this ever reads a long
|
|
// attribute, join continuation lines before splitting on ':'.
|
|
func manifestAttr(zr *zip.Reader, key string) (string, error) {
|
|
f, err := zr.Open("META-INF/MANIFEST.MF")
|
|
if err != nil {
|
|
return "", fmt.Errorf("updater: jar has no manifest: %w", err)
|
|
}
|
|
defer f.Close()
|
|
|
|
// Bound the read: a manifest is a few KiB, and this parses a file that arrived
|
|
// over the network in an earlier bootstrap run.
|
|
sc := bufio.NewScanner(io.LimitReader(f, 256<<10))
|
|
for sc.Scan() {
|
|
name, value, ok := strings.Cut(sc.Text(), ":")
|
|
if !ok || !strings.EqualFold(strings.TrimSpace(name), key) {
|
|
continue
|
|
}
|
|
if v := strings.TrimSpace(value); v != "" {
|
|
return v, nil
|
|
}
|
|
}
|
|
if err := sc.Err(); err != nil {
|
|
return "", fmt.Errorf("updater: read manifest: %w", err)
|
|
}
|
|
return "", fmt.Errorf("updater: manifest has no %s", key)
|
|
}
|