~ knotless Search/
↑↓ move↵ open⇧↵ all results

socialweb.computer/socialweb-computer-kcp

socialweb.computer: a compute market on atproto (kcp)

1 collaborator
0
0
83 lines · 2.3 KB Raw History
package compose

import (
	"context"
	"sync"

	apierrors "k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
	ctlruntime "github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime"
	"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kube"
)

func secretsContract(cc *v1alpha1.ComputeContract) bool {
	return cc.DeletionTimestamp == nil && cc.Spec.SecretsRef != nil &&
		cc.Status.Phase != v1alpha1.ComputeContractReleased && cc.Status.Phase != v1alpha1.ComputeContractFailed
}

func (c *Composer) SecretsContracts(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
	}
	n := 0
	for i := range items {
		if secretsContract(&items[i]) {
			n++
		}
	}
	return n, nil
}

type secretsContractIndex struct {
	mu sync.Mutex

	byWorkspace map[string]map[string]bool
}

func (x *secretsContractIndex) note(workspace, name string, live bool) bool {
	x.mu.Lock()
	defer x.mu.Unlock()
	if x.byWorkspace == nil {
		x.byWorkspace = map[string]map[string]bool{}
	}
	set := x.byWorkspace[workspace]
	before := len(set) > 0
	if live {
		if set == nil {
			set = map[string]bool{}
			x.byWorkspace[workspace] = set
		}
		set[name] = true
	} else {
		delete(set, name)
	}
	return before != (len(set) > 0)
}

func SecretsContractWatch(c *Composer, export, rootKind string) ctlruntime.Option {
	var gone sync.Map
	filter := ctlruntime.WatchFilter[*v1alpha1.ComputeContract]{Observe: func(cc *v1alpha1.ComputeContract, deleted bool) {
		gone.Store(cc.UID, deleted)
	}}
	return ctlruntime.WatchesFiltered(export, filter, func(_ context.Context, src ctlruntime.Request, cc *v1alpha1.ComputeContract) []ctlruntime.Request {
		out := c.deletingIn(rootKind, src.Workspace)
		deleted, _ := gone.LoadAndDelete(cc.UID)
		live := secretsContract(cc) && deleted != true
		if c.secretsContracts.note(src.Cluster+"|"+src.Workspace, cc.Name, live) {
			for _, name := range c.rootsIn(src.Cluster, rootKind) {
				out = append(out, ctlruntime.Request{Cluster: src.Cluster, Name: name})
			}
		}
		return out
	})
}