0
0
package main
import (
"context"
"fmt"
"os"
"os/exec"
"os/user"
"strconv"
"strings"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/internal/clicfg"
"github.com/johnandersen777/socialweb-computer-kcp/internal/devcheck"
"github.com/johnandersen777/socialweb-computer-kcp/internal/devinstance"
"github.com/johnandersen777/socialweb-computer-kcp/internal/hostsvc"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/fsx"
)
const helloTimeout = 2 * time.Second
func (a *app) record(verb string, vals clicfg.Values) (devinstance.Layout, devinstance.Record, int) {
l, err := a.layout(vals)
if err != nil {
return l, devinstance.Record{}, a.fail(exitRefused, "%s: %v", verb, err)
}
var rec devinstance.Record
if err := fsx.ReadJSON(l.Record, &rec); err != nil {
return l, rec, a.fail(exitFailed, "%s: instance %s has no record at %s; dev up first", verb, l.ID, l.Record)
}
return l, rec, exitOK
}
func runDevEnv(ctx context.Context, a *app, vals clicfg.Values, rest []string) int {
_, rec, code := a.record("dev env", vals)
if code != exitOK {
return code
}
ex := devinstance.Exports(rec)
if vals.Bool("json") {
a.printJSON(exportMap(ex))
return exitOK
}
fmt.Fprint(a.stdout, devinstance.ShellExports(ex))
return exitOK
}
type lsEntry struct {
Instance string `json:"instance"`
Worktree string `json:"worktree,omitempty"`
Profile string `json:"profile"`
Ready bool `json:"ready"`
StateDir string `json:"stateDir"`
KcpURL string `json:"kcpURL"`
Units int `json:"units"`
Created time.Time `json:"created"`
Reachable bool `json:"devsupReachable"`
DevsupPID int `json:"devsupPID,omitempty"`
}
func runDevLs(ctx context.Context, a *app, vals clicfg.Values, rest []string) int {
root, err := devinstance.StateRoot(vals.String("state-dir"), a.env)
if err != nil {
return a.fail(exitRefused, "dev ls: %v", err)
}
recs, err := devinstance.List(root)
if err != nil {
return a.fail(exitFailed, "dev ls: %v", err)
}
out := []lsEntry{}
for _, rec := range recs {
e := lsEntry{Instance: rec.Layout.ID, Worktree: rec.Worktree, Profile: rec.Profile, Ready: rec.Ready,
StateDir: rec.Layout.StateDir, KcpURL: rec.KcpURL, Units: len(rec.Units), Created: rec.Created}
hctx, cancel := context.WithTimeout(ctx, helloTimeout)
if c, h, err := helloDevsup(hctx, rec.Layout); err == nil {
e.Reachable, e.DevsupPID = true, h.PID
c.Close()
}
cancel()
out = append(out, e)
}
a.printJSON(out)
return exitOK
}
func lastLines(b []byte, n int) []byte {
if n <= 0 {
return b
}
s := strings.TrimSuffix(string(b), "\n")
lines := strings.Split(s, "\n")
if len(lines) > n {
lines = lines[len(lines)-n:]
}
return []byte(strings.Join(lines, "\n") + "\n")
}
func runDevLogs(ctx context.Context, a *app, vals clicfg.Values, rest []string) int {
l, err := a.layout(vals)
if err != nil {
return a.fail(exitRefused, "dev logs: %v", err)
}
if len(rest) != 1 {
return a.fail(exitRefused, "dev logs: name one unit: %s (or its unit name)", strings.Join(devinstance.LogNames(l), ", "))
}
path, err := devinstance.LogFile(l, rest[0])
if err != nil {
return a.fail(exitRefused, "dev logs: %v", err)
}
b, err := os.ReadFile(path)
if err != nil {
return a.fail(exitFailed, "dev logs: %v", err)
}
a.stdout.Write(lastLines(b, vals.Int("tail")))
return exitOK
}
type checkReport struct {
OK bool `json:"ok"`
At time.Time `json:"at"`
Results []devcheck.Result `json:"results"`
}
func runDevCheck(ctx context.Context, a *app, vals clicfg.Values, rest []string) int {
name := strconv.Itoa(os.Geteuid())
if u, err := user.Current(); err == nil {
name = u.Username
}
rs := devcheck.Run(devcheck.Host{Root: "/", Euid: os.Geteuid(), User: name, Env: a.env, LookPath: exec.LookPath})
a.printJSON(checkReport{OK: !devcheck.Failed(rs), At: time.Now().UTC(), Results: rs})
if devcheck.Failed(rs) {
return exitFailed
}
return exitOK
}
type coreRestartReport struct {
Instance string `json:"instance"`
Parent string `json:"parent,omitempty"`
Binary devinstance.Executable `json:"binary"`
Before devinstance.Core `json:"before"`
After devinstance.Core `json:"after"`
UnitsUnchanged bool `json:"unitsUnchanged"`
Seconds float64 `json:"seconds"`
}
func coreTarget(target string) (string, bool) {
if target == "core" {
return "", true
}
app, ok := strings.CutSuffix(target, "/core")
if !ok || app == "" || strings.ContainsAny(app, "/:") {
return "", false
}
if _, isKind := canonicalComponentKind(app); isKind {
return "", false
}
return app, true
}
func (a *app) coreRecord(ctx context.Context, vals clicfg.Values, childApp string) (devinstance.Layout, devinstance.Record, int) {
l, err := a.layout(vals)
if err != nil {
return l, devinstance.Record{}, a.fail(exitRefused, "dev restart: %v", err)
}
var rec devinstance.Record
if err := fsx.ReadJSON(l.Record, &rec); err != nil {
root, rerr := devinstance.StateRoot(vals.String("state-dir"), a.env)
if rerr != nil {
return l, rec, a.fail(exitRefused, "dev restart: %v", rerr)
}
cl, crec, ok := findNetworkChild(root, l.ID)
if !ok {
return l, rec, a.fail(exitFailed, "dev restart: instance %s has no record at %s and is no child application of a market network under %s; dev up first", l.ID, l.Record, root)
}
l, rec = cl, crec
}
if childApp != "" {
cl, crec, err := networkChild(ctx, l, rec, childApp)
if err != nil {
return l, rec, a.fail(exitRefused, "dev restart: %v", err)
}
l, rec = cl, crec
}
if rec.Parent != nil {
l = rec.Layout
}
return l, rec, exitOK
}
func runDevRestart(ctx context.Context, a *app, vals clicfg.Values, rest []string) int {
started := time.Now()
if len(rest) == 2 {
vals = vals.With("instance", rest[0])
rest = rest[1:]
}
if len(rest) != 1 {
return a.fail(exitRefused, "dev restart: dev restart [<instance>] [<app>/]core [--binary path] | dev restart [<instance>] [<app>/][<workspace>:][<kind>/]<component>; the PolicyEngine is the component controller and restarts with core; kcp and cluster rolls are dev roll (M3-KCP-ROLL)")
}
childApp, isCore := coreTarget(rest[0])
if !isCore {
return runDevRestartComponent(ctx, a, vals, rest[0])
}
readyTimeout, err := time.ParseDuration(vals.String("ready-timeout"))
if err != nil {
return a.fail(exitRefused, "dev restart: ready-timeout: %v", err)
}
l, rec, code := a.coreRecord(ctx, vals, childApp)
if code != exitOK {
return code
}
path := vals.String("binary")
if path == "" {
if path, err = selfExe(); err != nil {
return a.fail(exitFailed, "dev restart: %v", err)
}
}
bin, err := hashExe("binary", path)
if err != nil {
return a.fail(exitRefused, "dev restart: %v", err)
}
r := coreRestartReport{Instance: l.ID, Binary: bin}
var m hostsvc.Manager
if rec.Parent != nil {
r.Parent = rec.Parent.ID
if m, err = a.instanceManager(ctx, rec); err != nil {
return a.fail(exitFailed, "dev restart: the supervisor of %s, which places the core of %s, is unreachable (%v)", rec.Parent.ID, l.ID, err)
}
} else if m, _, err = helloDevsup(ctx, l); err != nil {
return a.fail(exitFailed, "dev restart: devsup of %s is unreachable (%v); dev up places a new core", l.ID, err)
}
defer m.Close()
fsx.ReadJSON(l.CoreRecord, &r.Before)
lock, err := lockFile(ctx, l.Lock, 30*time.Second)
if err != nil {
return a.fail(exitFailed, "dev restart: %v", err)
}
if err := m.Stop(ctx, l.CoreUnit()); err != nil {
lock.Close()
return a.fail(exitFailed, "dev restart: stopping the core: %v", err)
}
m.ResetFailed(ctx, l.CoreUnit())
if rec.Executables == nil {
rec.Executables = map[string]devinstance.Executable{}
}
rec.Executables["socialweb-computer"] = bin
if err := fsx.WriteJSON(l.Record, rec, 0o600); err != nil {
lock.Close()
return a.fail(exitFailed, "dev restart: %v", err)
}
lock.Close()
cspec, err := coreSpec(&rec, bin.Path, readyTimeout)
if err != nil {
return a.fail(exitFailed, "dev restart: %v", err)
}
st, err := m.Start(ctx, cspec)
if err != nil {
return a.fail(exitFailed, "dev restart: placing the core: %v", err)
}
if st.Adopted && rec.Parent != nil {
return a.fail(exitFailed, "dev restart: the supervisor of %s placed the core of %s again (invocation %s) before this restart did; run dev restart again",
rec.Parent.ID, l.ID, st.InvocationID)
}
if r.After, err = waitCore(ctx, l, m, cspec.Name, st.InvocationID, readyTimeout); err != nil {
return a.fail(exitFailed, "dev restart: %v", err)
}
r.UnitsUnchanged = len(r.After.Adoptions) == len(rec.Units)
for _, ad := range r.After.Adoptions {
u := rec.Unit(ad.Role)
if u == nil || !ad.Adopted || ad.InvocationID != u.Identity.InvocationID {
r.UnitsUnchanged = false
}
}
r.Seconds = time.Since(started).Seconds()
a.printJSON(r)
if !r.UnitsUnchanged {
return exitFailed
}
return exitOK
}