0
0
package main
import (
"context"
"errors"
"flag"
"fmt"
"io"
"log/slog"
"maps"
"os"
"os/signal"
"runtime"
"slices"
"sort"
"strings"
"syscall"
"github.com/johnandersen777/socialweb-computer-kcp/internal/app/marketbidder"
"github.com/johnandersen777/socialweb-computer-kcp/internal/app/marketrequester"
"github.com/johnandersen777/socialweb-computer-kcp/internal/app/sshgateway"
"github.com/johnandersen777/socialweb-computer-kcp/internal/assets"
"github.com/johnandersen777/socialweb-computer-kcp/internal/capabilities"
"github.com/johnandersen777/socialweb-computer-kcp/internal/ccmmain"
"github.com/johnandersen777/socialweb-computer-kcp/internal/checkhostmain"
"github.com/johnandersen777/socialweb-computer-kcp/internal/clicfg"
"github.com/johnandersen777/socialweb-computer-kcp/internal/foldmain"
"github.com/johnandersen777/socialweb-computer-kcp/internal/gatewaymain"
"github.com/johnandersen777/socialweb-computer-kcp/internal/hostcontract"
"github.com/johnandersen777/socialweb-computer-kcp/internal/hostsvc"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/logx"
"github.com/johnandersen777/socialweb-computer-kcp/internal/providermain"
"github.com/johnandersen777/socialweb-computer-kcp/internal/tenantcredentialmain"
"github.com/johnandersen777/socialweb-computer-kcp/internal/vaultmain"
)
const (
exitOK = 0
exitFailed = 1
exitRefused = 2
serviceName = "socialweb-computer"
backendOpt = "host-backend"
appRoleOpt = "app-role"
coreNetworkOpt = "core-network"
)
type app struct {
env clicfg.Env
stdout io.Writer
stderr io.Writer
spec clicfg.Spec
config map[string]any
goos string
goarch string
log *slog.Logger
args verbArgs
}
type verbFunc func(ctx context.Context, a *app, v clicfg.Values, rest []string) int
type builtVerb struct {
options []string
run verbFunc
}
func builtVerbs() map[string]builtVerb {
verbs := map[string]builtVerb{
"version": {[]string{"json"}, runVersion},
"dev up": {slices.Concat([]string{backendOpt, "instance", "state-dir", "profile", "bidders", "with-gateway", "with-knotless", "app-values", "network-bind", "network-domain", "network-atirc-url", "network-qr-origin", "network-timeout", "stand-ins", "parent", "die-with", "kcp-path", "kine-path", "postgres-root", "bao-path", "openbao-plugin-dir", "dumbpipe-path", "openbao-addr", "openbao-token-file", "asset-cache", "ready-timeout", "kcp-base-workspace", "fg", "keep-state", "guest-image-release-base", "no-guest-lan-udp", "guest-host-udp", "compute-kinds", "cpu-overcommit", "bidder-policy"}, devVMOptions), runDevUp},
"dev host": {[]string{backendOpt, "instance", "state-dir", "profile", "die-with", "kcp-path", "kine-path", "postgres-root", "bao-path", "asset-cache", "ready-timeout", "kcp-base-workspace", "fg", "keep-state"}, runDevHost},
"dev status": {[]string{"instance", "state-dir"}, runDevStatus},
"status": {[]string{"instance", "state-dir"}, runStatus},
"dev down": {[]string{"instance", "state-dir", "keep-state"}, runDevDown},
"dev ls": {[]string{"state-dir"}, runDevLs},
"dev logs": {[]string{"instance", "state-dir", "tail"}, runDevLogs},
"dev env": {[]string{"instance", "state-dir", "json"}, runDevEnv},
"dev check": {nil, runDevCheck},
"dev restart": {[]string{"instance", "state-dir", "binary", "ready-timeout"}, runDevRestart},
"dev links": {[]string{"instance", "state-dir", "json"}, runDevLinks},
"dev gc": {[]string{"asset-cache", "state-dir", "asset-gc-window"}, runDevGC},
"apply": {applyOptions, runApply},
"run bidder": {bidderOptions, runBidder},
"run request": {requestCreateOptions, runRequest},
"run requester": {requesterOptions, runRequester},
"run requester env": {requesterHelperOptions, runRequesterEnv},
"run requester ssh": {append(slices.Clone(requesterSSHOptions), execOpt), runRequesterSSH},
"run requester proxy": {requesterSSHOptions, runRequesterProxy},
"run requester cluster": {requesterGatewayOptions, runRequesterCluster},
"run requester kubeconfig": {requesterGatewayOptions, runRequesterKubeconfig},
"run requester password": {requesterPasswordOptions, runRequesterPassword},
"run requester signin": {requesterSigninOptions, runRequesterSignin},
"run gateway ssh": {gatewaySshOptions, runGatewaySsh},
"run request list": {[]string{"state-dir", "json"}, runRequestList},
"run request release": {requestOptions, runRequestRelease},
"run request resume": {requestExecOptions, runRequestResume},
"run request ssh": {append(slices.Clone(requestExecOptions), "contract"), runRequestSSH},
"run request proxy": {append(slices.Clone(requestOptions), "contract"), runRequestProxy},
"run request agent": {append(slices.Clone(requestOptions), "contract"), runRequestAgent},
"run request associate": {append(slices.Clone(requestOptions), "associate"), runRequestAssociate},
"run request r2": {append(slices.Clone(requestOptions), "r2-name"), runRequestR2},
"manifests list": {[]string{"json"}, runManifestsList},
"manifests render": {renderOptions, runManifestsRender},
"install gateway": {installOptions, runInstall(hostcontract.RoleGateway)},
"install bidder": {installOptions, runInstall(hostcontract.RoleBidder)},
"install requester": {installRequesterOptions, runInstall(hostcontract.RoleRequester)},
"uninstall gateway": {uninstallOptions, runUninstall(hostcontract.RoleGateway)},
"uninstall bidder": {uninstallOptions, runUninstall(hostcontract.RoleBidder)},
"uninstall requester": {uninstallOptions, runUninstall(hostcontract.RoleRequester)},
"upgrade": {upgradeOptions, runUpgrade},
"rollback": {[]string{"state-dir", "root"}, runRollback},
"units list": {[]string{backendOpt, "instance", "state-dir", "asset-cache", "json"}, runUnitsList},
"units audit": {[]string{backendOpt, "instance", "state-dir", "asset-cache", "json"}, runUnitsAudit},
"units roll kcp": {[]string{backendOpt, "state-dir", "handle", "kcp-path", "kine-path", "planned-outage", "ready-timeout", "unit-prefix", "store-backup-keep", "store-backup-keep-days"}, runUnitsRollKcp},
"units roll cluster": {[]string{"cluster-state-dir", "k3s-path", "kine-path", "idle-bound", "ready-timeout"}, runUnitsRoll("cluster")},
"units roll link": {[]string{"cluster-state-dir", "service", "dumbpipe-path", "ready-timeout"}, runUnitsRoll("link")},
"internal ns-exec": {[]string{"private-hostname", "bind", "inside"}, runNsExec},
"internal iroh-dial": {[]string{"socket", "dumbpipe-path"}, runIrohDial},
"internal deno-fence": {nil, runDenoFence},
"internal association": {nil, runInternalAssociation},
"identity agent-of add": {identityAgentOfOptions, runIdentityAgentOf(true)},
"identity agent-of remove": {identityAgentOfOptions, runIdentityAgentOf(false)},
"identity tombstone": {identityTombstoneOptions, runIdentityTombstone},
"internal ingress-relay": {ingressRelayOptions, runIngressRelay},
"internal atproto-relay": {atprotoRelayOptions, runAtprotoRelay},
"internal devsup": {[]string{"state", "socket", "die-with", "instance"}, runDevsup},
"internal dev-core": {[]string{"instance-dir", "ready-timeout"}, runDevCore},
"internal hostprocesses": {[]string{backendOpt, "instance", "state-dir", "kcp-kubeconfig", "kcp-base-workspace", "bao-path"}, runHostProcesses},
"dev roll kcp": {[]string{"instance", "state-dir", "ready-timeout", "store-backup-keep", "store-backup-keep-days"}, runDevRoll},
"internal vm start": {vmOptions, runVM("start")},
"internal vm inspect": {vmOptions, runVM("inspect")},
"internal vm stop": {vmOptions, runVM("stop")},
"internal vm list": {vmOptions, runVM("list")},
"serve gateway kcp": {serveGatewayOptions, runServeGatewayKcp},
"internal apiserver-front": {[]string{"owner", "kcp-front-address", "front-control", "front-state", "front-fd-store"},
runApiserverFront},
}
maps.Copy(verbs, releaseBuiltVerbs())
return verbs
}
var verbApps = map[string]string{
"run request": marketrequester.RequesterApp,
"run requester": marketrequester.RequesterApp,
"install requester": marketrequester.RequesterApp,
"run bidder": marketbidder.BidderApp,
"run gateway ssh": sshgateway.SshGatewayApp,
}
type foldedVerb struct {
prefix []string
main func(context.Context, foldmain.Invocation) int
}
func foldedVerbs() map[string]foldedVerb {
verbs := map[string]foldedVerb{
"serve gateway xrpc": {nil, gatewaymain.Main},
"serve provider": {nil, providermain.Main},
"migrate": {[]string{"migrate"}, providermain.Main},
"vault apply-root": {[]string{"apply-root"}, vaultmain.Main},
"check-host": {nil, checkhostmain.Main},
"internal cloud-controller-manager": {nil, ccmmain.Main},
"internal tenantcredential": {nil, tenantcredentialmain.Main},
}
maps.Copy(verbs, devFoldedVerbs())
return verbs
}
func main() {
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
code := run(ctx, os.Args[1:], clicfg.OSEnv{}, os.Stdout, os.Stderr, runtime.GOOS, runtime.GOARCH)
stop()
os.Exit(code)
}
func run(ctx context.Context, args []string, env clicfg.Env, stdout, stderr io.Writer, goos, goarch string) int {
spec, err := clicfg.Load()
if err != nil {
fmt.Fprintln(stderr, err)
return exitFailed
}
config, err := clicfg.ConfigFile(env)
if err != nil {
fmt.Fprintln(stderr, err)
return exitRefused
}
a := &app{env: env, stdout: stdout, stderr: stderr, spec: spec, config: config, goos: goos, goarch: goarch,
log: slog.New(logx.NewTee(slog.NewJSONHandler(stderr, nil))).With("service", serviceName)}
if err := assets.Ready(); err != nil {
fmt.Fprintf(stderr, "%s: %v\n", serviceName, err)
return exitRefused
}
if len(args) == 0 || args[0] == "help" || args[0] == "--help" || args[0] == "-h" {
a.usage(stdout, "")
if len(args) == 0 {
return exitRefused
}
return exitOK
}
verb, rest, ok := capabilities.Find(args)
if !ok {
group := strings.Join(args, " ")
if capabilities.Groups()[args[0]] {
a.usage(stderr, args[0])
return exitRefused
}
fmt.Fprintf(stderr, "%s: unknown subcommand %q\n", serviceName, group)
a.usage(stderr, "")
return exitRefused
}
if why, missing := capabilities.Missing(verb, goos, goarch); missing {
fmt.Fprintln(stderr, why)
return exitRefused
}
if f, ok := foldedVerbs()[verb.Path]; ok {
return a.runFolded(ctx, verb, f, rest)
}
if verb.Path == parseArgsVerb {
return a.parseArgs(rest)
}
p, code, done := a.parseVerb(verb, rest)
if done {
return code
}
built, isBuilt, vals, rest := p.built, p.isBuilt, p.vals, p.rest
for _, n := range verb.Needs {
if n != capabilities.NeedHostBackend {
continue
}
if err := spec.Require(vals, backendOpt); err != nil {
fmt.Fprintf(stderr, "%s: %v: this verb places host processes and never probes for a backend (systemd-user | proc)\n", verb.Path, err)
return exitRefused
}
if _, err := hostsvc.ParseBackend(vals.String(backendOpt)); err != nil {
fmt.Fprintf(stderr, "%s: %v\n", verb.Path, err)
return exitRefused
}
}
if !isBuilt {
fmt.Fprintf(stderr, "%s: not built yet; built by %s\n", verb.Path, verb.BuiltBy)
return exitRefused
}
return built.run(ctx, a, vals, rest)
}
type parsedVerb struct {
built builtVerb
isBuilt bool
vals clicfg.Values
rest []string
}
func (a *app) parseVerb(verb capabilities.Verb, rest []string) (parsedVerb, int, bool) {
built, isBuilt := builtVerbs()[verb.Path]
names := built.options
if !isBuilt {
names = nil
for _, n := range verb.Needs {
if n == capabilities.NeedHostBackend {
names = append(names, backendOpt)
}
}
}
argv := flagsFirst(a.spec, rest)
app := verbApps[verb.Path]
if isBuilt && (app != "" || takesCommand(names)) {
var err error
if argv, a.args, err = splitVerbArgs(a.spec, verb.Path, names, app, rest); err != nil {
fmt.Fprintln(a.stderr, err)
return parsedVerb{}, exitRefused, true
}
}
vals, rest, err := a.spec.Resolve(verb.Path, names, argv, a.env, a.config, a.stderr)
if errors.Is(err, flag.ErrHelp) {
printVerbUsage(a.stderr, verb.Path, names, a.args, app)
return parsedVerb{}, exitOK, true
}
if err != nil {
fmt.Fprintln(a.stderr, err)
return parsedVerb{}, exitRefused, true
}
if err := checkCommand(verb.Path, names, vals, a.args); err != nil {
fmt.Fprintln(a.stderr, err)
return parsedVerb{}, exitRefused, true
}
return parsedVerb{built: built, isBuilt: isBuilt, vals: vals, rest: rest}, exitOK, false
}
func (a *app) runFolded(ctx context.Context, verb capabilities.Verb, f foldedVerb, rest []string) int {
exe, err := foldmain.ResolveExe()
if err != nil {
fmt.Fprintf(a.stderr, "%s: resolving this binary's own path: %v\n", verb.Path, err)
return exitFailed
}
return f.main(ctx, foldmain.Invocation{
Args: append(append([]string(nil), f.prefix...), rest...),
Getenv: func(k string) string {
v, _ := a.env.LookupEnv(k)
return v
},
Stdout: a.stdout, Stderr: a.stderr, Exe: exe, Verb: verb.Words(),
})
}
func flagsFirst(spec clicfg.Spec, args []string) []string {
var flags, words []string
for i := 0; i < len(args); i++ {
arg := args[i]
if arg == "--" {
words = append(words, args[i:]...)
break
}
if !strings.HasPrefix(arg, "-") || arg == "-" {
words = append(words, arg)
continue
}
flags = append(flags, arg)
name := strings.TrimLeft(arg, "-")
if strings.Contains(name, "=") {
continue
}
if o, ok := spec.Options[name]; ok && o.Type != clicfg.TypeBoolean && o.Bare == "" && i+1 < len(args) {
i++
flags = append(flags, args[i])
}
}
return append(flags, words...)
}
func (a *app) usage(w io.Writer, group string) {
fmt.Fprintf(w, "usage: %s <subcommand> [options] (%s/%s)\n\n", serviceName, a.goos, a.goarch)
verbs := capabilities.Tree()
sort.SliceStable(verbs, func(i, j int) bool { return verbs[i].Path < verbs[j].Path })
for _, v := range verbs {
if group != "" && !strings.HasPrefix(v.Path, group+" ") {
continue
}
var marks []string
if why, missing := capabilities.Missing(v, a.goos, a.goarch); missing {
marks = append(marks, "no backend here: "+why[len(v.Path)+2:])
}
if !v.Built() {
marks = append(marks, "not built: "+v.BuiltBy)
}
mark := ""
if len(marks) > 0 {
mark = " [" + strings.Join(marks, "; ") + "]"
}
fmt.Fprintf(w, " %-34s %s%s\n", v.Path, v.Summary, mark)
}
fmt.Fprintf(w, "\nconfig: flag > env > %s file > default (internal/clicfg/options.json)\n", clicfg.ConfigPathEnv)
}