0
0
package ttl
import (
"context"
"errors"
"log/slog"
"slices"
"strings"
"sync"
"time"
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/ttlctl"
)
const (
Name = "ttl"
ExportBid = "computevms"
ExportComputeContract = "computecontracts"
ReportKindsLimit = 40
)
type Options struct {
Log *slog.Logger
Scope func(workspace string) bool
}
type entry struct {
kind string
cluster string
namespace string
name string
}
type deletion struct {
count int64
last time.Time
}
type Controller struct {
log *slog.Logger
mu sync.Mutex
tracked map[entry]struct{}
deleted map[string]*deletion
changedAt time.Time
}
func Register(m *ctlruntime.Manager, opts Options) (*Controller, error) {
log := opts.Log
if log == nil {
log = slog.New(slog.DiscardHandler)
}
c := &Controller{log: log.With("component", "ttl-controller"), tracked: map[entry]struct{}{}, deleted: map[string]*deletion{},
changedAt: time.Now()}
err := errors.Join(
register(m, c, opts, "Bid", ExportBid, func(o *v1alpha1.Bid) (*int32, []metav1.Condition) {
return o.Spec.TTLSecondsAfterFinished, o.Status.Conditions
}),
register(m, c, opts, "ComputeContract", ExportComputeContract, func(o *v1alpha1.ComputeContract) (*int32, []metav1.Condition) {
return o.Spec.TTLSecondsAfterFinished, o.Status.Conditions
}))
if err != nil {
return nil, err
}
return c, nil
}
func register[T ctlruntime.Object](m *ctlruntime.Manager, c *Controller, opts Options, kind, export string, finish func(T) (*int32, []metav1.Condition)) error {
r := &expiry[T]{c: c, kind: kind, finish: finish}
options := []ctlruntime.Option{ctlruntime.Export(export),
ctlruntime.Watches(func(_ context.Context, src ctlruntime.Request, obj T) []ctlruntime.Request {
return []ctlruntime.Request{{Cluster: src.Cluster, Namespace: obj.GetNamespace(), Name: obj.GetName()}}
}),
ctlruntime.Gone(func(_ context.Context, req ctlruntime.Request) { c.forget(entryOf(kind, req)) })}
if opts.Scope != nil {
options = append(options, ctlruntime.InWorkspaces(opts.Scope))
}
return ctlruntime.For[T](m, Name+"-"+strings.ToLower(kind), r, options...)
}
func entryOf(kind string, req ctlruntime.Request) entry {
return entry{kind: kind, cluster: req.Cluster, namespace: req.Namespace, name: req.Name}
}
type expiry[T ctlruntime.Object] struct {
c *Controller
kind string
finish func(T) (*int32, []metav1.Condition)
}
func (r *expiry[T]) Reconcile(ctx context.Context, req ctlruntime.Request, obj T) (ctlruntime.Result, error) {
key := entryOf(r.kind, req)
if !obj.GetDeletionTimestamp().IsZero() {
r.c.forget(key)
return ctlruntime.Result{}, nil
}
ttl, conditions := r.finish(obj)
at, due := ttlctl.Expiry(ttl, conditions)
if !due {
r.c.forget(key)
return ctlruntime.Result{}, nil
}
if wait := time.Until(at); wait > 0 {
r.c.track(key)
return ctlruntime.Result{RequeueAfter: wait}, nil
}
if err := req.Delete(ctx, obj); err != nil {
return ctlruntime.Result{}, err
}
r.c.removed(key)
r.c.log.Info("an object finished more than its TTL ago is deleted", "workspace", req.Workspace, "kind", r.kind, "name", req.Name,
"ttlSeconds", *ttl)
return ctlruntime.Result{}, nil
}
func (c *Controller) track(key entry) {
c.mu.Lock()
defer c.mu.Unlock()
if _, ok := c.tracked[key]; !ok {
c.tracked[key] = struct{}{}
c.changedAt = time.Now()
}
}
func (c *Controller) forget(key entry) {
c.mu.Lock()
defer c.mu.Unlock()
if _, ok := c.tracked[key]; ok {
delete(c.tracked, key)
c.changedAt = time.Now()
}
}
func (c *Controller) removed(key entry) {
c.mu.Lock()
defer c.mu.Unlock()
delete(c.tracked, key)
d := c.deleted[key.kind]
if d == nil {
d = &deletion{}
c.deleted[key.kind] = d
}
d.count++
d.last = time.Now()
c.changedAt = d.last
}
func (c *Controller) Report() *v1alpha1.TTLStatus {
c.mu.Lock()
defer c.mu.Unlock()
st := &v1alpha1.TTLStatus{SampledAt: c.changedAt.UTC().Format(time.RFC3339), Tracked: int64(len(c.tracked))}
for kind, d := range c.deleted {
st.Deleted = append(st.Deleted, v1alpha1.TTLDeleted{Kind: kind, Count: d.count, LastAt: d.last.UTC().Format(time.RFC3339)})
st.DeletedTotal += d.count
}
slices.SortFunc(st.Deleted, func(a, b v1alpha1.TTLDeleted) int { return strings.Compare(a.Kind, b.Kind) })
if len(st.Deleted) > ReportKindsLimit {
st.Deleted = st.Deleted[:ReportKindsLimit]
}
return st
}