0
0
package main
import (
"cmp"
"context"
"errors"
"fmt"
"maps"
"os"
"path/filepath"
"strings"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/app/compose"
appgateway "github.com/johnandersen777/socialweb-computer-kcp/internal/app/gateway"
"github.com/johnandersen777/socialweb-computer-kcp/internal/app/marketnetwork"
"github.com/johnandersen777/socialweb-computer-kcp/internal/assets"
"github.com/johnandersen777/socialweb-computer-kcp/internal/buildstamp"
"github.com/johnandersen777/socialweb-computer-kcp/internal/clicfg"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/clusterhome"
"github.com/johnandersen777/socialweb-computer-kcp/internal/devinstance"
"github.com/johnandersen777/socialweb-computer-kcp/internal/hostcontract"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/fsx"
"github.com/johnandersen777/socialweb-computer-kcp/internal/stack/gatewaykcp"
"github.com/johnandersen777/socialweb-computer-kcp/internal/stack/request"
)
var requesterGatewayOptions = []string{"name", "state-dir", "ready-file", "cluster", "network-timeout", "log-level"}
var requesterGatewayAssets = []string{gatewaykcp.ExeK3s, gatewaykcp.ExeExternalSecrets, gatewaykcp.ExeESOBundle, gatewaykcp.ExeWebDownloads,
gatewaykcp.ExeDumbpipe, gatewaykcp.ExeKine, gatewaykcp.ExeBao}
func (r *requesterRun) gatewayPreflight(vals clicfg.Values) (map[string]devinstance.Executable, error) {
results := hostcontract.EvaluateRequesterGateway(hostcontract.GatherRequesterGateway(hostcontract.Options{StateDir: r.dir}))
if failed := hostcontract.Failed(results); len(failed) > 0 {
hostcontract.Write(r.a.stderr, results, false)
return nil, fmt.Errorf("--with-gateway runs k3s and kine in this account's user manager, and the host does not provide what they need: %s (check-host -role gateway names the same fixes)",
strings.Join(failed, ", "))
}
if !assets.Release() {
return nil, errors.New("--with-gateway runs the gateway's embedded k3s and external-secrets: build with scripts/build-socialweb-computer.sh (--dev for a dev build)")
}
cache, err := r.a.assetCache(vals)
if err != nil {
return nil, err
}
out := map[string]devinstance.Executable{}
for _, name := range requesterGatewayAssets {
e, err := assets.Resolve(assets.Options{Cache: cache, Log: r.a.log}, name)
if err != nil {
return nil, fmt.Errorf("--with-gateway: %w", err)
}
out[name] = devinstance.Executable{Path: e.Path, Version: e.Version}
}
return out, nil
}
func (r *requesterRun) instanceRecord() (devinstance.Record, error) {
var rec devinstance.Record
if r.instance != nil {
return *r.instance, nil
}
if r.inv.Mode != request.ModeNetwork {
err := fsx.ReadJSON(r.standalone.Record, &rec)
return rec, err
}
netLayout, _, err := r.networkLayout()
if err != nil {
return rec, err
}
return r.childRecord(netLayout, r.inv.Instance)
}
func (r *requesterRun) startGateway(ctx context.Context, assetExes map[string]devinstance.Executable, did string) (<-chan error, *request.ReadyGateway, error) {
rec, err := r.instanceRecord()
if err != nil {
return nil, nil, fmt.Errorf("the requester's instance record: %w", err)
}
exes := map[string]devinstance.Executable{}
maps.Copy(exes, assetExes)
for name, e := range rec.Executables {
if e.Path != "" {
exes[name] = e
}
}
if exes[gatewaykcp.ExeCore].Path == "" {
exe, err := selfExe()
if err != nil {
return nil, nil, err
}
exes[gatewaykcp.ExeCore] = devinstance.Executable{Path: exe}
}
spec := gatewaykcp.RequesterSpec(v1alpha1.GatewaySpec{}, request.RootName, exes[gatewaykcp.ExeWebDownloads].Path, r.nodeDownloadBase())
cfg := gatewaykcp.Config{Backend: rec.Backend, Executables: exes, Spec: spec, RootName: appgateway.GatewayRootName, Environ: os.Environ(),
Exe: exes[gatewaykcp.ExeCore].Path, Stderr: r.a.stderr, Log: r.a.log}
ws := cmp.Or(strings.TrimSpace(rec.BaseWorkspace), r.workspace, "root")
applied := make(chan struct{})
errc := make(chan error, 1)
go func() { errc <- gatewaykcp.RunRequester(ctx, cfg, rec, did, func() { close(applied) }) }()
select {
case err := <-errc:
return nil, nil, fmt.Errorf("the gateway did not start: %w", err)
case <-applied:
case <-ctx.Done():
return nil, nil, ctx.Err()
}
r.log("the Gateway root (profile requester) is applied; its clusterprovider runs in this process", "workspace", ws, "root", appgateway.GatewayRootName)
wctx, cancel := context.WithCancel(ctx)
defer cancel()
waited := make(chan error, 1)
go func() {
_, err := gatewaykcp.WaitRequesterGateway(wctx, rec.AdminKubeconfig, ws, appgateway.GatewayRootName, r.networkTimeout, func(st v1alpha1.ApplicationStatus) {
r.log("gateway", "phase", string(st.Phase), "message", st.Message)
})
waited <- err
}()
select {
case err := <-errc:
return nil, nil, fmt.Errorf("the gateway's clusterprovider ended: %w", err)
case err := <-waited:
if err != nil {
return nil, nil, err
}
}
return errc, &request.ReadyGateway{Workspace: ws, Name: appgateway.GatewayRootName, Clusters: appgateway.ClusterStateDir(rec.Layout.StateDir)}, nil
}
func runRequesterKubeconfig(ctx context.Context, a *app, vals clicfg.Values, rest []string) int {
ready, _, _, code := readRequesterReady(a, vals, rest, "kubeconfig")
if code != exitOK {
return code
}
cluster := strings.TrimSpace(vals.String("cluster"))
if cluster == "" {
return a.fail(exitRefused, "run requester kubeconfig: --cluster names the tenant cluster")
}
if ready.Gateway == nil {
return a.fail(exitRefused, "run requester kubeconfig: the requester %s runs no gateway (start it with --with-gateway)", ready.Name)
}
path, err := gatewaykcp.TenantAdminKubeconfig(ready.Gateway.Clusters, ready.Did, cluster)
if err != nil {
return a.fail(exitRefused, "run requester kubeconfig: %v", err)
}
if !fsx.Exists(path) {
return a.fail(exitFailed, "run requester kubeconfig: the cluster %s has no admin kubeconfig yet (%s); kubectl get clusters.socialweb.computer in its home workspace shows its phase", cluster, path)
}
timeout, err := time.ParseDuration(vals.String("network-timeout"))
if err != nil {
return a.fail(exitRefused, "run requester kubeconfig: network-timeout: %v", err)
}
cctx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
phase, err := gatewaykcp.RequesterClusterPhase(cctx, ready.Kubeconfig, ready.Did, cluster)
if err != nil {
return a.fail(exitFailed, "run requester kubeconfig: the cluster %s: %v", cluster, err)
}
if phase != v1alpha1.ClusterReady {
return a.fail(exitFailed, "run requester kubeconfig: the cluster %s is %s, not Ready yet (its home workspace %s)", cluster, cmp.Or(string(phase), "without a phase"), clusterhome.HomePath(ready.Did, cluster))
}
fmt.Fprintln(a.stdout, path)
return exitOK
}
func runRequesterCluster(ctx context.Context, a *app, vals clicfg.Values, rest []string) int {
ready, _, _, code := readRequesterReady(a, vals, rest, "cluster")
if code != exitOK {
return code
}
cluster := strings.TrimSpace(vals.String("cluster"))
if cluster == "" {
return a.fail(exitRefused, "run requester cluster: --cluster names the tenant cluster")
}
if ready.Gateway == nil {
return a.fail(exitRefused, "run requester cluster: the requester %s runs no gateway (start it with --with-gateway)", ready.Name)
}
if ready.Did == "" {
return a.fail(exitFailed, "run requester cluster: the ready file names no did yet")
}
timeout, err := time.ParseDuration(vals.String("network-timeout"))
if err != nil {
return a.fail(exitRefused, "run requester cluster: network-timeout: %v", err)
}
cctx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
home, err := gatewaykcp.RequesterCluster(cctx, ready.Kubeconfig, ready.Gateway.Workspace, ready.Did, cluster, a.log)
if err != nil {
return a.fail(exitFailed, "run requester cluster: %v", err)
}
a.printJSON(map[string]string{"cluster": cluster, "account": ready.Did, "home": home,
"kubeconfig": "run requester kubeconfig " + ready.Name + " --cluster " + cluster})
return exitOK
}
func requesterGatewayMarker(l devinstance.Layout) string {
return filepath.Join(l.StateDir, gatewaykcp.RequesterGatewayDir)
}
func (a *app) requesterGatewayOutbound(ctx context.Context, rec devinstance.Record) (func(), error) {
if rec.Gateway != nil || rec.SharedKcp == "" || rec.AdminKubeconfig == "" || !fsx.Exists(requesterGatewayMarker(rec.Layout)) {
return func() {}, nil
}
if err := os.MkdirAll(rec.Layout.KcpDir(), 0o700); err != nil {
return nil, err
}
n, err := marketnetwork.ReadNetwork(ctx, rec.AdminKubeconfig)
if err != nil {
return nil, err
}
_, stop, err := gatewaykcp.NetworkOutbound(ctx, n.Status.Network, filepath.Join(requesterGatewayMarker(rec.Layout), "tls"),
gatewaykcp.RequesterEgressRecord(rec.Layout), a.log)
return stop, err
}
func (r *requesterRun) markGateway(ctx context.Context) error {
if r.inv.Mode != request.ModeNetwork {
return nil
}
netLayout, netRec, err := r.networkLayout()
if err != nil {
return err
}
n, err := marketnetwork.ReadNetwork(ctx, netRec.AdminKubeconfig)
if err != nil {
return err
}
for _, app := range n.Spec.Apps {
if app.Kind == v1alpha1.ApplicationKindGateway {
return fmt.Errorf("--with-gateway: the market network %s has the gateway child %s, whose clusterprovider serves every Cluster of the network's kcp; bring the network up without --with-gateway",
r.inv.Network, app.Name)
}
}
cl, err := devinstance.NewLayout(netLayout.ID+"-"+r.inv.Name, filepath.Join(netLayout.StateDir, compose.AppsDir), filepath.Join(netLayout.RuntimeDir, compose.AppsDir))
if err != nil {
return err
}
return os.MkdirAll(requesterGatewayMarker(cl), 0o700)
}
func (r *requesterRun) nodeDownloadBase() string {
base := strings.TrimRight(strings.TrimSpace(r.vals.String("node-download-base")), "/")
if r.inv.Mode == request.ModeNetwork && buildstamp.Dev() && r.vals.Source("node-download-base") == clicfg.SourceDefault {
return ""
}
return base
}