0
0
package eventstream
import (
"context"
"log/slog"
"strings"
"sync"
"sync/atomic"
"time"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
v1alpha1 "github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/market"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kube"
)
const (
foreignLogEvery = 1000
closedLogEvery = 100
temporaryNSIDPrefix = "com.publicdomainrelay.temp."
chasedReceiptsCap = 1024
)
type addressees struct {
role string
workspace string
log *slog.Logger
contracts *kube.Cache[v1alpha1.ComputeContract]
identities *kube.Cache[v1alpha1.MarketIdentity]
dirty atomic.Bool
mu sync.Mutex
index *market.Addressees
chased map[string]market.ContractRef
unread atomic.Int64
waits atomic.Int64
unaddressed atomic.Int64
closedRFPs atomic.Int64
}
func newAddressees(ctx context.Context, role, workspace string, dyn DynamicFactory, log *slog.Logger) (*addressees, error) {
client, err := dyn(workspace)
if err != nil {
return nil, err
}
a := &addressees{role: role, workspace: workspace, log: log, chased: map[string]market.ContractRef{}}
a.dirty.Store(true)
changed := func() { a.dirty.Store(true) }
if role == "requester" {
if a.contracts, err = kube.NewCache[v1alpha1.ComputeContract](client.Resource(v1alpha1.ComputeContractGVR), metav1.ListOptions{}, changed); err != nil {
return nil, err
}
go a.contracts.Run(ctx)
return a, nil
}
if a.identities, err = kube.NewCache[v1alpha1.MarketIdentity](client.Resource(v1alpha1.MarketIdentityGVR), metav1.ListOptions{}, changed); err != nil {
return nil, err
}
go a.identities.Run(ctx)
return a, nil
}
func (a *addressees) current(ctx context.Context) (*market.Addressees, bool) {
if a.contracts != nil && !a.contracts.WaitSynced(ctx) {
return nil, false
}
if a.identities != nil && !a.identities.WaitSynced(ctx) {
return nil, false
}
a.mu.Lock()
defer a.mu.Unlock()
if a.index == nil {
a.log.Info("market_addressees_synced", "role", a.role, "workspace", a.workspace)
}
if a.index == nil || a.dirty.Swap(false) {
if a.contracts != nil {
a.index = market.RequesterAddresseesOf(a.contracts.List(), market.RequesterContractSettled)
} else {
var dids []string
for _, id := range a.identities.List() {
dids = append(dids, id.Status.Did, id.Spec.Did)
}
a.index = market.BidderAddresseesOf(dids...)
}
}
return a.index, true
}
func (a *addressees) consumes(collection string) bool {
if a.role == "requester" {
return market.RequesterConsumes(collection)
}
return market.BidderConsumes(collection)
}
func (a *addressees) skipped(collection string) {
if strings.HasPrefix(collection, temporaryNSIDPrefix) {
a.drop(&a.unread, collection)
}
}
func (a *addressees) wants(ctx context.Context, collection, author string) bool {
if a.waits.Add(1) == 1 {
a.log.Info("market_addressees_first_record", "role", a.role, "workspace", a.workspace, "collection", collection)
}
if !a.consumes(collection) {
a.drop(&a.unread, collection)
return false
}
if a.role != "requester" {
return true
}
index, ok := a.current(ctx)
if !ok {
return false
}
if !index.RequesterWants(collection, author) {
a.drop(&a.unread, collection)
return false
}
return true
}
func (a *addressees) rkeyAddressed(ctx context.Context, collection, rkey string) bool {
if a.role == "requester" || collection != market.IngressOfferNSID {
return true
}
index, ok := a.current(ctx)
if !ok || !index.BidderOwnsRKey(collection, rkey) {
a.drop(&a.unaddressed, collection)
return false
}
return true
}
func (a *addressees) closed(source, collection, uri string, record map[string]any) bool {
if a.role == "requester" || collection != market.RFPNSID || !market.RFPBidWindowOver(uri, record, time.Now()) {
return false
}
if n := a.closedRFPs.Add(1); n == 1 || n%closedLogEvery == 0 {
a.log.Info("market_rfp_closed_dropped", "role", a.role, "workspace", a.workspace, "dropped", n, "source", source, "uri", uri,
"bidWindow", market.RFPBidWindow)
}
return true
}
type receiptFetch func(ctx context.Context, receiptURI string) (map[string]any, error)
func (a *addressees) owner(ctx context.Context, collection, author string, record map[string]any, fetch receiptFetch) (*market.ContractRef, bool) {
index, ok := a.current(ctx)
if !ok {
return nil, false
}
if a.role != "requester" {
if index.BidderAddressed(collection, record) {
return nil, true
}
a.drop(&a.unaddressed, collection)
return nil, false
}
ref, chase, matched := index.RequesterMatch(collection, author, record)
if !matched && chase != "" {
ref, matched = a.chase(ctx, index, chase, fetch)
}
if !matched {
a.drop(&a.unaddressed, collection)
return nil, false
}
return &ref, true
}
func (a *addressees) chase(ctx context.Context, index *market.Addressees, receiptURI string, fetch receiptFetch) (market.ContractRef, bool) {
a.mu.Lock()
known, seen := a.chased[receiptURI]
a.mu.Unlock()
if seen {
return known, true
}
record, err := fetch(ctx, receiptURI)
if err != nil {
return market.ContractRef{}, false
}
ref, ok := index.ReceiptMatch(record)
if ok {
a.mu.Lock()
if len(a.chased) >= chasedReceiptsCap {
clear(a.chased)
}
a.chased[receiptURI] = ref
a.mu.Unlock()
}
return ref, ok
}
func (a *addressees) drop(counter *atomic.Int64, collection string) {
n := counter.Add(1)
if n == 1 || n%foreignLogEvery == 0 {
a.log.Info("market_foreign_dropped", "role", a.role, "workspace", a.workspace, "unread", a.unread.Load(),
"unaddressed", a.unaddressed.Load(), "collection", collection)
}
}