0
0
package guestcontrolplane
import (
"context"
"errors"
"fmt"
"reflect"
"strings"
"sync"
"k8s.io/apimachinery/pkg/runtime"
commonv1 "github.com/johnandersen777/socialweb-computer-kcp/api/common/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"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kube"
"github.com/johnandersen777/socialweb-computer-kcp/internal/guestcp/queue"
)
func (c *Controller) Provide() {
bus.Provide(c.bus, GroupKind, guestcp.CapabilityInputs, func(_ context.Context, to commonv1.ObjectRef, _ []string) (guestcp.Source, error) {
workspace, name, err := target(to)
if err != nil {
return nil, err
}
return c.feedFor(workspace, name), nil
})
bus.Provide(c.bus, GroupKind, guestcp.CapabilityGuests, func(_ context.Context, to commonv1.ObjectRef, _ []string) (guestcp.Guests, error) {
workspace, _, err := target(to)
if err != nil {
return nil, err
}
return guests{store: c.store, workspace: workspace}, nil
})
bus.Provide(c.bus, GroupKind, guestcp.CapabilityGrants, func(_ context.Context, to commonv1.ObjectRef, _ []string) (guestcp.Grants, error) {
workspace, _, err := target(to)
if err != nil {
return nil, err
}
return grants{store: c.store, workspace: workspace}, nil
})
bus.Provide(c.bus, GroupKind, guestcp.CapabilityEvents, func(_ context.Context, to commonv1.ObjectRef, _ []string) (guestcp.Events, error) {
workspace, name, err := target(to)
if err != nil {
return nil, err
}
return c.hubFor(workspace, name), nil
})
bus.Provide(c.bus, GroupKind, guestcp.CapabilityQueue, func(_ context.Context, to commonv1.ObjectRef, _ []string) (guestcp.Queue, error) {
workspace, name, err := target(to)
if err != nil {
return nil, err
}
return c.hubFor(workspace, name), nil
})
}
func (c *Controller) hubFor(workspace, name string) *queue.Hub {
key := feedKey(workspace, name)
c.mu.Lock()
defer c.mu.Unlock()
h := c.hubs[key]
if h == nil {
h = queue.New()
c.hubs[key] = h
}
return h
}
func target(to commonv1.ObjectRef) (string, string, error) {
workspace, name := strings.TrimSpace(to.Workspace), strings.TrimSpace(to.Name)
if workspace == "" || name == "" {
return "", "", fmt.Errorf("guestcontrolplane: the handle target %s names no workspace or name", to.String())
}
return workspace, name, nil
}
type feed struct {
mu sync.Mutex
inputs guestcp.Inputs
held bool
next int
watchers map[int]func(guestcp.Inputs)
}
var _ guestcp.Source = (*feed)(nil)
func newFeed() *feed {
return &feed{watchers: map[int]func(guestcp.Inputs){}}
}
func (f *feed) Inputs(context.Context) (guestcp.Inputs, error) {
f.mu.Lock()
defer f.mu.Unlock()
return f.inputs, nil
}
func (f *feed) Watch(fn func(guestcp.Inputs)) func() {
if fn == nil {
return func() {}
}
f.mu.Lock()
id := f.next
f.next++
f.watchers[id] = fn
in, held := f.inputs, f.held
f.mu.Unlock()
if held {
fn(in)
}
return func() {
f.mu.Lock()
delete(f.watchers, id)
f.mu.Unlock()
}
}
func (f *feed) publish(in guestcp.Inputs) bool {
f.mu.Lock()
if f.held && reflect.DeepEqual(f.inputs, in) {
f.mu.Unlock()
return false
}
f.inputs, f.held = in, true
watchers := make([]func(guestcp.Inputs), 0, len(f.watchers))
for _, fn := range f.watchers {
watchers = append(watchers, fn)
}
f.mu.Unlock()
for _, fn := range watchers {
fn(in)
}
return true
}
func (f *feed) close() {
f.mu.Lock()
f.watchers = map[int]func(guestcp.Inputs){}
f.mu.Unlock()
}
type guests struct {
store Store
workspace string
}
var _ guestcp.Guests = guests{}
func (g guests) RecordGuest(ctx context.Context, name string, report v1alpha1.ComputeVMGuestReport) error {
name = strings.TrimSpace(name)
if name == "" {
return errors.New("guestcontrolplane: the guest report names no ComputeVM")
}
guest, err := runtime.DefaultUnstructuredConverter.ToUnstructured(&report)
if err != nil {
return err
}
doc := kube.Doc{
"apiVersion": v1alpha1.GroupVersion.String(),
"kind": "ComputeVM",
"metadata": map[string]any{"name": name},
"status": map[string]any{"market": map[string]any{"guest": guest}},
}
return g.store.Apply(ctx, g.workspace, FieldManager, doc, true)
}
type grants struct {
store Store
workspace string
}
var _ guestcp.Grants = grants{}
func (g grants) Apply(ctx context.Context, grant v1alpha1.GuestIdentityGrant) error {
if strings.TrimSpace(grant.Name) == "" {
return errors.New("guestcontrolplane: applying a GuestIdentityGrant with no name")
}
object, err := runtime.DefaultUnstructuredConverter.ToUnstructured(&grant)
if err != nil {
return err
}
metadata := map[string]any{"name": grant.Name}
held, _ := object["metadata"].(map[string]any)
if owners, _ := held["ownerReferences"].([]any); len(owners) > 0 {
metadata["ownerReferences"] = owners
}
if labels, _ := held["labels"].(map[string]any); len(labels) > 0 {
metadata["labels"] = labels
}
doc := kube.Doc{
"apiVersion": v1alpha1.GroupVersion.String(),
"kind": "GuestIdentityGrant",
"metadata": metadata,
"spec": object["spec"],
}
return g.store.Apply(ctx, g.workspace, FieldManager, doc, false)
}
func (g grants) Delete(ctx context.Context, name string) error {
name = strings.TrimSpace(name)
if name == "" {
return nil
}
grant := &v1alpha1.GuestIdentityGrant{}
grant.Name = name
return g.store.Delete(ctx, g.workspace, grant)
}