0
0
package cluster
import (
"context"
"errors"
"fmt"
"strings"
"sync"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/clusterprovider"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/clusterhome"
ctlruntime "github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime"
)
const (
ProviderName = "clusterprovider"
IdentityExport = "atprotoidentities"
HostProcessExport = "hostprocesses"
DefaultProviderWorkers = 32
)
type Pass interface {
Pass(ctx context.Context, ref clusterprovider.Ref, cl *v1alpha1.Cluster) (time.Duration, error)
Gone(ctx context.Context, ref clusterprovider.Ref)
ClaimGone(ctx context.Context)
}
type ProviderOptions struct {
Pass Pass
Keep func(ref clusterprovider.Ref) bool
Workers int
Changes <-chan string
}
type ProviderController struct {
pass Pass
keep func(ref clusterprovider.Ref) bool
mu sync.Mutex
byKey map[string]ctlruntime.Request
refs map[ctlruntime.Request]clusterprovider.Ref
}
func RegisterProvider(m *ctlruntime.Manager, opts ProviderOptions) (*ProviderController, error) {
if opts.Pass == nil {
return nil, errors.New("cluster: the provider controller needs a pass")
}
if err := m.AddToScheme(v1alpha1.AddToScheme); err != nil {
return nil, err
}
workers := opts.Workers
if workers <= 0 {
workers = DefaultProviderWorkers
}
ctl := &ProviderController{pass: opts.Pass, keep: opts.Keep, byKey: map[string]ctlruntime.Request{},
refs: map[ctlruntime.Request]clusterprovider.Ref{}}
options := []ctlruntime.Option{ctlruntime.Export(Export), ctlruntime.Workers(workers), ctlruntime.Gone(ctl.gone),
ctlruntime.InWorkspaces(homeOrUnresolved),
ctlruntime.Watches(ctl.nodeOf),
ctlruntime.Watches(ctl.claimOf),
ctlruntime.WatchesIn(IdentityExport, ctl.identityOf),
ctlruntime.WatchesIn(HostProcessExport, hostOf[*v1alpha1.HostProcess](ctl)),
ctlruntime.WatchesIn(HostProcessExport, hostOf[*v1alpha1.Postgres](ctl)),
ctlruntime.WatchesIn(HostProcessExport, hostOf[*v1alpha1.OpenBaoServer](ctl))}
if opts.Changes != nil {
events, err := ctlruntime.Forward(m, ProviderName+": changes", opts.Changes, ctl.requestsOf)
if err != nil {
return nil, fmt.Errorf("cluster: forwarding provider changes: %w", err)
}
options = append(options, ctlruntime.Events(events))
}
if err := ctlruntime.For[*v1alpha1.Cluster](m, ProviderName, ctl, options...); err != nil {
return nil, fmt.Errorf("cluster: registering the cluster provider controller: %w", err)
}
return ctl, nil
}
func (c *ProviderController) Reconcile(ctx context.Context, req ctlruntime.Request, object *v1alpha1.Cluster) (ctlruntime.Result, error) {
ref, err := refOf(req, object)
if err != nil {
return ctlruntime.Result{}, err
}
key, err := ref.Key()
if err != nil {
return ctlruntime.Result{}, err
}
if c.keep != nil && !c.keep(ref) {
return ctlruntime.Result{}, nil
}
c.remember(key, ctlruntime.Request{Cluster: req.Cluster, Namespace: req.Namespace, Name: req.Name}, ref)
after, err := c.pass.Pass(ctx, ref, object)
return ctlruntime.Result{RequeueAfter: after}, err
}
func refOf(req ctlruntime.Request, object *v1alpha1.Cluster) (clusterprovider.Ref, error) {
home := strings.TrimSpace(req.Workspace)
account, _, ok := strings.Cut(strings.TrimPrefix(home, clusterhome.RootWorkspace+":"), ":")
if !isHome(home) || !ok {
return clusterprovider.Ref{}, fmt.Errorf("cluster: the workspace path of cluster %s (logical cluster %s) is not resolved to a home %s:<account>:<cluster> yet: %q",
req.Name, req.Cluster, clusterhome.RootWorkspace, home)
}
if object.Spec.Account == "" {
return clusterprovider.Ref{}, fmt.Errorf("cluster: Cluster %s in %s has no spec.account, so no mount path can be derived for it", req.Name, home)
}
return clusterprovider.Ref{Account: clusterhome.RootWorkspace + ":" + account, DID: object.Spec.Account, Home: home, Name: req.Name}, nil
}
func isHome(workspace string) bool {
parts := strings.Split(workspace, ":")
return len(parts) == 3 && parts[0] == clusterhome.RootWorkspace && parts[1] != "" && parts[2] != ""
}
func homeOrUnresolved(workspace string) bool {
return !strings.Contains(workspace, ":") || isHome(workspace)
}
func (c *ProviderController) remember(key string, r ctlruntime.Request, ref clusterprovider.Ref) {
c.mu.Lock()
defer c.mu.Unlock()
c.byKey[key] = r
c.refs[r] = ref
}
func (c *ProviderController) gone(ctx context.Context, req ctlruntime.Request) {
r := ctlruntime.Request{Cluster: req.Cluster, Namespace: req.Namespace, Name: req.Name}
c.mu.Lock()
ref, known := c.refs[r]
if known {
delete(c.refs, r)
if key, err := ref.Key(); err == nil && c.byKey[key] == r {
delete(c.byKey, key)
}
}
c.mu.Unlock()
if known {
c.pass.Gone(ctx, ref)
}
}
func (c *ProviderController) Known() []clusterprovider.Ref {
c.mu.Lock()
defer c.mu.Unlock()
out := make([]clusterprovider.Ref, 0, len(c.refs))
for _, ref := range c.refs {
out = append(out, ref)
}
return out
}
func (c *ProviderController) request(key string) (ctlruntime.Request, bool) {
c.mu.Lock()
defer c.mu.Unlock()
r, ok := c.byKey[key]
return r, ok
}
func (c *ProviderController) nodeOf(_ context.Context, src ctlruntime.Request, node *v1alpha1.Node) []ctlruntime.Request {
if name := strings.TrimSpace(node.Spec.ClusterRef.Name); name != "" {
return []ctlruntime.Request{{Cluster: src.Cluster, Name: name}}
}
return nil
}
func (c *ProviderController) claimOf(ctx context.Context, src ctlruntime.Request, claim *v1alpha1.NodeClaim) []ctlruntime.Request {
if !claim.DeletionTimestamp.IsZero() {
c.pass.ClaimGone(ctx)
}
for _, owner := range claim.OwnerReferences {
if owner.Kind == "Cluster" && owner.Name != "" {
return []ctlruntime.Request{{Cluster: src.Cluster, Name: owner.Name}}
}
}
name := strings.TrimSpace(claim.Spec.ClusterRef.Name)
if name == "" {
return nil
}
if r, ok := c.request(name); ok {
return []ctlruntime.Request{r}
}
return []ctlruntime.Request{{Cluster: src.Cluster, Name: name}}
}
func (c *ProviderController) identityOf(_ context.Context, src ctlruntime.Request, _ *v1alpha1.AtprotoIdentity) []ctlruntime.Request {
c.mu.Lock()
defer c.mu.Unlock()
var out []ctlruntime.Request
for r, ref := range c.refs {
if ref.Account == src.Workspace {
out = append(out, r)
}
}
return out
}
func hostOf[T ctlruntime.Object](c *ProviderController) func(context.Context, ctlruntime.Request, T) []ctlruntime.Request {
return func(_ context.Context, _ ctlruntime.Request, obj T) []ctlruntime.Request {
if r, ok := c.request(obj.GetLabels()[clusterprovider.LabelCluster]); ok {
return []ctlruntime.Request{r}
}
return nil
}
}
func (c *ProviderController) requestsOf(key string) []ctlruntime.Request {
if r, ok := c.request(key); ok {
return []ctlruntime.Request{r}
}
return nil
}