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

socialweb.computer/socialweb-computer-kcp

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

1 collaborator
0
0
273 lines · 10.1 KB Raw History
package componentlink

import (
	"cmp"
	"context"
	"errors"
	"fmt"
	"log/slog"
	"strings"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	commonv1 "github.com/johnandersen777/socialweb-computer-kcp/api/common/v1alpha1"
	exposurev1alpha1 "github.com/johnandersen777/socialweb-computer-kcp/api/exposure/v1alpha1"
	"github.com/johnandersen777/socialweb-computer-kcp/internal/bus"
	"github.com/johnandersen777/socialweb-computer-kcp/internal/component"
	ctlruntime "github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime"
	"github.com/johnandersen777/socialweb-computer-kcp/internal/exposure"
	"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/binding"
	"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/conds"
)

const (
	Name = "componentlink"

	Export = "exposures"
)

type Options struct {
	Policy *exposure.LinkPolicy

	Registry *component.Registry

	Providers *bus.Bus

	Scope func(workspace string) bool

	Log *slog.Logger
}

type Controller struct {
	policy *exposure.LinkPolicy

	registry *component.Registry

	providers *bus.Bus

	log *slog.Logger

	targets *binding.Table[struct{}]

	events *ctlruntime.Queue

	scope func(workspace string) bool
}

func New(opts Options) (*Controller, error) {
	if opts.Policy == nil {
		return nil, errors.New("componentlink: a link policy is required")
	}
	log := opts.Log
	if log == nil {
		log = slog.New(slog.DiscardHandler)
	}
	return &Controller{policy: opts.Policy, registry: opts.Registry, providers: opts.Providers, log: log.With("component", "componentlink-controller"),
		targets: binding.New[struct{}](), events: ctlruntime.NewQueue()}, nil
}

func Register(m *ctlruntime.Manager, opts Options) (*Controller, error) {
	if err := m.AddToScheme(exposurev1alpha1.AddToScheme); err != nil {
		return nil, err
	}
	ctl, err := New(opts)
	if err != nil {
		return nil, err
	}
	events, err := ctl.events.Run(m, Name+": components")
	if err != nil {
		return nil, fmt.Errorf("%s: forwarding component changes: %w", Name, err)
	}
	if opts.Scope == nil {
		return nil, errors.New("componentlink: a workspace scope is required: the ComponentLinks it loads are those its reconciles handle")
	}
	options := []ctlruntime.Option{ctlruntime.Export(Export), ctlruntime.Events(events), ctlruntime.Gone(ctl.gone), ctlruntime.InWorkspaces(opts.Scope)}
	if err := ctlruntime.For[*exposurev1alpha1.ComponentLink](m, Name, ctl, options...); err != nil {
		return nil, fmt.Errorf("componentlink: registering the ComponentLink controller: %w", err)
	}
	ctl.scope = opts.Scope
	if err := m.Engaged(Export, ctl.load); err != nil {
		return nil, fmt.Errorf("componentlink: loading the ComponentLinks of each engaged workspace: %w", err)
	}
	ctl.policy.Expect(opts.Scope)
	return ctl, nil
}

func (c *Controller) load(ctx context.Context, e ctlruntime.Engagement) error {
	if !c.scope(e.Workspace) {
		c.policy.Load(e.Workspace, nil)
		return nil
	}
	synced, cancel := context.WithTimeout(ctx, ctlruntime.CacheSyncTimeout)
	_, err := e.Cache.GetInformer(synced, &exposurev1alpha1.ComponentLink{})
	cancel()
	if err != nil {
		return fmt.Errorf("componentlink: the ComponentLink cache of %s: %w", e.Workspace, err)
	}
	var list exposurev1alpha1.ComponentLinkList
	if err := e.Cache.List(ctx, &list); err != nil {
		return fmt.Errorf("componentlink: listing the ComponentLinks of %s: %w", e.Workspace, err)
	}
	links := map[string]bus.Link{}
	for i := range list.Items {
		object := &list.Items[i]
		if !object.DeletionTimestamp.IsZero() || object.Spec.Suspend {
			continue
		}
		if compiled, _, err := compileLink(e.Workspace, object.Name, object.Spec); err == nil {
			links[object.Name] = compiled
		}
	}
	c.policy.Load(e.Workspace, links)
	c.log.Info("the ComponentLinks of a workspace are loaded", "workspace", e.Workspace, "links", len(links), "listed", len(list.Items))
	return nil
}

func (c *Controller) ComponentChanged(key component.Key) {
	for _, t := range c.targets.Users(binding.Key(key.Workspace, key.Kind, key.Name)) {
		c.events.Add(ctlruntime.Request{Cluster: t.Cluster, Workspace: t.Workspace, Name: t.Name})
	}
}

func (c *Controller) gone(_ context.Context, req ctlruntime.Request) {
	c.forget(binding.Target{Cluster: req.Cluster, Workspace: req.Workspace, Name: req.Name})
}

func (c *Controller) forget(self binding.Target) {
	c.policy.Remove(self.Workspace, self.Name)
	c.targets.Set(self, nil)
}

func (c *Controller) Reconcile(ctx context.Context, req ctlruntime.Request, object *exposurev1alpha1.ComponentLink) (ctlruntime.Result, error) {
	self := binding.Target{Cluster: req.Cluster, Workspace: req.Workspace, Name: req.Name}
	if !object.DeletionTimestamp.IsZero() {
		c.forget(self)
		return ctlruntime.Result{}, nil
	}
	generation := object.Generation
	status := object.Status
	status.ObservedGeneration = generation
	compiled, reason, err := compileLink(req.Workspace, req.Name, object.Spec)
	switch {
	case err != nil:
		c.policy.Remove(req.Workspace, req.Name)
		conds.Set(&status.Conditions, generation, exposurev1alpha1.ComponentLinkConditionAccepted, false, reason, err.Error())
	case object.Spec.Suspend:
		c.policy.Remove(req.Workspace, req.Name)
		conds.Set(&status.Conditions, generation, exposurev1alpha1.ComponentLinkConditionAccepted, false, "Suspended", "the ComponentLink is suspended")
	default:
		c.policy.Set(req.Workspace, req.Name, []bus.Link{compiled})
		conds.Set(&status.Conditions, generation, exposurev1alpha1.ComponentLinkConditionAccepted, true, "Accepted",
			fmt.Sprintf("the bus allows %s to call %s with %s", fromString(compiled.From), compiled.To.String(), capabilitiesString(compiled.Capabilities)))
	}
	to := linkTarget(req.Workspace, object.Spec.To)
	if to.Kind != "" && to.Name != "" {
		c.targets.Set(self, &struct{}{}, binding.Key(to.Workspace, to.Kind, to.Name))
	} else {
		c.targets.Set(self, nil)
	}
	if c.targetRegistered(to) {
		conds.Set(&status.Conditions, generation, exposurev1alpha1.ComponentLinkConditionResolvedRefs, true, "TargetRegistered",
			fmt.Sprintf("the target %s is registered", to.String()))
	} else {
		conds.Set(&status.Conditions, generation, exposurev1alpha1.ComponentLinkConditionResolvedRefs, false, "TargetMissing",
			fmt.Sprintf("the target %s is not registered", to.String()))
	}
	next := object.DeepCopy()
	next.Status = status
	return ctlruntime.Result{}, req.ApplyStatus(ctx, next)
}

func (c *Controller) targetRegistered(to commonv1.ObjectRef) bool {
	if to.Kind == "" || to.Name == "" {
		return false
	}
	if c.registry != nil && c.registry.Has(to.Workspace, to.Kind, to.Name) {
		return true
	}
	return c.providers.Provides(to.Group, to.Kind)
}

func linkTarget(workspace string, to commonv1.ObjectRef) commonv1.ObjectRef {
	return commonv1.ObjectRef{Group: strings.TrimSpace(to.Group), Kind: strings.TrimSpace(to.Kind), Name: strings.TrimSpace(to.Name),
		Workspace: cmp.Or(strings.TrimSpace(to.Workspace), workspace)}
}

func compileLink(workspace, name string, spec exposurev1alpha1.ComponentLinkSpec) (bus.Link, string, error) {
	to := linkTarget(workspace, spec.To)
	switch {
	case to.Kind == "" || to.Name == "":
		return bus.Link{}, "InvalidSpec", errors.New("the ComponentLink to ref needs a kind and a name")
	case to.Workspace != workspace:
		return bus.Link{}, "NotProducerWorkspace", fmt.Errorf("the ComponentLink must live in the workspace of its target %s", to.String())
	}
	from, err := compileFrom(workspace, spec.From)
	if err != nil {
		return bus.Link{}, "InvalidSpec", err
	}
	if len(spec.Capabilities) == 0 {
		return bus.Link{}, "InvalidSpec", errors.New("the ComponentLink grants no capability")
	}
	capabilities := make([]bus.Capability, 0, len(spec.Capabilities))
	for _, capability := range spec.Capabilities {
		capabilityName := strings.ToLower(strings.TrimSpace(capability.Name))
		if capabilityName == "" {
			return bus.Link{}, "InvalidSpec", errors.New("the ComponentLink capabilities list has an empty name")
		}
		scope := make([]string, 0, len(capability.Scope))
		for _, entry := range capability.Scope {
			if entry = strings.TrimSpace(entry); entry == "" {
				return bus.Link{}, "InvalidSpec", fmt.Errorf("the capability %s has an empty scope entry", capabilityName)
			}
			scope = append(scope, entry)
		}
		capabilities = append(capabilities, bus.Capability{Name: capabilityName, Scope: scope})
	}
	return bus.Link{Workspace: workspace, Name: name, From: from, To: to, Capabilities: capabilities}, "", nil
}

func compileFrom(workspace string, from exposurev1alpha1.ComponentLinkFrom) (bus.LinkFrom, error) {
	switch {
	case from.Ref != nil && from.Selector != nil:
		return bus.LinkFrom{}, errors.New("the ComponentLink from names both a ref and a selector")
	case from.Ref != nil:
		ref := linkTarget(workspace, *from.Ref)
		if ref.Kind == "" || ref.Name == "" {
			return bus.LinkFrom{}, errors.New("the ComponentLink from ref needs a kind and a name")
		}
		return bus.LinkFrom{Ref: &ref}, nil
	case from.Selector != nil:
		sel := from.Selector
		if strings.TrimSpace(sel.Kind) == "" {
			return bus.LinkFrom{}, errors.New("the ComponentLink from selector needs a kind")
		}
		requirements := make([]metav1.LabelSelectorRequirement, 0, len(sel.MatchExpressions))
		for _, r := range sel.MatchExpressions {
			requirements = append(requirements, metav1.LabelSelectorRequirement{Key: r.Key, Operator: metav1.LabelSelectorOperator(r.Operator),
				Values: append([]string(nil), r.Values...)})
		}
		selector, err := metav1.LabelSelectorAsSelector(&metav1.LabelSelector{MatchLabels: sel.MatchLabels, MatchExpressions: requirements})
		if err != nil {
			return bus.LinkFrom{}, fmt.Errorf("the ComponentLink from selector: %w", err)
		}
		return bus.LinkFrom{Group: strings.TrimSpace(sel.Group), Kind: strings.TrimSpace(sel.Kind),
			Workspace: cmp.Or(strings.TrimSpace(sel.Workspace), workspace), Selector: selector}, nil
	default:
		return bus.LinkFrom{}, errors.New("the ComponentLink from needs a ref or a selector")
	}
}

func fromString(from bus.LinkFrom) string {
	if from.Ref != nil {
		return from.Ref.String()
	}
	return from.Workspace + ":" + from.Kind + "{" + from.Selector.String() + "}"
}

func capabilitiesString(capabilities []bus.Capability) string {
	parts := make([]string, 0, len(capabilities))
	for _, capability := range capabilities {
		parts = append(parts, capability.String())
	}
	return strings.Join(parts, ", ")
}