fix(mcp): 分离SSE连接生命周期与请求超时 (#4140)
parent
1b2c7af01a
commit
cf7aabeaca
|
|
@ -238,17 +238,25 @@ func NewMCPClient(config *ClientConfig) (MCPClient, error) {
|
|||
if config.Service.URL == nil || *config.Service.URL == "" {
|
||||
return nil, fmt.Errorf("URL is required for SSE transport")
|
||||
}
|
||||
// SSE keeps its GET response body open for the connection lifetime.
|
||||
// OAuth retains the bounded HTTP client; SSE bounds startup and RPCs
|
||||
// separately without putting an expiration on the event stream.
|
||||
sseHTTPClient := *httpClient
|
||||
sseHTTPClient.Timeout = 0
|
||||
options := []transport.ClientOption{
|
||||
transport.WithHTTPClient(httpClient),
|
||||
transport.WithHTTPClient(&sseHTTPClient),
|
||||
transport.WithHeaders(headers),
|
||||
transport.WithEndpointTimeout(timeout),
|
||||
transport.WithResponseTimeout(timeout),
|
||||
}
|
||||
if useOAuth {
|
||||
options = append(options, transport.WithOAuth(oauthConfig))
|
||||
}
|
||||
connection, err = transport.NewSSE(*config.Service.URL, options...)
|
||||
sse, err := transport.NewSSE(*config.Service.URL, options...)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to create SSE client: %w", err)
|
||||
}
|
||||
connection = &boundedSSEConnection{SSE: sse, timeout: timeout}
|
||||
case types.MCPTransportHTTPStreamable:
|
||||
if config.Service.URL == nil || *config.Service.URL == "" {
|
||||
return nil, fmt.Errorf("URL is required for HTTP Streamable transport")
|
||||
|
|
|
|||
|
|
@ -0,0 +1,62 @@
|
|||
package mcp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http/httptest"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
"github.com/Tencent/WeKnora/internal/utils"
|
||||
sdk "github.com/mark3labs/mcp-go/mcp"
|
||||
"github.com/mark3labs/mcp-go/server"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func TestSSECallBudgetIsNotConnectionLifetime(t *testing.T) {
|
||||
utils.SetSSRFWhitelistFromRaw("127.0.0.1")
|
||||
t.Cleanup(utils.ResetSSRFWhitelistForTest)
|
||||
for _, age := range []time.Duration{0, 1500 * time.Millisecond} {
|
||||
t.Run(age.String(), func(t *testing.T) { testSSECallAfterIdle(t, age) })
|
||||
}
|
||||
}
|
||||
|
||||
func testSSECallAfterIdle(t *testing.T, age time.Duration) {
|
||||
t.Helper()
|
||||
var executions atomic.Int32
|
||||
peer := server.NewMCPServer("lifetime-audit", "1")
|
||||
peer.AddTool(sdk.NewTool("slow", sdk.WithDescription("600 ms controlled read")),
|
||||
func(context.Context, sdk.CallToolRequest) (*sdk.CallToolResult, error) {
|
||||
executions.Add(1)
|
||||
time.Sleep(600 * time.Millisecond)
|
||||
return sdk.NewToolResultText("complete"), nil
|
||||
})
|
||||
httpServer := httptest.NewServer(server.NewSSEServer(peer))
|
||||
t.Cleanup(httpServer.Close)
|
||||
manager := NewMCPManager(nil)
|
||||
t.Cleanup(manager.Shutdown)
|
||||
url := httpServer.URL + "/sse"
|
||||
svc := &types.MCPService{
|
||||
ID: "lifetime", Name: "lifetime", Enabled: true, URL: &url,
|
||||
TransportType: types.MCPTransportSSE,
|
||||
AdvancedConfig: &types.MCPAdvancedConfig{Timeout: 2},
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(t.Context(), 8*time.Second)
|
||||
defer cancel()
|
||||
connectedAt := time.Now()
|
||||
c, err := manager.GetOrCreateClient(ctx, svc)
|
||||
require.NoError(t, err)
|
||||
_, err = c.ListTools(ctx)
|
||||
require.NoError(t, err)
|
||||
time.Sleep(age)
|
||||
require.True(t, c.IsConnected(), "connection must be healthy before the call")
|
||||
callCtx, stop := context.WithTimeout(ctx, 2*time.Second)
|
||||
defer stop()
|
||||
start := time.Now()
|
||||
result, err := c.CallTool(callCtx, "slow", map[string]interface{}{})
|
||||
t.Logf("connection_age=%s call_duration=%s executions=%d context_error=%v call_error=%v",
|
||||
time.Since(connectedAt), time.Since(start), executions.Load(), callCtx.Err(), err)
|
||||
require.NoError(t, err, "a 600 ms tool must fit its fresh 2 s call budget regardless of connection age")
|
||||
require.Equal(t, "complete", result.Content[0].Text)
|
||||
}
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
package mcp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/mark3labs/mcp-go/client/transport"
|
||||
sdk "github.com/mark3labs/mcp-go/mcp"
|
||||
)
|
||||
|
||||
// boundedSSEConnection separates establishment and RPC budgets from the
|
||||
// persistent event stream. Embedding SSE preserves its optional transport hooks.
|
||||
type boundedSSEConnection struct {
|
||||
*transport.SSE
|
||||
timeout time.Duration
|
||||
mu sync.Mutex
|
||||
cancel context.CancelCauseFunc
|
||||
}
|
||||
|
||||
func (c *boundedSSEConnection) Start(ctx context.Context) error {
|
||||
lifetime, cancel := context.WithCancelCause(ctx)
|
||||
c.mu.Lock()
|
||||
c.cancel = cancel
|
||||
c.mu.Unlock()
|
||||
// Unlike WithTimeout, this timer can be stopped without cancelling the
|
||||
// successful stream. It covers headers as well as the endpoint event.
|
||||
timer := time.AfterFunc(c.timeout, func() { cancel(context.DeadlineExceeded) })
|
||||
err := c.SSE.Start(lifetime)
|
||||
if !timer.Stop() {
|
||||
cancel(context.DeadlineExceeded)
|
||||
}
|
||||
if cause := context.Cause(lifetime); cause != nil {
|
||||
err = cause
|
||||
}
|
||||
if err != nil {
|
||||
cancel(err)
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func (c *boundedSSEConnection) SendRequest(
|
||||
ctx context.Context, request transport.JSONRPCRequest,
|
||||
) (*transport.JSONRPCResponse, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, c.timeout)
|
||||
defer cancel()
|
||||
// Includes both POST acknowledgement and waiting for its SSE response.
|
||||
return c.SSE.SendRequest(ctx, request)
|
||||
}
|
||||
|
||||
func (c *boundedSSEConnection) SendNotification(ctx context.Context, notification sdk.JSONRPCNotification) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, c.timeout)
|
||||
defer cancel()
|
||||
return c.SSE.SendNotification(ctx, notification)
|
||||
}
|
||||
|
||||
func (c *boundedSSEConnection) Close() error {
|
||||
c.mu.Lock()
|
||||
cancel := c.cancel
|
||||
c.mu.Unlock()
|
||||
if cancel != nil {
|
||||
cancel(context.Canceled)
|
||||
}
|
||||
return c.SSE.Close()
|
||||
}
|
||||
|
|
@ -0,0 +1,136 @@
|
|||
package mcp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/mark3labs/mcp-go/client/transport"
|
||||
sdk "github.com/mark3labs/mcp-go/mcp"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
const sseTestBudget = 150 * time.Millisecond
|
||||
|
||||
func newBoundedSSETestConnection(t *testing.T, handler http.HandlerFunc) *boundedSSEConnection {
|
||||
t.Helper()
|
||||
server := httptest.NewServer(handler)
|
||||
t.Cleanup(server.Close)
|
||||
sse, err := transport.NewSSE(server.URL, transport.WithHTTPClient(server.Client()))
|
||||
require.NoError(t, err)
|
||||
c := &boundedSSEConnection{SSE: sse, timeout: sseTestBudget}
|
||||
t.Cleanup(func() { require.NoError(t, c.Close()) })
|
||||
return c
|
||||
}
|
||||
|
||||
func TestSSEStartupBudgetAndCancellation(t *testing.T) {
|
||||
for _, mode := range []string{"headers", "endpoint", "cancelled"} {
|
||||
t.Run(mode, func(t *testing.T) {
|
||||
started, closed := make(chan struct{}), make(chan struct{})
|
||||
c := newBoundedSSETestConnection(t, func(w http.ResponseWriter, r *http.Request) {
|
||||
close(started)
|
||||
defer close(closed)
|
||||
if mode == "endpoint" {
|
||||
w.Header().Set("Content-Type", "text/event-stream")
|
||||
w.WriteHeader(http.StatusOK)
|
||||
w.(http.Flusher).Flush()
|
||||
}
|
||||
<-r.Context().Done()
|
||||
})
|
||||
ctx, cancel := context.WithCancel(t.Context())
|
||||
defer cancel()
|
||||
done := make(chan error, 1)
|
||||
go func() { done <- c.Start(ctx) }()
|
||||
<-started
|
||||
want := context.DeadlineExceeded
|
||||
if mode == "cancelled" {
|
||||
cancel()
|
||||
want = context.Canceled
|
||||
}
|
||||
select {
|
||||
case err := <-done:
|
||||
require.ErrorIs(t, err, want)
|
||||
case <-time.After(time.Second):
|
||||
t.Fatal("SSE establishment did not stop")
|
||||
}
|
||||
select {
|
||||
case <-closed:
|
||||
case <-time.After(time.Second):
|
||||
t.Fatal("failed establishment left the HTTP request running")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestSSERPCBudgetKeepsEventStreamAlive(t *testing.T) {
|
||||
for _, mode := range []string{"post_headers", "post_body", "event_response", "notification", "cancelled"} {
|
||||
t.Run(mode, func(t *testing.T) { testSSERPCBudget(t, mode) })
|
||||
}
|
||||
}
|
||||
|
||||
func testSSERPCBudget(t *testing.T, mode string) {
|
||||
t.Helper()
|
||||
streamClosed := make(chan struct{})
|
||||
c := newBoundedSSETestConnection(t, func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Method == http.MethodGet {
|
||||
w.Header().Set("Content-Type", "text/event-stream")
|
||||
_, _ = fmt.Fprint(w, "event: endpoint\ndata: /message\n\n")
|
||||
w.(http.Flusher).Flush()
|
||||
<-r.Context().Done()
|
||||
close(streamClosed)
|
||||
return
|
||||
}
|
||||
_, _ = io.Copy(io.Discard, r.Body)
|
||||
if mode == "event_response" {
|
||||
w.WriteHeader(http.StatusAccepted)
|
||||
return
|
||||
}
|
||||
if mode == "post_body" {
|
||||
w.WriteHeader(http.StatusAccepted)
|
||||
w.(http.Flusher).Flush()
|
||||
}
|
||||
<-r.Context().Done()
|
||||
})
|
||||
require.NoError(t, c.Start(t.Context()))
|
||||
ctx, cancel := context.WithTimeout(t.Context(), time.Second)
|
||||
defer cancel()
|
||||
if mode == "cancelled" {
|
||||
cancel()
|
||||
}
|
||||
start := time.Now()
|
||||
err := sendSSETestOperation(ctx, c, mode)
|
||||
require.Error(t, err)
|
||||
require.Less(t, time.Since(start), 750*time.Millisecond)
|
||||
if mode != "cancelled" {
|
||||
require.NoError(t, ctx.Err(), "service budget must expire before the caller budget")
|
||||
} else {
|
||||
require.ErrorIs(t, err, context.Canceled)
|
||||
}
|
||||
select {
|
||||
case <-streamClosed:
|
||||
t.Fatal("an RPC timeout or cancellation must not close the event stream")
|
||||
default:
|
||||
}
|
||||
require.NoError(t, c.Close())
|
||||
select {
|
||||
case <-streamClosed:
|
||||
case <-time.After(time.Second):
|
||||
t.Fatal("explicit Close did not release the event stream")
|
||||
}
|
||||
}
|
||||
|
||||
func sendSSETestOperation(ctx context.Context, c *boundedSSEConnection, mode string) error {
|
||||
if mode == "notification" {
|
||||
return c.SendNotification(ctx, sdk.JSONRPCNotification{
|
||||
JSONRPC: "2.0", Notification: sdk.Notification{Method: "notifications/initialized"},
|
||||
})
|
||||
}
|
||||
_, err := c.SendRequest(ctx, transport.JSONRPCRequest{
|
||||
JSONRPC: "2.0", ID: sdk.NewRequestId(1), Method: "tools/list",
|
||||
})
|
||||
return err
|
||||
}
|
||||
Loading…
Reference in New Issue