0
0
package bootstrap
import (
"context"
"errors"
"fmt"
"log/slog"
"net"
"os"
"path/filepath"
"time"
"strings"
"github.com/johnandersen777/socialweb-computer-kcp/internal/apiserverfront"
"github.com/johnandersen777/socialweb-computer-kcp/internal/hostsvc"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kcpdatastore"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kcpserver"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/opt"
"github.com/johnandersen777/socialweb-computer-kcp/internal/versions"
)
type InstalledRoll struct {
Kcp string
Kine string
PlannedOutage bool
Retention kcpdatastore.BackupRetention
Compat []versions.KcpCompat
ReadyTimeout time.Duration
OnListen func(name string, addr net.Addr)
Log *slog.Logger
}
type InstalledRollReport struct {
Pair kcpserver.PairVerdict `json:"pair"`
KcpFrom kcpserver.Asset `json:"kcpFrom"`
KcpTo kcpserver.Asset `json:"kcpTo"`
KineFrom string `json:"kineFrom"`
KineTo string `json:"kineTo"`
Roll kcpserver.RollReport `json:"roll"`
Slots kcpserver.Slots `json:"slots"`
Boot []string `json:"boot,omitempty"`
BootError string `json:"bootError,omitempty"`
}
func resolveTarget(link, target string) (string, error) {
cur, err := filepath.EvalSymlinks(link)
if err != nil {
return "", fmt.Errorf("bootstrap: the asset link %s: %w", link, err)
}
if target == "" {
return cur, nil
}
if !filepath.IsAbs(target) {
return "", fmt.Errorf("bootstrap: asset %s must be an absolute path", target)
}
return filepath.EvalSymlinks(target)
}
func RollInstalled(ctx context.Context, m hostsvc.Manager, p Params, o InstalledRoll) (InstalledRollReport, error) {
log := o.Log
if log == nil {
log = slog.Default()
}
var out InstalledRollReport
slots, err := kcpserver.ReadSlots(p.SlotsFile())
if err != nil {
return out, fmt.Errorf("bootstrap: no %s; this installed kcp has not booted: %w", p.SlotsFile(), err)
}
from := slots.Active
if out.KcpFrom, err = kcpserver.ReadAsset(ctx, p.KcpPath); err != nil {
return out, err
}
out.KcpTo = out.KcpFrom
if o.Kcp != "" {
if out.KcpTo, err = kcpserver.ReadAsset(ctx, o.Kcp); err != nil {
return out, err
}
}
if out.KineFrom, err = resolveTarget(p.KinePath, ""); err != nil {
return out, err
}
if out.KineTo, err = resolveTarget(p.KinePath, o.Kine); err != nil {
return out, err
}
out.Pair, err = kcpserver.CheckPair(out.KcpFrom, out.KcpTo, o.Compat, o.PlannedOutage)
if err != nil {
return out, err
}
app := p.App
kcpChanged := out.KcpTo.Path != out.KcpFrom.Path
kineChanged := out.KineTo != out.KineFrom
outage := out.Pair.Mode == kcpserver.ModePlannedOutage || slots.Shape != kcpserver.ShapeBlueGreen
to := kcpserver.Other(from)
if slots.Shape != kcpserver.ShapeBlueGreen {
to = from
out.Pair.Mode = kcpserver.ModePlannedOutage
out.Pair.Reason += "; a single-slot kcp rolls as a short restart of its slot"
}
if kineChanged && !outage && app.KineOf(to) == app.KineOf(from) {
return out, fmt.Errorf("bootstrap: slots %s and %s share kine %s; a kine change needs --planned-outage", from, to, app.KineOf(from))
}
a, err := kcpserver.ReadSharedAdmin(p.SharedDir())
if err != nil {
return out, err
}
frontURL := slots.Front.URL()
admin, err := kcpserver.NewHTTPAdmin(a, frontURL)
if err != nil {
return out, err
}
for _, slot := range app.Slots {
if err := kcpserver.WriteSlotFiles(p.SlotRoot(slot)); err != nil {
return out, err
}
}
names := app.Names()
retargeted, aborted := false, false
point := func(kcp, kine string) error {
if err := retarget(p.KcpPath, kcp); err != nil {
return err
}
return retarget(p.KinePath, kine)
}
timeout := o.ReadyTimeout
timeout = opt.Positive(timeout, DefaultReadyTimeout)
start := func(ctx context.Context, slot string, spec hostsvc.UnitSpec) (hostsvc.UnitStatus, error) {
if (kcpChanged || kineChanged) && !retargeted && !aborted {
if err := point(out.KcpTo.Path, out.KineTo); err != nil {
return hostsvc.UnitStatus{}, err
}
retargeted = true
log.Info("asset links retargeted", "kcp", out.KcpTo.Path, "kine", out.KineTo)
}
ks := app.KineOf(slot)
kine := names.Kine(ks)
if ks != app.KineOf(from) || kineChanged {
m.Stop(ctx, kine)
m.ResetFailed(ctx, kine)
}
if err := os.MkdirAll(p.KineDir(ks), 0o700); err != nil {
return hostsvc.UnitStatus{}, err
}
if _, err := hostsvc.StartInstalled(ctx, m, kine); err != nil {
return hostsvc.UnitStatus{}, err
}
kctx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
if err := waitUnixSocket(kctx, p.KineSocket(ks)); err != nil {
return hostsvc.UnitStatus{}, fmt.Errorf("bootstrap: %s: %w", kine, err)
}
f, err := hostsvc.RenderInstalled(spec, hostsvc.InstallOptions{EnvFile: p.EnvFile(spec.Name)})
if err != nil {
return hostsvc.UnitStatus{}, err
}
if err := writePrivate(f.EnvPath, f.Env); err != nil {
return hostsvc.UnitStatus{}, err
}
return hostsvc.StartInstalled(ctx, m, spec.Name)
}
abort := func(context.Context) error {
if aborted {
return nil
}
aborted = true
if !retargeted {
return nil
}
log.Warn("roll aborted; the asset links point back at the previous assets", "kcp", out.KcpFrom.Path, "kine", out.KineFrom)
return point(out.KcpFrom.Path, out.KineFrom)
}
retire := func(ctx context.Context, old, current string) error {
if app.KineOf(old) == app.KineOf(current) {
return nil
}
kine := names.Kine(app.KineOf(old))
if err := m.Stop(ctx, kine); err != nil {
return err
}
m.ResetFailed(ctx, kine)
return nil
}
rep, after, rerr := kcpserver.Roll(ctx, m, apiserverfront.Client{Path: p.FrontControl()}, admin, kcpserver.RollConfig{
SlotsFile: p.SlotsFile(), Shared: p.SharedDir(), MemberToken: kcpserver.MemberTokenPath(p.Dir),
SpecFor: func(slot string) (hostsvc.UnitSpec, string, error) {
return p.slotSpec(slot, frontURL)
},
KineFor: func(slot string) string { return p.KineURL(app.KineOf(slot)) },
Backup: p.storeBackup(o.Retention, log),
Start: start,
Retire: retire,
Abort: abort,
Describe: func(string) (string, string) { return out.KcpTo.SHA256, out.KcpTo.Version },
Outage: outage, ReadyTimeout: o.ReadyTimeout, OnListen: o.OnListen, Log: log,
})
out.Roll, out.Slots = rep, after
if rerr != nil && after.Active != rep.To {
if err := abort(ctx); err != nil {
rerr = errors.Join(rerr, err)
}
}
if after.Active == rep.To && rep.To != rep.From {
enable := []string{names.Slot(rep.To), names.Kine(app.KineOf(rep.To))}
disable := []string{names.Slot(rep.From)}
if app.KineOf(rep.From) != app.KineOf(rep.To) {
disable = append(disable, names.Kine(app.KineOf(rep.From)))
}
if err := hostsvc.SetBoot(ctx, m, enable, disable); err != nil {
out.BootError = err.Error()
if !errors.Is(err, hostsvc.ErrUnsupported) {
rerr = errors.Join(rerr, err)
}
} else {
out.Boot = enable
}
pruneInactiveAuditLogs(p.SlotRoot(rep.From), log)
}
return out, rerr
}
func pruneInactiveAuditLogs(root string, log *slog.Logger) {
entries, err := os.ReadDir(root)
if err != nil {
return
}
removed := 0
for _, e := range entries {
if e.IsDir() || !strings.HasPrefix(e.Name(), "audit-") || !strings.HasSuffix(e.Name(), ".log") {
continue
}
if err := os.Remove(filepath.Join(root, e.Name())); err == nil {
removed++
}
}
if removed > 0 {
log.Info("removed the audit logs of the retired kcp slot", "slotRoot", root, "files", removed)
}
}
func writePrivate(path string, b []byte) error {
if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
return err
}
tmp := path + ".tmp"
if err := os.WriteFile(tmp, b, 0o600); err != nil {
return err
}
return os.Rename(tmp, path)
}