0
0
package compose
import (
"cmp"
"context"
"fmt"
"maps"
"slices"
"sort"
"strings"
apierrors "k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/api/meta"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
commonv1 "github.com/johnandersen777/socialweb-computer-kcp/api/common/v1alpha1"
pdsv1alpha1 "github.com/johnandersen777/socialweb-computer-kcp/api/pds/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/atprotorepo"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/market"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/vault"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kube"
)
const SessionOwnerLabel = market.SessionOwnerLabel
type SessionOwner struct {
DID string
Vault string
Scope string
}
type SessionOwnerState struct {
PdsURL string
Ready bool
Message string
}
func (o SessionOwner) did() string { return strings.TrimSpace(o.DID) }
func (o SessionOwner) sessionPath() string { return "session/" + o.did() }
func (o SessionOwner) sessionScope() string {
return "auth/" + AtprotoMountPath + "/" + o.sessionPath()
}
func (o SessionOwner) SessionRef(r Root) commonv1.SecretRef {
return commonv1.SecretRef{Vault: &commonv1.ObjectRef{Group: v1alpha1.GroupName, Kind: KindVault, Name: o.Vault, Workspace: r.Workspace},
Mount: "auth/" + AtprotoMountPath, Path: o.sessionPath()}
}
func ownerPdsName(pdsURL string) string {
return "owner-" + Stamp(strings.TrimRight(strings.TrimSpace(pdsURL), "/"))
}
func SessionOwnerPds(pdsURL, ws string) (commonv1.ObjectRef, string) {
return RemotePDSRefIn(ownerPdsName(pdsURL), ws), pdsServiceDID(pdsURL)
}
func sessionOwnerLabels() map[string]string {
return map[string]string{SessionOwnerLabel: "true"}
}
func SessionOwnerLinks(r Root, ws, contracts string, o SessionOwner, pdsURL string) []Link {
identity := AppRef(KindMarketIdentity, OwnerIdentityName(o.did()), ws)
links := []Link{RefLink(identity, VaultRefIn(o.Vault, r.Workspace), Cap(vault.CapabilityAtprotoSession, o.sessionScope()))}
if pdsURL = strings.TrimRight(strings.TrimSpace(pdsURL), "/"); pdsURL == "" {
return links
}
repo := RepoRefIn(o.did(), ws)
remote := AppRef(KindRemoteRepo, repo.Name, ws)
links = append(links, RepoBackendLink(repo, remote))
links = append(links, RemoteRepoLinks(remote, RemotePDSRefIn(ownerPdsName(pdsURL), ws), identity, o.did())...)
return append(links, InfraLinks(contracts, repo)...)
}
func (c *Composer) SessionOwnerState(ctx context.Context, ws, did string) (SessionOwnerState, error) {
name := OwnerIdentityName(did)
id, err := c.Identity(ctx, ws, name)
if apierrors.IsNotFound(err) {
return SessionOwnerState{Message: "the MarketIdentity " + name + " is not applied yet"}, nil
}
if err != nil {
return SessionOwnerState{}, err
}
return SessionOwnerStateOf(id, did), nil
}
func SessionOwnerStateOf(id *v1alpha1.MarketIdentity, did string) SessionOwnerState {
name := OwnerIdentityName(did)
if id.Spec.Mode != v1alpha1.MarketIdentityModeOAuthSessionProxy || strings.TrimSpace(id.Status.Did) != strings.TrimSpace(did) {
return SessionOwnerState{Message: "the MarketIdentity " + name + " has not reported " + did + " yet"}
}
st := SessionOwnerState{Message: cmp.Or(id.Status.Message, string(id.Status.Phase)),
Ready: id.Status.Phase == v1alpha1.MarketIdentityPhaseReady && id.Status.ObservedGeneration >= id.Generation}
switch id.Status.Phase {
case v1alpha1.MarketIdentityPhaseReady, v1alpha1.MarketIdentityPhaseSessionExpired:
st.PdsURL = strings.TrimRight(strings.TrimSpace(id.Status.PdsURL), "/")
}
return st
}
const (
ConditionSessionOwnersReady = "SessionOwnersReady"
ReasonSessionOwnersReady = "Ready"
ReasonSessionOwnerNotReady = "OwnerNotReady"
)
func SetSessionOwnersCondition(conditions *[]metav1.Condition, gen int64, states map[string]SessionOwnerState) {
var waiting []string
for _, did := range slices.Sorted(maps.Keys(states)) {
if st := states[did]; !st.Ready {
waiting = append(waiting, did+": "+st.Message)
}
}
if len(waiting) == 0 {
meta.SetStatusCondition(conditions, metav1.Condition{Type: ConditionSessionOwnersReady, Status: metav1.ConditionTrue,
Reason: ReasonSessionOwnersReady, Message: fmt.Sprintf("%d tenant owner(s) publish Infra through the web app session", len(states)),
ObservedGeneration: gen})
return
}
meta.SetStatusCondition(conditions, metav1.Condition{Type: ConditionSessionOwnersReady, Status: metav1.ConditionFalse,
Reason: ReasonSessionOwnerNotReady, Message: strings.Join(waiting, "; "), ObservedGeneration: gen})
}
func (c *Composer) ApplySessionOwner(ctx context.Context, r Root, ws string, o SessionOwner, pdsURL string) error {
ref := o.SessionRef(r)
name := OwnerIdentityName(o.did())
identity := &v1alpha1.MarketIdentity{ObjectMeta: metav1.ObjectMeta{Name: name, Labels: sessionOwnerLabels()},
Spec: v1alpha1.MarketIdentitySpec{Mode: v1alpha1.MarketIdentityModeOAuthSessionProxy, Did: o.did(), Association: v1alpha1.AssociationSkip, SessionRef: &ref,
SessionScope: strings.TrimSpace(o.Scope)}}
if err := c.ApplyTyped(ctx, r, ws, MarketIdentityGVR, v1alpha1.GroupVersion.String(), KindMarketIdentity, identity); err != nil {
return err
}
if pdsURL = strings.TrimRight(strings.TrimSpace(pdsURL), "/"); pdsURL == "" {
return nil
}
remote := pdsv1alpha1.RemotePDSSpec{URL: pdsURL, DID: pdsServiceDID(pdsURL)}
if _, err := c.ApplyRemotePDS(ctx, r, ws, &pdsv1alpha1.RemotePDS{ObjectMeta: metav1.ObjectMeta{Name: ownerPdsName(pdsURL), Labels: sessionOwnerLabels()}, Spec: remote}); err != nil {
return err
}
repo := RepoRefIn(o.did(), ws).Name
spec := v1alpha1.RemoteRepoSpec{DID: o.did(), PdsRef: RemotePDSRefIn(ownerPdsName(pdsURL), ""),
CredentialsRef: commonv1.CredentialsRef{ObjectRef: commonv1.ObjectRef{Group: v1alpha1.GroupName, Kind: KindMarketIdentity, Name: name}}}
return c.applyRepo(ctx, r, ws, repo, KindRemoteRepo, v1alpha1.RemoteRepoGVR,
&v1alpha1.RemoteRepo{ObjectMeta: metav1.ObjectMeta{Name: repo, Labels: sessionOwnerLabels()}, Spec: spec}, sessionOwnerLabels())
}
func (c *Composer) SessionOwners(ctx context.Context, ws string) ([]string, error) {
ri, err := c.Client(ws, MarketIdentityGVR)
if err != nil {
return nil, err
}
items, err := kube.List[v1alpha1.MarketIdentity](ctx, ri, metav1.ListOptions{LabelSelector: SessionOwnerLabel + "=true"})
if apierrors.IsNotFound(err) {
return nil, nil
}
if err != nil {
return nil, err
}
var out []string
for _, id := range items {
if did := strings.TrimSpace(id.Spec.Did); did != "" && id.Spec.Mode == v1alpha1.MarketIdentityModeOAuthSessionProxy {
out = append(out, did)
}
}
sort.Strings(out)
return out, nil
}
func (c *Composer) InfraRecordRepos(ctx context.Context, ws string) (map[string]bool, error) {
ri, err := c.Client(ws, AtprotoRecordGVR)
if err != nil {
return nil, err
}
items, err := kube.List[v1alpha1.AtprotoRecord](ctx, ri, metav1.ListOptions{LabelSelector: v1alpha1.InfraKindLabel})
if apierrors.IsNotFound(err) {
return map[string]bool{}, nil
}
if err != nil {
return nil, err
}
out := map[string]bool{}
for _, rec := range items {
if rec.Spec.RepoRef != nil && strings.TrimSpace(rec.Spec.RepoRef.Name) != "" {
out[strings.TrimSpace(rec.Spec.RepoRef.Name)] = true
}
}
return out, nil
}
func (c *Composer) PruneSessionOwners(ctx context.Context, ws string, keep []string) error {
identities, repos := map[string]bool{}, map[string]bool{}
for _, did := range keep {
identities[OwnerIdentityName(did)] = true
repos[atprotorepo.RepoName(strings.TrimSpace(did))] = true
}
selector := SessionOwnerLabel + "=true"
if err := c.Prune(ctx, ws, v1alpha1.AtprotoRepoGVR, selector, repos); err != nil {
return err
}
if err := c.Prune(ctx, ws, v1alpha1.RemoteRepoGVR, selector, repos); err != nil {
return err
}
pdses, err := c.sessionOwnerPDSes(ctx, ws, selector)
if err != nil {
return err
}
if err := c.Prune(ctx, ws, RemotePDSGVR, selector, pdses); err != nil {
return err
}
return c.Prune(ctx, ws, MarketIdentityGVR, selector, identities)
}
func (c *Composer) sessionOwnerPDSes(ctx context.Context, ws, selector string) (map[string]bool, error) {
ri, err := c.Client(ws, v1alpha1.RemoteRepoGVR)
if err != nil {
return nil, err
}
items, err := kube.List[v1alpha1.RemoteRepo](ctx, ri, metav1.ListOptions{LabelSelector: selector})
if apierrors.IsNotFound(err) {
return map[string]bool{}, nil
}
if err != nil {
return nil, err
}
out := map[string]bool{}
for _, repo := range items {
if repo.DeletionTimestamp == nil && strings.TrimSpace(repo.Spec.PdsRef.Name) != "" {
out[strings.TrimSpace(repo.Spec.PdsRef.Name)] = true
}
}
return out, nil
}
func (c *Composer) SessionOwnerAppliedPdsURL(ctx context.Context, ws, did string) (string, error) {
repo, err := Get[v1alpha1.RemoteRepo](ctx, c, ws, v1alpha1.RemoteRepoGVR, RepoRefIn(did, ws).Name)
if apierrors.IsNotFound(err) {
return "", nil
}
if err != nil || repo == nil || strings.TrimSpace(repo.Spec.PdsRef.Name) == "" {
return "", err
}
pds, err := Get[pdsv1alpha1.RemotePDS](ctx, c, ws, RemotePDSGVR, strings.TrimSpace(repo.Spec.PdsRef.Name))
if apierrors.IsNotFound(err) {
return "", nil
}
if err != nil || pds == nil {
return "", err
}
return strings.TrimRight(strings.TrimSpace(pds.Spec.URL), "/"), nil
}