// Package update is de self-update van een geïnstalleerde BlueGit. // Het HTTP-endpoint schrijft alleen een verzoek weg en start de unit. // Het script in packaging doet de bouw en de installatie. package update import ( "context" "crypto/sha256" "crypto/subtle" "encoding/json" "errors" "fmt" "io" "os" "os/exec" "path/filepath" "regexp" "strings" "time" ) const ( // Unit is de enige systemd-unit die de bluegit-gebruiker mag starten. Unit = "bluegit-update.service" // TokenEnv is de sleutel. Zonder waarde is het endpoint uit. TokenEnv = "BLUEGIT_UPDATE_TOKEN" // RequestFile is één regel: leeg betekent HEAD, anders een sha of ref. RequestFile = "update-request" // StatusFile is de laatste poging, gelezen door de Info- en setup-pagina. StatusFile = "update-status.json" // LogFile is de uitvoer van de laatste run van het update-script. LogFile = "update.log" // LogTailLines is hoeveel regels GET /api/v1/admin/self-update teruggeeft. LogTailLines = 200 logTailBytes = 256 * 1024 ) // Status is het resultaat dat het update-script en de webpagina delen. type Status struct { Time string `json:"time"` SHA string `json:"sha"` Result string `json:"result"` Error string `json:"error,omitempty"` } // Token is de geconfigureerde sleutel. Leeg betekent dat self-update uit staat. func Token() string { return strings.TrimSpace(os.Getenv(TokenEnv)) } // Enabled is false zolang er geen sleutel in de omgeving staat. func Enabled() bool { return Token() != "" } // Equal vergelijkt twee sleutels zonder de lengte of de inhoud te lekken // via een vroege return. Een lege verwachte sleutel past nooit. func Equal(secret, got string) bool { if secret == "" || got == "" { return false } sumS := sha256.Sum256([]byte(secret)) sumG := sha256.Sum256([]byte(got)) return subtle.ConstantTimeCompare(sumS[:], sumG[:]) == 1 } var refPattern = regexp.MustCompile(`^[0-9A-Za-z][0-9A-Za-z._/-]{0,199}$`) // ValidRef staat een lege ref toe (HEAD van de bare repo), een sha, of een // branchnaam. Punt-punt en @{ zijn geen git-ref die we aan het script geven. func ValidRef(ref string) bool { if ref == "" { return true } if strings.Contains(ref, "..") || strings.Contains(ref, "@{") { return false } return refPattern.MatchString(ref) } // WriteRequest zet de gevraagde ref klaar voor de unit. func WriteRequest(dir, ref string) error { if dir == "" { return errors.New("state-map ontbreekt") } if err := os.MkdirAll(dir, 0o750); err != nil { return err } target := filepath.Join(dir, RequestFile) tmp, err := os.CreateTemp(dir, RequestFile+".*") if err != nil { return err } tmpName := tmp.Name() cleanup := true defer func() { if cleanup { _ = os.Remove(tmpName) } }() if _, err := tmp.WriteString(ref + "\n"); err != nil { _ = tmp.Close() return err } if err := tmp.Chmod(0o640); err != nil { _ = tmp.Close() return err } if err := tmp.Close(); err != nil { return err } if err := os.Rename(tmpName, target); err != nil { return err } cleanup = false return nil } // ReadStatus leest de laatste update. Een ontbrekend bestand is geen fout. func ReadStatus(dir string) (Status, error) { if dir == "" { return Status{}, nil } raw, err := os.ReadFile(filepath.Join(dir, StatusFile)) if err != nil { if errors.Is(err, os.ErrNotExist) { return Status{}, nil } return Status{}, err } var st Status if err := json.Unmarshal(raw, &st); err != nil { return Status{}, nil } return st, nil } // WriteStatus is voor tests en voor een mislukte start vanuit het proces. func WriteStatus(dir string, st Status) error { if dir == "" { return errors.New("state-map ontbreekt") } if st.Time == "" { st.Time = time.Now().UTC().Format(time.RFC3339) } raw, err := json.Marshal(st) if err != nil { return err } raw = append(raw, '\n') if err := os.MkdirAll(dir, 0o750); err != nil { return err } target := filepath.Join(dir, StatusFile) tmp, err := os.CreateTemp(dir, StatusFile+".*") if err != nil { return err } tmpName := tmp.Name() cleanup := true defer func() { if cleanup { _ = os.Remove(tmpName) } }() if _, err := tmp.Write(raw); err != nil { _ = tmp.Close() return err } if err := tmp.Chmod(0o644); err != nil { _ = tmp.Close() return err } if err := tmp.Close(); err != nil { return err } if err := os.Rename(tmpName, target); err != nil { return err } cleanup = false return nil } // ReadLogTail leest de laatste regels van het update-log. // Een ontbrekend bestand is geen fout: de geïnstalleerde updater schrijft // het pas nadat deze versie geïnstalleerd is. func ReadLogTail(dir string, lines int) (string, error) { if dir == "" || lines <= 0 { return "", nil } f, err := os.Open(filepath.Join(dir, LogFile)) if err != nil { if errors.Is(err, os.ErrNotExist) { return "", nil } return "", err } defer f.Close() info, err := f.Stat() if err != nil { return "", err } start := int64(0) if info.Size() > logTailBytes { start = info.Size() - logTailBytes } if _, err := f.Seek(start, io.SeekStart); err != nil { return "", err } raw, err := io.ReadAll(io.LimitReader(f, logTailBytes+1)) if err != nil { return "", err } text := string(raw) if start > 0 { if i := strings.IndexByte(text, '\n'); i >= 0 { text = text[i+1:] } } return lastLines(text, lines), nil } func lastLines(text string, n int) string { text = strings.TrimRight(text, "\n") if text == "" || n <= 0 { return "" } parts := strings.Split(text, "\n") if len(parts) > n { parts = parts[len(parts)-n:] } return strings.Join(parts, "\n") } // FreshRunning is waar als een update nog bezig hoort te zijn. func FreshRunning(st Status, now time.Time, window time.Duration) bool { if st.Result != "running" || st.Time == "" { return false } t, err := time.Parse(time.RFC3339, st.Time) if err != nil { return false } return now.Sub(t) < window && now.Sub(t) > -time.Minute } // StartSystemd start de oneshot zonder erop te wachten. De aanroepende // CI-job moet kunnen eindigen, anders wacht de updater eeuwig op zichzelf. func StartSystemd(ctx context.Context) error { cmd := exec.CommandContext(ctx, "systemctl", "start", "--no-block", Unit) out, err := cmd.CombinedOutput() if err != nil { msg := strings.TrimSpace(string(out)) if len(msg) > 200 { msg = msg[:200] } if msg == "" { return err } return fmt.Errorf("systemctl: %s", msg) } return nil }