0
0
package kcpapply
import (
"cmp"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"log/slog"
"maps"
"net/http"
"net/url"
"reflect"
"sort"
"strings"
"sync"
"time"
tenancyv1alpha1 "github.com/kcp-dev/sdk/apis/tenancy/v1alpha1"
authenticationv1 "k8s.io/api/authentication/v1"
apierrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/wait"
"k8s.io/apimachinery/pkg/watch"
"k8s.io/client-go/dynamic"
"k8s.io/client-go/rest"
"k8s.io/client-go/tools/cache"
watchtools "k8s.io/client-go/tools/watch"
"github.com/johnandersen777/socialweb-computer-kcp/api/kcpgvr"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kube"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/manifests"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/opt"
)
const (
FieldManager = "socialweb-computer"
DefaultWaitTimeout = time.Minute
DefaultPoll = time.Second
FirstPoll = 50 * time.Millisecond
defaultNamespace = "default"
schemaKind = "APIResourceSchema"
)
var (
ErrSchemaChanged = errors.New("kcpapply: an APIResourceSchema is immutable and its live spec differs; publish a new revision name")
ErrKubectlManaged = errors.New("kcpapply: the object was applied by kubectl and is never adopted; apply into a fresh instance")
ErrWaitTimedOut = errors.New("kcpapply: a wait did not hold before its deadline")
ErrWaitFailed = errors.New("kcpapply: a waited-on object reports a failure, so the wait cannot hold")
)
type Action string
const (
Created Action = "created"
Configured Action = "configured"
Unchanged Action = "unchanged"
)
type Options struct {
DryRun bool
WaitTimeout time.Duration
Poll time.Duration
FieldManager string
Base string
Labels map[string]string
Log *slog.Logger
}
func (a *Applier) fieldManager() string {
if a.opts.FieldManager != "" {
return a.opts.FieldManager
}
return FieldManager
}
type FieldChange struct {
Field string `json:"field"`
From []string `json:"from"`
To []string `json:"to"`
}
type Change struct {
Kind string `json:"kind"`
Namespace string `json:"namespace,omitempty"`
Name string `json:"name"`
Action Action `json:"action"`
Managers []FieldChange `json:"managers,omitempty"`
}
type WaitReport struct {
When string `json:"when"`
Kind string `json:"kind"`
Name string `json:"name,omitempty"`
Workspace string `json:"workspace"`
For string `json:"for"`
Met bool `json:"met"`
Captured string `json:"captured,omitempty"`
Seconds float64 `json:"seconds"`
}
type PhaseReport struct {
Set string `json:"set"`
Phase string `json:"phase"`
Workspace string `json:"workspace"`
Changes []Change `json:"changes"`
Waits []WaitReport `json:"waits,omitempty"`
}
type Report struct {
DryRun bool `json:"dryRun"`
Phases []PhaseReport `json:"phases"`
}
func (r Report) Changed() int {
n := 0
for _, p := range r.Phases {
for _, c := range p.Changes {
if c.Action != Unchanged {
n++
}
}
}
return n
}
type Applier struct {
base *rest.Config
opts Options
ownerMu sync.Mutex
owner string
}
type workspaceOwner struct {
Username string `json:"username"`
Groups []string `json:"groups,omitempty"`
}
func New(cfg *rest.Config, o Options) (*Applier, error) {
if cfg == nil {
return nil, errors.New("kcpapply: no rest.Config")
}
u, err := url.Parse(cfg.Host)
if err != nil || u.Host == "" {
return nil, fmt.Errorf("kcpapply: the rest.Config host %q is no URL", cfg.Host)
}
if i := strings.Index(u.Path, "/clusters/"); i >= 0 {
u.Path = u.Path[:i]
}
u.Path = strings.TrimSuffix(u.Path, "/")
base := rest.CopyConfig(cfg)
base.Host = u.String()
if base.QPS == 0 {
base.QPS, base.Burst = 50, 100
}
o.WaitTimeout = opt.Positive(o.WaitTimeout, DefaultWaitTimeout)
o.Poll = opt.Positive(o.Poll, DefaultPoll)
if o.Log == nil {
o.Log = slog.New(slog.DiscardHandler)
}
return &Applier{base: base, opts: o}, nil
}
func (a *Applier) ForWorkspace(path string) *rest.Config {
c := rest.CopyConfig(a.base)
c.Host = a.base.Host + "/clusters/" + path
return c
}
var (
setLocksMu sync.Mutex
setLocks = map[string]*sync.Mutex{}
)
func setLock(key string) *sync.Mutex {
setLocksMu.Lock()
defer setLocksMu.Unlock()
l, ok := setLocks[key]
if !ok {
l = &sync.Mutex{}
setLocks[key] = l
}
return l
}
func (a *Applier) Apply(ctx context.Context, set manifests.Set, values any) (Report, error) {
set.Base = cmp.Or(set.Base, a.opts.Base)
l := setLock(a.base.Host + "|" + set.Base + "|" + set.Name)
l.Lock()
defer l.Unlock()
rep := Report{DryRun: a.opts.DryRun}
if set.BaseCluster == "" && set.Scope != manifests.ScopeKcp && set.Base != "" && set.Base != "root" {
id, err := a.ClusterOf(ctx, set.Base)
if err != nil {
return rep, fmt.Errorf("kcpapply: set %s: the logical cluster of %s: %w", set.Name, set.Base, err)
}
set.BaseCluster = id
}
for _, p := range set.Phases {
pr, err := a.applyPhase(ctx, set, p, values)
rep.Phases = append(rep.Phases, pr)
if err != nil {
return rep, fmt.Errorf("kcpapply: set %s phase %s: %w", set.Name, p.Name, err)
}
}
return rep, nil
}
func (a *Applier) applyPhase(ctx context.Context, set manifests.Set, p manifests.Phase, values any) (PhaseReport, error) {
pr := PhaseReport{Set: set.Name, Phase: p.Name, Changes: []Change{}}
ws, err := set.Workspace(p, nil, values)
if err != nil {
return pr, err
}
pr.Workspace = ws
for _, w := range p.Before {
wr, err := a.wait(ctx, set, p, w, values, nil, "before")
pr.Waits = append(pr.Waits, wr)
if err != nil {
return pr, err
}
}
r, err := set.RenderPhase(p, values)
if err != nil {
return pr, err
}
if len(r.Objects) > 0 {
changes, err := a.ApplyObjects(ctx, ws, r.Objects)
pr.Changes = append(pr.Changes, changes...)
if err != nil {
return pr, err
}
a.opts.Log.Info("phase applied", "set", set.Name, "phase", p.Name, "workspace", ws, "objects", len(changes))
}
for _, w := range p.After {
wr, err := a.wait(ctx, set, p, w, values, r.Objects, "after")
pr.Waits = append(pr.Waits, wr)
if err != nil {
return pr, err
}
}
return pr, nil
}
func (a *Applier) ClusterOf(ctx context.Context, path string) (string, error) {
i := strings.LastIndex(path, ":")
if i < 0 {
return path, nil
}
dyn, err := dynamic.NewForConfig(a.ForWorkspace(path[:i]))
if err != nil {
return "", err
}
u, err := dyn.Resource(kcpgvr.Workspaces).Get(ctx, path[i+1:], metav1.GetOptions{})
if err != nil {
return "", err
}
id, _, _ := unstructured.NestedString(u.Object, "spec", "cluster")
if id == "" {
return "", fmt.Errorf("the workspace %s names no logical cluster yet", path)
}
return id, nil
}
func (a *Applier) ApplyObjects(ctx context.Context, workspace string, objs []manifests.Object) ([]Change, error) {
cfg := a.ForWorkspace(workspace)
served, err := a.servedFor(ctx, cfg, workspace, objs)
if err != nil {
return nil, err
}
dyn, err := dynamic.NewForConfig(cfg)
if err != nil {
return nil, err
}
var out []Change
for _, o := range objs {
u := o.Unstructured
gvk := u.GroupVersionKind()
m, ok := served[gvk]
if !ok {
return out, fmt.Errorf("%s: %s %s is not served in %s", o.Path, gvk, u.GetName(), workspace)
}
var ri dynamic.ResourceInterface = dyn.Resource(m.resource)
ns := ""
if m.namespaced {
ns = u.GetNamespace()
ns = cmp.Or(ns, defaultNamespace)
ri = dyn.Resource(m.resource).Namespace(ns)
}
c, err := a.applyOne(ctx, ri, u)
c.Namespace = ns
out = append(out, c)
if err != nil {
return out, fmt.Errorf("%s: %s %s in %s: %w", o.Path, gvk.Kind, u.GetName(), workspace, err)
}
}
return out, nil
}
type servedResource struct {
resource schema.GroupVersionResource
namespaced bool
}
func (a *Applier) servedFor(ctx context.Context, cfg *rest.Config, workspace string, objs []manifests.Object) (map[schema.GroupVersionKind]servedResource, error) {
deadline := time.Now().Add(a.opts.WaitTimeout)
for attempt := 1; ; attempt++ {
served, err := discover(ctx, cfg, objs)
if err != nil {
return nil, fmt.Errorf("discovery for %s: %w", workspace, err)
}
var missing *manifests.Object
for i := range objs {
if _, ok := served[objs[i].Unstructured.GroupVersionKind()]; !ok {
missing = &objs[i]
break
}
}
if missing == nil {
return served, nil
}
if !time.Now().Before(deadline) {
return nil, fmt.Errorf("%s: %s %s is not served in %s after %s", missing.Path,
missing.Unstructured.GroupVersionKind(), missing.Unstructured.GetName(), workspace, a.opts.WaitTimeout)
}
a.opts.Log.Info("waiting for every object to be served", "workspace", workspace, "attempt", attempt,
"path", missing.Path, "kind", missing.Unstructured.GroupVersionKind().String(), "deadline", a.opts.WaitTimeout.String())
select {
case <-ctx.Done():
return nil, ctx.Err()
case <-time.After(min(FirstPoll<<min(attempt-1, 10), a.opts.Poll)):
}
}
}
func discover(ctx context.Context, cfg *rest.Config, objs []manifests.Object) (map[schema.GroupVersionKind]servedResource, error) {
hc, err := rest.HTTPClientFor(cfg)
if err != nil {
return nil, err
}
out := map[schema.GroupVersionKind]servedResource{}
fetched := map[schema.GroupVersion]bool{}
for _, o := range objs {
gv := o.Unstructured.GroupVersionKind().GroupVersion()
if fetched[gv] {
continue
}
fetched[gv] = true
path := "/apis/" + gv.Group + "/" + gv.Version
if gv.Group == "" {
path = "/api/" + gv.Version
}
req, err := http.NewRequestWithContext(ctx, http.MethodGet, cfg.Host+path, nil)
if err != nil {
return nil, err
}
req.Header.Set("Accept", "application/json")
resp, err := hc.Do(req)
if err != nil {
return nil, err
}
body, err := io.ReadAll(io.LimitReader(resp.Body, 8<<20))
resp.Body.Close()
if err != nil {
return nil, err
}
if resp.StatusCode == http.StatusNotFound {
continue
}
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("GET %s: %s", path, resp.Status)
}
var list metav1.APIResourceList
if err := json.Unmarshal(body, &list); err != nil {
return nil, fmt.Errorf("GET %s: %w", path, err)
}
for _, r := range list.APIResources {
if strings.Contains(r.Name, "/") {
continue
}
out[gv.WithKind(r.Kind)] = servedResource{resource: gv.WithResource(r.Name), namespaced: r.Namespaced}
}
}
return out, nil
}
func (a *Applier) dryRun() []string {
if a.opts.DryRun {
return []string{metav1.DryRunAll}
}
return nil
}
func (a *Applier) applyOne(ctx context.Context, ri dynamic.ResourceInterface, u *unstructured.Unstructured) (Change, error) {
c := Change{Kind: u.GetKind(), Name: u.GetName()}
live, err := ri.Get(ctx, u.GetName(), metav1.GetOptions{})
switch {
case apierrors.IsNotFound(err):
live = nil
case err != nil:
return c, err
}
if live != nil {
if err := refuseKubectl(live); err != nil {
return c, err
}
}
if u.GetKind() == schemaKind {
return a.applySchema(ctx, ri, u, live, c)
}
if live != nil && u.GroupVersionKind().Group == "apis.kcp.io" && u.GetKind() == "APIBinding" &&
covered(u.Object["spec"], live.Object["spec"]) {
c.Action = Unchanged
return c, nil
}
if len(a.opts.Labels) > 0 {
u = u.DeepCopy()
labels := u.GetLabels()
if labels == nil {
labels = map[string]string{}
}
maps.Copy(labels, a.opts.Labels)
u.SetLabels(labels)
}
if u.GroupVersionKind().Group == tenancyv1alpha1.SchemeGroupVersion.Group && u.GetKind() == "Workspace" {
stamped, err := a.stampOwner(ctx, u, live)
if err != nil {
return c, err
}
u = stamped
}
body, err := json.Marshal(u.Object)
if err != nil {
return c, err
}
force := true
got, err := ri.Patch(ctx, u.GetName(), types.ApplyPatchType, body,
metav1.PatchOptions{FieldManager: a.fieldManager(), Force: &force, DryRun: a.dryRun()})
if err != nil {
return c, err
}
c.Managers = managerChanges(live, got)
switch {
case live == nil:
c.Action = Created
case len(c.Managers) == 0 && sameContent(live, got):
c.Action = Unchanged
default:
c.Action = Configured
}
return c, nil
}
func (a *Applier) stampOwner(ctx context.Context, u, live *unstructured.Unstructured) (*unstructured.Unstructured, error) {
if _, set := u.GetAnnotations()[tenancyv1alpha1.ExperimentalWorkspaceOwnerAnnotationKey]; set {
return u, nil
}
var owner string
if live != nil {
var held bool
if owner, held = live.GetAnnotations()[tenancyv1alpha1.ExperimentalWorkspaceOwnerAnnotationKey]; !held {
return u, nil
}
} else {
var err error
if owner, err = a.workspaceOwner(ctx); err != nil {
return nil, err
}
}
out := u.DeepCopy()
ann := out.GetAnnotations()
if ann == nil {
ann = map[string]string{}
}
ann[tenancyv1alpha1.ExperimentalWorkspaceOwnerAnnotationKey] = owner
out.SetAnnotations(ann)
return out, nil
}
func (a *Applier) workspaceOwner(ctx context.Context) (string, error) {
a.ownerMu.Lock()
defer a.ownerMu.Unlock()
if a.owner == "" {
dyn, err := dynamic.NewForConfig(a.ForWorkspace("root"))
if err != nil {
return "", err
}
review := &unstructured.Unstructured{Object: map[string]any{"apiVersion": "authentication.k8s.io/v1", "kind": "SelfSubjectReview"}}
got, err := dyn.Resource(kcpgvr.SelfSubjectReviews).Create(ctx, review, metav1.CreateOptions{})
if err != nil {
return "", fmt.Errorf("reading the applying identity for the workspace owner: %w", err)
}
var r authenticationv1.SelfSubjectReview
if err := runtime.DefaultUnstructuredConverter.FromUnstructured(got.Object, &r); err != nil {
return "", err
}
b, err := json.Marshal(workspaceOwner{Username: r.Status.UserInfo.Username, Groups: r.Status.UserInfo.Groups})
if err != nil {
return "", err
}
a.owner = string(b)
}
return a.owner, nil
}
func (a *Applier) applySchema(ctx context.Context, ri dynamic.ResourceInterface, u, live *unstructured.Unstructured, c Change) (Change, error) {
if live == nil {
got, err := ri.Create(ctx, u, metav1.CreateOptions{FieldManager: a.fieldManager(), DryRun: a.dryRun()})
switch {
case err == nil:
c.Action, c.Managers = Created, managerChanges(nil, got)
return c, nil
case apierrors.IsAlreadyExists(err):
live, err = ri.Get(ctx, u.GetName(), metav1.GetOptions{})
if err != nil {
return c, err
}
default:
return c, err
}
}
want, _, _ := unstructured.NestedMap(u.Object, "spec")
have, _, _ := unstructured.NestedMap(live.Object, "spec")
if at, same := derivative(want, have, "spec"); !same {
return c, fmt.Errorf("%w: %s differs at %s", ErrSchemaChanged, u.GetName(), at)
}
c.Action = Unchanged
return c, nil
}
func sameContent(a, b *unstructured.Unstructured) bool {
strip := func(u *unstructured.Unstructured) map[string]any {
c := u.DeepCopy()
unstructured.RemoveNestedField(c.Object, "metadata", "resourceVersion")
unstructured.RemoveNestedField(c.Object, "metadata", "managedFields")
unstructured.RemoveNestedField(c.Object, "metadata", "generation")
return c.Object
}
_, same := derivative(strip(a), strip(b), "")
_, back := derivative(strip(b), strip(a), "")
return same && back
}
func derivative(want, have any, at string) (string, bool) {
switch w := want.(type) {
case map[string]any:
h, ok := have.(map[string]any)
if !ok {
return at, false
}
keys := make([]string, 0, len(w))
for k := range w {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
if p, same := derivative(w[k], h[k], at+"."+k); !same {
return p, false
}
}
return at, true
case []any:
h, ok := have.([]any)
if !ok || len(h) != len(w) {
return at, false
}
for i := range w {
if p, same := derivative(w[i], h[i], fmt.Sprintf("%s[%d]", at, i)); !same {
return p, false
}
}
return at, true
}
if wn, ok := number(want); ok {
hn, ok := number(have)
return at, ok && wn == hn
}
return at, reflect.DeepEqual(want, have)
}
func number(v any) (float64, bool) {
switch n := v.(type) {
case int64:
return float64(n), true
case int:
return float64(n), true
case float64:
return n, true
case json.Number:
f, err := n.Float64()
return f, err == nil
}
return 0, false
}
func refuseKubectl(u *unstructured.Unstructured) error {
for _, m := range u.GetManagedFields() {
if strings.HasPrefix(m.Manager, "kubectl") && !annotationsOnly(m) {
return fmt.Errorf("%w: %s %s is managed by %s", ErrKubectlManaged, u.GetKind(), u.GetName(), m.Manager)
}
}
return nil
}
func annotationsOnly(m metav1.ManagedFieldsEntry) bool {
if m.FieldsV1 == nil || len(m.FieldsV1.Raw) == 0 {
return false
}
var fields map[string]any
if err := json.Unmarshal(m.FieldsV1.Raw, &fields); err != nil {
return false
}
allowed := map[string]bool{"f:metadata": true, "f:apiVersion": true, "f:kind": true}
for k := range fields {
if !allowed[k] {
return false
}
}
meta, ok := fields["f:metadata"].(map[string]any)
if !ok {
return false
}
for k := range meta {
if k != "f:annotations" && k != "f:labels" {
return false
}
}
return true
}
func owners(u *unstructured.Unstructured) map[string][]string {
out := map[string][]string{}
if u == nil {
return out
}
for _, m := range u.GetManagedFields() {
if m.FieldsV1 == nil {
continue
}
var tree map[string]any
if json.Unmarshal(m.FieldsV1.GetRawBytes(), &tree) != nil {
continue
}
who := fmt.Sprintf("%s (%s)", m.Manager, m.Operation)
walkFields(tree, "", func(path string) { out[path] = append(out[path], who) })
}
for k := range out {
sort.Strings(out[k])
}
return out
}
func walkFields(tree map[string]any, at string, leaf func(string)) {
for k, v := range tree {
if k == "." {
continue
}
path := k
if at != "" {
path = at + "." + k
}
child, _ := v.(map[string]any)
if len(child) == 0 || (len(child) == 1 && child["."] != nil) {
leaf(path)
continue
}
walkFields(child, path, leaf)
}
}
func managerChanges(before, after *unstructured.Unstructured) []FieldChange {
b, a := owners(before), owners(after)
paths := map[string]bool{}
for p := range b {
paths[p] = true
}
for p := range a {
paths[p] = true
}
var out []FieldChange
for p := range paths {
if !reflect.DeepEqual(b[p], a[p]) {
out = append(out, FieldChange{Field: p, From: b[p], To: a[p]})
}
}
sort.Slice(out, func(i, j int) bool { return out[i].Field < out[j].Field })
return out
}
func (a *Applier) wait(ctx context.Context, set manifests.Set, p manifests.Phase, w manifests.Wait, values any, applied []manifests.Object, when string) (WaitReport, error) {
wr := WaitReport{When: when, Kind: w.Kind, Name: w.Name, For: w.For}
ws, err := set.Workspace(p, &w, values)
if err != nil {
return wr, err
}
wr.Workspace = ws
kind := manifests.WaitKinds[w.Kind]
dyn, err := dynamic.NewForConfig(a.ForWorkspace(ws))
if err != nil {
return wr, err
}
names := []string{w.Name}
if w.Name == "" && w.Kind != "APIBinding" {
names = nil
for _, o := range applied {
if o.Unstructured.GetKind() == w.Kind {
names = append(names, o.Unstructured.GetName())
}
}
if len(names) == 0 {
return wr, fmt.Errorf("a %s %s wait names no object and the phase applied none", w.Kind, w.For)
}
}
start := time.Now()
var met bool
var captured string
var last error
if a.opts.DryRun {
met, captured, last = a.check(ctx, dyn, kind.Resource, kind.Namespaced, w, names)
} else {
met, captured, last = a.watchFor(ctx, dyn, kind.Resource, kind.Namespaced, w, names)
}
wr.Seconds = time.Since(start).Seconds()
if errors.Is(last, ErrWaitFailed) && !w.BestEffort {
return wr, fmt.Errorf("%s %v in %s for %s: %w", w.Kind, names, ws, w.For, last)
}
if met {
wr.Met = true
if w.Capture != nil {
if err := manifests.SetCaptured(values, *w.Capture, captured); err != nil {
return wr, err
}
wr.Captured = captured
}
return wr, nil
}
if err := ctx.Err(); err != nil {
return wr, err
}
if a.opts.DryRun || w.BestEffort {
a.opts.Log.Warn("wait not met; continuing", "kind", w.Kind, "name", w.Name, "workspace", ws, "for", w.For, "dryRun", a.opts.DryRun, "err", last)
return wr, nil
}
if w.Kind == "Workspace" {
if why := a.workspaceStall(ctx, ws, names); why != "" {
last = fmt.Errorf("%v; %s", last, why)
}
}
return wr, fmt.Errorf("%w: %s %v in %s for %s after %s (last error: %v)", ErrWaitTimedOut, w.Kind, names, ws, w.For, a.opts.WaitTimeout, last)
}
func (a *Applier) workspaceStall(ctx context.Context, ws string, names []string) string {
var out []string
for _, name := range names {
dyn, err := dynamic.NewForConfig(a.ForWorkspace(ws))
if err != nil {
continue
}
u, err := dyn.Resource(kcpgvr.Workspaces).Get(ctx, name, metav1.GetOptions{})
if err != nil {
continue
}
phase, _, _ := unstructured.NestedString(u.Object, "status", "phase")
initializers, _, _ := unstructured.NestedStringSlice(u.Object, "status", "initializers")
why := fmt.Sprintf("Workspace %s phase %s initializers %v", name, phase, initializers)
if child, err := dynamic.NewForConfig(a.ForWorkspace(ws + ":" + name)); err == nil {
if lc, err := child.Resource(kcpgvr.LogicalClusters).Get(ctx, "cluster", metav1.GetOptions{}); err == nil {
conditions, _, _ := unstructured.NestedSlice(lc.Object, "status", "conditions")
for _, raw := range conditions {
c, _ := raw.(map[string]any)
if c["status"] == "False" {
why += fmt.Sprintf("; %v=False %v: %v", c["type"], c["reason"], c["message"])
}
}
}
}
out = append(out, why)
}
return strings.Join(out, "; ")
}
func (a *Applier) watchFor(ctx context.Context, dyn dynamic.Interface, gvr schema.GroupVersionResource, namespaced bool, w manifests.Wait, names []string) (bool, string, error) {
var ri dynamic.ResourceInterface = dyn.Resource(gvr)
if namespaced {
ri = dyn.Resource(gvr).Namespace(defaultNamespace)
}
wctx, cancel := context.WithTimeout(ctx, a.opts.WaitTimeout)
defer cancel()
lw := &cache.ListWatch{
ListWithContextFunc: func(ctx context.Context, o metav1.ListOptions) (runtime.Object, error) {
return kube.ListServed(ctx, func(ctx context.Context) (runtime.Object, error) { return ri.List(ctx, o) })
},
WatchFuncWithContext: func(ctx context.Context, o metav1.ListOptions) (watch.Interface, error) { return ri.Watch(ctx, o) },
}
seen := map[string]*unstructured.Unstructured{}
var met bool
var captured string
var last error = fmt.Errorf("no %s observed yet", w.Kind)
eval := func() (bool, error) {
met, captured, last = a.evaluate(w, names, seen)
if errors.Is(last, ErrWaitFailed) && !w.BestEffort {
return false, last
}
return met, nil
}
_, err := watchtools.UntilWithSync(wctx, lw, &unstructured.Unstructured{}, func(store cache.Store) (bool, error) {
for _, item := range store.List() {
if u, ok := item.(*unstructured.Unstructured); ok {
seen[u.GetName()] = u
}
}
return eval()
}, func(ev watch.Event) (bool, error) {
u, ok := ev.Object.(*unstructured.Unstructured)
if !ok {
return false, nil
}
switch ev.Type {
case watch.Deleted:
delete(seen, u.GetName())
case watch.Added, watch.Modified:
seen[u.GetName()] = u
default:
return false, nil
}
return eval()
})
if met {
return true, captured, nil
}
if errors.Is(last, ErrWaitFailed) {
return false, "", last
}
if err != nil && !wait.Interrupted(err) && !errors.Is(err, watchtools.ErrWatchClosed) {
last = err
}
return false, "", last
}
func (a *Applier) evaluate(w manifests.Wait, names []string, seen map[string]*unstructured.Unstructured) (bool, string, error) {
if w.Kind == "APIBinding" {
if len(seen) == 0 {
return false, "", errors.New("no APIBinding yet")
}
for name, u := range seen {
if met, _ := w.Met(u); !met {
return false, "", fmt.Errorf("APIBinding %s not Ready", name)
}
}
return true, "", nil
}
captured := ""
for _, n := range names {
u, ok := seen[n]
if !ok {
return false, "", fmt.Errorf("%s %s not found", w.Kind, n)
}
met, value := w.Met(u)
if !met {
if why := failedObject(u); why != "" {
return false, "", fmt.Errorf("%w: %s %s %s", ErrWaitFailed, w.Kind, n, why)
}
return false, "", fmt.Errorf("%s %s not %s", w.Kind, n, w.For)
}
captured = value
}
return true, captured, nil
}
func (a *Applier) check(ctx context.Context, dyn dynamic.Interface, gvr schema.GroupVersionResource, namespaced bool, w manifests.Wait, names []string) (bool, string, error) {
var ri dynamic.ResourceInterface = dyn.Resource(gvr)
if namespaced {
ri = dyn.Resource(gvr).Namespace(defaultNamespace)
}
if w.Kind == "APIBinding" {
list, err := ri.List(ctx, metav1.ListOptions{})
if err != nil {
return false, "", err
}
if len(list.Items) == 0 {
return false, "", errors.New("no APIBinding yet")
}
for i := range list.Items {
if met, _ := w.Met(&list.Items[i]); !met {
return false, "", fmt.Errorf("APIBinding %s not Ready", list.Items[i].GetName())
}
}
return true, "", nil
}
captured := ""
for _, n := range names {
u, err := ri.Get(ctx, n, metav1.GetOptions{})
if err != nil {
return false, "", err
}
met, value := w.Met(u)
if !met {
if why := failedObject(u); why != "" {
return false, "", fmt.Errorf("%w: %s %s %s", ErrWaitFailed, w.Kind, n, why)
}
return false, "", fmt.Errorf("%s %s not %s", w.Kind, n, w.For)
}
captured = value
}
return true, captured, nil
}
func failedObject(u *unstructured.Unstructured) string {
phase, _, _ := unstructured.NestedString(u.Object, "status", "phase")
msg, _, _ := unstructured.NestedString(u.Object, "status", "message")
observed, found, _ := unstructured.NestedInt64(u.Object, "status", "observedGeneration")
current := !found || observed == u.GetGeneration()
if phase == "Failed" && current {
return "is Failed: " + msg
}
return ""
}
func covered(want, live any) bool {
switch w := want.(type) {
case map[string]any:
l, ok := live.(map[string]any)
if !ok {
return false
}
for k, v := range w {
lv, ok := l[k]
if !ok || !covered(v, lv) {
return false
}
}
return true
case []any:
l, ok := live.([]any)
if !ok || len(l) != len(w) {
return false
}
for i := range w {
if !covered(w[i], l[i]) {
return false
}
}
return true
default:
return reflect.DeepEqual(want, live)
}
}