rproxy tests: a cut-off answer closes the connection, also after its first part reached the visitor

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

internal/rproxy/limits_test.go

@@ -386,7 +386,8 @@ type deadlineRecorder struct {
 	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 {
 	if w.flushError != nil {
 		return w.flushError

internal/rproxy/request.go

@@ -272,10 +272,6 @@ func (rq *request) modifyResponse(res *http.Response) error {
 
 	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}
 	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
 	// ends now. Go's server would otherwise keep the connection open while it
-	// reads the rest. modifyResponse sets afterStatus only when it passes the
-	// app's answer on. Any refusal after that has cut the answer off, since a
-	// refusal ends the request to the app. Any answer is cut off when the time to
-	// send it runs out: a flush then fails, and every flush after a failed one
-	// fails too. ReverseProxy ignores the failure, but panics if it was still
-	// 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.
+	// reads the rest. A flush fails if the time to send the answer ran out, and
+	// every flush after a failed one fails too. ReverseProxy ignores the failure,
+	// but panics if it was still 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 {
-	case rq.out.afterStatus != nil && rq.refused.Load() != 0,
-		rq.out.status != 0 && rq.out.status != http.StatusSwitchingProtocols &&
-			errors.Is(rq.rc.Flush(), os.ErrDeadlineExceeded):
+	case rq.out.status != 0 && rq.out.status != http.StatusSwitchingProtocols &&
+		errors.Is(rq.rc.Flush(), os.ErrDeadlineExceeded):
 		rq.stopPassingOnBody(time.Now())
 	case rq.refused.Load() == 0:
 		rq.stopPassingOnBody(rq.requestDeadline())
@@ -560,30 +552,20 @@ func (rq *request) wroteRequest(info httptrace.WroteRequestInfo) {
 
 	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()
 	defer rq.mu.Unlock()
 
-	if rq.timersStopped || rq.responseTimer != nil {
+	if rq.timersStopped {
 		return
 	}
 
-	rq.responseTimer = time.AfterFunc(time.Until(requestEnd.Add(limit)),
-		rq.responseTimedOut)
+	stopTimer(rq.requestTimer)
+
+	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