0
0
package atprotorecord
import (
"context"
"errors"
"fmt"
"log/slog"
"strings"
"time"
apierrors "k8s.io/apimachinery/pkg/api/errors"
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/api/v1alpha1"
infrarecord "github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/infra"
"github.com/johnandersen777/socialweb-computer-kcp/internal/bus"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/atprotorepo"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/pds"
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/kit/binding"
)
const (
Name = "atprotorecord"
Export = "marketidentities"
RepoExport = "applications"
LinkExport = "exposures"
Kind = "AtprotoRecord"
RepoKind = "AtprotoRepo"
boundQueue = 64
MarketIdentityKind = "MarketIdentity"
RecordWatchKind = "AtprotoRecordWatch"
ConditionReferencesResolved = v1alpha1.ConditionReferencesResolved
ConditionInSync = v1alpha1.ConditionRecordInSync
ReasonLinkDenied = "LinkDenied"
ReasonRepoNotReady = "RepoNotReady"
ReasonInvalidSpec = "InvalidSpec"
ReasonSwapMismatch = "SwapMismatch"
ReasonRepoGone = "RepoGone"
ReasonDeleteGaveUp = "DeleteGaveUp"
)
var OwnKinds = []string{MarketIdentityKind, Kind, RecordWatchKind}
type DynamicFactory = kube.Factory
type Options struct {
Bus *bus.Bus
Dynamic DynamicFactory
Scope func(workspace string) bool
Log *slog.Logger
}
type Controller struct {
bus *bus.Bus
dynamic DynamicFactory
log *slog.Logger
repos *binding.Table[commonv1.ObjectRef]
bound chan ctlruntime.Request
}
func New(opts Options) *Controller {
log := opts.Log
if log == nil {
log = slog.New(slog.DiscardHandler)
}
return &Controller{bus: opts.Bus, dynamic: opts.Dynamic, log: log.With("component", "atprotorecord-controller"),
repos: binding.New[commonv1.ObjectRef](), bound: make(chan ctlruntime.Request, boundQueue)}
}
func (c *Controller) wakeOnBind() {
c.bus.Subscribe(func(key bus.Key) {
if key.Kind != RepoKind {
return
}
for _, req := range c.users(key.Workspace, RepoKind, key.Name) {
select {
case c.bound <- req:
default:
}
}
})
}
func Register(m *ctlruntime.Manager, opts Options) (*Controller, error) {
if err := m.AddToScheme(v1alpha1.AddToScheme, exposurev1alpha1.AddToScheme); err != nil {
return nil, err
}
ctl := New(opts)
ctl.wakeOnBind()
options := []ctlruntime.Option{ctlruntime.Export(Export), ctlruntime.Events(ctl.bound),
ctlruntime.Finalizer(v1alpha1.FinalizerAtprotoRecord),
ctlruntime.WatchesIn(RepoExport, func(_ context.Context, src ctlruntime.Request, obj *v1alpha1.AtprotoRepo) []ctlruntime.Request {
return ctl.users(src.Workspace, RepoKind, obj.Name)
}),
ctlruntime.WatchesIn(LinkExport, func(_ context.Context, src ctlruntime.Request, obj *exposurev1alpha1.ComponentLink) []ctlruntime.Request {
to := obj.Spec.To
if !strings.EqualFold(strings.TrimSpace(to.Kind), RepoKind) {
return nil
}
return ctl.users(to.InWorkspace(src.Workspace), RepoKind, to.Name)
}),
ctlruntime.Watches(func(_ context.Context, src ctlruntime.Request, obj *v1alpha1.MarketIdentity) []ctlruntime.Request {
return ctl.users(src.Workspace, MarketIdentityKind, obj.Name)
}),
ctlruntime.Watches(func(_ context.Context, src ctlruntime.Request, obj *v1alpha1.AtprotoRecord) []ctlruntime.Request {
return ctl.users(src.Workspace, Kind, obj.Name)
}),
ctlruntime.Watches(func(_ context.Context, src ctlruntime.Request, obj *v1alpha1.AtprotoRecordWatch) []ctlruntime.Request {
return ctl.users(src.Workspace, RecordWatchKind, obj.Name)
}),
ctlruntime.Gone(func(_ context.Context, req ctlruntime.Request) {
ctl.repos.Set(binding.Target{Cluster: req.Cluster, Workspace: req.Workspace, Name: req.Name}, nil)
})}
if opts.Scope != nil {
options = append(options, ctlruntime.InWorkspaces(opts.Scope))
}
if err := ctlruntime.For[*v1alpha1.AtprotoRecord](m, Name, ctl, options...); err != nil {
return nil, fmt.Errorf("atprotorecord: registering the AtprotoRecord controller: %w", err)
}
return ctl, nil
}
func (c *Controller) users(workspace, kind, name string) []ctlruntime.Request {
var out []ctlruntime.Request
for _, t := range c.repos.Users(binding.Key(workspace, kind, name)) {
out = append(out, ctlruntime.Request{Cluster: t.Cluster, Workspace: t.Workspace, Name: t.Name})
}
return out
}
func repoRef(workspace string, spec v1alpha1.AtprotoRecordSpec) (commonv1.ObjectRef, error) {
if spec.RepoRef == nil {
return commonv1.ObjectRef{}, errors.New("the record names no repoRef")
}
ref := *spec.RepoRef
if !strings.EqualFold(strings.TrimSpace(ref.Kind), RepoKind) || strings.TrimSpace(ref.Name) == "" {
return commonv1.ObjectRef{}, fmt.Errorf("the repoRef must name an %s, not %s %s", RepoKind, ref.Kind, ref.Name)
}
return commonv1.ObjectRef{Group: v1alpha1.GroupName, Kind: RepoKind, Name: strings.TrimSpace(ref.Name), Workspace: ref.InWorkspace(workspace)}, nil
}
func scopeOf(spec v1alpha1.AtprotoRecordSpec) []string {
return []string{strings.TrimSpace(spec.Collection)}
}
func (c *Controller) Reconcile(ctx context.Context, req ctlruntime.Request, object *v1alpha1.AtprotoRecord) (ctlruntime.Result, error) {
target := binding.Target{Cluster: req.Cluster, Workspace: req.Workspace, Name: req.Name}
if !object.DeletionTimestamp.IsZero() {
done, err := c.finalize(ctx, req, object, target)
if err != nil || done {
return ctlruntime.Result{}, err
}
return ctlruntime.Result{Waiting: true, Backoff: true}, nil
}
ref, err := repoRef(req.Workspace, object.Spec)
if err != nil {
c.repos.Set(target, nil)
return ctlruntime.Result{}, c.fail(ctx, req, object, ReasonInvalidSpec, err)
}
c.repos.Set(target, &ref, append([]string{binding.Key(ref.Workspace, RepoKind, ref.Name)}, referenceKeys(req.Workspace, object.Spec.Record)...)...)
repo, err := bus.Resolve[atprotorepo.Repo](ctx, c.bus, self(req, object), ref,
bus.Capability{Name: atprotorepo.CapabilityWrite, Scope: scopeOf(object.Spec)})
if err != nil {
return ctlruntime.Result{}, c.resolveFailed(ctx, req, object, err)
}
return ctlruntime.Result{}, c.sync(ctx, req, object, repo)
}
func self(req ctlruntime.Request, object *v1alpha1.AtprotoRecord) commonv1.ObjectRef {
return commonv1.ObjectRef{Group: v1alpha1.GroupName, Kind: Kind, Name: object.Name, Workspace: req.Workspace}
}
func (c *Controller) resolveFailed(ctx context.Context, req ctlruntime.Request, object *v1alpha1.AtprotoRecord, err error) error {
if errors.Is(err, bus.ErrLinkDenied) {
return errors.Join(err, c.fail(ctx, req, object, ReasonLinkDenied, err))
}
if errors.Is(err, atprotorepo.ErrNotBound) || errors.Is(err, pds.ErrNotFound) {
c.log.Info("an AtprotoRecord waits for its repo binding", "workspace", req.Workspace, "name", object.Name, "err", err.Error())
next := object.DeepCopy()
next.Status = failed(object, ReasonRepoNotReady, err).Status(object)
return req.ApplyStatus(ctx, next)
}
return errors.Join(err, c.fail(ctx, req, object, ReasonRepoNotReady, err))
}
func (c *Controller) sync(ctx context.Context, req ctlruntime.Request, object *v1alpha1.AtprotoRecord, repo atprotorepo.Repo) error {
dyn, err := c.client(req.Workspace)
if err != nil {
return err
}
own := func(ctx context.Context, from v1alpha1.AtprotoValueFrom) (map[string]any, bool, error) {
return ReadOwn(ctx, req, from)
}
outcome, err := Apply(ctx, repo, object, References{Own: own, Dynamic: dyn, Factory: c.dynamic, Workspace: req.Workspace})
if outcome.Written {
c.log.Info("an AtprotoRecord wrote its declared record", "workspace", req.Workspace, "name", object.Name, "uri", outcome.URI,
"cid", outcome.CID, "reason", outcome.Reason)
}
if err != nil {
c.log.Warn("an AtprotoRecord is not applied", "workspace", req.Workspace, "name", object.Name, "reason", outcome.Reason, "err", err.Error())
}
next := object.DeepCopy()
next.Status = outcome.Status(object)
if applyErr := req.ApplyStatus(ctx, next); applyErr != nil {
return errors.Join(err, applyErr)
}
if outcome.Retry {
return err
}
return nil
}
func (c *Controller) finalize(ctx context.Context, req ctlruntime.Request, object *v1alpha1.AtprotoRecord, target binding.Target) (bool, error) {
release := func(reason string, cause error) (bool, error) {
c.repos.Set(target, nil)
if reason != "" {
c.log.Warn("atprotorecord_released_without_delete", "workspace", req.Workspace, "name", object.Name,
"uri", object.Status.URI, "reason", reason, "err", cause.Error())
}
return true, nil
}
if strings.TrimSpace(object.Status.URI) == "" && strings.TrimSpace(object.Status.Cid) == "" {
return release("", nil)
}
if object.Spec.DeletionPolicy == v1alpha1.RecordDeletionRetain || keptCollection(object.Spec.Collection) {
c.log.Info("atprotorecord_retained", "workspace", req.Workspace, "name", object.Name, "uri", object.Status.URI,
"policy", object.Spec.DeletionPolicy)
return release("", nil)
}
ref, err := repoRef(req.Workspace, object.Spec)
if err != nil {
return release(ReasonInvalidSpec, err)
}
c.repos.Set(target, &ref, binding.Key(ref.Workspace, RepoKind, ref.Name))
gaveUp := time.Since(object.DeletionTimestamp.Time) > atprotorepo.RecordDeleteGiveUp
repo, err := bus.Resolve[atprotorepo.Repo](ctx, c.bus, self(req, object), ref,
bus.Capability{Name: atprotorepo.CapabilityWrite, Scope: scopeOf(object.Spec)})
switch {
case err != nil && c.repoGone(ctx, req.Workspace, ref):
return release(ReasonRepoGone, err)
case err != nil && gaveUp:
return release(ReasonDeleteGaveUp, err)
case errors.Is(err, atprotorepo.ErrNotBound) || errors.Is(err, pds.ErrNotFound):
c.log.Info("atprotorecord_delete_waits", "workspace", req.Workspace, "name", object.Name, "repo", ref.String(), "err", err.Error())
return false, nil
case err != nil:
return false, err
}
if err := deleteRecord(ctx, repo, strings.TrimSpace(object.Spec.Collection), strings.TrimSpace(object.Spec.Rkey)); err != nil {
if gaveUp {
return release(ReasonDeleteGaveUp, err)
}
return false, err
}
return release("", nil)
}
var keptCollections = map[string]bool{infrarecord.InfraNSID: true, infrarecord.EphemeralInfraNSID: true}
func keptCollection(collection string) bool {
return keptCollections[strings.TrimSpace(collection)]
}
func (c *Controller) repoGone(ctx context.Context, workspace string, ref commonv1.ObjectRef) bool {
cl, err := c.client(ref.InWorkspace(workspace))
if err != nil || cl == nil {
return false
}
_, err = kube.Get[metav1.PartialObjectMetadata](ctx, cl.Resource(v1alpha1.AtprotoRepoGVR), ref.Name)
return apierrors.IsNotFound(err)
}
func (c *Controller) client(workspace string) (*kube.Client, error) {
if c.dynamic == nil {
return nil, nil
}
return c.dynamic(workspace)
}
func (c *Controller) fail(ctx context.Context, req ctlruntime.Request, object *v1alpha1.AtprotoRecord, reason string, cause error) error {
c.log.Warn("an AtprotoRecord is not applied", "workspace", req.Workspace, "name", object.Name, "reason", reason, "err", cause.Error())
next := object.DeepCopy()
next.Status = failed(object, reason, cause).Status(object)
return req.ApplyStatus(ctx, next)
}