0
0
package guestcontrolplane
import (
"context"
"errors"
"fmt"
"log/slog"
"strings"
"sync"
apierrors "k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/runtime/schema"
"sigs.k8s.io/controller-runtime/pkg/client"
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/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/bus"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/guestcp"
ctlruntime "github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kube"
"github.com/johnandersen777/socialweb-computer-kcp/internal/guestcp/queue"
)
const (
Name = "guestcontrolplane"
Kind = "GuestControlPlane"
Export = "applications"
ComputeVMExport = "computevms"
IdentityExport = "marketidentities"
VaultExport = "hostprocesses"
ExposureExport = "exposures"
DefaultVaultServer = "bidder"
FieldManager = v1alpha1.FieldManagerComputeVMMarketGuest
)
var GroupKind = schema.GroupKind{Group: v1alpha1.GroupName, Kind: Kind}
type Store interface {
Get(ctx context.Context, workspace, name string, obj client.Object) error
List(ctx context.Context, workspace string, list client.ObjectList) error
Apply(ctx context.Context, workspace, fieldManager string, obj kube.Doc, status bool) error
Delete(ctx context.Context, workspace string, obj client.Object) error
}
type Options struct {
Bus *bus.Bus
Store Store
Scope func(workspace string) bool
Log *slog.Logger
}
type Controller struct {
bus *bus.Bus
store Store
log *slog.Logger
mu sync.Mutex
feeds map[string]*feed
hubs map[string]*queue.Hub
planes map[string]map[string]bool
}
func New(opts Options) (*Controller, error) {
if opts.Store == nil {
return nil, errors.New("guestcontrolplane: the controller needs a workspace object store")
}
log := opts.Log
if log == nil {
log = slog.New(slog.DiscardHandler)
}
return &Controller{bus: opts.Bus, store: opts.Store, log: log.With("component", "guestcontrolplane-controller"),
feeds: map[string]*feed{}, hubs: map[string]*queue.Hub{}, planes: map[string]map[string]bool{}}, nil
}
func Register(m *ctlruntime.Manager, opts Options) (*Controller, error) {
if err := m.AddToScheme(v1alpha1.AddToScheme, exposurev1alpha1.AddToScheme); err != nil {
return nil, err
}
ctl, err := New(opts)
if err != nil {
return nil, err
}
ctl.Provide()
options := []ctlruntime.Option{ctlruntime.Export(Export), ctlruntime.FieldManager(FieldManager), ctlruntime.Gone(ctl.gone),
ctlruntime.WatchesIn(ComputeVMExport, func(_ context.Context, src ctlruntime.Request, _ *v1alpha1.ComputeVM) []ctlruntime.Request {
return ctl.planesIn(src.Cluster)
}),
ctlruntime.WatchesIn(ComputeVMExport, func(_ context.Context, src ctlruntime.Request, _ *v1alpha1.GuestIdentityGrant) []ctlruntime.Request {
return ctl.planesIn(src.Cluster)
}),
ctlruntime.WatchesIn(IdentityExport, func(_ context.Context, src ctlruntime.Request, _ *v1alpha1.MarketIdentity) []ctlruntime.Request {
return ctl.planesIn(src.Cluster)
}),
ctlruntime.WatchesIn(VaultExport, func(_ context.Context, src ctlruntime.Request, _ *v1alpha1.OpenBaoServer) []ctlruntime.Request {
return ctl.planesIn(src.Cluster)
}),
ctlruntime.WatchesIn(ExposureExport, func(_ context.Context, src ctlruntime.Request, _ *exposurev1alpha1.Exposure) []ctlruntime.Request {
return ctl.planesIn(src.Cluster)
}),
}
if opts.Scope != nil {
options = append(options, ctlruntime.InWorkspaces(opts.Scope))
}
if err := ctlruntime.For[*v1alpha1.GuestControlPlane](m, Name, ctl, options...); err != nil {
return nil, fmt.Errorf("guestcontrolplane: registering the GuestControlPlane input controller: %w", err)
}
return ctl, nil
}
func (c *Controller) Reconcile(ctx context.Context, req ctlruntime.Request, object *v1alpha1.GuestControlPlane) (ctlruntime.Result, error) {
if !object.DeletionTimestamp.IsZero() {
c.forget(req)
return ctlruntime.Result{}, nil
}
c.remember(req)
in, err := c.inputs(ctx, req.Workspace, object)
if err != nil {
return ctlruntime.Result{}, err
}
if c.feedFor(req.Workspace, object.Name).publish(in) {
c.log.Info("the guest control plane inputs changed", "workspace", req.Workspace, "name", object.Name,
"computevms", len(in.ComputeVMs), "grants", len(in.Grants), "did", in.DID, "issuer", in.Issuer, "openbao", in.OpenBao != nil)
}
return ctlruntime.Result{}, nil
}
func (c *Controller) gone(_ context.Context, req ctlruntime.Request) {
c.forget(req)
}
func (c *Controller) inputs(ctx context.Context, workspace string, object *v1alpha1.GuestControlPlane) (guestcp.Inputs, error) {
var in guestcp.Inputs
if ref := identityRef(object.Spec); ref != nil && strings.TrimSpace(ref.Name) != "" {
var identity v1alpha1.MarketIdentity
switch err := c.store.Get(ctx, workspace, strings.TrimSpace(ref.Name), &identity); {
case err == nil:
in.DID = strings.TrimSpace(identity.Status.Did)
case !apierrors.IsNotFound(err):
return guestcp.Inputs{}, fmt.Errorf("reading the MarketIdentity %s: %w", ref.Name, err)
}
}
var exposure exposurev1alpha1.Exposure
switch err := c.store.Get(ctx, workspace, ExposureName(object.Name), &exposure); {
case err == nil:
in.Issuer = strings.TrimSpace(exposure.Status.Address)
case !apierrors.IsNotFound(err):
return guestcp.Inputs{}, fmt.Errorf("reading the Exposure %s: %w", ExposureName(object.Name), err)
}
if server := v1alpha1.VaultServer(object.Spec.VaultRef, DefaultVaultServer); !strings.HasPrefix(server, v1alpha1.KindRemoteOpenBao+"/") {
var openbao v1alpha1.OpenBaoServer
switch err := c.store.Get(ctx, workspace, server, &openbao); {
case err == nil:
in.OpenBao = openbao.Status.DeepCopy()
case !apierrors.IsNotFound(err):
return guestcp.Inputs{}, fmt.Errorf("reading the OpenBaoServer %s: %w", server, err)
}
}
var vms v1alpha1.ComputeVMList
if err := c.store.List(ctx, workspace, &vms); err != nil {
return guestcp.Inputs{}, fmt.Errorf("listing the ComputeVMs: %w", err)
}
in.ComputeVMs = vms.Items
var grants v1alpha1.GuestIdentityGrantList
if err := c.store.List(ctx, workspace, &grants); err != nil {
return guestcp.Inputs{}, fmt.Errorf("listing the GuestIdentityGrants: %w", err)
}
in.Grants = grants.Items
return in, nil
}
func ExposureName(name string) string {
return "svc-guestcontrolplane-" + strings.TrimSpace(name) + "-ingress"
}
func identityRef(spec v1alpha1.GuestControlPlaneSpec) *commonv1.ObjectRef {
if spec.Identity != nil {
return spec.Identity.MarketIdentityRef
}
return spec.PdsRef
}
func (c *Controller) remember(req ctlruntime.Request) {
c.mu.Lock()
defer c.mu.Unlock()
names := c.planes[req.Cluster]
if names == nil {
names = map[string]bool{}
c.planes[req.Cluster] = names
}
names[req.Name] = true
}
func (c *Controller) forget(req ctlruntime.Request) {
c.mu.Lock()
if names := c.planes[req.Cluster]; names != nil {
delete(names, req.Name)
if len(names) == 0 {
delete(c.planes, req.Cluster)
}
}
key := feedKey(req.Workspace, req.Name)
f := c.feeds[key]
delete(c.feeds, key)
c.mu.Unlock()
if f != nil {
f.close()
}
}
func (c *Controller) planesIn(cluster string) []ctlruntime.Request {
c.mu.Lock()
defer c.mu.Unlock()
out := make([]ctlruntime.Request, 0, len(c.planes[cluster]))
for name := range c.planes[cluster] {
out = append(out, ctlruntime.Request{Cluster: cluster, Name: name})
}
return out
}
func (c *Controller) feedFor(workspace, name string) *feed {
key := feedKey(workspace, name)
c.mu.Lock()
defer c.mu.Unlock()
f := c.feeds[key]
if f == nil {
f = newFeed()
c.feeds[key] = f
}
return f
}
func feedKey(workspace, name string) string {
return strings.TrimSpace(workspace) + "/" + strings.TrimSpace(name)
}