0
0
package guestagent
import (
"context"
"encoding/json"
"errors"
"fmt"
"net/http"
"net/url"
"os"
"path/filepath"
"strconv"
"strings"
"time"
"github.com/gorilla/websocket"
)
const (
subscribeBackoffMin = 2 * time.Second
subscribeBackoffMax = 30 * time.Second
subscribeReadTimeout = 90 * time.Second
subscribeDialTimeout = 20 * time.Second
maxFrame = 1 << 20
)
var errFutureCursor = errors.New("guestagent: the bidder has no events up to the cursor")
type eventFrame struct {
Type string `json:"$type"`
Seq int64 `json:"seq"`
URI string `json:"uri"`
CID string `json:"cid"`
Record json.RawMessage `json:"record"`
Error string `json:"error"`
Message string `json:"message"`
}
type guestRecord struct {
Type string `json:"$type"`
Kind string `json:"kind"`
Tag string `json:"tag"`
Ciphertext string `json:"ciphertext"`
}
func (a *Agent) subscribe(ctx context.Context) {
backoff := subscribeBackoffMin
for ctx.Err() == nil {
connected, err := a.stream(ctx)
if ctx.Err() != nil {
return
}
if connected {
backoff = subscribeBackoffMin
}
if errors.Is(err, errFutureCursor) {
a.log.Warn("the bidder answered FutureCursor; restarting the subscription from cursor 0", "cursor", a.cursor)
a.saveCursor(0)
}
a.log.Warn("the guest event subscription closed; reconnecting", "err", errText(err), "cursor", a.cursor, "retryIn", backoff.String())
select {
case <-ctx.Done():
return
case <-time.After(backoff):
}
backoff = min(backoff*2, subscribeBackoffMax)
}
}
func (a *Agent) subscribeURL() (string, error) {
u, err := url.Parse(a.cfg.Bidder.Base + SubscribeEventsPath)
if err != nil {
return "", err
}
switch u.Scheme {
case "http":
u.Scheme = "ws"
case "https":
u.Scheme = "wss"
}
u.RawQuery = url.Values{"cursor": {strconv.FormatInt(a.cursor, 10)}}.Encode()
return u.String(), nil
}
func (a *Agent) stream(ctx context.Context) (bool, error) {
target, err := a.subscribeURL()
if err != nil {
return false, err
}
token, err := a.tokens.Token(ctx)
if err != nil {
return false, err
}
dialer := websocket.Dialer{HandshakeTimeout: subscribeDialTimeout, Proxy: nil}
conn, resp, err := dialer.DialContext(ctx, target, http.Header{"Authorization": {"Bearer " + token}})
if err != nil {
if resp != nil {
defer resp.Body.Close()
if resp.StatusCode == http.StatusUnauthorized || resp.StatusCode == http.StatusForbidden {
a.tokens.Invalidate(token)
}
return false, fmt.Errorf("upgrade refused: http %d", resp.StatusCode)
}
return false, err
}
defer conn.Close()
conn.SetReadLimit(maxFrame)
stop := context.AfterFunc(ctx, func() { _ = conn.Close() })
defer stop()
a.log.Info("the guest event subscription is open", "cursor", a.cursor)
for {
_ = conn.SetReadDeadline(time.Now().Add(subscribeReadTimeout))
kind, data, err := conn.ReadMessage()
if err != nil {
var closeErr *websocket.CloseError
if errors.As(err, &closeErr) && closeErr.Code == websocket.ClosePolicyViolation && strings.Contains(closeErr.Text, errFutureCursorName) {
return true, errFutureCursor
}
return true, err
}
if kind != websocket.TextMessage {
continue
}
var frame eventFrame
if err := json.Unmarshal(data, &frame); err != nil {
a.log.Warn("a subscription frame is not JSON", "bytes", len(data))
continue
}
if frame.Error != "" {
if frame.Error == errFutureCursorName {
return true, errFutureCursor
}
return true, fmt.Errorf("the bidder ended the subscription: %s: %s", frame.Error, tail(frame.Message, 256))
}
a.receive(frame)
if frame.Seq > a.cursor {
a.saveCursor(frame.Seq)
}
}
}
func (a *Agent) receive(frame eventFrame) {
var record guestRecord
if err := json.Unmarshal(frame.Record, &record); err != nil {
a.log.Warn("a guest event record is not a JSON object", "seq", frame.Seq)
return
}
id := frame.URI + "#" + frame.CID
if a.seen[id] {
a.log.Debug("a guest event was seen before", "seq", frame.Seq)
return
}
a.seen[id] = true
_, known := a.cfg.Tunnel(record.Tag)
switch {
case record.Type == SecretsNSID:
a.sealedSecrets(a.ctx, frame.Seq, record.Ciphertext)
case record.Type == PublicKeyNSID:
a.log.Debug("requester publicKey for tag "+record.Tag, "seq", frame.Seq, "tag", record.Tag, "known", known)
case record.Type == AgentStartNSID:
a.startAgent(frame.Seq)
case record.Type == SecretsUpdatedNSID:
a.wg.Go(func() { a.refetchSecrets(frame.Seq) })
case record.Type == R2StartNSID:
a.wg.Go(func() { a.startGuestRequester(frame.Seq, frame.Record) })
case record.Type == R2ReleaseNSID:
a.wg.Go(func() { a.releaseGuestRequester(frame.Seq) })
case record.Type == SignalWebRTCNSID && record.Tag == requesterTag && record.Kind == signalKindOffer:
a.requesterOffer(frame.Seq, record.Ciphertext)
case record.Type != SignalWebRTCNSID:
a.log.Debug("a guest event of another collection", "seq", frame.Seq, "collection", record.Type)
case !known:
a.log.Debug("a signal for a tag this guest does not serve", "seq", frame.Seq, "tag", record.Tag)
case record.Kind != signalKindOffer:
a.log.Debug("a signal that is not an offer", "seq", frame.Seq, "tag", record.Tag, "kind", record.Kind)
default:
a.offer(frame.Seq, record.Tag, record.Ciphertext)
}
}
func (a *Agent) loadCursor() {
raw, err := os.ReadFile(filepath.Join(a.cfg.StateDir, CursorFile))
if err != nil {
return
}
value, err := strconv.ParseInt(strings.TrimSpace(string(raw)), 10, 64)
if err != nil || value < 0 {
a.log.Warn("the saved cursor is not a non-negative integer; starting from 0", "bytes", len(raw))
return
}
a.cursor = value
}
func (a *Agent) saveCursor(value int64) {
a.cursor = value
path := filepath.Join(a.cfg.StateDir, CursorFile)
part := path + ".part"
if err := os.WriteFile(part, []byte(strconv.FormatInt(value, 10)+"\n"), 0o600); err != nil {
a.log.Warn("saving the cursor failed", "err", err.Error())
return
}
if err := os.Rename(part, path); err != nil {
a.log.Warn("saving the cursor failed", "err", err.Error())
}
}
func errText(err error) string {
if err == nil {
return ""
}
return err.Error()
}