0
0
package guestcontrolplane
import (
"context"
"encoding/json"
"errors"
"fmt"
"net/http"
"strconv"
"strings"
"time"
"github.com/gorilla/websocket"
"github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/market"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/guestcp"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/httpjson"
)
const (
SubscribeEventsPath = "/xrpc/" + market.ComputeGuestSubscribeEventsNSID
SubscribeKeepalive = 25 * time.Second
subscribeWriteTimeout = 10 * time.Second
)
var subscribeUpgrader = websocket.Upgrader{CheckOrigin: func(*http.Request) bool { return true }}
type eventFrame struct {
Type string `json:"$type"`
guestcp.QueuedEvent
}
type errorFrame struct {
Error string `json:"error"`
Message string `json:"message,omitempty"`
}
func (s *Service) openStream(ctx context.Context, authorization string, cursor *int64) (string, guestcp.EventStream, error) {
guest := s.guest()
s.mu.Lock()
queue := s.queue
s.mu.Unlock()
if guest == nil || queue == nil {
return "", nil, guestcp.ErrQueueNotOpen
}
name, err := guest.Authenticate(ctx, authorization)
if err != nil {
return "", nil, err
}
stream, err := queue.Subscribe(name, cursor)
return name, stream, err
}
func relayedAuthorization(headers map[string]string) string {
for name, value := range headers {
if strings.EqualFold(name, "Authorization") {
return value
}
}
return ""
}
func parseCursor(raw string) (*int64, error) {
raw = strings.TrimSpace(raw)
if raw == "" {
return nil, nil
}
value, err := strconv.ParseInt(raw, 10, 64)
if err != nil || value < 0 {
return nil, fmt.Errorf("cursor %q is not a non-negative integer", raw)
}
return &value, nil
}
func subscribeErrorStatus(err error) (int, string) {
switch {
case errors.Is(err, guestcp.ErrUnauthenticated):
return http.StatusUnauthorized, "AuthenticationRequired"
case errors.Is(err, guestcp.ErrUnknownGuest):
return http.StatusNotFound, "UnknownGuest"
case errors.Is(err, guestcp.ErrFutureCursor):
return http.StatusBadRequest, market.GuestSubscribeEventsErrFutureCursor
default:
return http.StatusServiceUnavailable, "Unavailable"
}
}
func encodeEvent(event guestcp.QueuedEvent) ([]byte, error) {
return json.Marshal(eventFrame{Type: market.ComputeGuestSubscribeEventsNSID + "#event", QueuedEvent: event})
}
func (s *Service) handleSubscribeEvents(w http.ResponseWriter, r *http.Request) {
cursor, err := parseCursor(r.URL.Query().Get("cursor"))
if err != nil {
writeGuestError(w, http.StatusBadRequest, err.Error())
return
}
name, stream, err := s.openStream(r.Context(), r.Header.Get("Authorization"), cursor)
if err != nil && !errors.Is(err, guestcp.ErrFutureCursor) {
status, code := subscribeErrorStatus(err)
httpjson.Write(w, status, errorFrame{Error: code, Message: err.Error()})
return
}
conn, upgradeErr := subscribeUpgrader.Upgrade(w, r, nil)
if upgradeErr != nil {
if stream != nil {
stream.Close()
}
return
}
defer conn.Close()
if err != nil {
raw, _ := json.Marshal(errorFrame{Error: market.GuestSubscribeEventsErrFutureCursor, Message: err.Error()})
_ = conn.SetWriteDeadline(time.Now().Add(subscribeWriteTimeout))
_ = conn.WriteMessage(websocket.TextMessage, raw)
_ = conn.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.ClosePolicyViolation, market.GuestSubscribeEventsErrFutureCursor), time.Now().Add(time.Second))
return
}
defer stream.Close()
ctx, cancel := context.WithCancel(r.Context())
defer cancel()
go func() {
defer cancel()
for {
if _, _, err := conn.ReadMessage(); err != nil {
return
}
}
}()
write := func(kind int, data []byte) error {
_ = conn.SetWriteDeadline(time.Now().Add(subscribeWriteTimeout))
return conn.WriteMessage(kind, data)
}
s.log.Info("a guest subscribes to its events", "computevm", name, "cursor", cursorValue(cursor))
err = s.streamEvents(ctx, stream, func(frame []byte) error { return write(websocket.TextMessage, frame) },
func() error { return write(websocket.BinaryMessage, nil) })
if errors.Is(err, guestcp.ErrQueueGone) {
_ = conn.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseGoingAway, "the ComputeVM is gone"), time.Now().Add(time.Second))
}
s.log.Info("a guest event subscription ends", "computevm", name, "reason", errString(err))
}
func (s *Service) subscribeDirect(ctx context.Context) func(string, string, map[string]string, map[string]string, func(json.RawMessage), func([]byte)) (func(), error) {
return func(_, nsid string, params, headers map[string]string, onEvent func(json.RawMessage), onData func([]byte)) (func(), error) {
if nsid != market.ComputeGuestSubscribeEventsNSID {
return nil, fmt.Errorf("guestcontrolplane: no subscription %s", nsid)
}
cursor, err := parseCursor(params["cursor"])
if err != nil {
return nil, err
}
name, stream, err := s.openStream(ctx, relayedAuthorization(headers), cursor)
if err != nil {
_, code := subscribeErrorStatus(err)
return nil, fmt.Errorf("%s: %v", code, err)
}
runCtx, cancel := context.WithCancel(ctx)
s.log.Info("a guest subscribes to its events through the relay", "computevm", name, "cursor", cursorValue(cursor))
s.wg.Go(func() {
defer stream.Close()
err := s.streamEvents(runCtx, stream, func(frame []byte) error { onEvent(frame); return nil },
func() error { onData(nil); return nil })
s.log.Info("a guest event subscription through the relay ends", "computevm", name, "reason", errString(err))
})
return cancel, nil
}
}
func (s *Service) streamEvents(ctx context.Context, stream guestcp.EventStream, send func([]byte) error, keepalive func() error) error {
events := make(chan guestcp.QueuedEvent)
failed := make(chan error, 1)
go func() {
for {
event, err := stream.Next(ctx)
if err != nil {
failed <- err
return
}
select {
case events <- event:
case <-ctx.Done():
return
}
}
}()
ticker := time.NewTicker(SubscribeKeepalive)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return ctx.Err()
case err := <-failed:
return err
case event := <-events:
frame, err := encodeEvent(event)
if err != nil {
return err
}
if err := send(frame); err != nil {
return err
}
case <-ticker.C:
if err := keepalive(); err != nil {
return err
}
}
}
}
func cursorValue(cursor *int64) string {
if cursor == nil {
return ""
}
return strconv.FormatInt(*cursor, 10)
}
func errString(err error) string {
if err == nil {
return ""
}
return err.Error()
}