mirror of
https://github.com/BaaRai/ARTEX.git
synced 2026-11-18 06:00:54 +08:00
fix(traffic): bound stream message pages, spill before the transaction, seconds timestamps
Stream payloads over 4 KiB now spill to the blob store (spillAt with maxStreamInline; spill keeps maxInlineBody for HTTP bodies) and StreamMessages clips every payload to 4 KiB, reading a spilled binary preview from its blob. The byte cap counts the inline preview. persistStream spills before opening the transaction, as record() does. Without the library lock nothing is read. ts is unix seconds. Adds the final-message-on-close and route tests.
This commit is contained in:
@@ -0,0 +1,89 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestTrafficStreamRoute(t *testing.T) {
|
||||
s, request := ingestServer(t)
|
||||
db := s.m.Traffic().DB()
|
||||
if _, err := db.Exec(`INSERT INTO exchanges(id,ts,host,method,url_template,url,status,content_type,req_len,resp_len,path)
|
||||
VALUES('1-0001',1,'ws.example.com','GET','/ws','wss://ws.example.com/ws',101,'websocket',0,0,'')`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := db.Exec(`INSERT INTO exchange_bodies(id,req_head,resp_head) VALUES('1-0001','GET /ws HTTP/1.1\n','HTTP/1.1 101 Switching Protocols\n')`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
const total = 250
|
||||
tx, err := db.Begin()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for i := 1; i <= total; i++ {
|
||||
kind, payload := 1, []byte("hello")
|
||||
if i%2 == 0 {
|
||||
kind, payload = 2, []byte{0, 1, 2}
|
||||
}
|
||||
if _, err := tx.Exec(`INSERT INTO stream_messages(exchange_id,seq,ts,direction,kind,size,payload) VALUES('1-0001',?,1,'c2s',?,?,?)`, i, kind, len(payload), payload); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if err := tx.Commit(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
type page struct {
|
||||
Items []struct {
|
||||
Seq int64 `json:"seq"`
|
||||
Type string `json:"type"`
|
||||
Payload string `json:"payload"`
|
||||
Encoding string `json:"encoding"`
|
||||
} `json:"items"`
|
||||
Total int `json:"total"`
|
||||
}
|
||||
get := func(path string, wantStatus int) page {
|
||||
t.Helper()
|
||||
w := request("GET", path, "")
|
||||
if w.Code != wantStatus {
|
||||
t.Fatalf("GET %s = %d %s, want %d", path, w.Code, w.Body, wantStatus)
|
||||
}
|
||||
var p page
|
||||
if wantStatus == 200 {
|
||||
if err := json.Unmarshal(w.Body.Bytes(), &p); err != nil {
|
||||
t.Fatalf("GET %s: %v in %s", path, err, w.Body)
|
||||
}
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
get("/api/traffic/stream", 400)
|
||||
if p := get("/api/traffic/stream?exchange=nope", 200); p.Items == nil || len(p.Items) != 0 || p.Total != 0 {
|
||||
t.Fatalf("unknown exchange = %+v, want items [] and total 0", p)
|
||||
}
|
||||
p := get("/api/traffic/stream?exchange=1-0001", 200)
|
||||
if p.Total != total || len(p.Items) != 50 || p.Items[0].Seq != 1 {
|
||||
t.Fatalf("default page: total %d, %d items, first seq %d", p.Total, len(p.Items), p.Items[0].Seq)
|
||||
}
|
||||
if first, second := p.Items[0], p.Items[1]; first.Type != "text" || first.Payload != "hello" || second.Type != "binary" || second.Encoding != "base64" || second.Payload != "AAEC" {
|
||||
t.Fatalf("payloads %+v %+v", first, second)
|
||||
}
|
||||
if p := get("/api/traffic/stream?exchange=1-0001&limit=500", 200); len(p.Items) != 200 {
|
||||
t.Fatalf("limit=500 returned %d items, want the 200 cap", len(p.Items))
|
||||
}
|
||||
if p := get("/api/traffic/stream?exchange=1-0001&offset=-5&limit=1", 200); len(p.Items) != 1 || p.Items[0].Seq != 1 {
|
||||
t.Fatalf("negative offset: %+v, want seq 1", p.Items)
|
||||
}
|
||||
if p := get("/api/traffic/stream?exchange=1-0001&offset=248&limit=10", 200); len(p.Items) != 2 || p.Items[0].Seq != 249 {
|
||||
t.Fatalf("last page: %+v, want seqs 249 and 250", p.Items)
|
||||
}
|
||||
|
||||
w := request("GET", "/api/traffic/exchange?id=1-0001", "")
|
||||
var ex struct {
|
||||
StreamCount int `json:"stream_count"`
|
||||
StreamKind string `json:"stream_kind"`
|
||||
}
|
||||
if err := json.Unmarshal(w.Body.Bytes(), &ex); err != nil || w.Code != 200 || ex.StreamCount != total || ex.StreamKind != "websocket" {
|
||||
t.Fatalf("exchange = %d %s", w.Code, w.Body)
|
||||
}
|
||||
}
|
||||
+82
-38
@@ -30,9 +30,12 @@ const (
|
||||
// values go-mitmproxy reports in WebSocketMessage.Type.
|
||||
wsText = 1
|
||||
wsBinary = 2
|
||||
// streamPreview caps one message's payload in a StreamMessages row when the
|
||||
// payload spilled to the blob store; the hash points at the rest.
|
||||
// streamPreview caps one message's payload in a StreamMessages row; a longer
|
||||
// payload lives in the blob store and the row carries its hash.
|
||||
streamPreview = 4 * 1024
|
||||
// maxStreamInline is the inline threshold for message payloads: anything
|
||||
// longer spills to the blob store, so a page of 200 rows stays bounded.
|
||||
maxStreamInline = streamPreview
|
||||
// toolStreamPreview caps one message's preview in traffic_messages, so a page
|
||||
// of messages stays small in the agent's context.
|
||||
toolStreamPreview = 1024
|
||||
@@ -47,7 +50,8 @@ type streamState struct {
|
||||
consumed int // library messages/events already handled
|
||||
seq int64
|
||||
stored int
|
||||
// storedBytes counts the payload bytes kept, after truncation.
|
||||
// storedBytes counts what the kept messages occupy: the payload after
|
||||
// truncation, plus the inline preview spill keeps for a spilled payload.
|
||||
storedBytes int64
|
||||
dropped bool
|
||||
droppedMsgs int64
|
||||
@@ -59,7 +63,7 @@ type streamState struct {
|
||||
|
||||
// streamRow is one stream_messages row before it is written.
|
||||
type streamRow struct {
|
||||
ts int64 // unix milliseconds
|
||||
ts int64 // unix seconds, like exchanges.ts; seq carries the order
|
||||
direction string
|
||||
kind int
|
||||
event string
|
||||
@@ -154,8 +158,9 @@ func (s *sink) startStream(f *mproxy.Flow, kind string) {
|
||||
// libMutex returns the unexported mu sync.Mutex that go-mitmproxy holds while it
|
||||
// appends to WebSocketData.Messages / SSEData.Events. The library exposes no
|
||||
// accessor, and the two WebSocket goroutines append concurrently, so reading the
|
||||
// slice without that lock is a data race. Nil when the field is absent (a library
|
||||
// change), in which case the read falls back to unlocked.
|
||||
// slice without that lock is a data race. Reaching a private field ties this to
|
||||
// the pinned go-mitmproxy v1.9.2: TestLibMutexFound is the upgrade guard. Nil
|
||||
// when the field is absent, and then nothing is read (see lockLib).
|
||||
func libMutex(v any) *sync.Mutex {
|
||||
rv := reflect.ValueOf(v)
|
||||
if rv.Kind() != reflect.Pointer || rv.IsNil() {
|
||||
@@ -170,23 +175,28 @@ func libMutex(v any) *sync.Mutex {
|
||||
|
||||
var libMutexMissing sync.Once
|
||||
|
||||
func lockLib(v any) func() {
|
||||
// lockLib takes the library's lock on v. ok is false when the lock cannot be
|
||||
// found; callers then read nothing rather than race the library.
|
||||
func lockLib(v any) (unlock func(), ok bool) {
|
||||
mu := libMutex(v)
|
||||
if mu == nil {
|
||||
libMutexMissing.Do(func() {
|
||||
log.Printf("[traffic] go-mitmproxy stream data has no mu field; reading stream messages without its lock")
|
||||
log.Printf("[traffic] go-mitmproxy stream data has no mu field; stream messages are not recorded")
|
||||
})
|
||||
return func() {}
|
||||
return nil, false
|
||||
}
|
||||
mu.Lock()
|
||||
return mu.Unlock
|
||||
return mu.Unlock, true
|
||||
}
|
||||
|
||||
// wsMessagesSince returns every WebSocket message appended since the last call,
|
||||
// in the library's order, so each is handled exactly once whichever goroutine's
|
||||
// hook gets there first. The library slice itself is never modified.
|
||||
func wsMessagesSince(ws *mproxy.WebSocketData, st *streamState) []streamRow {
|
||||
unlock := lockLib(ws)
|
||||
unlock, ok := lockLib(ws)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
msgs := ws.Messages
|
||||
if st.consumed > len(msgs) {
|
||||
st.consumed = len(msgs)
|
||||
@@ -209,14 +219,17 @@ func wsMessagesSince(ws *mproxy.WebSocketData, st *streamState) []streamRow {
|
||||
if m.Type == wsBinary {
|
||||
ctype = "application/octet-stream"
|
||||
}
|
||||
rows = append(rows, streamRow{ts: m.Timestamp.UnixMilli(), direction: dir, kind: m.Type, size: len(m.Content), payload: m.Content, ctype: ctype})
|
||||
rows = append(rows, streamRow{ts: m.Timestamp.Unix(), direction: dir, kind: m.Type, size: len(m.Content), payload: m.Content, ctype: ctype})
|
||||
}
|
||||
return rows
|
||||
}
|
||||
|
||||
// sseEventsSince is wsMessagesSince for Server-Sent Events.
|
||||
func sseEventsSince(sse *mproxy.SSEData, st *streamState) []streamRow {
|
||||
unlock := lockLib(sse)
|
||||
unlock, ok := lockLib(sse)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
events := sse.Events
|
||||
if st.consumed > len(events) {
|
||||
st.consumed = len(events)
|
||||
@@ -230,7 +243,7 @@ func sseEventsSince(sse *mproxy.SSEData, st *streamState) []streamRow {
|
||||
continue
|
||||
}
|
||||
st.respBytes += int64(len(e.Raw))
|
||||
rows = append(rows, streamRow{ts: e.Time.UnixMilli(), direction: "s2c", event: e.Event, eventID: e.ID,
|
||||
rows = append(rows, streamRow{ts: e.Time.Unix(), direction: "s2c", event: e.Event, eventID: e.ID,
|
||||
retry: e.Retry, size: len(e.Data), payload: []byte(e.Data), ctype: "text/event-stream"})
|
||||
}
|
||||
return rows
|
||||
@@ -333,7 +346,8 @@ func (t *Traffic) persistStream(st *streamState, rows []streamRow) {
|
||||
r.payload = r.payload[:maxStreamPayload]
|
||||
r.truncated = true
|
||||
}
|
||||
if st.dropped || st.stored >= maxStreamMessages || st.storedBytes+int64(len(r.payload)) > maxStreamBytes {
|
||||
cost := streamStoredCost(r)
|
||||
if st.dropped || st.stored >= maxStreamMessages || st.storedBytes+cost > maxStreamBytes {
|
||||
if !st.dropped {
|
||||
st.dropped = true
|
||||
addMeta = true
|
||||
@@ -343,7 +357,7 @@ func (t *Traffic) persistStream(st *streamState, rows []streamRow) {
|
||||
continue
|
||||
}
|
||||
st.stored++
|
||||
st.storedBytes += int64(len(r.payload))
|
||||
st.storedBytes += cost
|
||||
keep = append(keep, r)
|
||||
}
|
||||
var meta []byte
|
||||
@@ -356,36 +370,52 @@ func (t *Traffic) persistStream(st *streamState, rows []streamRow) {
|
||||
|
||||
t.wmu.Lock()
|
||||
defer t.wmu.Unlock()
|
||||
// Sequence numbers and blob writes come first, as in record(): blob writes are
|
||||
// filesystem work and must not sit inside the SQLite transaction. Holding wmu
|
||||
// keeps gcBlobs from collecting a blob before its reference is committed.
|
||||
type preparedRow struct {
|
||||
streamRow
|
||||
seq int64
|
||||
body storedBody
|
||||
}
|
||||
prepared := make([]preparedRow, 0, len(keep))
|
||||
for _, r := range keep {
|
||||
st.seq++
|
||||
prepared = append(prepared, preparedRow{streamRow: r, seq: st.seq, body: t.spillAt(r.payload, r.ctype, maxStreamInline)})
|
||||
}
|
||||
var metaSeq int64
|
||||
if meta != nil {
|
||||
st.seq++
|
||||
metaSeq = st.seq
|
||||
}
|
||||
|
||||
tx, err := t.db.Begin()
|
||||
if err != nil {
|
||||
log.Printf("[traffic] failed to record stream messages of %s (beginning transaction): %v", st.id, err)
|
||||
return
|
||||
}
|
||||
defer tx.Rollback() //nolint:errcheck // no-op once committed
|
||||
for _, r := range keep {
|
||||
st.seq++
|
||||
b := t.spill(r.payload, r.ctype)
|
||||
inline := b.inline
|
||||
for _, p := range prepared {
|
||||
inline := p.body.inline
|
||||
if inline == nil {
|
||||
inline = []byte{}
|
||||
}
|
||||
if _, err := tx.Exec(`INSERT INTO stream_messages(exchange_id,seq,ts,direction,kind,event,event_id,retry,size,payload,payload_blob,truncated)
|
||||
VALUES(?,?,?,?,?,?,?,?,?,?,?,?)`, st.id, st.seq, r.ts, r.direction, r.kind, r.event, r.eventID, r.retry, r.size,
|
||||
inline, nullIfEmpty(b.hash), boolInt(r.truncated)); err != nil {
|
||||
log.Printf("[traffic] failed to record stream message %d of %s: %v", st.seq, st.id, err)
|
||||
VALUES(?,?,?,?,?,?,?,?,?,?,?,?)`, st.id, p.seq, p.ts, p.direction, p.kind, p.event, p.eventID, p.retry, p.size,
|
||||
inline, nullIfEmpty(p.body.hash), boolInt(p.truncated)); err != nil {
|
||||
log.Printf("[traffic] failed to record stream message %d of %s: %v", p.seq, st.id, err)
|
||||
return
|
||||
}
|
||||
if b.hash != "" {
|
||||
if _, err := tx.Exec(`INSERT OR IGNORE INTO blob_refs(hash,exchange_id) VALUES(?,?)`, b.hash, st.id); err != nil {
|
||||
log.Printf("[traffic] failed to record stream message %d of %s (registering blob reference): %v", st.seq, st.id, err)
|
||||
if p.body.hash != "" {
|
||||
if _, err := tx.Exec(`INSERT OR IGNORE INTO blob_refs(hash,exchange_id) VALUES(?,?)`, p.body.hash, st.id); err != nil {
|
||||
log.Printf("[traffic] failed to record stream message %d of %s (registering blob reference): %v", p.seq, st.id, err)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
if meta != nil {
|
||||
st.seq++
|
||||
if _, err := tx.Exec(`INSERT INTO stream_messages(exchange_id,seq,ts,direction,kind,size,payload)
|
||||
VALUES(?,?,?,'meta',0,?,?)`, st.id, st.seq, time.Now().UnixMilli(), len(meta), meta); err != nil {
|
||||
VALUES(?,?,?,'meta',0,?,?)`, st.id, metaSeq, time.Now().Unix(), len(meta), meta); err != nil {
|
||||
log.Printf("[traffic] failed to record stream limit marker of %s: %v", st.id, err)
|
||||
return
|
||||
}
|
||||
@@ -395,6 +425,20 @@ VALUES(?,?,?,'meta',0,?,?)`, st.id, st.seq, time.Now().UnixMilli(), len(meta), m
|
||||
}
|
||||
}
|
||||
|
||||
// streamStoredCost is what keeping r adds to the index and blob store: the
|
||||
// payload, plus the inline preview spillAt keeps when the payload spills (a text
|
||||
// prefix of at most blobPreview, or a one-line tag for binary).
|
||||
func streamStoredCost(r streamRow) int64 {
|
||||
n := int64(len(r.payload))
|
||||
if len(r.payload) <= maxStreamInline {
|
||||
return n
|
||||
}
|
||||
if isBinaryBody(r.ctype, r.payload) {
|
||||
return n + int64(len(binaryTag(r.ctype, r.payload)))
|
||||
}
|
||||
return n + int64(len(truncateUTF8(r.payload, blobPreview)))
|
||||
}
|
||||
|
||||
func streamMetaPayload(st *streamState) []byte {
|
||||
b, _ := json.Marshal(map[string]int64{"dropped_messages": st.droppedMsgs, "dropped_bytes": st.droppedBytes})
|
||||
return b
|
||||
@@ -429,7 +473,7 @@ func (t *Traffic) finishStream(st *streamState) {
|
||||
// StreamMessage is one recorded WebSocket message or SSE event.
|
||||
type StreamMessage struct {
|
||||
Seq int64 `json:"seq"`
|
||||
TS int64 `json:"ts"` // unix milliseconds
|
||||
TS int64 `json:"ts"` // unix seconds, like an exchange's ts; Seq orders
|
||||
Direction string `json:"direction"`
|
||||
Kind int `json:"kind"`
|
||||
// Type is "text" or "binary" (WebSocket), "event" (SSE), or "meta" (the
|
||||
@@ -447,8 +491,9 @@ type StreamMessage struct {
|
||||
}
|
||||
|
||||
// StreamMessages returns one page of an exchange's stream messages in order.
|
||||
// limit is 1..200 (default 50) and offset >= 0. A payload that spilled to the
|
||||
// blob store comes back as a preview of at most 4 KiB plus its hash.
|
||||
// limit is 1..200 (default 50) and offset >= 0. Every payload comes back as at
|
||||
// most streamPreview (4 KiB); a longer one lives in the blob store and the row
|
||||
// carries its hash for the rest (traffic_blob, GET /api/traffic/blob).
|
||||
func (t *Traffic) StreamMessages(exchangeID string, offset, limit int) ([]StreamMessage, int, error) {
|
||||
if limit <= 0 {
|
||||
limit = 50
|
||||
@@ -490,16 +535,15 @@ FROM stream_messages WHERE exchange_id=? ORDER BY seq LIMIT ? OFFSET ?`, exchang
|
||||
default:
|
||||
m.Type = "event"
|
||||
}
|
||||
if m.Blob != "" {
|
||||
payload = clipBytes(payload, streamPreview)
|
||||
}
|
||||
if m.Type == "binary" {
|
||||
m.Payload, m.Encoding = base64.StdEncoding.EncodeToString(payload), "base64"
|
||||
} else {
|
||||
m.Payload = string(payload)
|
||||
if m.Blob != "" {
|
||||
m.Payload = truncateUTF8(payload, streamPreview)
|
||||
// A spilled binary payload keeps only a descriptive tag inline;
|
||||
// the preview is the payload's own leading bytes.
|
||||
payload, _, _ = t.BlobRange(m.Blob, 0, streamPreview)
|
||||
}
|
||||
m.Payload, m.Encoding = base64.StdEncoding.EncodeToString(clipBytes(payload, streamPreview)), "base64"
|
||||
} else {
|
||||
m.Payload = truncateUTF8(payload, streamPreview)
|
||||
}
|
||||
out = append(out, m)
|
||||
}
|
||||
|
||||
+94
-7
@@ -156,7 +156,7 @@ func TestWebSocketMessagesRecorded(t *testing.T) {
|
||||
}
|
||||
return got
|
||||
}
|
||||
before := time.Now().UnixMilli()
|
||||
before := time.Now().Unix()
|
||||
if got := exchange(websocket.TextMessage, []byte("hello")); string(got) != "echo:hello" {
|
||||
t.Fatalf("echo %q", got)
|
||||
}
|
||||
@@ -374,7 +374,14 @@ func TestStreamMessageLimitStoresOneMetaRow(t *testing.T) {
|
||||
func TestStreamByteLimitStoresOneMetaRow(t *testing.T) {
|
||||
tr, s, f := unitStream(t, "bytes.test")
|
||||
chunk := bytes.Repeat([]byte{7}, maxStreamPayload)
|
||||
n := maxStreamBytes/maxStreamPayload + 1
|
||||
// Each kept 1 MiB payload spills and also keeps its inline tag, so the cap
|
||||
// admits floor(maxStreamBytes / (payload + tag)) of them.
|
||||
cost := streamStoredCost(streamRow{payload: chunk, ctype: "application/octet-stream"})
|
||||
if cost <= maxStreamPayload {
|
||||
t.Fatalf("cost %d does not count the inline preview", cost)
|
||||
}
|
||||
kept := int(maxStreamBytes / cost)
|
||||
n := kept + 1
|
||||
for i := 0; i < n; i++ {
|
||||
addWS(f, false, websocket.BinaryMessage, chunk)
|
||||
}
|
||||
@@ -384,8 +391,8 @@ func TestStreamByteLimitStoresOneMetaRow(t *testing.T) {
|
||||
s.WebSocketEnd(f)
|
||||
id := onlyExchange(t, tr)
|
||||
msgs := allMessages(t, tr, id)
|
||||
if len(msgs) != n {
|
||||
t.Fatalf("%d rows, want %d stored and one meta row", len(msgs), n-1)
|
||||
if len(msgs) != kept+1 {
|
||||
t.Fatalf("%d rows, want %d stored and one meta row", len(msgs), kept)
|
||||
}
|
||||
meta := msgs[len(msgs)-1]
|
||||
if meta.Direction != "meta" {
|
||||
@@ -394,9 +401,10 @@ func TestStreamByteLimitStoresOneMetaRow(t *testing.T) {
|
||||
if dn, db := metaCounts(t, meta); dn != 2 || db != maxStreamPayload+1 {
|
||||
t.Fatalf("meta dropped_messages=%d dropped_bytes=%d", dn, db)
|
||||
}
|
||||
var stored int64
|
||||
if err := tr.DB().QueryRow(`SELECT SUM(size) FROM stream_messages WHERE exchange_id=? AND direction<>'meta'`, id).Scan(&stored); err != nil || stored != maxStreamBytes {
|
||||
t.Fatalf("stored %d bytes err=%v, want %d", stored, err, maxStreamBytes)
|
||||
var stored, inline int64
|
||||
if err := tr.DB().QueryRow(`SELECT SUM(size), SUM(LENGTH(payload)) FROM stream_messages WHERE exchange_id=? AND direction<>'meta'`, id).Scan(&stored, &inline); err != nil ||
|
||||
stored != int64(kept*maxStreamPayload) || stored+inline > maxStreamBytes {
|
||||
t.Fatalf("stored %d payload bytes + %d inline err=%v, want %d within %d", stored, inline, err, kept*maxStreamPayload, maxStreamBytes)
|
||||
}
|
||||
var respLen int64
|
||||
if err := tr.DB().QueryRow(`SELECT resp_len FROM exchanges WHERE id=?`, id).Scan(&respLen); err != nil || respLen != int64(n*maxStreamPayload+1) {
|
||||
@@ -404,6 +412,81 @@ func TestStreamByteLimitStoresOneMetaRow(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// A payload over maxStreamInline goes to the blob store; the row returns at
|
||||
// most 4 KiB and the hash, and the blob holds the whole payload.
|
||||
func TestStreamPayloadSpillsAboveInlineLimit(t *testing.T) {
|
||||
tr, s, f := unitStream(t, "spill.test")
|
||||
bigText := []byte(strings.Repeat("0123456789", 1024)) // 10 KiB
|
||||
bigBin := make([]byte, 10*1024)
|
||||
for i := range bigBin {
|
||||
bigBin[i] = byte(i)
|
||||
}
|
||||
small := []byte(strings.Repeat("s", 1024))
|
||||
addWS(f, true, websocket.TextMessage, bigText)
|
||||
addWS(f, false, websocket.BinaryMessage, bigBin)
|
||||
addWS(f, true, websocket.TextMessage, small)
|
||||
s.WebSocketMessage(f)
|
||||
msgs := allMessages(t, tr, onlyExchange(t, tr))
|
||||
if len(msgs) != 3 {
|
||||
t.Fatalf("%d messages", len(msgs))
|
||||
}
|
||||
text, bin, inline := msgs[0], msgs[1], msgs[2]
|
||||
if text.Blob == "" || len(text.Payload) > streamPreview || text.Payload != string(bigText[:streamPreview]) || text.Size != len(bigText) || text.Truncated {
|
||||
t.Fatalf("10 KiB text row: blob %q payload %d bytes size %d truncated %v", text.Blob, len(text.Payload), text.Size, text.Truncated)
|
||||
}
|
||||
if data, total, err := tr.BlobRange(text.Blob, 0, int64(len(bigText))); err != nil || total != int64(len(bigText)) || !bytes.Equal(data, bigText) {
|
||||
t.Fatalf("text blob total=%d err=%v, want the full 10 KiB", total, err)
|
||||
}
|
||||
raw, err := base64.StdEncoding.DecodeString(bin.Payload)
|
||||
if bin.Blob == "" || err != nil || !bytes.Equal(raw, bigBin[:streamPreview]) {
|
||||
t.Fatalf("10 KiB binary row: blob %q preview %d bytes err=%v, want its first 4 KiB", bin.Blob, len(raw), err)
|
||||
}
|
||||
if data, total, err := tr.BlobRange(bin.Blob, 0, int64(len(bigBin))); err != nil || total != int64(len(bigBin)) || !bytes.Equal(data, bigBin) {
|
||||
t.Fatalf("binary blob total=%d err=%v", total, err)
|
||||
}
|
||||
if inline.Blob != "" || inline.Payload != string(small) {
|
||||
t.Fatalf("1 KiB row: blob %q payload %d bytes, want inline and complete", inline.Blob, len(inline.Payload))
|
||||
}
|
||||
}
|
||||
|
||||
// The server writes a message and closes at once; the message the client read
|
||||
// must be recorded even though WebSocketEnd fires as soon as one direction ends.
|
||||
func TestWebSocketFinalMessageOnClose(t *testing.T) {
|
||||
tr, _, proxyURL := startProxy(t)
|
||||
up := websocket.Upgrader{CheckOrigin: func(*http.Request) bool { return true }}
|
||||
srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
c, err := up.Upgrade(w, r, nil)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
_ = c.WriteMessage(websocket.TextMessage, []byte("final"))
|
||||
_ = c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
|
||||
_ = c.Close()
|
||||
}))
|
||||
t.Cleanup(srv.Close)
|
||||
c, _, err := wsDialer(t, tr, proxyURL).Dial("wss://"+strings.TrimPrefix(localhostURL(srv.URL), "https://")+"/ws", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, got, err := c.ReadMessage(); err != nil || string(got) != "final" {
|
||||
t.Fatalf("read %q err=%v", got, err)
|
||||
}
|
||||
_ = c.Close()
|
||||
var id string
|
||||
waitFor(t, "websocket end", func() bool {
|
||||
exs := streamExchanges(t, tr, "websocket")
|
||||
if len(exs) != 1 || exs[0].respLen == 0 {
|
||||
return false
|
||||
}
|
||||
id = exs[0].id
|
||||
return true
|
||||
})
|
||||
msgs := allMessages(t, tr, id)
|
||||
if len(msgs) != 1 || msgs[0].Direction != "s2c" || msgs[0].Payload != "final" {
|
||||
t.Fatalf("messages %+v, want the final server message", msgs)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeleteHostRemovesStreamMessagesAndBlobs(t *testing.T) {
|
||||
tr, s, f := unitStream(t, "gone.test")
|
||||
addWS(f, false, websocket.BinaryMessage, bytes.Repeat([]byte{9}, maxInlineBody+1))
|
||||
@@ -547,4 +630,8 @@ func TestLibMutexFound(t *testing.T) {
|
||||
if libMutex(&mproxy.WebSocketData{}) == nil || libMutex(&mproxy.SSEData{}) == nil {
|
||||
t.Fatal("go-mitmproxy WebSocketData/SSEData no longer have a sync.Mutex field named mu")
|
||||
}
|
||||
// Without the lock nothing is read: no unlocked fallback.
|
||||
if _, ok := lockLib(&struct{ Messages []int }{}); ok {
|
||||
t.Fatal("lockLib reported a lock on a type without mu")
|
||||
}
|
||||
}
|
||||
|
||||
+8
-2
@@ -78,7 +78,7 @@ CREATE INDEX IF NOT EXISTS idx_blob_refs_ex ON blob_refs(exchange_id);
|
||||
CREATE TABLE IF NOT EXISTS stream_messages (
|
||||
exchange_id TEXT NOT NULL,
|
||||
seq INTEGER NOT NULL,
|
||||
ts INTEGER NOT NULL, -- unix milliseconds
|
||||
ts INTEGER NOT NULL, -- unix seconds, like exchanges.ts
|
||||
direction TEXT NOT NULL, -- 'c2s' | 's2c' | 'meta'
|
||||
kind INTEGER NOT NULL, -- WebSocket opcode (1 text, 2 binary), 0 for SSE and meta
|
||||
event TEXT NOT NULL DEFAULT '',
|
||||
@@ -558,6 +558,12 @@ type storedBody struct {
|
||||
// are handed to the full-text index in full (up to maxIndexBody) — indexing is
|
||||
// independent of where the bytes end up.
|
||||
func (t *Traffic) spill(body []byte, contentType string) storedBody {
|
||||
return t.spillAt(body, contentType, maxInlineBody)
|
||||
}
|
||||
|
||||
// spillAt is spill with the inline threshold as a parameter: bodies up to
|
||||
// maxInline stay inline. Stream messages use a much lower one (maxStreamInline).
|
||||
func (t *Traffic) spillAt(body []byte, contentType string, maxInline int) storedBody {
|
||||
if len(body) == 0 {
|
||||
return storedBody{}
|
||||
}
|
||||
@@ -568,7 +574,7 @@ func (t *Traffic) spill(body []byte, contentType string) storedBody {
|
||||
}
|
||||
return string(clipBytes(body, maxIndexBody))
|
||||
}
|
||||
if len(body) <= maxInlineBody {
|
||||
if len(body) <= maxInline {
|
||||
return storedBody{inline: body, index: indexText()}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user