0
0
package compose
import (
"context"
"encoding/json"
"errors"
"fmt"
"maps"
"reflect"
"slices"
"sort"
"strings"
"sync"
"time"
apierrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kube"
)
const (
ReasonChildEditReverted = "ChildEditReverted"
eventNamespace = "default"
)
type Desired struct {
Kind string
Name string
Spec any
}
func DesiredKeys(desired []Desired) []string {
out := make([]string, 0, len(desired))
for _, d := range desired {
out = append(out, ComponentKey(d.Kind, d.Name))
}
return out
}
func ToMap(obj any) (map[string]any, error) {
if v := reflect.ValueOf(obj); v.IsValid() && v.Kind() != reflect.Pointer {
ptr := reflect.New(v.Type())
ptr.Elem().Set(v)
obj = ptr.Interface()
}
return runtime.DefaultUnstructuredConverter.ToUnstructured(obj)
}
func SpecMap(spec any) (map[string]any, error) {
if spec == nil {
return nil, nil
}
if m, ok := spec.(map[string]any); ok {
return m, nil
}
m, err := ToMap(spec)
if err != nil {
return nil, failf("the component spec: %w", err)
}
if len(m) == 0 {
return nil, nil
}
return m, nil
}
type Generic struct {
metav1.TypeMeta `json:",inline"`
metav1.ObjectMeta `json:"metadata,omitempty"`
Spec kube.Doc `json:"spec,omitempty"`
Status kube.Doc `json:"status,omitempty"`
}
func DocMeta(d kube.Doc) map[string]any {
m, _ := d["metadata"].(map[string]any)
if m == nil {
m = map[string]any{}
d["metadata"] = m
}
return m
}
func docField(d kube.Doc, key string) string {
s, _ := d[key].(string)
return s
}
func docMetaField(d kube.Doc, key string) string {
m, _ := d["metadata"].(map[string]any)
s, _ := m[key].(string)
return s
}
func NewDoc(apiVersion, kind, name string) kube.Doc {
return kube.Doc{"apiVersion": apiVersion, "kind": kind, "metadata": map[string]any{"name": name}}
}
func (c *Composer) Object(r Root, ws, apiVersion, kind, name string, labels map[string]string) kube.Doc {
d := NewDoc(apiVersion, kind, name)
merged := r.Labels("")
maps.Copy(merged, labels)
meta := DocMeta(d)
meta["labels"] = merged
if ws == "" || ws == r.Workspace {
meta["ownerReferences"] = []metav1.OwnerReference{r.OwnerRef()}
}
return d
}
func (c *Composer) ApplyComponent(ctx context.Context, r Root, ws string, d Desired) error {
ct, err := componentTypeFor(d.Kind)
if err != nil {
return err
}
spec, err := SpecMap(d.Spec)
if err != nil {
return err
}
ws = workspaceOr(ws, r.Workspace)
u := c.Object(r, ws, ct.APIVersion(), ct.Kind, d.Name, map[string]string{ComponentLabel: d.Kind})
if spec != nil {
u["spec"] = spec
}
current, err := c.applyChild(ctx, r, r.Manager(), ws, ct.GVR, u)
if err != nil || current {
return err
}
return c.revertForeignSpec(ctx, r, ws, ct.GVR, u)
}
func (c *Composer) EnsureComponents(ctx context.Context, r Root, desired []Desired) error {
for _, d := range desired {
if err := c.ApplyComponent(ctx, r, r.Workspace, d); err != nil {
return fmt.Errorf("%s %s: %w", d.Kind, d.Name, err)
}
}
return nil
}
func workspaceOr(ws, fallback string) string {
if ws = strings.TrimSpace(ws); ws != "" {
return ws
}
return fallback
}
func (c *Composer) Apply(ctx context.Context, r Root, ws string, gvr schema.GroupVersionResource, u kube.Doc) error {
return c.applyAs(ctx, r, r.Manager(), ws, gvr, u)
}
func (c *Composer) applyAs(ctx context.Context, r Root, manager, ws string, gvr schema.GroupVersionResource, u kube.Doc) error {
_, err := c.applyChild(ctx, r, manager, ws, gvr, u)
return err
}
func (c *Composer) applyChild(ctx context.Context, r Root, manager, ws string, gvr schema.GroupVersionResource, u kube.Doc) (bool, error) {
ws = workspaceOr(ws, r.Workspace)
ri, err := c.Client(ws, gvr)
if err != nil {
return false, err
}
delete(u, "status")
if m, ok := u["metadata"].(map[string]any); ok {
delete(m, "creationTimestamp")
}
namespace := docMetaField(u, "namespace")
rc := ri.In(namespace)
kind, name := docField(u, "kind"), docMetaField(u, "name")
key, digest := applyKey(ws, gvr, namespace, name, manager), applyDigest(u)
if c.applies.current(key, digest) {
return true, nil
}
got, err := kube.Apply[kube.Doc](ctx, rc, u, kube.ApplyOptions{FieldManager: manager})
if err == nil {
c.applies.record(key, kind, digest, docObject(*got))
return false, nil
}
c.applies.drop(key)
if !apierrors.IsConflict(err) {
return false, fmt.Errorf("compose: applying %s %s in %s: %w", kind, name, ws, err)
}
c.recordConflict(ctx, r, ws, u, err)
got, err = kube.Apply[kube.Doc](ctx, rc, u, kube.ApplyOptions{FieldManager: manager, Force: true})
if err != nil {
return false, fmt.Errorf("compose: applying %s %s in %s: %w", kind, name, ws, err)
}
c.applies.record(key, kind, digest, docObject(*got))
return false, nil
}
func (c *Composer) recordConflict(ctx context.Context, r Root, ws string, u kube.Doc, cause error) {
kind, name := docField(u, "kind"), docMetaField(u, "name")
message := fmt.Sprintf("%s %s: a field another manager set is reverted to the spec %s %s composes: %s", kind, name, r.Kind, r.Name, cause.Error())
c.log.Warn("a direct edit of a composed child is reverted", "root", r.Owner(), "kind", kind, "name", name, "workspace", ws, "err", cause.Error())
c.Event(ctx, r, ws, docField(u, "apiVersion"), kind, name, "Warning", ReasonChildEditReverted, message)
}
func (c *Composer) Event(ctx context.Context, r Root, ws, apiVersion, kind, name, eventType, reason, message string) {
ri, err := c.Client(ws, EventGVR)
if err != nil {
return
}
now := time.Now().UTC().Format(time.RFC3339)
if len(message) > 1024 {
message = message[:1024]
}
ev := kube.Doc{
"apiVersion": "v1",
"kind": "Event",
"metadata": map[string]any{"generateName": strings.ToLower(kind) + "-" + name + "-", "namespace": eventNamespace},
"involvedObject": map[string]any{"apiVersion": apiVersion, "kind": kind, "name": name},
"reason": reason,
"message": message,
"type": eventType,
"source": map[string]any{"component": r.ManagedBy()},
"reportingComponent": r.ManagedBy(),
"firstTimestamp": now,
"lastTimestamp": now,
"count": int64(1),
}
if _, err := kube.Create[kube.Doc](ctx, ri.In(eventNamespace), ev, metav1.CreateOptions{FieldManager: r.Manager()}); err != nil && ctx.Err() == nil {
c.log.Warn("recording an event", "root", r.Owner(), "reason", reason, "err", err.Error())
}
}
func (c *Composer) ApplyTyped(ctx context.Context, r Root, ws string, gvr schema.GroupVersionResource, apiVersion, kind string, obj any) error {
m, err := ToMap(obj)
if err != nil {
return err
}
u := kube.Doc(m)
u["apiVersion"], u["kind"] = apiVersion, kind
ws = workspaceOr(ws, r.Workspace)
meta := DocMeta(u)
labels := r.Labels(kind)
if own, ok := meta["labels"].(map[string]any); ok {
for k, v := range own {
if s, ok := v.(string); ok {
labels[k] = s
}
}
}
meta["labels"] = labels
if ws == r.Workspace {
meta["ownerReferences"] = []metav1.OwnerReference{r.OwnerRef()}
}
return c.Apply(ctx, r, ws, gvr, u)
}
func Get[T any](ctx context.Context, c *Composer, ws string, gvr schema.GroupVersionResource, name string) (*T, error) {
ri, err := c.Client(ws, gvr)
if err != nil {
return nil, err
}
return kube.Get[T](ctx, ri, name)
}
func (c *Composer) GetComponent(ctx context.Context, ws, kind, name string) (ComponentView, bool, error) {
ct, err := componentTypeFor(kind)
if err != nil {
return ComponentView{}, false, err
}
o, err := Get[Generic](ctx, c, ws, ct.GVR, name)
if apierrors.IsNotFound(err) {
return ComponentView{Kind: kind, Name: name, Workspace: ws}, false, nil
}
if err != nil {
return ComponentView{}, false, err
}
v, err := ComponentViewOf(ws, kind, o)
return v, err == nil, err
}
func (c *Composer) ListComponents(ctx context.Context, ws, owner string) ([]ComponentView, error) {
views := make([][]ComponentView, len(ComponentTypes))
errs := make([]error, len(ComponentTypes))
var wg sync.WaitGroup
for i, ct := range ComponentTypes {
wg.Go(func() { views[i], errs[i] = c.listComponents(ctx, ws, owner, ct.Kind, ct.GVR) })
}
wg.Wait()
if err := errors.Join(errs...); err != nil {
return nil, err
}
out := slices.Concat(views...)
sort.Slice(out, func(i, j int) bool {
if out[i].Kind != out[j].Kind {
return out[i].Kind < out[j].Kind
}
return out[i].Name < out[j].Name
})
return out, nil
}
func (c *Composer) DeleteComponent(ctx context.Context, ws, kind, name string) error {
ct, err := componentTypeFor(kind)
if err != nil {
return err
}
ri, err := c.Client(ws, ct.GVR)
if err != nil {
return err
}
if err := ri.Delete(ctx, name, metav1.DeleteOptions{}); err != nil && !apierrors.IsNotFound(err) {
return err
}
return nil
}
func (c *Composer) DeleteComponentsExcept(ctx context.Context, ws, owner string, keep []string) (int, error) {
views, err := c.ListComponents(ctx, ws, owner)
if err != nil {
return 0, err
}
left := 0
for _, v := range views {
if slices.Contains(keep, ComponentKey(v.Kind, v.Name)) {
continue
}
left++
if err := c.DeleteComponent(ctx, ws, v.Kind, v.Name); err != nil {
return left, err
}
c.log.Info("deleted a component the root object omits", "owner", owner, "kind", v.Kind, "name", v.Name, "workspace", ws)
}
return left, nil
}
func (c *Composer) RestartComponent(ctx context.Context, r Root, ws, kind, name string) error {
ct, err := componentTypeFor(kind)
if err != nil {
return err
}
u := NewDoc(ct.APIVersion(), ct.Kind, name)
u["spec"] = map[string]any{"restartedAt": time.Now().UTC().Format(time.RFC3339Nano)}
return c.applyAs(ctx, r, r.Manager()+"/restart", ws, ct.GVR, u)
}
func (c *Composer) Prune(ctx context.Context, ws string, gvr schema.GroupVersionResource, selector string, keep map[string]bool) error {
ri, err := c.Client(ws, gvr)
if err != nil {
return err
}
items, err := kube.List[metav1.PartialObjectMetadata](ctx, ri, metav1.ListOptions{LabelSelector: selector})
if apierrors.IsNotFound(err) || apierrors.IsForbidden(err) {
return nil
}
if err != nil {
return err
}
for i := range items {
name := items[i].Name
if keep[name] {
continue
}
if err := ri.Delete(ctx, name, metav1.DeleteOptions{}); err != nil && !apierrors.IsNotFound(err) {
return err
}
}
return nil
}
func (c *Composer) listComponents(ctx context.Context, ws, owner, kind string, gvr schema.GroupVersionResource) ([]ComponentView, error) {
ri, err := c.Client(ws, gvr)
if err != nil {
return nil, err
}
items, err := kube.List[Generic](ctx, ri, metav1.ListOptions{LabelSelector: OwnerLabel + "=" + owner})
if apierrors.IsNotFound(err) {
return nil, nil
}
if err != nil {
return nil, err
}
out := make([]ComponentView, 0, len(items))
for i := range items {
v, err := ComponentViewOf(ws, kind, &items[i])
if err != nil {
return nil, err
}
if gen := c.cfg.CoreGeneration; gen > 0 && CoreObservedKinds[kind] && v.Status.Ready && v.Status.ObservedCore != gen {
v.Status.Ready = false
v.Status.Message = fmt.Sprintf("its status is core generation %d's; this core (%d) has not observed it yet", v.Status.ObservedCore, gen)
}
out = append(out, v)
}
return out, nil
}
func (c *Composer) DeleteOwned(ctx context.Context, ws string, gvr schema.GroupVersionResource, owner string) (int, error) {
ri, err := c.Client(ws, gvr)
if err != nil {
return 0, err
}
items, err := kube.List[metav1.PartialObjectMetadata](ctx, ri, metav1.ListOptions{LabelSelector: OwnerLabel + "=" + owner})
if apierrors.IsNotFound(err) {
return 0, nil
}
if err != nil {
return 0, err
}
for _, o := range items {
if o.DeletionTimestamp == nil {
if err := ri.Delete(ctx, o.Name, metav1.DeleteOptions{}); err != nil && !apierrors.IsNotFound(err) {
return len(items), err
}
}
}
return len(items), nil
}
func (c *Composer) DeleteAll(ctx context.Context, ws string, gvr schema.GroupVersionResource) (int, error) {
ri, err := c.Client(ws, gvr)
if err != nil {
return 0, err
}
items, err := kube.List[metav1.PartialObjectMetadata](ctx, ri, metav1.ListOptions{})
if apierrors.IsNotFound(err) {
return 0, nil
}
if err != nil {
return 0, err
}
for _, o := range items {
if o.DeletionTimestamp == nil {
if err := ri.Delete(ctx, o.Name, metav1.DeleteOptions{}); err != nil && !apierrors.IsNotFound(err) {
return len(items), err
}
}
}
return len(items), nil
}
func (c *Composer) DeleteDeployments(ctx context.Context, ws string) (int, error) {
left := 0
for _, gvr := range []schema.GroupVersionResource{v1alpha1.InfraGVR, v1alpha1.EphemeralInfraGVR} {
n, err := c.DeleteAll(ctx, ws, gvr)
if err != nil {
return left + n, err
}
left += n
}
return left, nil
}
func (c *Composer) HeldContracts(ctx context.Context, ws string) (int, error) {
ri, err := c.Client(ws, ComputeContractGVR)
if err != nil {
return 0, err
}
items, err := kube.List[v1alpha1.ComputeContract](ctx, ri, metav1.ListOptions{})
if apierrors.IsNotFound(err) {
return 0, nil
}
if err != nil {
return 0, err
}
held := 0
for i := range items {
if items[i].HoldsGuest() {
held++
}
}
return held, nil
}
func (c *Composer) SetSpecField(ctx context.Context, r Root, ws string, gvr schema.GroupVersionResource, apiVersion, kind, name string, spec map[string]any) error {
u := NewDoc(apiVersion, kind, name)
u["spec"] = spec
return c.Apply(ctx, r, ws, gvr, u)
}
func jsonCopy(in any, out any) error {
b, err := json.Marshal(in)
if err != nil {
return err
}
return json.Unmarshal(b, out)
}