0
0
package request
import (
"context"
"crypto/rand"
"encoding/hex"
"errors"
"fmt"
"strings"
"time"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
commonv1 "github.com/johnandersen777/socialweb-computer-kcp/api/common/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"
"github.com/johnandersen777/socialweb-computer-kcp/internal/webrtcproxy"
)
const contractEventPrefix = "cli-"
var _ webrtcproxy.Signaling = (*ContractSignaling)(nil)
type ContractSignaling struct {
k *Kcp
contract string
session string
}
func (k *Kcp) Signaling() *ContractSignaling {
var b [6]byte
_, _ = rand.Read(b[:])
return &ContractSignaling{k: k, contract: k.ContractName(), session: hex.EncodeToString(b[:])}
}
func (s *ContractSignaling) eventName(suffix string) string {
return contractEventPrefix + s.session + "-" + suffix
}
func (s *ContractSignaling) create(ctx context.Context, suffix string, spec v1alpha1.ContractEventSpec) error {
spec.ContractRef = commonv1.LocalObjectRef{Name: s.contract}
spec.Direction = v1alpha1.ContractEventOutbound
event := v1alpha1.ContractEvent{TypeMeta: typeMeta("ContractEvent"),
ObjectMeta: metav1.ObjectMeta{Name: s.eventName(suffix)}, Spec: spec}
body, err := kube.ApplyBody(&event, false)
if err != nil {
return err
}
_, err = kube.Create[kube.Doc](ctx, s.k.dyn.Resource(v1alpha1.ContractEventGVR), body, metav1.CreateOptions{FieldManager: FieldManager})
return err
}
func (s *ContractSignaling) PublishKey(ctx context.Context, tag, key string) error {
return s.create(ctx, "key", v1alpha1.ContractEventSpec{NSID: v1alpha1.ContractEventNSIDGuestPublicKey,
Kind: market.GuestPublicKeyKindAgeX25519, Tag: tag, Key: key})
}
func (s *ContractSignaling) PublishOffer(ctx context.Context, tag, ciphertext string) error {
return s.create(ctx, "offer", v1alpha1.ContractEventSpec{NSID: v1alpha1.ContractEventNSIDGuestSignalWebRTC,
Kind: market.GuestSignalKindOffer, Tag: tag, Ciphertext: ciphertext})
}
func (s *ContractSignaling) PublishR2Start(ctx context.Context, start v1alpha1.ContractEventR2Start) (string, error) {
suffix := "r2-" + start.Name
return s.eventName(suffix), s.create(ctx, suffix, v1alpha1.ContractEventSpec{NSID: v1alpha1.ContractEventNSIDGuestR2Start, R2Start: &start})
}
func (s *ContractSignaling) PublishAgentStart(ctx context.Context) (string, error) {
return s.eventName("agent"), s.create(ctx, "agent", v1alpha1.ContractEventSpec{NSID: v1alpha1.ContractEventNSIDGuestAgentStart})
}
func (k *Kcp) WaitContractEvent(ctx context.Context, name string, timeout time.Duration, done func(*v1alpha1.ContractEvent) bool) (*v1alpha1.ContractEvent, error) {
return kube.Await(ctx, k.dyn.Resource(v1alpha1.ContractEventGVR), name, timeout, func(e *v1alpha1.ContractEvent) (bool, error) {
return e != nil && done(e), nil
})
}
func (s *ContractSignaling) inbound(e v1alpha1.ContractEvent, nsid, kind, tag string) bool {
return e.DeletionTimestamp == nil && e.Spec.Direction == v1alpha1.ContractEventInbound && e.Spec.ContractRef.Name == s.contract &&
e.Spec.NSID == nsid && e.Spec.Kind == kind && e.Spec.Tag == tag && e.Status.Phase == v1alpha1.ContractEventReceived
}
func (s *ContractSignaling) Guest(ctx context.Context, tag string) (webrtcproxy.Guest, error) {
var guest webrtcproxy.Guest
var failed error
_, err := kube.Await(ctx, s.k.dyn.Resource(v1alpha1.ComputeContractGVR), s.contract, 0, func(c *v1alpha1.ComputeContract) (bool, error) {
if c == nil {
return false, nil
}
switch c.Status.Phase {
case v1alpha1.ComputeContractReleased, v1alpha1.ComputeContractFailed:
failed = fmt.Errorf("the contract is %s: %s", c.Status.Phase, c.Status.Message)
return true, nil
}
if c.Status.Contract == nil {
return false, nil
}
for _, n := range c.Status.Contract.Networks {
if n.Tag == tag && n.Kind == v1alpha1.NetworkKindWebRTC && strings.TrimSpace(n.Address) != "" {
guest.Fingerprint = n.Address
return true, nil
}
}
return false, nil
})
if failed != nil {
return guest, failed
}
if err != nil {
return guest, fmt.Errorf("no onNetwork kind webrtc for the tag in status.contract.networks: %w", err)
}
_, err = kube.AwaitList(ctx, s.k.dyn.Resource(v1alpha1.ContractEventGVR), metav1.ListOptions{}, 0, func(items []v1alpha1.ContractEvent) (bool, error) {
var newest *v1alpha1.ContractEvent
for i := range items {
e := &items[i]
if !s.inbound(*e, v1alpha1.ContractEventNSIDGuestPublicKey, market.GuestPublicKeyKindAgeX25519, tag) || e.Spec.Key == "" {
continue
}
if newest == nil || newest.CreationTimestamp.Before(&e.CreationTimestamp) {
newest = e
}
}
if newest == nil {
return false, nil
}
guest.Key = newest.Spec.Key
return true, nil
})
if err != nil {
return guest, fmt.Errorf("no inbound guest publicKey ContractEvent for the tag: %w", err)
}
return guest, nil
}
func (s *ContractSignaling) Answers(ctx context.Context, tag string, each func(ciphertext string) bool) error {
seen := map[string]bool{}
_, err := kube.AwaitList(ctx, s.k.dyn.Resource(v1alpha1.ContractEventGVR), metav1.ListOptions{}, 0, func(items []v1alpha1.ContractEvent) (bool, error) {
for _, e := range items {
key := e.Name + "/" + string(e.UID)
if seen[key] || !s.inbound(e, v1alpha1.ContractEventNSIDGuestSignalWebRTC, market.GuestSignalKindAnswer, tag) || e.Spec.Ciphertext == "" {
continue
}
seen[key] = true
if each(e.Spec.Ciphertext) {
return true, nil
}
}
return false, nil
})
if errors.Is(err, kube.ErrAwaitTimeout) {
return context.DeadlineExceeded
}
return err
}