0
0
package main
import (
"context"
"fmt"
"path/filepath"
"strings"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/internal/app/compose"
"github.com/johnandersen777/socialweb-computer-kcp/internal/app/marketnetwork"
"github.com/johnandersen777/socialweb-computer-kcp/internal/bootstrap"
"github.com/johnandersen777/socialweb-computer-kcp/internal/clicfg"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/manifests"
"github.com/johnandersen777/socialweb-computer-kcp/internal/devinstance"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/fsx"
"github.com/johnandersen777/socialweb-computer-kcp/internal/stack/componentcore"
)
type componentTarget struct {
App string
Instance string
Kubeconfig string
Base string
Workspaces []string
Kind string
Name string
}
type componentRestartReport struct {
Instance string `json:"instance"`
App string `json:"app,omitempty"`
Workspace string `json:"workspace"`
Kind string `json:"kind"`
Name string `json:"name"`
Request string `json:"request"`
Before componentcore.RestartStatus `json:"before"`
After componentcore.RestartStatus `json:"after"`
Seconds float64 `json:"seconds"`
}
func canonicalComponentKind(name string) (string, bool) {
for _, kind := range compose.ComponentTypes {
if strings.EqualFold(kind.Kind, name) {
return kind.Kind, true
}
}
return "", false
}
func workspaceName(base, workspace string) string {
workspace = strings.TrimSpace(workspace)
if workspace == "" {
return base
}
if workspace != "root" && !strings.HasPrefix(workspace, "root:") {
workspace = "root:" + workspace
}
return manifests.Rebase(base, workspace)
}
func (a *app) resolveComponentTarget(ctx context.Context, l devinstance.Layout, rec devinstance.Record, target string) (componentTarget, error) {
t := componentTarget{Instance: l.ID, Kubeconfig: rec.AdminKubeconfig, Base: baseWorkspace(rec)}
rest := target
if head, tail, ok := strings.Cut(rest, "/"); ok {
if kind, ok := canonicalComponentKind(head); ok && !strings.Contains(tail, "/") {
t.Kind, rest = kind, tail
} else if !strings.Contains(tail, "/") {
t.App, rest = head, tail
} else {
return t, fmt.Errorf("%q is not [<app>/][<workspace>:][<kind>/]<component>", target)
}
}
if strings.Contains(rest, "/") {
return t, fmt.Errorf("%q is not [<app>/][<workspace>:][<kind>/]<component>", target)
}
workspace := ""
if i := strings.LastIndex(rest, ":"); i >= 0 {
workspace, rest = rest[:i], rest[i+1:]
}
t.Name = rest
if t.Name == "" {
return t, fmt.Errorf("%q names no component", target)
}
switch {
case t.App != "":
cl, crec, err := networkChild(ctx, l, rec, t.App)
if err != nil {
return t, err
}
t.Instance, t.Kubeconfig, t.Base = cl.ID, crec.AdminKubeconfig, baseWorkspace(crec)
default:
t.Workspaces = networkWorkspaces(ctx, rec)
}
if workspace != "" {
t.Workspaces = []string{workspaceName(t.Base, workspace)}
}
if len(t.Workspaces) == 0 {
t.Workspaces = componentcore.AppWorkspaces(t.Base)
}
if t.Kind == compose.ComponentKindPolicyEngine {
return t, fmt.Errorf("the PolicyEngine is the component controller; dev restart core restarts it")
}
if t.Kubeconfig == "" {
return t, fmt.Errorf("instance %s records no admin kubeconfig; dev up first", t.Instance)
}
return t, nil
}
func childLayout(network devinstance.Layout, id string) (devinstance.Layout, error) {
return devinstance.NewLayout(id, filepath.Join(network.StateDir, compose.AppsDir), filepath.Join(network.RuntimeDir, compose.AppsDir))
}
func networkChild(ctx context.Context, l devinstance.Layout, rec devinstance.Record, app string) (devinstance.Layout, devinstance.Record, error) {
if rec.Profile != bootstrap.ProfileMarketNetwork || rec.AdminKubeconfig == "" {
return l, rec, fmt.Errorf("instance %s is not a market network; it has no child application %s", l.ID, app)
}
n, err := marketnetwork.ReadNetwork(ctx, rec.AdminKubeconfig)
if err != nil {
return l, rec, fmt.Errorf("reading the MarketNetwork of %s: %w", l.ID, err)
}
var names []string
for _, ap := range n.Status.Apps {
names = append(names, ap.Name)
if ap.Name != app {
continue
}
if ap.Instance == "" {
return l, rec, fmt.Errorf("network child %s has no instance yet (phase %s)", app, ap.Phase)
}
cl, err := childLayout(l, ap.Instance)
if err != nil {
return l, rec, err
}
var crec devinstance.Record
if err := fsx.ReadJSON(cl.Record, &crec); err != nil {
return l, rec, fmt.Errorf("network child %s (instance %s) has no record: %w", app, ap.Instance, err)
}
return cl, crec, nil
}
return l, rec, fmt.Errorf("market network %s has no child application %s (it has: %s)", l.ID, app, strings.Join(names, ", "))
}
func findNetworkChild(root, id string) (devinstance.Layout, devinstance.Record, bool) {
recs, err := devinstance.List(root)
if err != nil {
return devinstance.Layout{}, devinstance.Record{}, false
}
for _, nrec := range recs {
if nrec.Profile != bootstrap.ProfileMarketNetwork {
continue
}
cl, err := childLayout(nrec.Layout, id)
if err != nil {
continue
}
var crec devinstance.Record
if fsx.ReadJSON(cl.Record, &crec) == nil {
return cl, crec, true
}
}
return devinstance.Layout{}, devinstance.Record{}, false
}
func networkWorkspaces(ctx context.Context, rec devinstance.Record) []string {
if rec.Profile != bootstrap.ProfileMarketNetwork || rec.AdminKubeconfig == "" {
return nil
}
n, err := marketnetwork.ReadNetwork(ctx, rec.AdminKubeconfig)
if err != nil {
return nil
}
var out []string
seen := map[string]bool{}
add := func(workspace string) {
if workspace == "" || seen[workspace] {
return
}
seen[workspace] = true
out = append(out, workspace)
}
for _, workspace := range componentcore.NetworkWorkspaces(baseWorkspace(rec)) {
add(workspace)
}
for _, c := range n.Status.Components {
add(c.Workspace)
}
for _, app := range n.Status.Apps {
if app.Workspace != "" {
add(app.Workspace)
add(app.Workspace + ":" + componentcore.ComponentWorkspace)
}
}
return out
}
func runDevRestartComponent(ctx context.Context, a *app, vals clicfg.Values, target string) int {
started := time.Now()
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.record("dev restart", vals)
if code != exitOK {
return code
}
t, err := a.resolveComponentTarget(ctx, l, rec, target)
if err != nil {
return a.fail(exitRefused, "dev restart: %v", err)
}
factory, err := componentcore.NewDynamicFactory(t.Kubeconfig)
if err != nil {
return a.fail(exitFailed, "dev restart: %v", err)
}
refs, err := componentcore.FindComponents(ctx, factory, t.Workspaces, t.Kind, t.Name)
if err != nil {
return a.fail(exitFailed, "dev restart: %v", err)
}
switch len(refs) {
case 0:
available := componentcore.DescribeComponents(ctx, factory, t.Workspaces)
if len(available) == 0 {
return a.fail(exitRefused, "dev restart: no component %s in %s of instance %s", t.Name, strings.Join(t.Workspaces, ", "), t.Instance)
}
return a.fail(exitRefused, "dev restart: no component %s in %s of instance %s (it has: %s)", t.Name,
strings.Join(t.Workspaces, ", "), t.Instance, strings.Join(available, ", "))
case 1:
default:
var names []string
for _, ref := range refs {
names = append(names, ref.Workspace+":"+ref.Kind+"/"+ref.Name)
}
return a.fail(exitRefused, "dev restart: %s names %d components (%s); name it as <workspace>:<kind>/<component>",
t.Name, len(refs), strings.Join(names, ", "))
}
ref := refs[0]
before, err := componentcore.ReadStatus(ctx, factory, ref)
if err != nil {
return a.fail(exitFailed, "dev restart: %v", err)
}
stamp, err := componentcore.Restart(ctx, factory, ref)
if err != nil {
return a.fail(exitFailed, "dev restart: %v", err)
}
after, err := componentcore.WaitRestarted(ctx, factory, ref, stamp, before, readyTimeout)
r := componentRestartReport{Instance: t.Instance, App: t.App, Workspace: ref.Workspace, Kind: ref.Kind, Name: ref.Name,
Request: stamp, Before: before, After: after, Seconds: time.Since(started).Seconds()}
a.printJSON(r)
if err != nil {
return a.fail(exitFailed, "dev restart: %v", err)
}
return exitOK
}