From c866dd6a1f63f8754f5733240a3eb7a7541d08ab Mon Sep 17 00:00:00 2001 From: Jon Zhang Date: Wed, 18 Nov 2026 00:25:20 -0800 Subject: [PATCH] fix(http): wait for active requests during shutdown Wait for the Streamable HTTP grace period after the listener closes. Close remaining connections on a shutdown error and preserve the cause for the CLI. Cover in-flight responses, deadline expiry, startup cancellation, and listener errors. --- pkg/http/server.go | 50 ++++++--- pkg/http/shutdown_test.go | 213 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 249 insertions(+), 14 deletions(-) create mode 100644 pkg/http/shutdown_test.go diff --git a/pkg/http/server.go b/pkg/http/server.go index 320df45ef0..cc1d9cbf07 100644 --- a/pkg/http/server.go +++ b/pkg/http/server.go @@ -2,6 +2,7 @@ package http import ( "context" + "errors" "fmt" "io" "log/slog" @@ -225,35 +226,56 @@ func RunHTTPServer(cfg ServerConfig) error { addr := resolveListenAddress(cfg.ListenHost, cfg.Port) httpSvr := http.Server{ - Addr: addr, Handler: r, ReadHeaderTimeout: 60 * time.Second, } - go func() { - <-ctx.Done() - shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second) - defer cancel() - logger.Info("shutting down server") - if err := httpSvr.Shutdown(shutdownCtx); err != nil { - logger.Error("error during server shutdown", "error", err) - } - }() - if cfg.ExportTranslations { // Once server is initialized, all translations are loaded dumpTranslations() } - logger.Info("HTTP server listening", "addr", addr) - if err := httpSvr.ListenAndServe(); err != nil && err != http.ErrServerClosed { + listener, err := net.Listen("tcp", addr) + if err != nil { return fmt.Errorf("HTTP server error: %w", err) } - + logger.Info("HTTP server listening", "addr", addr) + if err := serveHTTP(ctx, &httpSvr, listener, 5*time.Second, logger); err != nil { + return err + } logger.Info("server stopped gracefully") return nil } +func serveHTTP(ctx context.Context, server *http.Server, listener net.Listener, shutdownTimeout time.Duration, logger *slog.Logger) error { + serveResult := make(chan error, 1) + go func() { + serveResult <- server.Serve(listener) + }() + + select { + case err := <-serveResult: + return fmt.Errorf("HTTP server error: %w", errors.Join(err, server.Close())) + case <-ctx.Done(): + } + + logger.Info("shutting down server") + shutdownCtx, cancel := context.WithTimeout(context.Background(), shutdownTimeout) + defer cancel() + // Serve returns when Shutdown closes the listener, before active requests drain. + shutdownErr := server.Shutdown(shutdownCtx) + if shutdownErr != nil { + shutdownErr = errors.Join(shutdownErr, server.Close()) + } + if err := <-serveResult; err != http.ErrServerClosed { + return fmt.Errorf("HTTP server error: %w", errors.Join(err, shutdownErr)) + } + if shutdownErr != nil { + return fmt.Errorf("error during server shutdown: %w", shutdownErr) + } + return nil +} + func newHTTPRouter(registerMCPRoutes, registerOAuthRoutes func(chi.Router)) chi.Router { r := chi.NewRouter() r.Use(middleware.SetCorsHeaders) diff --git a/pkg/http/shutdown_test.go b/pkg/http/shutdown_test.go new file mode 100644 index 0000000000..8664259453 --- /dev/null +++ b/pkg/http/shutdown_test.go @@ -0,0 +1,213 @@ +package http + +import ( + "bufio" + "context" + "io" + "log/slog" + "net" + "net/http" + "sync" + "testing" + "testing/synctest" + "time" + + "github.com/stretchr/testify/require" +) + +const testShutdownTimeout = time.Second + +func TestServeHTTPDrainsActiveRequest(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + listener, client := newShutdownPipeListener(t) + started := make(chan struct{}) + release := make(chan struct{}) + server := &http.Server{ + ReadHeaderTimeout: time.Second, + Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + close(started) + select { + case <-release: + _, _ = io.WriteString(w, "finished") + case <-r.Context().Done(): + } + }), + } + defer finishFailedShutdownTest(t, server) + + ctx, cancel := context.WithCancel(t.Context()) + defer cancel() + serveResult := make(chan error, 1) + go func() { + serveResult <- serveHTTP(ctx, server, listener, testShutdownTimeout, slog.New(slog.DiscardHandler)) + }() + requestResult := readShutdownResponse(client) + <-started + + cancel() + <-listener.closed + synctest.Wait() + select { + case err := <-serveResult: + t.Fatalf("server returned while the request was active: %v", err) + case response := <-requestResult: + t.Fatalf("request ended before its handler was released: %+v", response) + default: + } + + close(release) + response := <-requestResult + require.NoError(t, response.err) + require.Equal(t, http.StatusOK, response.status) + require.Equal(t, "finished", response.body) + require.NoError(t, <-serveResult) + }) +} + +func TestServeHTTPClosesActiveConnectionOnTimeout(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + listener, client := newShutdownPipeListener(t) + started := make(chan struct{}) + requestCanceled := make(chan error, 1) + server := &http.Server{ + ReadHeaderTimeout: time.Second, + Handler: http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) { + close(started) + <-r.Context().Done() + requestCanceled <- r.Context().Err() + }), + } + defer finishFailedShutdownTest(t, server) + + ctx, cancel := context.WithCancel(t.Context()) + defer cancel() + serveResult := make(chan error, 1) + go func() { + serveResult <- serveHTTP(ctx, server, listener, testShutdownTimeout, slog.New(slog.DiscardHandler)) + }() + requestResult := readShutdownResponse(client) + <-started + + cancel() + <-listener.closed + require.ErrorIs(t, <-serveResult, context.DeadlineExceeded) + + synctest.Wait() + select { + case err := <-requestCanceled: + require.ErrorIs(t, err, context.Canceled) + default: + t.Fatal("request context is still active after shutdown timed out") + } + select { + case response := <-requestResult: + require.Error(t, response.err, "client received an HTTP response after shutdown timed out") + default: + t.Fatal("client connection is still open after shutdown timed out") + } + }) +} + +func TestServeHTTPReturnsListenerError(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + listener := &shutdownPipeListener{closed: make(chan struct{})} + require.NoError(t, listener.Close()) + server := &http.Server{ReadHeaderTimeout: time.Second} + + err := serveHTTP(t.Context(), server, listener, time.Second, slog.New(slog.DiscardHandler)) + + require.ErrorIs(t, err, net.ErrClosed) + }) +} + +func TestServeHTTPClosesListenerWhenAlreadyCanceled(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + listener := &shutdownPipeListener{closed: make(chan struct{})} + ctx, cancel := context.WithCancel(t.Context()) + cancel() + + server := &http.Server{ReadHeaderTimeout: time.Second} + err := serveHTTP(ctx, server, listener, time.Second, slog.New(slog.DiscardHandler)) + require.NoError(t, err) + select { + case <-listener.closed: + default: + t.Fatal("listener is still open after shutdown") + } + }) +} + +func finishFailedShutdownTest(t *testing.T, server *http.Server) { + if t.Failed() { + _ = server.Close() + // Let a detached Shutdown goroutine finish before leaving the synctest bubble. + time.Sleep(testShutdownTimeout) + } +} + +type shutdownPipeListener struct { + pending chan net.Conn + closed chan struct{} + once sync.Once +} + +// In-memory connections allow synctest to observe blocked HTTP I/O. +func newShutdownPipeListener(t *testing.T) (*shutdownPipeListener, net.Conn) { + t.Helper() + server, client := net.Pipe() + t.Cleanup(func() { + _ = client.Close() + _ = server.Close() + }) + + listener := &shutdownPipeListener{ + pending: make(chan net.Conn, 1), + closed: make(chan struct{}), + } + listener.pending <- server + return listener, client +} + +func (l *shutdownPipeListener) Accept() (net.Conn, error) { + select { + case conn := <-l.pending: + return conn, nil + case <-l.closed: + return nil, net.ErrClosed + } +} + +func (l *shutdownPipeListener) Close() error { + l.once.Do(func() { close(l.closed) }) + return nil +} + +func (*shutdownPipeListener) Addr() net.Addr { + return &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1)} +} + +type shutdownResponse struct { + status int + body string + err error +} + +func readShutdownResponse(conn net.Conn) <-chan shutdownResponse { + result := make(chan shutdownResponse, 1) + go func() { + _, err := io.WriteString(conn, "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n") + if err != nil { + result <- shutdownResponse{err: err} + return + } + resp, err := http.ReadResponse(bufio.NewReader(conn), nil) + if err != nil { + result <- shutdownResponse{err: err} + return + } + defer resp.Body.Close() + body, err := io.ReadAll(resp.Body) + result <- shutdownResponse{status: resp.StatusCode, body: string(body), err: err} + }() + return result +}