0
0
package compose
import (
"context"
"crypto/sha256"
"encoding/hex"
"fmt"
"net/url"
"slices"
"strings"
apierrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime/schema"
commonv1 "github.com/johnandersen777/socialweb-computer-kcp/api/common/v1alpha1"
eventsv1alpha1 "github.com/johnandersen777/socialweb-computer-kcp/api/events/v1alpha1"
exposurev1alpha1 "github.com/johnandersen777/socialweb-computer-kcp/api/exposure/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/contract/atprotorepo"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/events"
"github.com/johnandersen777/socialweb-computer-kcp/internal/eventstream"
)
const (
marketStreamLabel = "socialweb.computer/market-stream"
marketSourceLabel = "socialweb.computer/market-source"
rootSourceValue = "root"
NetworkRelaySourceName = "relay-network"
LocalRepoSourceName = "local-repo"
JetstreamEastSourceName = "jetstream-bsky-us-east"
JetstreamWestSourceName = "jetstream-bsky-us-west"
PublicJetstreamEastURL = v1alpha1.PublicJetstreamEastURL
PublicJetstreamWestURL = v1alpha1.PublicJetstreamWestURL
publicSourcePrefix = "firehose-"
networkSourcePrefix = "network-"
publicSourceValue = "public-"
)
var RequesterStreamCollections = []string{market.BidNSID, market.ReceiptNSID, market.EventNSID}
var BidderStreamCollections = []string{market.RFPNSID, market.AcceptNSID, market.EventNSID, market.IngressOfferNSID}
func MarketStreamCollections(role string) []string {
if role == RequesterStreamRole {
return slices.Clone(RequesterStreamCollections)
}
return slices.Clone(BidderStreamCollections)
}
type SourceInput struct {
Network *v1alpha1.MarketNetworkValue
LocalDID string
}
type rootSource struct {
Name string
Relay *eventsv1alpha1.RelayEventSourceSpec
Jetstream *eventsv1alpha1.JetstreamEventSourceSpec
Pds *eventsv1alpha1.PdsEventSourceSpec
}
func (s rootSource) backend() (commonv1.ObjectRef, schema.GroupVersionResource, any) {
ref := commonv1.ObjectRef{Group: eventsv1alpha1.GroupName, Name: s.Name}
meta := metav1.ObjectMeta{Name: s.Name}
switch {
case s.Relay != nil:
ref.Kind = eventsv1alpha1.RelayEventSourceKind
return ref, eventsv1alpha1.RelayEventSourceGVR, &eventsv1alpha1.RelayEventSource{ObjectMeta: meta, Spec: *s.Relay}
case s.Pds != nil:
ref.Kind = eventsv1alpha1.PdsEventSourceKind
return ref, eventsv1alpha1.PdsEventSourceGVR, &eventsv1alpha1.PdsEventSource{ObjectMeta: meta, Spec: *s.Pds}
}
ref.Kind = eventsv1alpha1.JetstreamEventSourceKind
return ref, eventsv1alpha1.JetstreamEventSourceGVR, &eventsv1alpha1.JetstreamEventSource{ObjectMeta: meta, Spec: *s.Jetstream}
}
func MarketCommsMode(comms *v1alpha1.MarketComms) v1alpha1.MarketCommsMode {
if comms == nil || strings.TrimSpace(string(comms.Mode)) == "" {
return v1alpha1.MarketCommsModeXRPC
}
return comms.Mode
}
func OAuthReceiveOnly(mode v1alpha1.MarketIdentityMode) bool {
switch mode {
case v1alpha1.MarketIdentityModeOAuthQr, v1alpha1.MarketIdentityModeOAuthBrowser, v1alpha1.MarketIdentityModeOAuthDelegated:
return true
}
return false
}
func watchSources(network *v1alpha1.MarketNetworkValue) []rootSource {
if relay := network.RelayURL(); relay != "" {
return []rootSource{{Name: NetworkRelaySourceName, Relay: &eventsv1alpha1.RelayEventSourceSpec{URL: relay}}}
}
if comms := network.MergeComms(nil); comms != nil && (comms.RelayURLs != nil || comms.JetstreamURLs != nil) {
var out []rootSource
if comms.RelayURLs != nil {
for _, u := range comms.FirehoseRelays(network) {
out = append(out, rootSource{Name: ObjectName(networkSourcePrefix+"relay", u), Relay: &eventsv1alpha1.RelayEventSourceSpec{URL: u}})
}
}
if comms.JetstreamURLs != nil {
for _, u := range comms.FirehoseJetstreams() {
out = append(out, rootSource{Name: ObjectName(networkSourcePrefix+"jetstream", u), Jetstream: &eventsv1alpha1.JetstreamEventSourceSpec{URL: u}})
}
}
if len(out) > 0 {
return out
}
}
return []rootSource{
{Name: JetstreamEastSourceName, Jetstream: &eventsv1alpha1.JetstreamEventSourceSpec{URL: PublicJetstreamEastURL}},
{Name: JetstreamWestSourceName, Jetstream: &eventsv1alpha1.JetstreamEventSourceSpec{URL: PublicJetstreamWestURL}},
}
}
func rootSources(in SourceInput) []rootSource {
out := watchSources(in.Network)
if did := strings.TrimSpace(in.LocalDID); did != "" {
out = append(out, rootSource{Name: LocalRepoSourceName, Pds: &eventsv1alpha1.PdsEventSourceSpec{
RepoRef: commonv1.ObjectRef{Group: v1alpha1.GroupName, Kind: KindAtprotoRepo, Name: atprotorepo.RepoName(did)}}})
}
return out
}
func WatchEventSources(in SourceInput) []commonv1.ObjectRef {
var out []commonv1.ObjectRef
for _, s := range watchSources(in.Network) {
out = append(out, EventSourceRef(s.Name))
}
return out
}
func marketSourceRefs(ws string, comms *v1alpha1.MarketComms, network *v1alpha1.MarketNetworkValue, oauth bool) []commonv1.ObjectRef {
var out []commonv1.ObjectRef
add := func(ref commonv1.ObjectRef) {
ref = commonv1.ObjectRef{Group: eventsv1alpha1.GroupName, Kind: eventsv1alpha1.EventSourceKind, Name: strings.TrimSpace(ref.Name),
Workspace: ref.InWorkspace(ws)}
if ref.Name != "" && !slices.Contains(out, ref) {
out = append(out, ref)
}
}
if comms != nil {
for _, ref := range comms.EventSourceRefs {
add(ref)
}
}
if network != nil && network.RelayURL() != "" {
add(EventSourceRef(NetworkRelaySourceName))
}
if len(out) == 0 && oauth {
add(EventSourceRef(watchSources(network)[0].Name))
}
return out
}
func marketStreamName(role string, ref commonv1.ObjectRef) string {
sum := sha256.Sum256([]byte(role + "|" + ref.Workspace + "/" + ref.Name))
return ObjectName("market-"+role, hex.EncodeToString(sum[:8]))
}
func eventLinkName(parts ...string) string {
sum := sha256.Sum256([]byte(strings.Join(parts, "|")))
return "events-" + hex.EncodeToString(sum[:10])
}
func streamSelector(ws string, labels map[string]string, expressions []exposurev1alpha1.ComponentLinkSelectorRequirement) exposurev1alpha1.ComponentLinkSelector {
return exposurev1alpha1.ComponentLinkSelector{Group: eventsv1alpha1.GroupName, Kind: "EventStream",
Workspace: ws, MatchLabels: labels, MatchExpressions: expressions}
}
type Streams struct {
Role string
Workspace string
Comms *v1alpha1.MarketComms
Sources SourceInput
ForceFirehose bool
Public PublicSources
}
type PublicSources struct {
Relays []string
Jetstreams []string
}
func RequesterPublicSources(comms *v1alpha1.MarketComms, network *v1alpha1.MarketNetworkValue, mode v1alpha1.MarketCommsMode) PublicSources {
if mode != v1alpha1.MarketCommsModeFirehose && mode != v1alpha1.MarketCommsModeBoth {
return PublicSources{}
}
return PublicSources{Relays: comms.FirehoseRelays(network), Jetstreams: comms.FirehoseJetstreams()}
}
func PublicSourceName(kind, raw string) string {
host := raw
if u, err := url.Parse(strings.TrimSpace(raw)); err == nil && u.Host != "" {
host = u.Host
}
return ObjectName(publicSourcePrefix+kind, host)
}
func (p PublicSources) sources() []rootSource {
var out []rootSource
seen := map[string]bool{}
add := func(s rootSource) {
if !seen[s.Name] {
seen[s.Name] = true
out = append(out, s)
}
}
for _, u := range p.Relays {
add(rootSource{Name: PublicSourceName("relay", u), Relay: &eventsv1alpha1.RelayEventSourceSpec{URL: u}})
}
for _, u := range p.Jetstreams {
add(rootSource{Name: PublicSourceName("jetstream", u), Jetstream: &eventsv1alpha1.JetstreamEventSourceSpec{URL: u}})
}
return out
}
type MarketStreams struct {
Links []Link
}
func RequesterCommsMode(comms *v1alpha1.MarketComms, forceFirehose bool) v1alpha1.MarketCommsMode {
return streamMode(Streams{Role: RequesterStreamRole, Comms: comms, ForceFirehose: forceFirehose})
}
func streamMode(s Streams) v1alpha1.MarketCommsMode {
if s.ForceFirehose {
return v1alpha1.MarketCommsModeFirehose
}
if s.Role == RequesterStreamRole && (s.Comms == nil || strings.TrimSpace(string(s.Comms.Mode)) == "") {
return v1alpha1.MarketCommsModeBoth
}
return MarketCommsMode(s.Comms)
}
type marketStreamRef struct {
ref commonv1.ObjectRef
dids []string
bound bool
resume eventsv1alpha1.EventStreamResume
collections []string
}
func (r marketStreamRef) streamCollections(role string) []string {
if len(r.collections) > 0 {
return slices.Clone(r.collections)
}
return MarketStreamCollections(role)
}
func (c *Composer) ApplyMarketStreams(ctx context.Context, r Root, s Streams) (MarketStreams, error) {
ws := workspaceOr(s.Workspace, r.Workspace)
offersOnly := s.Role == BidderStreamRole && streamMode(s) != v1alpha1.MarketCommsModeFirehose && streamMode(s) != v1alpha1.MarketCommsModeBoth
if offersOnly {
s.Public = PublicSources{Relays: s.Comms.FirehoseRelays(s.Sources.Network), Jetstreams: s.Comms.FirehoseJetstreams()}
}
links, err := c.applyRootSources(ctx, r, ws, s.Sources)
if err != nil {
return MarketStreams{}, err
}
publicRefs, publicLinks, err := c.applySources(ctx, r, ws, s.Role, publicSourceValue, s.Public.sources())
if err != nil {
return MarketStreams{}, err
}
links = append(links, publicLinks...)
if err := c.pruneRetiredBidderSources(ctx, ws, s.Role); err != nil {
return MarketStreams{}, err
}
var requesters []string
if s.Role == BidderStreamRole {
if requesters, err = c.liveRequesters(ctx, ws); err != nil {
return MarketStreams{}, err
}
}
requesterRefs, requesterLinks, err := c.applySources(ctx, r, ws, s.Role, requesterSourceValue, requesterSources(s.Comms, s.Sources.Network, requesters))
if err != nil {
return MarketStreams{}, err
}
links = append(links, requesterLinks...)
mode := streamMode(s)
var refs []marketStreamRef
if mode == v1alpha1.MarketCommsModeFirehose || mode == v1alpha1.MarketCommsModeBoth {
for _, ref := range marketSourceRefs(ws, s.Comms, s.Sources.Network, s.ForceFirehose && len(publicRefs) == 0) {
refs = append(refs, marketStreamRef{ref: ref})
}
for _, ref := range publicRefs {
refs = append(refs, marketStreamRef{ref: ref, bound: true, resume: eventsv1alpha1.EventStreamResumeLive})
}
if len(refs) == 0 && (mode == v1alpha1.MarketCommsModeFirehose || s.Role != RequesterStreamRole) {
return MarketStreams{}, fmt.Errorf("compose: comms mode %s names no event source (spec.comms.eventSourceRefs) and the network has no relay; it fails closed instead of using XRPC", mode)
}
}
if offersOnly {
offer := []string{market.IngressOfferNSID}
for _, ref := range publicRefs {
refs = append(refs, marketStreamRef{ref: ref, bound: true, resume: eventsv1alpha1.EventStreamResumeLive, collections: offer})
}
if s.Sources.Network.RelayURL() != "" {
refs = append(refs, marketStreamRef{ref: EventSourceRefIn(eventsv1alpha1.EventSourceKind, NetworkRelaySourceName, ws), bound: true,
resume: eventsv1alpha1.EventStreamResumeLive, collections: offer})
}
}
var requesterStreams []string
for _, ref := range requesterRefs {
refs = append(refs, marketStreamRef{ref: ref, dids: requesters, bound: true, resume: eventsv1alpha1.EventStreamResumeRecent})
}
if s.Role == BidderStreamRole {
defer func() { c.logRequesterStreams(ws, s.Role, requesters, requesterStreams) }()
}
if len(refs) == 0 {
return MarketStreams{Links: links}, c.Prune(ctx, ws, eventsv1alpha1.EventStreamGVR, marketStreamLabel+"="+s.Role, nil)
}
streamLabels := map[string]string{marketStreamLabel: s.Role}
sink := eventstream.MarketHandlerName(s.Role, ws)
keep := map[string]bool{}
for _, entry := range refs {
ref := entry.ref
name := marketStreamName(s.Role, ref)
keep[name] = true
sourceRef := ref
if sourceRef.Workspace == ws {
sourceRef.Workspace = ""
}
stream := &eventsv1alpha1.EventStream{ObjectMeta: metav1.ObjectMeta{Name: name, Labels: streamLabels},
Spec: eventsv1alpha1.EventStreamSpec{
SourceRef: sourceRef,
Filter: eventsv1alpha1.EventStreamFilter{Collections: entry.streamCollections(s.Role), DIDs: slices.Clone(entry.dids)},
Resume: entry.resume,
Sink: eventsv1alpha1.EventStreamSink{Kind: eventsv1alpha1.EventStreamSinkHandler, Name: sink},
}}
if s.ForceFirehose && entry.resume == "" {
stream.Spec.Cursor = new(int64(0))
}
if err := c.ApplyTyped(ctx, r, ws, eventsv1alpha1.EventStreamGVR, eventsv1alpha1.GroupVersion.String(), "EventStream", stream); err != nil {
return MarketStreams{}, err
}
if len(entry.dids) > 0 {
requesterStreams = append(requesterStreams, name)
}
if !entry.bound {
user, err := c.userSourceLink(ctx, s.Role, ref)
if err != nil {
return MarketStreams{}, err
}
links = append(links, user...)
}
links = append(links, SelectorLink(eventLinkName(s.Role, "subscribe", ref.Workspace, ref.Name), streamSelector(ws, streamLabels, nil), ref,
Cap(events.CapabilitySubscribe, append(entry.streamCollections(s.Role), entry.dids...)...)))
}
links = append(links, SelectorLink(eventLinkName(s.Role, "deliver", ws, sink), streamSelector(ws, streamLabels, nil),
commonv1.ObjectRef{Group: eventsv1alpha1.GroupName, Kind: events.HandlerKind, Name: sink, Workspace: ws},
Cap(events.CapabilityDeliver, sink)))
if err := c.Prune(ctx, ws, eventsv1alpha1.EventStreamGVR, marketStreamLabel+"="+s.Role, keep); err != nil {
return MarketStreams{}, err
}
return MarketStreams{Links: links}, nil
}
func (c *Composer) applyRootSources(ctx context.Context, r Root, ws string, in SourceInput) ([]Link, error) {
labels := map[string]string{marketSourceLabel: rootSourceValue}
keep := map[string]bool{}
var links []Link
watchSelector := streamSelector(ws, nil, []exposurev1alpha1.ComponentLinkSelectorRequirement{
{Key: eventstream.RecordWatchLabel, Operator: exposurev1alpha1.ComponentLinkSelectorExists}})
for _, s := range rootSources(in) {
keep[s.Name] = true
backendRef, backendGVR, backend := s.backend()
if err := c.ApplyTyped(ctx, r, ws, backendGVR, eventsv1alpha1.GroupVersion.String(), backendRef.Kind, withLabels(backend, labels)); err != nil {
return nil, err
}
abstract := &eventsv1alpha1.EventSource{ObjectMeta: metav1.ObjectMeta{Name: s.Name, Labels: labels},
Spec: eventsv1alpha1.EventSourceSpec{BackendRef: backendRef}}
if err := c.ApplyTyped(ctx, r, ws, eventsv1alpha1.EventSourceGVR, eventsv1alpha1.GroupVersion.String(), eventsv1alpha1.EventSourceKind, abstract); err != nil {
return nil, err
}
source := EventSourceRef(s.Name)
source.Workspace = ws
backendRef.Workspace = ws
links = append(links,
SelectorLink(eventLinkName(rootSourceValue, "watch", ws, s.Name), watchSelector, source, Cap(events.CapabilitySubscribe, events.ScopeAll)),
Link{Name: eventLinkName(rootSourceValue, "bind", ws, s.Name), Spec: exposurev1alpha1.ComponentLinkSpec{
From: exposurev1alpha1.ComponentLinkFrom{Ref: &source}, To: backendRef,
Capabilities: []exposurev1alpha1.LinkCapability{Cap(events.CapabilitySubscribe, events.ScopeAll)}}})
switch {
case s.Pds != nil:
repo := s.Pds.RepoRef
repo.Workspace = ws
links = append(links, PdsEventSourceLink(backendRef, repo, ScopeAll))
case s.Relay != nil && s.Relay.RelayRef != nil:
links = append(links, RelayEventSourceLink(backendRef, AppRef(ComponentKindRelay, s.Relay.RelayRef.Name, ws)))
}
}
for _, watch := range []string{AssociationWatch, ReleaseChannelWatch} {
links = append(links, SelectorLink(eventLinkName(rootSourceValue, "deliver", ws, watch), watchSelector,
commonv1.ObjectRef{Group: v1alpha1.GroupName, Kind: events.RecordWatchKind, Name: watch, Workspace: ws},
Cap(events.CapabilityDeliver, watch)))
}
selector := marketSourceLabel + "=" + rootSourceValue
for _, gvr := range []schema.GroupVersionResource{eventsv1alpha1.EventSourceGVR, eventsv1alpha1.RelayEventSourceGVR,
eventsv1alpha1.JetstreamEventSourceGVR, eventsv1alpha1.PdsEventSourceGVR} {
if err := c.Prune(ctx, ws, gvr, selector, keep); err != nil {
return nil, err
}
}
return links, nil
}
func (c *Composer) applySources(ctx context.Context, r Root, ws, role, value string, sources []rootSource) ([]commonv1.ObjectRef, []Link, error) {
labels := map[string]string{marketSourceLabel: value + role}
keep := map[string]bool{}
var refs []commonv1.ObjectRef
var links []Link
for _, s := range sources {
keep[s.Name] = true
backendRef, backendGVR, backend := s.backend()
if err := c.ApplyTyped(ctx, r, ws, backendGVR, eventsv1alpha1.GroupVersion.String(), backendRef.Kind, withLabels(backend, labels)); err != nil {
return nil, nil, err
}
abstract := &eventsv1alpha1.EventSource{ObjectMeta: metav1.ObjectMeta{Name: s.Name, Labels: labels},
Spec: eventsv1alpha1.EventSourceSpec{BackendRef: backendRef}}
if err := c.ApplyTyped(ctx, r, ws, eventsv1alpha1.EventSourceGVR, eventsv1alpha1.GroupVersion.String(), eventsv1alpha1.EventSourceKind, abstract); err != nil {
return nil, nil, err
}
source := EventSourceRef(s.Name)
source.Workspace = ws
backendRef.Workspace = ws
refs = append(refs, source)
links = append(links, Link{Name: eventLinkName(role, "bind", ws, s.Name), Spec: exposurev1alpha1.ComponentLinkSpec{
From: exposurev1alpha1.ComponentLinkFrom{Ref: &source}, To: backendRef,
Capabilities: []exposurev1alpha1.LinkCapability{Cap(events.CapabilitySubscribe, events.ScopeAll)}}})
}
selector := marketSourceLabel + "=" + value + role
for _, gvr := range []schema.GroupVersionResource{eventsv1alpha1.EventSourceGVR, eventsv1alpha1.RelayEventSourceGVR, eventsv1alpha1.JetstreamEventSourceGVR} {
if err := c.Prune(ctx, ws, gvr, selector, keep); err != nil {
return nil, nil, err
}
}
return refs, links, nil
}
func (c *Composer) userSourceLink(ctx context.Context, role string, ref commonv1.ObjectRef) ([]Link, error) {
if ref.Name == NetworkRelaySourceName || ref.Name == LocalRepoSourceName || ref.Name == JetstreamEastSourceName || ref.Name == JetstreamWestSourceName ||
strings.HasPrefix(ref.Name, networkSourcePrefix) {
return nil, nil
}
source, err := Get[eventsv1alpha1.EventSource](ctx, c, ref.Workspace, eventsv1alpha1.EventSourceGVR, ref.Name)
if apierrors.IsNotFound(err) {
return nil, nil
}
if err != nil {
return nil, err
}
backend := source.Spec.BackendRef
if backend.InWorkspace(ref.Workspace) != ref.Workspace {
return nil, nil
}
backend.Workspace = ref.Workspace
from := EventSourceRef(ref.Name)
from.Workspace = ref.Workspace
return []Link{{Name: eventLinkName(role, "bind", ref.Workspace, ref.Name), Spec: exposurev1alpha1.ComponentLinkSpec{
From: exposurev1alpha1.ComponentLinkFrom{Ref: &from}, To: backend,
Capabilities: []exposurev1alpha1.LinkCapability{Cap(events.CapabilitySubscribe, events.ScopeAll)}}}}, nil
}
func withLabels(obj any, labels map[string]string) any {
switch o := obj.(type) {
case *eventsv1alpha1.RelayEventSource:
o.Labels = labels
case *eventsv1alpha1.JetstreamEventSource:
o.Labels = labels
case *eventsv1alpha1.PdsEventSource:
o.Labels = labels
}
return obj
}