0
0
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, ", ")
}