Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
50 changes: 36 additions & 14 deletions pkg/http/server.go
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,7 @@ package http

import (
"context"
"errors"
"fmt"
"io"
"log/slog"
Expand Down Expand Up @@ -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)
Expand Down
213 changes: 213 additions & 0 deletions pkg/http/shutdown_test.go
Original file line number Diff line number Diff line change
@@ -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
}