0
0
package compose
import (
"crypto/sha256"
"encoding/hex"
"encoding/json"
"sort"
"sync"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/types"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kube"
)
type appliedChild struct {
digest string
uid types.UID
live string
}
type applyCache struct {
mu sync.Mutex
applied map[string]appliedChild
live map[types.UID]string
keys map[types.UID]map[string]bool
kinds map[string]bool
}
func applyKey(ws string, gvr schema.GroupVersionResource, namespace, name, manager string) string {
return ws + "|" + gvr.Group + "/" + gvr.Resource + "|" + namespace + "/" + name + "|" + manager
}
func applyDigest(u kube.Doc) string {
raw, err := json.Marshal(u)
if err != nil {
return ""
}
sum := sha256.Sum256(raw)
return hex.EncodeToString(sum[:])
}
func liveFingerprint(o metav1.Object) string {
if o == nil || o.GetUID() == "" || o.GetDeletionTimestamp() != nil {
return ""
}
type field struct {
Manager string `json:"m"`
Operation string `json:"o"`
Fields any `json:"f,omitempty"`
}
var fields []field
for _, e := range o.GetManagedFields() {
if e.Subresource != "" {
continue
}
f := field{Manager: e.Manager, Operation: string(e.Operation)}
if e.FieldsV1 != nil && len(e.FieldsV1.Raw) > 0 {
var v any
if err := json.Unmarshal(e.FieldsV1.Raw, &v); err == nil {
f.Fields = v
}
}
fields = append(fields, f)
}
sort.SliceStable(fields, func(i, j int) bool {
if fields[i].Manager != fields[j].Manager {
return fields[i].Manager < fields[j].Manager
}
return fields[i].Operation < fields[j].Operation
})
raw, err := json.Marshal(struct {
Generation int64 `json:"g"`
Labels map[string]string `json:"l,omitempty"`
Owners []metav1.OwnerReference `json:"o,omitempty"`
Finalizers []string `json:"x,omitempty"`
Fields []field `json:"f,omitempty"`
}{o.GetGeneration(), o.GetLabels(), o.GetOwnerReferences(), o.GetFinalizers(), fields})
if err != nil {
return ""
}
sum := sha256.Sum256(raw)
return hex.EncodeToString(sum[:])
}
func docObject(d kube.Doc) metav1.Object {
o, err := kube.Decode[metav1.PartialObjectMetadata](d)
if err != nil {
return nil
}
return o
}
func (a *applyCache) current(key, digest string) bool {
if digest == "" {
return false
}
a.mu.Lock()
defer a.mu.Unlock()
got, ok := a.applied[key]
if !ok || got.digest != digest || got.live == "" {
return false
}
live, seen := a.live[got.uid]
return seen && live == got.live
}
func (a *applyCache) watch(kind string) {
a.mu.Lock()
defer a.mu.Unlock()
if a.kinds == nil {
a.kinds = map[string]bool{}
}
a.kinds[kind] = true
}
func (a *applyCache) record(key, kind, digest string, obj metav1.Object) {
fp := liveFingerprint(obj)
a.mu.Lock()
defer a.mu.Unlock()
if a.applied == nil {
a.applied = map[string]appliedChild{}
a.keys = map[types.UID]map[string]bool{}
}
if digest == "" || fp == "" || !a.kinds[kind] {
delete(a.applied, key)
return
}
uid := obj.GetUID()
a.applied[key] = appliedChild{digest: digest, uid: uid, live: fp}
if a.keys[uid] == nil {
a.keys[uid] = map[string]bool{}
}
a.keys[uid][key] = true
}
func (a *applyCache) drop(key string) {
a.mu.Lock()
defer a.mu.Unlock()
delete(a.applied, key)
}
func (a *applyCache) observe(obj metav1.Object, gone bool) {
uid := obj.GetUID()
if uid == "" {
return
}
var fp string
if !gone {
fp = liveFingerprint(obj)
}
a.mu.Lock()
defer a.mu.Unlock()
if a.live == nil {
a.live = map[types.UID]string{}
}
if fp != "" {
a.live[uid] = fp
return
}
delete(a.live, uid)
for key := range a.keys[uid] {
if a.applied[key].uid == uid {
delete(a.applied, key)
}
}
delete(a.keys, uid)
}