0
0
package localrepo
import (
"context"
"errors"
"fmt"
"log/slog"
"maps"
"slices"
"strings"
"sync"
"github.com/bluesky-social/indigo/atproto/syntax"
"k8s.io/apimachinery/pkg/runtime/schema"
commonv1 "github.com/johnandersen777/socialweb-computer-kcp/api/common/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
atpds "github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/pds"
atrepo "github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/repo"
"github.com/johnandersen777/socialweb-computer-kcp/internal/atprotorepo/scoped"
"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"
pdsctl "github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/pds"
ctlruntime "github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/binding"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/conds"
)
const (
Name = "localrepo"
Export = "applications"
Kind = "LocalRepo"
PdsKind = "Pds"
ReasonReady = "Ready"
ReasonInvalidSpec = "InvalidSpec"
ReasonLinkDenied = "LinkDenied"
ReasonPdsUnavailable = "PdsUnavailable"
ReasonAccountMissing = "AccountMissing"
ReasonAccountInactive = "AccountInactive"
ReasonObserveFailed = "ObserveFailed"
commitQueue = 256
)
var GroupKind = schema.GroupKind{Group: v1alpha1.GroupName, Kind: Kind}
type Options struct {
Bus *bus.Bus
Network atprotorepo.RecordReader
Pds pdsctl.Lookup
Scope func(workspace string) bool
Log *slog.Logger
}
type Controller struct {
bus *bus.Bus
network atprotorepo.RecordReader
pds pdsctl.Lookup
log *slog.Logger
backends *binding.Table[backend]
commits chan ctlruntime.Request
mu sync.Mutex
feeds map[string]*commitFeed
ready map[binding.Target]bool
closed bool
relays sync.WaitGroup
}
type commitFeed struct {
srv *atpds.Server
stop chan struct{}
}
func New(opts Options) *Controller {
log := opts.Log
if log == nil {
log = slog.New(slog.DiscardHandler)
}
return &Controller{bus: opts.Bus, network: opts.Network, pds: opts.Pds, log: log.With("component", "localrepo-controller"),
backends: binding.New[backend](), commits: make(chan ctlruntime.Request, commitQueue), feeds: map[string]*commitFeed{},
ready: map[binding.Target]bool{}}
}
func Register(m *ctlruntime.Manager, opts Options) (*Controller, error) {
if err := m.AddToScheme(v1alpha1.AddToScheme); err != nil {
return nil, err
}
ctl := New(opts)
ctl.Provide()
options := []ctlruntime.Option{ctlruntime.Export(Export),
ctlruntime.Watches(func(_ context.Context, src ctlruntime.Request, obj *v1alpha1.Pds) []ctlruntime.Request {
var out []ctlruntime.Request
for _, t := range ctl.backends.Users(binding.Key(src.Workspace, PdsKind, obj.Name)) {
out = append(out, ctlruntime.Request{Cluster: t.Cluster, Workspace: t.Workspace, Name: t.Name})
}
return out
}),
ctlruntime.Events(ctl.commits),
ctlruntime.Gone(func(_ context.Context, req ctlruntime.Request) {
ctl.release(binding.Target{Cluster: req.Cluster, Workspace: req.Workspace, Name: req.Name})
})}
if opts.Scope != nil {
options = append(options, ctlruntime.InWorkspaces(opts.Scope))
}
if err := ctlruntime.For[*v1alpha1.LocalRepo](m, Name, ctl, options...); err != nil {
return nil, fmt.Errorf("localrepo: registering the LocalRepo controller: %w", err)
}
if err := m.Go(Name+": commit feeds", ctl.serveFeeds); err != nil {
return nil, fmt.Errorf("localrepo: the commit feeds: %w", err)
}
return ctl, nil
}
func (c *Controller) serveFeeds(ctx context.Context) error {
<-ctx.Done()
c.mu.Lock()
c.closed = true
for key, feed := range c.feeds {
close(feed.stop)
delete(c.feeds, key)
}
c.mu.Unlock()
c.relays.Wait()
return nil
}
func (c *Controller) Provide() {
provide[atprotorepo.Repo](c, atprotorepo.CapabilityWrite)
provide[atprotorepo.RecordWriter](c, atprotorepo.CapabilityWrite)
provide[atprotorepo.RecordReader](c, atprotorepo.CapabilityRead)
provide[atprotorepo.Subscriber](c, atprotorepo.CapabilitySubscribe)
}
func provide[T any](c *Controller, capability string) {
bus.Provide(c.bus, GroupKind, capability, func(ctx context.Context, to commonv1.ObjectRef, scope []string) (T, error) {
var zero T
b, ok := c.backends.Get(to.Workspace, to.Name)
if !ok {
return zero, fmt.Errorf("%w: the LocalRepo %s is not reconciled", atprotorepo.ErrNotBound, to.String())
}
repo, err := open(ctx, c.bus, b, scope, c.network)
if err != nil {
return zero, err
}
out, ok := repo.(T)
if !ok {
return zero, fmt.Errorf("localrepo: the repo handle is not a %T", zero)
}
return out, nil
})
}
func (c *Controller) Reconcile(ctx context.Context, req ctlruntime.Request, object *v1alpha1.LocalRepo) (ctlruntime.Result, error) {
target := binding.Target{Cluster: req.Cluster, Workspace: req.Workspace, Name: req.Name}
if !object.DeletionTimestamp.IsZero() {
c.release(target)
return ctlruntime.Result{}, nil
}
generation := object.Generation
status := v1alpha1.AtprotoRepoBackendStatus{ObservedGeneration: generation, DID: strings.TrimSpace(object.Spec.DID),
Conditions: slices.Clone(object.Status.Conditions)}
pdsRef := object.Spec.PdsRef
pdsRef.Group = v1alpha1.GroupName
pdsRef.Workspace = pdsRef.InWorkspace(req.Workspace)
switch {
case !strings.EqualFold(strings.TrimSpace(pdsRef.Kind), PdsKind) || strings.TrimSpace(pdsRef.Name) == "":
c.release(target)
return c.notReady(ctx, req, object, status, ReasonInvalidSpec, "the pdsRef must name a Pds component", nil)
case !validDID(status.DID):
c.release(target)
return c.notReady(ctx, req, object, status, ReasonInvalidSpec, fmt.Sprintf("the did %q is not a DID", status.DID), nil)
}
repo := backend{Self: commonv1.ObjectRef{Group: v1alpha1.GroupName, Kind: Kind, Name: object.Name, Workspace: req.Workspace},
Labels: maps.Clone(object.Labels), Pds: pdsRef, DID: status.DID}
pdsKey := binding.Key(pdsRef.Workspace, PdsKind, pdsRef.Name)
prior, held := c.backends.Get(req.Workspace, req.Name)
c.backends.Set(target, &repo, pdsKey)
if !held || prior.Self != repo.Self || prior.Pds != repo.Pds || prior.DID != repo.DID || !maps.Equal(prior.Labels, repo.Labels) {
c.bus.NotifyBound(bus.Key{Workspace: req.Workspace, Kind: Kind, Name: req.Name})
}
c.follow(pdsKey, pdsRef)
c.prune()
handle, err := accounts(ctx, c.bus, repo)
if err != nil {
return c.resolveFailed(ctx, req, object, status, err)
}
info, err := handle.Describe(ctx)
if err != nil {
return c.notReady(ctx, req, object, status, ReasonObserveFailed, err.Error(), err)
}
status.Address = info.URL
account, err := handle.Account(ctx, status.DID)
if errors.Is(err, pds.ErrNotFound) {
return c.notReady(ctx, req, object, status, ReasonAccountMissing, err.Error(), nil)
}
if err != nil {
return c.notReady(ctx, req, object, status, ReasonObserveFailed, err.Error(), err)
}
status.KeyFingerprint = account.SigningKey
commits, err := syncer(ctx, c.bus, repo)
if err != nil {
return c.resolveFailed(ctx, req, object, status, err)
}
if head, err := commits.LatestCommit(ctx, status.DID); err == nil {
status.Head, status.Rev = head.CID, head.Rev
} else if !errors.Is(err, pds.ErrNotFound) {
return c.notReady(ctx, req, object, status, ReasonObserveFailed, err.Error(), err)
}
if _, err := open(ctx, c.bus, repo, nil, nil); err != nil {
return c.resolveFailed(ctx, req, object, status, err)
}
if !account.Active {
return c.notReady(ctx, req, object, status, ReasonAccountInactive, "the Pds account "+status.DID+" is not active", nil)
}
status.Writable = account.SigningKey != ""
conds.Set(&status.Conditions, generation, commonv1.ConditionReady, true, ReasonReady,
fmt.Sprintf("the Pds %s signs the repo %s in process", pdsRef.Name, status.DID))
if err := c.apply(ctx, req, object, status); err != nil {
return ctlruntime.Result{}, err
}
c.settle(req, true)
return ctlruntime.Result{}, nil
}
func (c *Controller) settle(req ctlruntime.Request, ready bool) {
target := binding.Target{Cluster: req.Cluster, Workspace: req.Workspace, Name: req.Name}
c.mu.Lock()
was := c.ready[target]
if ready {
c.ready[target] = true
} else {
delete(c.ready, target)
}
c.mu.Unlock()
if ready && !was {
c.bus.NotifyBound(bus.Key{Workspace: req.Workspace, Kind: Kind, Name: req.Name})
}
}
func (c *Controller) resolveFailed(ctx context.Context, req ctlruntime.Request, object *v1alpha1.LocalRepo,
status v1alpha1.AtprotoRepoBackendStatus, err error) (ctlruntime.Result, error) {
switch {
case errors.Is(err, bus.ErrLinkDenied):
return c.notReady(ctx, req, object, status, ReasonLinkDenied, err.Error(), err)
case errors.Is(err, pds.ErrNotFound), errors.Is(err, atprotorepo.ErrNotFound), errors.Is(err, bus.ErrNoProvider):
return c.notReady(ctx, req, object, status, ReasonPdsUnavailable, err.Error(), nil)
}
return c.notReady(ctx, req, object, status, ReasonObserveFailed, err.Error(), err)
}
func (c *Controller) notReady(ctx context.Context, req ctlruntime.Request, object *v1alpha1.LocalRepo, status v1alpha1.AtprotoRepoBackendStatus,
reason, message string, cause error) (ctlruntime.Result, error) {
c.settle(req, false)
status.Writable = false
conds.Set(&status.Conditions, object.Generation, commonv1.ConditionReady, false, reason, message)
if err := c.apply(ctx, req, object, status); err != nil {
return ctlruntime.Result{}, errors.Join(cause, err)
}
return ctlruntime.Result{}, cause
}
func (c *Controller) apply(ctx context.Context, req ctlruntime.Request, object *v1alpha1.LocalRepo, status v1alpha1.AtprotoRepoBackendStatus) error {
next := object.DeepCopy()
next.Status = status
return req.ApplyStatus(ctx, next)
}
func validDID(raw string) bool {
_, err := syntax.ParseDID(raw)
return err == nil
}
type backend struct {
Self commonv1.ObjectRef
Labels map[string]string
Pds commonv1.ObjectRef
DID string
}
func (b backend) caller(ctx context.Context) context.Context {
return bus.WithCallerLabels(ctx, b.Self, b.Labels)
}
func open(ctx context.Context, b *bus.Bus, repo backend, scope []string, network atprotorepo.RecordReader) (atprotorepo.Repo, error) {
signer, err := bus.Resolve[atprotorepo.Repo](repo.caller(ctx), b, repo.Self, repo.Pds,
bus.Capability{Name: pds.CapabilityAccount, Scope: []string{repo.DID}})
if err != nil {
return nil, err
}
return scoped.New(scoped.Route(signer, network), scope), nil
}
func accounts(ctx context.Context, b *bus.Bus, repo backend) (pds.Accounts, error) {
return bus.Resolve[pds.Accounts](repo.caller(ctx), b, repo.Self, repo.Pds,
bus.Capability{Name: pds.CapabilityAccount, Scope: []string{repo.DID}})
}
func syncer(ctx context.Context, b *bus.Bus, repo backend) (pds.Sync, error) {
return bus.Resolve[pds.Sync](repo.caller(ctx), b, repo.Self, repo.Pds, bus.Capability{Name: pds.CapabilitySync})
}
func (c *Controller) release(target binding.Target) {
c.backends.Set(target, nil)
c.mu.Lock()
delete(c.ready, target)
c.mu.Unlock()
c.prune()
}
func (c *Controller) follow(pdsKey string, pdsRef commonv1.ObjectRef) {
if c.pds == nil {
return
}
srv, ok := c.pds(pdsRef.Workspace, strings.TrimSpace(pdsRef.Name))
c.mu.Lock()
defer c.mu.Unlock()
if c.closed {
return
}
current := c.feeds[pdsKey]
if !ok || srv == nil {
if current != nil {
close(current.stop)
delete(c.feeds, pdsKey)
}
return
}
if current != nil && current.srv == srv {
return
}
if current != nil {
close(current.stop)
}
feed := &commitFeed{srv: srv, stop: make(chan struct{})}
c.feeds[pdsKey] = feed
c.relays.Go(func() { c.relay(pdsKey, feed) })
}
func (c *Controller) prune() {
c.mu.Lock()
defer c.mu.Unlock()
for key, feed := range c.feeds {
if len(c.backends.Users(key)) == 0 {
close(feed.stop)
delete(c.feeds, key)
}
}
}
func (c *Controller) relay(pdsKey string, feed *commitFeed) {
for {
live, cancel := feed.srv.Sequencer().Subscribe()
stopped := c.forward(pdsKey, feed, live)
cancel()
if stopped {
return
}
c.log.Warn("the Pds commit feed dropped the LocalRepo controller; it resubscribes", "pds", pdsKey)
if !c.enqueue(pdsKey, "", feed.stop) {
return
}
}
}
func (c *Controller) forward(pdsKey string, feed *commitFeed, live <-chan *atrepo.CommitEvent) bool {
for {
select {
case <-feed.stop:
return true
case ev, ok := <-live:
if !ok {
return false
}
if !c.enqueue(pdsKey, ev.Repo.String(), feed.stop) {
return true
}
}
}
}
func (c *Controller) enqueue(pdsKey, did string, stop <-chan struct{}) bool {
for _, t := range c.backends.Users(pdsKey) {
if did != "" {
b, ok := c.backends.Get(t.Workspace, t.Name)
if !ok || b.DID != did {
continue
}
}
select {
case <-stop:
return false
case c.commits <- ctlruntime.Request{Cluster: t.Cluster, Name: t.Name}:
}
}
return true
}