Compare commits

..
1 Commits
Author SHA1 Message Date
sneak e3c5b4ecf8 rproxy tests: a cut-off answer closes the connection, also after its first part reached the visitor
check / check (push) Failing after 1m20s
The app now sends its late parts only once rproxy has ended the request to
it, not after a sleep timed against the limit. With the body in one part it
stalls after its headers; with two parts, after the first part, which
reaches the visitor. Both cases fail on the current code: nothing cuts the
answer off, and the connection stays open. The 2-second limit lets rproxy
pass on a part sent at once, even on a busy host.

A new test, which passes on the current code, has every flush fail with no
refusal, so that only the failed-flush check in finish ends the reading of
the visitor's body.

Model: opus-5-5
2026-11-11 08:45:51 +00:00
2 changed files with 17 additions and 34 deletions

No files matched your search

+2 -1
View File
@@ -386,7 +386,8 @@ type deadlineRecorder struct {
flushError error flushError error
} }
// FlushError returns flushError if it is set, and otherwise flushes. // FlushError, which http.ResponseController calls to flush, returns flushError
// if it is set, and otherwise flushes.
func (w *deadlineRecorder) FlushError() error { func (w *deadlineRecorder) FlushError() error {
if w.flushError != nil { if w.flushError != nil {
return w.flushError return w.flushError
+15 -33
View File
@@ -272,10 +272,6 @@ func (rq *request) modifyResponse(res *http.Response) error {
rq.closeAfterAnswer() rq.closeAfterAnswer()
// An answer that arrives before the app has been sent the whole request ends
// the request, and SWRP_MAX_RESPONSE_TIME_MS starts.
rq.startResponseTimer(requestEnd)
res.Body = &responseBody{body: limitBody(res.Body, maxBytes), rq: rq} res.Body = &responseBody{body: limitBody(res.Body, maxBytes), rq: rq}
rq.out.afterStatus = rq.setResponseDeadline rq.out.afterStatus = rq.setResponseDeadline
@@ -390,18 +386,14 @@ func (rq *request) finish(ctx context.Context) {
// After a cut-off answer, the reading of a body that has not arrived whole // After a cut-off answer, the reading of a body that has not arrived whole
// ends now. Go's server would otherwise keep the connection open while it // ends now. Go's server would otherwise keep the connection open while it
// reads the rest. modifyResponse sets afterStatus only when it passes the // reads the rest. A flush fails if the time to send the answer ran out, and
// app's answer on. Any refusal after that has cut the answer off, since a // every flush after a failed one fails too. ReverseProxy ignores the failure,
// refusal ends the request to the app. Any answer is cut off when the time to // but panics if it was still waiting for more of the app's answer; finish runs
// send it runs out: a flush then fails, and every flush after a failed one // either way. Before a status, a flush would send a 200; after a 101,
// fails too. ReverseProxy ignores the failure, but panics if it was still // ReverseProxy has taken over the connection.
// waiting for more of the app's answer; finish runs either way. Before a
// status, a flush would send a 200; after a 101, ReverseProxy has taken over
// the connection.
switch { switch {
case rq.out.afterStatus != nil && rq.refused.Load() != 0, case rq.out.status != 0 && rq.out.status != http.StatusSwitchingProtocols &&
rq.out.status != 0 && rq.out.status != http.StatusSwitchingProtocols && errors.Is(rq.rc.Flush(), os.ErrDeadlineExceeded):
errors.Is(rq.rc.Flush(), os.ErrDeadlineExceeded):
rq.stopPassingOnBody(time.Now()) rq.stopPassingOnBody(time.Now())
case rq.refused.Load() == 0: case rq.refused.Load() == 0:
rq.stopPassingOnBody(rq.requestDeadline()) rq.stopPassingOnBody(rq.requestDeadline())
@@ -560,30 +552,20 @@ func (rq *request) wroteRequest(info httptrace.WroteRequestInfo) {
requestEnd := rq.endRequest() requestEnd := rq.endRequest()
rq.mu.Lock()
stopTimer(rq.requestTimer)
rq.mu.Unlock()
rq.startResponseTimer(requestEnd)
}
// startResponseTimer starts SWRP_MAX_RESPONSE_TIME_MS, which runs from
// requestEnd, unless it has started already.
func (rq *request) startResponseTimer(requestEnd time.Time) {
limit := rq.h.config.MaxResponseTime
if limit == 0 {
return
}
rq.mu.Lock() rq.mu.Lock()
defer rq.mu.Unlock() defer rq.mu.Unlock()
if rq.timersStopped || rq.responseTimer != nil { if rq.timersStopped {
return return
} }
rq.responseTimer = time.AfterFunc(time.Until(requestEnd.Add(limit)), stopTimer(rq.requestTimer)
rq.responseTimedOut)
limit := rq.h.config.MaxResponseTime
if limit > 0 {
rq.responseTimer = time.AfterFunc(time.Until(requestEnd.Add(limit)),
rq.responseTimedOut)
}
} }
// responseTimedOut is called when SWRP_MAX_RESPONSE_TIME_MS runs out before the // responseTimedOut is called when SWRP_MAX_RESPONSE_TIME_MS runs out before the