0
0
package openbaoserver
import (
"context"
"errors"
"fmt"
"log/slog"
"sync"
"k8s.io/apimachinery/pkg/api/equality"
apierrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
ctlruntime "github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/conds"
"github.com/johnandersen777/socialweb-computer-kcp/internal/openbaoctl"
)
const (
Name = "openbaoserver"
Export = "hostprocesses"
GrantExport = "computevms"
GrantEventBuffer = 1024
)
type Grants interface {
List(ctx context.Context, workspace string) ([]v1alpha1.GuestIdentityGrant, error)
}
type Options struct {
Servers *openbaoctl.Servers
Grants Grants
Scope func(workspace string) bool
Log *slog.Logger
}
type grantKey struct {
cluster string
name string
}
type Controller struct {
log *slog.Logger
servers *openbaoctl.Servers
grants Grants
events chan ctlruntime.Request
mu sync.Mutex
identity map[string]map[string]struct{}
outcomes map[grantKey]v1alpha1.GuestIdentityGrantStatus
}
func New(opts Options) (*Controller, error) {
if opts.Servers == nil {
return nil, errors.New("openbaoserver: the OpenBao servers backend is required")
}
log := opts.Log
if log == nil {
log = slog.New(slog.DiscardHandler)
}
return &Controller{log: log.With("component", "openbaoserver-controller"), servers: opts.Servers, grants: opts.Grants,
events: make(chan ctlruntime.Request, GrantEventBuffer), identity: map[string]map[string]struct{}{},
outcomes: map[grantKey]v1alpha1.GuestIdentityGrantStatus{}}, nil
}
func Register(m *ctlruntime.Manager, opts Options) (*Controller, error) {
ctl, err := New(opts)
if err != nil {
return nil, err
}
options := []ctlruntime.Option{ctlruntime.Export(Export), ctlruntime.Owns[*v1alpha1.HostProcess](), ctlruntime.Gone(ctl.gone),
ctlruntime.WatchesIn(GrantExport, func(_ context.Context, src ctlruntime.Request, _ *v1alpha1.GuestIdentityGrant) []ctlruntime.Request {
return ctl.identityServers(src.Cluster)
})}
if opts.Scope != nil {
options = append(options, ctlruntime.InWorkspaces(opts.Scope))
}
if err := ctlruntime.For[*v1alpha1.OpenBaoServer](m, Name, ctl, options...); err != nil {
return nil, fmt.Errorf("openbaoserver: registering the OpenBaoServer controller: %w", err)
}
return ctl, nil
}
func (c *Controller) GrantEvents() <-chan ctlruntime.Request { return c.events }
func (c *Controller) Outcome(cluster, name string) (v1alpha1.GuestIdentityGrantStatus, bool) {
c.mu.Lock()
defer c.mu.Unlock()
st, ok := c.outcomes[grantKey{cluster: cluster, name: name}]
return st, ok
}
func (c *Controller) Forget(cluster, name string) {
c.mu.Lock()
defer c.mu.Unlock()
delete(c.outcomes, grantKey{cluster: cluster, name: name})
}
func (c *Controller) identityServers(cluster string) []ctlruntime.Request {
c.mu.Lock()
defer c.mu.Unlock()
out := make([]ctlruntime.Request, 0, len(c.identity[cluster]))
for name := range c.identity[cluster] {
out = append(out, ctlruntime.Request{Cluster: cluster, Name: name})
}
return out
}
func (c *Controller) index(cluster, name string, identity bool) {
c.mu.Lock()
defer c.mu.Unlock()
if !identity {
delete(c.identity[cluster], name)
if len(c.identity[cluster]) == 0 {
delete(c.identity, cluster)
}
return
}
if c.identity[cluster] == nil {
c.identity[cluster] = map[string]struct{}{}
}
c.identity[cluster][name] = struct{}{}
}
func (c *Controller) record(cluster string, outcomes map[string]v1alpha1.GuestIdentityGrantStatus) []string {
c.mu.Lock()
defer c.mu.Unlock()
var changed []string
for name, st := range outcomes {
k := grantKey{cluster: cluster, name: name}
if held, ok := c.outcomes[k]; ok && equality.Semantic.DeepEqual(held, st) {
continue
}
c.outcomes[k] = st
changed = append(changed, name)
}
return changed
}
func (c *Controller) Reconcile(ctx context.Context, req ctlruntime.Request, object *v1alpha1.OpenBaoServer) (ctlruntime.Result, error) {
if !object.DeletionTimestamp.IsZero() {
return ctlruntime.Result{}, nil
}
identity := openbaoctl.NeedsGrants(*object)
c.index(req.Cluster, object.Name, identity)
var grants []v1alpha1.GuestIdentityGrant
if identity {
if c.grants == nil {
return ctlruntime.Result{}, c.apply(ctx, req, object, failed(object, "this core reads no GuestIdentityGrants, so it cannot hold spec.declared.identityOIDC"))
}
list, err := c.grants.List(ctx, req.Workspace)
if err != nil && !apierrors.IsNotFound(err) {
return ctlruntime.Result{}, errors.Join(fmt.Errorf("openbaoserver: listing the GuestIdentityGrants of %s: %w", req.Workspace, err),
c.apply(ctx, req, object, failed(object, fmt.Sprintf("listing the GuestIdentityGrants: %v", err))))
}
grants = list
}
pctx, cancel := context.WithTimeout(ctx, openbaoctl.PassTimeout)
out := c.servers.Reconcile(pctx, *object, grants, children{req: req, owner: object})
cancel()
if err := c.apply(ctx, req, object, out.Status); err != nil {
return ctlruntime.Result{}, errors.Join(out.Err, err)
}
if changed := c.record(req.Cluster, out.Grants); len(changed) > 0 {
for _, name := range changed {
select {
case c.events <- ctlruntime.Request{Cluster: req.Cluster, Name: name}:
case <-ctx.Done():
return ctlruntime.Result{}, ctx.Err()
}
}
}
if out.Err != nil {
return ctlruntime.Result{}, fmt.Errorf("openbaoserver: %s: %w", object.Name, out.Err)
}
c.log.Debug("the OpenBaoServer is reconciled", "cluster", req.Cluster, "workspace", req.Workspace, "name", req.Name,
"phase", out.Status.Phase, "requeueAfter", out.RequeueAfter.String())
return ctlruntime.Result{RequeueAfter: out.RequeueAfter}, nil
}
func failed(object *v1alpha1.OpenBaoServer, message string) v1alpha1.OpenBaoServerStatus {
st := *object.Status.DeepCopy()
st.ObservedGeneration, st.Phase, st.Message, st.Ready = object.Generation, v1alpha1.OpenBaoServerPhaseFailed, message, false
conds.Set(&st.Conditions, object.Generation, openbaoctl.ConditionReady, false, "Failed", message)
return st
}
func (c *Controller) apply(ctx context.Context, req ctlruntime.Request, object *v1alpha1.OpenBaoServer, status v1alpha1.OpenBaoServerStatus) error {
next := object.DeepCopy()
next.Status = status
return req.ApplyStatus(ctx, next)
}
func (c *Controller) gone(ctx context.Context, req ctlruntime.Request) {
c.index(req.Cluster, req.Name, false)
name := openbaoctl.ChildName(req.Name)
var child v1alpha1.HostProcess
if err := req.Get(ctx, "", name, &child); err != nil {
return
}
if child.Labels[openbaoctl.OwnerLabel] != req.Name {
return
}
if err := req.Delete(ctx, &child); err != nil {
c.log.Warn("deleting the HostProcess of a gone OpenBaoServer", "workspace", req.Workspace, "openbaoserver", req.Name,
"hostprocess", name, "err", err.Error())
return
}
c.log.Info("the OpenBaoServer is gone; its HostProcess is deleted and the supervisor stops the unit; the storage stays",
"workspace", req.Workspace, "openbaoserver", req.Name, "hostprocess", name)
}
var _ openbaoctl.Children = children{}
type children struct {
req ctlruntime.Request
owner *v1alpha1.OpenBaoServer
}
func (c children) Ensure(ctx context.Context, name string, spec v1alpha1.HostProcessSpec) (v1alpha1.HostProcess, error) {
var cur v1alpha1.HostProcess
err := c.req.Get(ctx, "", name, &cur)
switch {
case err == nil:
if cur.Labels[openbaoctl.OwnerLabel] != c.owner.Name {
return cur, fmt.Errorf("HostProcess %s exists and is not owned by OpenBaoServer %s", name, c.owner.Name)
}
case !apierrors.IsNotFound(err):
return cur, err
}
want := &v1alpha1.HostProcess{ObjectMeta: metav1.ObjectMeta{Name: name, Labels: map[string]string{openbaoctl.OwnerLabel: c.owner.Name},
OwnerReferences: []metav1.OwnerReference{{APIVersion: v1alpha1.GroupVersion.String(), Kind: "OpenBaoServer", Name: c.owner.Name,
UID: c.owner.UID, Controller: new(true)}}}, Spec: spec}
if err := c.req.Apply(ctx, want); err != nil {
return cur, err
}
if err != nil {
return *want, nil
}
cur.Spec = spec
return cur, nil
}
func (c children) Delete(ctx context.Context, name string) error {
return c.req.Delete(ctx, &v1alpha1.HostProcess{ObjectMeta: metav1.ObjectMeta{Name: name}})
}