mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-16 22:57:53 +08:00
- Compress finalized Codex OAuth request bodies with zstd on the verified ChatGPT backend path, with size/benefit gating, header-body alignment, and one uncompressed retry on 400/415 rejection. - Negotiate downstream HTTP response compression under server.response-compression (zstd/gzip with q-values, SSE-safe flushing, commit-time Vary merging) and enable negotiated permessage-deflate on Codex and downstream WebSockets. - Advertise Accept-Encoding to Codex upstreams and decode gzip/deflate/br/zstd upstream responses through a shared decoder before parsing or relaying. Closes: #6905
133 lines
4.2 KiB
Go
133 lines
4.2 KiB
Go
package executor
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"context"
|
|
"math/rand"
|
|
"net"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
|
|
"github.com/gorilla/websocket"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/config"
|
|
cliproxyauth "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/auth"
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// compressionFrameRecorder observes the first WebSocket frame after HTTP hijacking.
|
|
type compressionFrameRecorder struct {
|
|
net.Conn
|
|
firstByte chan byte
|
|
once sync.Once
|
|
}
|
|
|
|
func (c *compressionFrameRecorder) Read(data []byte) (int, error) {
|
|
n, errRead := c.Conn.Read(data)
|
|
if n > 0 {
|
|
c.once.Do(func() { c.firstByte <- data[0] })
|
|
}
|
|
return n, errRead
|
|
}
|
|
|
|
type compressionHijackRecorder struct {
|
|
http.ResponseWriter
|
|
firstByte chan byte
|
|
}
|
|
|
|
func (w *compressionHijackRecorder) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
conn, buffered, errHijack := w.ResponseWriter.(http.Hijacker).Hijack()
|
|
if errHijack != nil {
|
|
return nil, nil, errHijack
|
|
}
|
|
recorder := &compressionFrameRecorder{Conn: conn, firstByte: w.firstByte}
|
|
return recorder, bufio.NewReadWriter(bufio.NewReader(recorder), buffered.Writer), nil
|
|
}
|
|
|
|
func TestWebsocketCompressionRoundTrip(t *testing.T) {
|
|
enabled, disabled := true, false
|
|
for _, provider := range []string{"codex", "xai"} {
|
|
for _, tc := range []struct {
|
|
name string
|
|
cfg *config.Config
|
|
want bool
|
|
}{
|
|
{name: "nil_config", want: true},
|
|
{name: "default", cfg: &config.Config{}, want: true},
|
|
{name: "enabled", cfg: &config.Config{Codex: config.CodexConfig{WebsocketCompression: &enabled}}, want: true},
|
|
{name: "disabled", cfg: &config.Config{Codex: config.CodexConfig{WebsocketCompression: &disabled}}},
|
|
} {
|
|
t.Run(provider+"/"+tc.name, func(t *testing.T) {
|
|
firstByte := make(chan byte, 1)
|
|
serverErr := make(chan error, 1)
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
upgrader := websocket.Upgrader{EnableCompression: true, ReadBufferSize: 1024}
|
|
conn, errUpgrade := upgrader.Upgrade(&compressionHijackRecorder{ResponseWriter: w, firstByte: firstByte}, r, nil)
|
|
if errUpgrade != nil {
|
|
serverErr <- errUpgrade
|
|
return
|
|
}
|
|
defer func() {
|
|
if errClose := conn.Close(); errClose != nil {
|
|
log.Errorf("close compression test server websocket: %v", errClose)
|
|
}
|
|
}()
|
|
messageType, payload, errReadMessage := conn.ReadMessage()
|
|
if errReadMessage != nil {
|
|
serverErr <- errReadMessage
|
|
return
|
|
}
|
|
serverErr <- conn.WriteMessage(messageType, payload)
|
|
}))
|
|
defer server.Close()
|
|
wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
|
|
auth := &cliproxyauth.Auth{ProxyURL: "direct"}
|
|
var conn *websocket.Conn
|
|
var closer *websocketConnectionCloser
|
|
var response *http.Response
|
|
var errDial error
|
|
if provider == "codex" {
|
|
conn, closer, response, errDial = NewCodexWebsocketsExecutor(tc.cfg).dialCodexWebsocket(context.Background(), auth, wsURL, nil)
|
|
} else {
|
|
conn, closer, response, errDial = NewXAIWebsocketsExecutor(tc.cfg).dialXAIWebsocket(context.Background(), auth, wsURL, nil)
|
|
}
|
|
if errDial != nil {
|
|
t.Fatal(errDial)
|
|
}
|
|
defer func() {
|
|
if errClose := closer.Close(); errClose != nil {
|
|
log.Errorf("close compression test client websocket: %v", errClose)
|
|
}
|
|
}()
|
|
if !strings.Contains(response.Header.Get("Sec-WebSocket-Extensions"), "permessage-deflate") {
|
|
t.Fatal("compression was not negotiated")
|
|
}
|
|
payload := make([]byte, 96*1024)
|
|
random := rand.New(rand.NewSource(6905))
|
|
for i := range payload {
|
|
payload[i] = byte(' ' + random.Intn(95))
|
|
}
|
|
if errWriteMessage := conn.WriteMessage(websocket.TextMessage, payload); errWriteMessage != nil {
|
|
t.Fatal(errWriteMessage)
|
|
}
|
|
_, echoed, errReadMessage := conn.ReadMessage()
|
|
if errReadMessage != nil {
|
|
t.Fatal(errReadMessage)
|
|
}
|
|
if !bytes.Equal(echoed, payload) {
|
|
t.Fatal("large payload echo differs")
|
|
}
|
|
if errServer := <-serverErr; errServer != nil {
|
|
t.Fatal(errServer)
|
|
}
|
|
if got := (<-firstByte)&0x40 != 0; got != tc.want {
|
|
t.Fatalf("frame RSV1 = %v, want %v", got, tc.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|