0
0
package main
import (
"cmp"
"context"
"encoding/json"
"fmt"
"io"
"os"
"path/filepath"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/internal/app/marketbidder"
"github.com/johnandersen777/socialweb-computer-kcp/internal/assets"
"github.com/johnandersen777/socialweb-computer-kcp/internal/clicfg"
"github.com/johnandersen777/socialweb-computer-kcp/internal/devinstance"
"github.com/johnandersen777/socialweb-computer-kcp/internal/hostsvc"
"github.com/johnandersen777/socialweb-computer-kcp/internal/progress"
"github.com/johnandersen777/socialweb-computer-kcp/internal/versions"
"github.com/johnandersen777/socialweb-computer-kcp/internal/vmruntime"
)
var vmOptions = append([]string{backendOpt, "instance", "state-dir", "asset-cache", "handle", "vm-runtime-dir", "guest-image-source", "vm-stop-grace", "vmm"},
devOnly("userns-stage-path", "pasta-path", "vmexec-path", "firecracker-path", "qemu-path")...)
func (a *app) vmExe(vals clicfg.Values, executable, option string) (string, error) {
if !assets.Release() {
p := vals.String(option)
if p == "" || !filepath.IsAbs(p) {
return "", fmt.Errorf("%s must be an absolute path in this dev build (never PATH), got %q", option, p)
}
return p, nil
}
cache, err := a.assetCache(vals)
if err != nil {
return "", err
}
e, err := assets.Resolve(assets.Options{Cache: cache, Log: a.log}, executable)
if err != nil {
return "", err
}
return e.Path, nil
}
func (a *app) vmRuntime(ctx context.Context, vals clicfg.Values) (vmruntime.Runtime, hostsvc.Manager, error) {
state := vals.String("state-dir")
if state == "" || !filepath.IsAbs(state) {
return nil, nil, fmt.Errorf("state-dir must be an absolute path: the VM work dirs, images and the slot lock live under it")
}
if vals.String("handle") == "" {
return nil, nil, fmt.Errorf("handle is required: VM units are named by the handle of the bidder instance that owns them")
}
vmm, err := vmruntime.ParseVMM(vals.String("vmm"))
if err != nil {
return nil, nil, err
}
paths, err := a.vmExes(vals, vmm)
if err != nil {
return nil, nil, err
}
p, err := a.placement(ctx, vals)
if err != nil {
return nil, nil, err
}
grace, err := vmStopGrace(vals)
if err != nil {
p.manager.Close()
return nil, nil, err
}
rt, err := vmruntime.ForHost(vmruntime.Config{
Manager: p.manager, StateDir: state, RuntimeDir: vals.String("vm-runtime-dir"), VMM: vmm, Exec: vmExecutables(paths, vmm),
ImageSource: vals.String("guest-image-source"), StopGrace: grace,
ImageOut: a.stderr, ImageTTY: progress.IsTTYWriter(a.stderr),
})
if err != nil {
p.manager.Close()
return nil, nil, err
}
return rt, p.manager, nil
}
var vmExeOptions = map[string]string{
"swc-userns-stage": "userns-stage-path",
"pasta": "pasta-path",
"socialweb-vmexec": "vmexec-path",
"firecracker": "firecracker-path",
vmruntime.QEMUExecutable: "qemu-path",
}
func (a *app) vmExes(vals clicfg.Values, vmm string) (map[string]string, error) {
out := map[string]string{}
for _, n := range vmruntime.ExecutableNames(vmm) {
p, err := a.vmExe(vals, n, vmExeOptions[n])
if err != nil {
return nil, err
}
out[n] = p
}
return out, nil
}
func vmExecutables(paths map[string]string, vmm string) vmruntime.Executables {
return vmruntime.Executables{Stage: paths["swc-userns-stage"], Pasta: paths["pasta"], VMExec: paths["socialweb-vmexec"],
VMM: paths[vmruntime.VMMExecutable(vmm)]}
}
var devVMOptions = append([]string{"handle", "vm-host-backend", "vm-runtime-dir", "guest-image-source", "requested-image-budget", "vm-stop-grace", "vmm"},
devOnly("userns-stage-path", "pasta-path", "vmexec-path", "firecracker-path", "qemu-path")...)
func (a *app) devVMExecutables(vals clicfg.Values) (map[string]devinstance.Executable, error) {
out := map[string]devinstance.Executable{}
vmm, err := vmruntime.ParseVMM(vals.String("vmm"))
if err != nil {
return nil, err
}
for _, n := range vmruntime.ExecutableNames(vmm) {
if !assets.Release() && vals.String(vmExeOptions[n]) == "" {
continue
}
p, err := a.vmExe(vals, n, vmExeOptions[n])
if err != nil {
if assets.Release() {
if a.log != nil {
a.log.Warn("the dev VM executable does not resolve; the network will record it missing", "executable", n, "err", err.Error())
}
continue
}
return nil, err
}
out[n] = devinstance.Executable{Path: p}
}
downloads, err := a.guestDownloads(vals)
switch {
case err != nil && a.log != nil:
a.log.Warn("the guest downloads asset does not resolve; the GuestControlPlane serves no /v1/downloads", "asset", marketbidder.GuestDownloadsExecutable, "err", err.Error())
case downloads.Path != "":
out[marketbidder.GuestDownloadsExecutable] = downloads
}
return out, nil
}
func (a *app) guestDownloads(vals clicfg.Values) (devinstance.Executable, error) {
if !assets.Release() {
return devinstance.Executable{}, nil
}
cache, err := a.assetCache(vals)
if err != nil {
return devinstance.Executable{}, err
}
e, err := assets.Resolve(assets.Options{Cache: cache, Log: a.log}, marketbidder.GuestDownloadsExecutable)
if err != nil {
return devinstance.Executable{}, err
}
return devinstance.Executable{Path: e.Path, Version: e.Version}, nil
}
func (a *app) devVM(vals clicfg.Values, l devinstance.Layout) (*devinstance.VMRuntime, error) {
handle := vals.String("handle")
if handle == "" {
return nil, nil
}
backend := hostsvc.BackendProc
if b := vals.String("vm-host-backend"); b != "" {
var err error
if backend, err = hostsvc.ParseBackend(b); err != nil {
return nil, err
}
}
rt := vals.String("vm-runtime-dir")
rt = cmp.Or(rt, l.RuntimeDir)
if !filepath.IsAbs(rt) {
return nil, fmt.Errorf("vm-runtime-dir %q must be absolute: each VM's API socket lives under it", rt)
}
grace, err := vmStopGrace(vals)
if err != nil {
return nil, err
}
vmm, err := vmruntime.ParseVMM(vals.String("vmm"))
if err != nil {
return nil, err
}
paths, err := a.vmExes(vals, vmm)
if err != nil {
return nil, err
}
return &devinstance.VMRuntime{Handle: handle, Backend: backend, ImageSource: vals.String("guest-image-source"),
StopGrace: grace.String(), RuntimeDir: rt, VMM: vmm, Executables: paths}, nil
}
func vmStopGrace(vals clicfg.Values) (time.Duration, error) {
if s := vals.String("vm-stop-grace"); s != "" {
d, err := time.ParseDuration(s)
if err != nil {
return 0, fmt.Errorf("vm-stop-grace: %w", err)
}
return d, nil
}
return versions.VMStopGrace()
}
func (a *app) instanceVMRuntime(ctx context.Context, rec devinstance.Record) (vmruntime.Runtime, hostsvc.Manager, error) {
v := rec.VM
cfg := hostsvc.Config{Backend: v.Backend}
if v.Backend == hostsvc.BackendProc {
cfg.ProcSocket = rec.Layout.Socket
if rec.Parent != nil {
cfg.ProcSocket = rec.Parent.Socket
}
}
m, err := hostsvc.Open(ctx, cfg)
if err != nil {
return nil, nil, fmt.Errorf("the VM placement backend %s: %w", v.Backend, err)
}
grace, err := time.ParseDuration(v.StopGrace)
if err != nil {
m.Close()
return nil, nil, err
}
vmm := cmp.Or(v.VMM, vmruntime.VMMFirecracker)
rt, err := vmruntime.ForHost(vmruntime.Config{Manager: m, StateDir: rec.Layout.StateDir, RuntimeDir: v.RuntimeDir,
VMM: vmm, Exec: vmExecutables(v.Executables, vmm),
ImageSource: v.ImageSource, StopGrace: grace, ImageOut: a.stderr, ImageTTY: progress.IsTTYWriter(a.stderr)})
if err != nil {
m.Close()
return nil, nil, err
}
return rt, m, nil
}
func (a *app) downVMs(ctx context.Context, rec devinstance.Record) ([]string, []string) {
if rec.VM == nil {
return nil, nil
}
rt, m, err := a.instanceVMRuntime(ctx, rec)
if err != nil {
a.log.Warn("the VM runtime of the instance; its VMs are not stopped here", "err", err.Error())
return nil, []string{err.Error()}
}
defer m.Close()
listed, err := rt.List(ctx, rec.VM.Handle)
if err != nil {
return nil, []string{err.Error()}
}
var stopped, left []string
for _, l := range listed {
ref, err := rt.Load(rec.VM.Handle, l.Name)
if err != nil {
ref = vmruntime.RuntimeRef{Handle: rec.VM.Handle, Name: l.Name, Unit: l.Unit}
}
res, err := rt.Stop(ctx, ref)
if err != nil {
left = append(left, l.Unit+": "+err.Error())
continue
}
stopped = append(stopped, l.Unit)
a.log.Info("VM stopped with its instance", "unit", l.Unit, "graceful", res.Graceful, "result", res.Result)
}
if err := m.StopSlice(ctx, vmruntime.SliceName(rec.VM.Handle)); err != nil {
left = append(left, err.Error())
}
return stopped, left
}
func runVM(verb string) verbFunc {
return func(ctx context.Context, a *app, vals clicfg.Values, rest []string) int {
rt, m, err := a.vmRuntime(ctx, vals)
if err != nil {
return a.fail(exitRefused, "vm %s: %v", verb, err)
}
defer m.Close()
handle := vals.String("handle")
name := ""
if verb != "start" && verb != "list" {
if len(rest) != 1 {
return a.fail(exitRefused, "vm %s: name exactly one VM", verb)
}
name = rest[0]
}
var out any
switch verb {
case "start":
raw, err := io.ReadAll(os.Stdin)
if err != nil {
return a.fail(exitFailed, "vm start: reading the spec from stdin: %v", err)
}
var spec vmruntime.VMSpec
if err := json.Unmarshal(raw, &spec); err != nil {
return a.fail(exitRefused, "vm start: the spec on stdin: %v", err)
}
spec.Handle = handle
p, err := rt.Prepare(ctx, spec)
if err != nil {
return a.fail(exitFailed, "vm start: %v", err)
}
ref, err := rt.Start(ctx, p)
if err != nil {
return a.fail(exitFailed, "vm start: %v", err)
}
out = ref
case "inspect":
ref, err := rt.Load(handle, name)
if os.IsNotExist(err) {
out = vmruntime.Observation{Verdict: hostsvc.VerdictLost.String(), Reason: hostsvc.LostUnitGone, Detail: "no runtime record for " + name}
break
}
if err != nil {
return a.fail(exitFailed, "vm inspect: %v", err)
}
obs, err := rt.Inspect(ctx, ref)
if err != nil {
return a.fail(exitFailed, "vm inspect: %v", err)
}
out = obs
case "stop":
ref, err := rt.Load(handle, name)
if os.IsNotExist(err) {
ref = vmruntime.RuntimeRef{Handle: handle, Name: name, Unit: vmruntime.UnitName(handle, name)}
} else if err != nil {
return a.fail(exitFailed, "vm stop: %v", err)
}
res, err := rt.Stop(ctx, ref)
if err != nil {
return a.fail(exitFailed, "vm stop: %v", err)
}
out = res
case "list":
l, err := rt.List(ctx, handle)
if err != nil {
return a.fail(exitFailed, "vm list: %v", err)
}
out = l
}
a.printJSON(out)
return exitOK
}
}
func devOnly(names ...string) []string {
if clicfg.ReleaseBuild() {
return nil
}
return names
}