mirror of
https://github.com/caddyserver/caddy.git
synced 2026-11-17 21:41:58 +00:00
caddyhttp: end request-body deadline ownership with handler (#8107)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Francis Lavoie <lavofr@gmail.com>
This commit is contained in:
parent
ac63faabb8
commit
ab7e6b6d81
5 changed files with 418 additions and 11 deletions
|
|
@ -17,6 +17,7 @@ package caddyhttp
|
|||
import (
|
||||
"io"
|
||||
"net/http"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"go.uber.org/zap"
|
||||
|
|
@ -79,25 +80,91 @@ type IdleTimeoutReader struct {
|
|||
Deadline IdleDeadline
|
||||
Logger *zap.Logger
|
||||
|
||||
// DrainDeadline makes HandlerDone arm a final idle deadline if
|
||||
// the body is unfinished, bounding net/http's post-handler drain.
|
||||
// Only HTTP/1 drains a request body on the connection after the
|
||||
// handler returns, so it is pointless (and costs a timer on
|
||||
// HTTP/2) for other protocols or requests without a body.
|
||||
DrainDeadline bool
|
||||
|
||||
mu sync.Mutex
|
||||
unsupported bool
|
||||
deadlineSet bool
|
||||
finished bool
|
||||
terminalErr error
|
||||
}
|
||||
|
||||
func (r *IdleTimeoutReader) Read(p []byte) (int, error) {
|
||||
if !r.unsupported {
|
||||
if err := r.Ctrl.SetReadDeadline(r.Deadline.next()); err != nil {
|
||||
r.unsupported = true
|
||||
if c := r.Logger.Check(zapcore.DebugLevel, "could not set read deadline"); c != nil {
|
||||
c.Write(zap.Error(err))
|
||||
}
|
||||
}
|
||||
r.mu.Lock()
|
||||
if r.terminalErr != nil {
|
||||
err := r.terminalErr
|
||||
r.mu.Unlock()
|
||||
return 0, err
|
||||
}
|
||||
if !r.finished && !r.unsupported {
|
||||
r.setDeadlineLocked("could not set read deadline")
|
||||
}
|
||||
r.mu.Unlock()
|
||||
|
||||
n, err := r.ReadCloser.Read(p)
|
||||
|
||||
r.mu.Lock()
|
||||
r.Deadline.transferred += int64(n)
|
||||
if err != nil {
|
||||
r.terminalErr = err
|
||||
if !r.finished {
|
||||
r.clearDeadlineLocked()
|
||||
}
|
||||
}
|
||||
r.mu.Unlock()
|
||||
|
||||
return n, err
|
||||
}
|
||||
|
||||
// HandlerDone prevents later body reads from using the response controller.
|
||||
// If the body is not finished and DrainDeadline is set, it leaves an idle
|
||||
// deadline armed for net/http's post-handler drain. It must be called before
|
||||
// the installing handler returns.
|
||||
func (r *IdleTimeoutReader) HandlerDone() {
|
||||
r.mu.Lock()
|
||||
defer r.mu.Unlock()
|
||||
|
||||
if r.finished {
|
||||
return
|
||||
}
|
||||
if r.terminalErr != nil {
|
||||
r.clearDeadlineLocked()
|
||||
} else if r.DrainDeadline && !r.deadlineSet && !r.unsupported {
|
||||
r.setDeadlineLocked("could not set final read deadline")
|
||||
}
|
||||
r.finished = true
|
||||
}
|
||||
|
||||
func (r *IdleTimeoutReader) setDeadlineLocked(logMessage string) {
|
||||
if err := r.Ctrl.SetReadDeadline(r.Deadline.next()); err != nil {
|
||||
r.unsupported = true
|
||||
if c := r.Logger.Check(zapcore.DebugLevel, logMessage); c != nil {
|
||||
c.Write(zap.Error(err))
|
||||
}
|
||||
return
|
||||
}
|
||||
r.deadlineSet = true
|
||||
}
|
||||
|
||||
func (r *IdleTimeoutReader) clearDeadlineLocked() {
|
||||
if !r.deadlineSet {
|
||||
return
|
||||
}
|
||||
if err := r.Ctrl.SetReadDeadline(time.Time{}); err != nil {
|
||||
r.unsupported = true
|
||||
if c := r.Logger.Check(zapcore.DebugLevel, "could not clear read deadline"); c != nil {
|
||||
c.Write(zap.Error(err))
|
||||
}
|
||||
return
|
||||
}
|
||||
r.deadlineSet = false
|
||||
}
|
||||
|
||||
// IdleTimeoutWriter wraps a ResponseWriter with IdleDeadline, resetting
|
||||
// the write deadline before every Write call, the same way
|
||||
// IdleTimeoutReader does for reads. A handler that pauses between
|
||||
|
|
|
|||
|
|
@ -16,9 +16,13 @@ package caddyhttp
|
|||
|
||||
import (
|
||||
"bytes"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
|
|
@ -27,6 +31,43 @@ import (
|
|||
"go.uber.org/zap"
|
||||
)
|
||||
|
||||
type readDeadlineRecorder struct {
|
||||
*httptest.ResponseRecorder
|
||||
mu sync.Mutex
|
||||
deadlines []time.Time
|
||||
failAt int
|
||||
}
|
||||
|
||||
func (w *readDeadlineRecorder) SetReadDeadline(deadline time.Time) error {
|
||||
w.mu.Lock()
|
||||
defer w.mu.Unlock()
|
||||
w.deadlines = append(w.deadlines, deadline)
|
||||
if len(w.deadlines) == w.failAt {
|
||||
return errors.New("deadline failure")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (w *readDeadlineRecorder) snapshot() []time.Time {
|
||||
w.mu.Lock()
|
||||
defer w.mu.Unlock()
|
||||
return append([]time.Time(nil), w.deadlines...)
|
||||
}
|
||||
|
||||
type blockingReadCloser struct {
|
||||
started chan struct{}
|
||||
release chan struct{}
|
||||
once sync.Once
|
||||
}
|
||||
|
||||
func (r *blockingReadCloser) Read([]byte) (int, error) {
|
||||
r.once.Do(func() { close(r.started) })
|
||||
<-r.release
|
||||
return 0, io.EOF
|
||||
}
|
||||
|
||||
func (*blockingReadCloser) Close() error { return nil }
|
||||
|
||||
// pacedReader emits chunkCount chunks of chunkSize bytes, sleeping delay
|
||||
// before each one, simulating a client that trickles a request body.
|
||||
type pacedReader struct {
|
||||
|
|
@ -87,6 +128,257 @@ func TestIdleTimeoutReader(t *testing.T) {
|
|||
})
|
||||
}
|
||||
|
||||
func TestIdleTimeoutReaderClearsDeadlineAtEOF(t *testing.T) {
|
||||
w := &readDeadlineRecorder{ResponseRecorder: httptest.NewRecorder()}
|
||||
r := &IdleTimeoutReader{
|
||||
ReadCloser: io.NopCloser(strings.NewReader("body")),
|
||||
Ctrl: http.NewResponseController(w),
|
||||
Deadline: IdleDeadline{Timeout: time.Second},
|
||||
Logger: zap.NewNop(),
|
||||
}
|
||||
|
||||
_, err := io.Copy(io.Discard, r)
|
||||
require.NoError(t, err)
|
||||
deadlines := w.snapshot()
|
||||
require.NotEmpty(t, deadlines)
|
||||
assert.True(t, deadlines[len(deadlines)-1].IsZero())
|
||||
}
|
||||
|
||||
func TestIdleTimeoutReaderHandlerDone(t *testing.T) {
|
||||
body := &blockingReadCloser{
|
||||
started: make(chan struct{}),
|
||||
release: make(chan struct{}),
|
||||
}
|
||||
w := &readDeadlineRecorder{ResponseRecorder: httptest.NewRecorder()}
|
||||
r := &IdleTimeoutReader{
|
||||
ReadCloser: body,
|
||||
Ctrl: http.NewResponseController(w),
|
||||
Deadline: IdleDeadline{Timeout: time.Second},
|
||||
Logger: zap.NewNop(),
|
||||
}
|
||||
|
||||
readDone := make(chan struct{})
|
||||
go func() {
|
||||
defer close(readDone)
|
||||
_, _ = r.Read(make([]byte, 1))
|
||||
}()
|
||||
<-body.started
|
||||
|
||||
r.HandlerDone()
|
||||
deadlines := w.snapshot()
|
||||
require.Len(t, deadlines, 1)
|
||||
assert.False(t, deadlines[0].IsZero())
|
||||
|
||||
close(body.release)
|
||||
<-readDone
|
||||
_, _ = r.Read(make([]byte, 1))
|
||||
r.HandlerDone()
|
||||
assert.Len(t, w.snapshot(), len(deadlines))
|
||||
}
|
||||
|
||||
func TestIdleTimeoutReaderHandlerDoneAfterResetFailure(t *testing.T) {
|
||||
w := &readDeadlineRecorder{
|
||||
ResponseRecorder: httptest.NewRecorder(),
|
||||
failAt: 2,
|
||||
}
|
||||
r := &IdleTimeoutReader{
|
||||
ReadCloser: io.NopCloser(strings.NewReader("body")),
|
||||
Ctrl: http.NewResponseController(w),
|
||||
Deadline: IdleDeadline{Timeout: time.Second},
|
||||
Logger: zap.NewNop(),
|
||||
}
|
||||
|
||||
_, _ = r.Read(make([]byte, 1))
|
||||
_, _ = r.Read(make([]byte, 1))
|
||||
r.HandlerDone()
|
||||
|
||||
deadlines := w.snapshot()
|
||||
require.Len(t, deadlines, 2)
|
||||
assert.False(t, deadlines[0].IsZero())
|
||||
assert.False(t, deadlines[1].IsZero())
|
||||
}
|
||||
|
||||
func TestIdleTimeoutReaderHandlerDoneRetriesTerminalClear(t *testing.T) {
|
||||
w := &readDeadlineRecorder{
|
||||
ResponseRecorder: httptest.NewRecorder(),
|
||||
failAt: 3,
|
||||
}
|
||||
r := &IdleTimeoutReader{
|
||||
ReadCloser: io.NopCloser(strings.NewReader("body")),
|
||||
Ctrl: http.NewResponseController(w),
|
||||
Deadline: IdleDeadline{Timeout: time.Second},
|
||||
Logger: zap.NewNop(),
|
||||
}
|
||||
|
||||
_, err := io.Copy(io.Discard, r)
|
||||
require.NoError(t, err)
|
||||
r.HandlerDone()
|
||||
|
||||
deadlines := w.snapshot()
|
||||
require.Len(t, deadlines, 4)
|
||||
assert.False(t, deadlines[0].IsZero())
|
||||
assert.False(t, deadlines[1].IsZero())
|
||||
assert.True(t, deadlines[2].IsZero())
|
||||
assert.True(t, deadlines[3].IsZero())
|
||||
}
|
||||
|
||||
func TestIdleTimeoutReaderHandlerDoneArmsDrain(t *testing.T) {
|
||||
w := &readDeadlineRecorder{ResponseRecorder: httptest.NewRecorder()}
|
||||
r := &IdleTimeoutReader{
|
||||
ReadCloser: io.NopCloser(strings.NewReader("body")),
|
||||
Ctrl: http.NewResponseController(w),
|
||||
Deadline: IdleDeadline{Timeout: time.Second},
|
||||
Logger: zap.NewNop(),
|
||||
DrainDeadline: true,
|
||||
}
|
||||
|
||||
r.HandlerDone()
|
||||
deadlines := w.snapshot()
|
||||
require.Len(t, deadlines, 1)
|
||||
assert.False(t, deadlines[0].IsZero())
|
||||
}
|
||||
|
||||
func TestIdleTimeoutReaderHandlerDoneWithoutDrainDeadline(t *testing.T) {
|
||||
w := &readDeadlineRecorder{ResponseRecorder: httptest.NewRecorder()}
|
||||
r := &IdleTimeoutReader{
|
||||
ReadCloser: io.NopCloser(strings.NewReader("body")),
|
||||
Ctrl: http.NewResponseController(w),
|
||||
Deadline: IdleDeadline{Timeout: time.Second},
|
||||
Logger: zap.NewNop(),
|
||||
}
|
||||
|
||||
r.HandlerDone()
|
||||
assert.Empty(t, w.snapshot())
|
||||
}
|
||||
|
||||
func TestIdleTimeoutReaderAfterHandlerReturnsHTTP2(t *testing.T) {
|
||||
lateBody := make(chan io.ReadCloser, 1)
|
||||
srv := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
wrapped := &IdleTimeoutReader{
|
||||
ReadCloser: r.Body,
|
||||
Ctrl: http.NewResponseController(w),
|
||||
Deadline: IdleDeadline{Timeout: time.Second},
|
||||
Logger: zap.NewNop(),
|
||||
}
|
||||
defer wrapped.HandlerDone()
|
||||
lateBody <- wrapped
|
||||
_, _ = io.WriteString(w, "ok")
|
||||
}))
|
||||
srv.EnableHTTP2 = true
|
||||
srv.StartTLS()
|
||||
defer srv.Close()
|
||||
|
||||
resp, err := srv.Client().Post(srv.URL, "text/plain", strings.NewReader("body"))
|
||||
require.NoError(t, err)
|
||||
responseBody, err := io.ReadAll(resp.Body)
|
||||
require.NoError(t, err)
|
||||
require.NoError(t, resp.Body.Close())
|
||||
require.Equal(t, 2, resp.ProtoMajor)
|
||||
require.Equal(t, "ok", string(responseBody))
|
||||
|
||||
readResult := make(chan error, 1)
|
||||
go func() {
|
||||
var result error
|
||||
defer func() {
|
||||
if recovered := recover(); recovered != nil {
|
||||
result = fmt.Errorf("late request-body read panicked: %v", recovered)
|
||||
}
|
||||
readResult <- result
|
||||
}()
|
||||
_, _ = io.Copy(io.Discard, <-lateBody)
|
||||
}()
|
||||
select {
|
||||
case err := <-readResult:
|
||||
assert.NoError(t, err)
|
||||
case <-time.After(time.Second):
|
||||
t.Fatal("late request-body read did not return")
|
||||
}
|
||||
}
|
||||
|
||||
func TestIdleTimeoutReaderHandlerDonePreservesHTTP1Connection(t *testing.T) {
|
||||
const idle = 100 * time.Millisecond
|
||||
|
||||
remoteAddresses := make(chan string, 2)
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
wrapped := &IdleTimeoutReader{
|
||||
ReadCloser: r.Body,
|
||||
Ctrl: http.NewResponseController(w),
|
||||
Deadline: IdleDeadline{Timeout: idle},
|
||||
Logger: zap.NewNop(),
|
||||
DrainDeadline: r.ProtoMajor == 1 && r.ContentLength != 0,
|
||||
}
|
||||
defer wrapped.HandlerDone()
|
||||
remoteAddresses <- r.RemoteAddr
|
||||
if r.Method == http.MethodPost {
|
||||
_, _ = wrapped.Read(make([]byte, 1))
|
||||
}
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
transport := &http.Transport{MaxConnsPerHost: 1}
|
||||
client := &http.Client{Transport: transport}
|
||||
defer transport.CloseIdleConnections()
|
||||
|
||||
resp, err := client.Post(srv.URL, "text/plain", strings.NewReader("body"))
|
||||
require.NoError(t, err)
|
||||
require.NoError(t, resp.Body.Close())
|
||||
require.Equal(t, http.StatusNoContent, resp.StatusCode)
|
||||
firstAddress := <-remoteAddresses
|
||||
|
||||
time.Sleep(3 * idle)
|
||||
resp, err = client.Get(srv.URL)
|
||||
require.NoError(t, err)
|
||||
require.NoError(t, resp.Body.Close())
|
||||
require.Equal(t, http.StatusNoContent, resp.StatusCode)
|
||||
assert.Equal(t, firstAddress, <-remoteAddresses)
|
||||
}
|
||||
|
||||
func TestIdleTimeoutReaderDeadlineClearedAfterBodyEOF(t *testing.T) {
|
||||
const idle = 150 * time.Millisecond
|
||||
|
||||
upstream := httptest.NewServer(http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) {
|
||||
_, _ = io.Copy(io.Discard, r.Body)
|
||||
}))
|
||||
defer upstream.Close()
|
||||
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
wrapped := &IdleTimeoutReader{
|
||||
ReadCloser: r.Body,
|
||||
Ctrl: http.NewResponseController(w),
|
||||
Deadline: IdleDeadline{Timeout: idle},
|
||||
Logger: zap.NewNop(),
|
||||
}
|
||||
defer wrapped.HandlerDone()
|
||||
|
||||
upReq, err := http.NewRequestWithContext(r.Context(), r.Method, upstream.URL, wrapped)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
return
|
||||
}
|
||||
upReq.ContentLength = r.ContentLength
|
||||
resp, err := http.DefaultClient.Do(upReq)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
return
|
||||
}
|
||||
_ = resp.Body.Close()
|
||||
|
||||
select {
|
||||
case <-r.Context().Done():
|
||||
w.WriteHeader(http.StatusTeapot)
|
||||
case <-time.After(3 * idle):
|
||||
w.WriteHeader(http.StatusOK)
|
||||
}
|
||||
}))
|
||||
defer srv.Close()
|
||||
|
||||
resp, err := http.Post(srv.URL, "application/octet-stream", strings.NewReader("{}"))
|
||||
require.NoError(t, err)
|
||||
defer resp.Body.Close()
|
||||
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
||||
}
|
||||
|
||||
func TestIdleTimeoutReader_HardDeadlineCapsIdleReset(t *testing.T) {
|
||||
const idle = 500 * time.Millisecond
|
||||
const hard = 200 * time.Millisecond
|
||||
|
|
|
|||
|
|
@ -586,7 +586,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|||
writeHardDeadline = start.Add(time.Duration(s.WriteTimeout))
|
||||
}
|
||||
if s.ReadIdleTimeout > 0 && r.Body != nil {
|
||||
r.Body = &IdleTimeoutReader{
|
||||
idleReader := &IdleTimeoutReader{
|
||||
ReadCloser: r.Body,
|
||||
Ctrl: rc,
|
||||
Deadline: IdleDeadline{
|
||||
|
|
@ -595,8 +595,11 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|||
MinRate: s.ReadMinRate,
|
||||
HardDeadline: readHardDeadline,
|
||||
},
|
||||
Logger: s.logger,
|
||||
Logger: s.logger,
|
||||
DrainDeadline: r.ProtoMajor == 1 && r.ContentLength != 0,
|
||||
}
|
||||
defer idleReader.HandlerDone()
|
||||
r.Body = idleReader
|
||||
}
|
||||
if s.WriteIdleTimeout > 0 {
|
||||
w = &IdleTimeoutWriter{
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ func (t Timeouts) ServeHTTP(w http.ResponseWriter, r *http.Request, next caddyht
|
|||
start := time.Now()
|
||||
|
||||
if t.ReadTimeout > 0 && r.Body != nil {
|
||||
r.Body = &caddyhttp.IdleTimeoutReader{
|
||||
idleReader := &caddyhttp.IdleTimeoutReader{
|
||||
ReadCloser: r.Body,
|
||||
Ctrl: rc,
|
||||
Deadline: caddyhttp.IdleDeadline{
|
||||
|
|
@ -100,8 +100,11 @@ func (t Timeouts) ServeHTTP(w http.ResponseWriter, r *http.Request, next caddyht
|
|||
Timeout: t.ReadTimeout,
|
||||
MinRate: t.ReadMinRate,
|
||||
},
|
||||
Logger: t.logger,
|
||||
Logger: t.logger,
|
||||
DrainDeadline: r.ProtoMajor == 1 && r.ContentLength != 0,
|
||||
}
|
||||
defer idleReader.HandlerDone()
|
||||
r.Body = idleReader
|
||||
}
|
||||
if t.WriteTimeout > 0 {
|
||||
w = &caddyhttp.IdleTimeoutWriter{
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@ import (
|
|||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
|
|
@ -28,6 +29,16 @@ import (
|
|||
"github.com/caddyserver/caddy/v2/modules/caddyhttp"
|
||||
)
|
||||
|
||||
type readDeadlineRecorder struct {
|
||||
*httptest.ResponseRecorder
|
||||
deadlines []time.Time
|
||||
}
|
||||
|
||||
func (w *readDeadlineRecorder) SetReadDeadline(deadline time.Time) error {
|
||||
w.deadlines = append(w.deadlines, deadline)
|
||||
return nil
|
||||
}
|
||||
|
||||
// pacedReader emits chunkCount chunks of chunkSize bytes, sleeping delay
|
||||
// before each one, simulating a client that trickles a request body.
|
||||
type pacedReader struct {
|
||||
|
|
@ -83,6 +94,37 @@ func TestTimeouts_ReadTimeoutIsIdleReset(t *testing.T) {
|
|||
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
||||
}
|
||||
|
||||
func TestTimeoutsStopsReadDeadlineBeforeReturning(t *testing.T) {
|
||||
tm := Timeouts{ReadTimeout: time.Second, logger: zap.NewNop()}
|
||||
w := &readDeadlineRecorder{ResponseRecorder: httptest.NewRecorder()}
|
||||
req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader("body"))
|
||||
var body io.Reader
|
||||
|
||||
err := tm.ServeHTTP(w, req, caddyhttp.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) error {
|
||||
body = r.Body
|
||||
_, _ = body.Read(make([]byte, 1))
|
||||
return nil
|
||||
}))
|
||||
require.NoError(t, err)
|
||||
require.Len(t, w.deadlines, 1)
|
||||
assert.False(t, w.deadlines[0].IsZero())
|
||||
|
||||
_, _ = io.Copy(io.Discard, body)
|
||||
assert.Len(t, w.deadlines, 1)
|
||||
}
|
||||
|
||||
func TestTimeoutsSkipsDrainDeadlineWithoutBody(t *testing.T) {
|
||||
tm := Timeouts{ReadTimeout: time.Second, logger: zap.NewNop()}
|
||||
w := &readDeadlineRecorder{ResponseRecorder: httptest.NewRecorder()}
|
||||
req := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
|
||||
err := tm.ServeHTTP(w, req, caddyhttp.HandlerFunc(func(http.ResponseWriter, *http.Request) error {
|
||||
return nil
|
||||
}))
|
||||
require.NoError(t, err)
|
||||
assert.Empty(t, w.deadlines)
|
||||
}
|
||||
|
||||
func TestTimeouts_WriteMaxChunkOverride(t *testing.T) {
|
||||
const size = 10000
|
||||
const maxChunk = 100
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue