0
0
package main
import (
"context"
"encoding/json"
"fmt"
"os"
"path"
"sort"
"strings"
"time"
"k8s.io/client-go/rest"
"sigs.k8s.io/yaml"
"github.com/johnandersen777/socialweb-computer-kcp/internal/clicfg"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kcpapply"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/manifests"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kcpserver"
)
var (
applyOptions = []string{"set", "values", "phase", "dry-run", "wait-timeout", "instance", "state-dir", "kcp-kubeconfig"}
renderOptions = []string{"set", "values", "phase"}
)
type listedSet struct {
Name string `json:"name"`
Summary string `json:"summary"`
Values string `json:"values"`
Phases []string `json:"phases"`
Workspaces []string `json:"workspaces"`
Files int `json:"files"`
}
type listing struct {
Sets []listedSet `json:"sets"`
Unapplied []manifests.Unapplied `json:"unapplied"`
}
func runManifestsList(ctx context.Context, a *app, vals clicfg.Values, rest []string) int {
ix, err := manifests.Load()
if err != nil {
return a.fail(exitFailed, "manifests list: %v", err)
}
out := listing{Unapplied: ix.Unapplied}
for _, s := range ix.Sets {
ls := listedSet{Name: s.Name, Summary: s.Summary, Values: s.Values}
seen := map[string]bool{}
for _, p := range s.Phases {
ls.Phases = append(ls.Phases, p.Name)
ls.Files += len(p.Files)
if !seen[p.Workspace] {
seen[p.Workspace] = true
ls.Workspaces = append(ls.Workspaces, p.Workspace)
}
}
out.Sets = append(out.Sets, ls)
}
if vals.Bool("json") {
a.printJSON(out)
return exitOK
}
for _, s := range out.Sets {
fmt.Fprintf(a.stdout, "%-22s values=%-20s phases=%-2d files=%-2d %s\n", s.Name, s.Values, len(s.Phases), s.Files, s.Summary)
fmt.Fprintf(a.stdout, "%-22s %s\n", "", strings.Join(s.Phases, " -> "))
}
fmt.Fprintln(a.stdout)
for _, u := range out.Unapplied {
fmt.Fprintf(a.stdout, "unapplied %-30s %s\n", u.Path, u.Why)
}
return exitOK
}
func selectSets(vals clicfg.Values) ([]manifests.Set, map[string]any, error) {
ix, err := manifests.Load()
if err != nil {
return nil, nil, err
}
names := strings.Split(vals.String("set"), ",")
if vals.String("set") == "" {
return nil, nil, fmt.Errorf("--set names no set; one of %s", strings.Join(ix.Names(), ", "))
}
raw := map[string]json.RawMessage{}
if p := vals.String("values"); p != "" {
b, err := os.ReadFile(p)
if err != nil {
return nil, nil, err
}
if err := yaml.Unmarshal(b, &raw); err != nil {
return nil, nil, fmt.Errorf("%s: %w", p, err)
}
}
var sets []manifests.Set
values := map[string]any{}
for _, n := range names {
s, ok := ix.Set(strings.TrimSpace(n))
if !ok {
return nil, nil, fmt.Errorf("no set %q; one of %s", n, strings.Join(ix.Names(), ", "))
}
v, err := manifests.DecodeValues(s.Values, raw[s.Name])
if err != nil {
return nil, nil, err
}
delete(raw, s.Name)
if sel := vals.String("phase"); sel != "" {
only, err := selectPhases(s, sel)
if err != nil {
return nil, nil, err
}
s.Phases = only
}
sets = append(sets, s)
values[s.Name] = v
}
if len(raw) > 0 {
var extra []string
for k := range raw {
extra = append(extra, k)
}
sort.Strings(extra)
return nil, nil, fmt.Errorf("the values file names %v, which --set does not apply", extra)
}
return sets, values, nil
}
func selectPhases(s manifests.Set, sel string) ([]manifests.Phase, error) {
index := map[string]int{}
for i, p := range s.Phases {
index[p.Name] = i
}
pick := make([]bool, len(s.Phases))
for item := range strings.SplitSeq(sel, ",") {
from, to, isRange := strings.Cut(strings.TrimSpace(item), "..")
if !isRange {
to = from
}
i, ok := index[from]
j, ok2 := index[to]
if !ok || !ok2 || j < i {
return nil, fmt.Errorf("set %s has no phase or ordered phase range %q (phases %v)", s.Name, item, phaseNames(s))
}
for k := i; k <= j; k++ {
pick[k] = true
}
}
var out []manifests.Phase
for i, p := range s.Phases {
if pick[i] {
out = append(out, p)
}
}
return out, nil
}
func phaseNames(s manifests.Set) []string {
out := make([]string, 0, len(s.Phases))
for _, p := range s.Phases {
out = append(out, p.Name)
}
return out
}
func runManifestsRender(ctx context.Context, a *app, vals clicfg.Values, rest []string) int {
sets, values, err := selectSets(vals)
if err != nil {
return a.fail(exitRefused, "manifests render: %v", err)
}
for _, s := range sets {
for _, p := range s.Phases {
ws, texts, err := s.RenderText(p, values[s.Name])
if err == nil {
_, err = s.RenderPhase(p, values[s.Name])
}
if err != nil {
return a.fail(exitFailed, "manifests render: set %s phase %s: %v", s.Name, p.Name, err)
}
for _, tx := range texts {
fmt.Fprintf(a.stdout, "--- # set=%s phase=%s workspace=%s file=%s\n", s.Name, p.Name, ws, path.Clean(tx.Path))
a.stdout.Write(tx.Body)
}
}
}
return exitOK
}
func (a *app) applyConfig(vals clicfg.Values) (*rest.Config, error) {
kubeconfig := vals.String("kcp-kubeconfig")
if kubeconfig == "" {
_, rec, code := a.record("apply", vals)
if code != exitOK {
return nil, fmt.Errorf("no --kcp-kubeconfig and no dev instance record")
}
kubeconfig = rec.AdminKubeconfig
}
return kcpserver.FrontRestConfig(kubeconfig)
}
func runApply(ctx context.Context, a *app, vals clicfg.Values, rest []string) int {
if len(rest) > 0 {
return a.fail(exitRefused, "apply: unexpected arguments %v; name sets with --set", rest)
}
sets, values, err := selectSets(vals)
if err != nil {
return a.fail(exitRefused, "apply: %v", err)
}
timeout, err := time.ParseDuration(vals.String("wait-timeout"))
if err != nil {
return a.fail(exitRefused, "apply: --wait-timeout: %v", err)
}
cfg, err := a.applyConfig(vals)
if err != nil {
return a.fail(exitRefused, "apply: %v", err)
}
ap, err := kcpapply.New(cfg, kcpapply.Options{DryRun: vals.Bool("dry-run"), WaitTimeout: timeout, Log: a.log})
if err != nil {
return a.fail(exitFailed, "apply: %v", err)
}
all := kcpapply.Report{DryRun: vals.Bool("dry-run"), Phases: []kcpapply.PhaseReport{}}
for _, s := range sets {
r, err := ap.Apply(ctx, s, values[s.Name])
all.Phases = append(all.Phases, r.Phases...)
if err != nil {
a.printJSON(all)
return a.fail(exitFailed, "apply: %v", err)
}
}
a.printJSON(all)
return exitOK
}
func readSpecFile[T any](path string) (T, error) {
var s T
b, err := os.ReadFile(path)
if err != nil {
return s, err
}
if err := yaml.UnmarshalStrict(b, &s); err != nil {
return s, fmt.Errorf("%s: %w", path, err)
}
return s, nil
}