check / check (push) Waiting to run
timeLimits in internal/rproxy/timelimits.go owns the mutex, the two timers and the end of the request; request holds one field of it. It is given refuse, whether the visitor's body is being waited on, and a function that ends that read. Tests of the type alone run in a synctest bubble. Model: opus-5-5
166 lines
4.3 KiB
Go
166 lines
4.3 KiB
Go
package rproxy
|
|
|
|
import (
|
|
"net/http"
|
|
"net/http/httptrace"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// timeLimits are one request's two time limits: SWW_RPROXY_MAX_REQUEST_TIME_MS,
|
|
// which runs from the request's headers being read until the app has been sent
|
|
// the whole request, and SWW_RPROXY_MAX_RESPONSE_TIME_MS, which runs from then
|
|
// until the app has sent its whole answer. A limit of zero is off. Each limit
|
|
// runs on a goroutine of its own, and the transport starts and stops them from
|
|
// its own.
|
|
type timeLimits struct {
|
|
maxRequestTime time.Duration
|
|
maxResponseTime time.Duration
|
|
// start is when the request's headers had been read.
|
|
start time.Time
|
|
// refuse refuses the request with 408 or 504 when a limit runs out.
|
|
refuse func(status int)
|
|
// waitingForVisitor reports whether a read of the visitor's body is waiting
|
|
// for the visitor to send more.
|
|
waitingForVisitor func() bool
|
|
// endVisitorRead ends at once a read of the visitor's body that is waiting.
|
|
endVisitorRead func()
|
|
|
|
// mu guards what follows. Once stopped is set, neither limit acts any more.
|
|
mu sync.Mutex
|
|
stopped bool
|
|
requestTimer *time.Timer
|
|
responseTimer *time.Timer
|
|
// requestEnd is when the app had been sent the whole request, or the answer
|
|
// started, if that was sooner.
|
|
requestEnd time.Time
|
|
}
|
|
|
|
// requestDeadline is when the visitor must have sent its whole request, or zero
|
|
// when SWW_RPROXY_MAX_REQUEST_TIME_MS is off.
|
|
func (l *timeLimits) requestDeadline() time.Time {
|
|
if l.maxRequestTime == 0 {
|
|
return time.Time{}
|
|
}
|
|
|
|
return l.start.Add(l.maxRequestTime)
|
|
}
|
|
|
|
// startRequestTimer starts SWW_RPROXY_MAX_REQUEST_TIME_MS.
|
|
func (l *timeLimits) startRequestTimer() {
|
|
deadline := l.requestDeadline()
|
|
if deadline.IsZero() {
|
|
return
|
|
}
|
|
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
|
|
l.requestTimer = time.AfterFunc(time.Until(deadline), l.requestTimedOut)
|
|
}
|
|
|
|
// requestTimedOut is called when SWW_RPROXY_MAX_REQUEST_TIME_MS runs out while
|
|
// the request is still on its way to the app. The answer names the side rproxy
|
|
// was waiting on at that moment: 408 when it was waiting for the visitor to send
|
|
// more of its body, 504 when it was waiting for the app to be reached or to take
|
|
// what it had.
|
|
func (l *timeLimits) requestTimedOut() {
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
|
|
if l.stopped {
|
|
return
|
|
}
|
|
|
|
if !l.waitingForVisitor() {
|
|
l.refuse(http.StatusGatewayTimeout)
|
|
|
|
return
|
|
}
|
|
|
|
l.refuse(http.StatusRequestTimeout)
|
|
// The transport gives up on the app only once its Read of the visitor's body
|
|
// returns, so that Read is ended now. The lock keeps this from reaching the
|
|
// connection after the request is handled.
|
|
l.endVisitorRead()
|
|
}
|
|
|
|
// wroteRequest is called once the app has been sent the whole request:
|
|
// SWW_RPROXY_MAX_REQUEST_TIME_MS ends and SWW_RPROXY_MAX_RESPONSE_TIME_MS
|
|
// starts.
|
|
func (l *timeLimits) wroteRequest(info httptrace.WroteRequestInfo) {
|
|
if info.Err != nil {
|
|
return // the transport gives up, or tries again
|
|
}
|
|
|
|
requestEnd := l.endRequest()
|
|
|
|
l.mu.Lock()
|
|
stopTimer(l.requestTimer)
|
|
l.mu.Unlock()
|
|
|
|
l.startResponseTimer(requestEnd)
|
|
}
|
|
|
|
// startResponseTimer starts SWW_RPROXY_MAX_RESPONSE_TIME_MS, which runs from
|
|
// requestEnd, unless it has started already.
|
|
func (l *timeLimits) startResponseTimer(requestEnd time.Time) {
|
|
if l.maxResponseTime == 0 {
|
|
return
|
|
}
|
|
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
|
|
if l.stopped || l.responseTimer != nil {
|
|
return
|
|
}
|
|
|
|
l.responseTimer = time.AfterFunc(
|
|
time.Until(requestEnd.Add(l.maxResponseTime)),
|
|
l.responseTimedOut,
|
|
)
|
|
}
|
|
|
|
// responseTimedOut is called when SWW_RPROXY_MAX_RESPONSE_TIME_MS runs out
|
|
// before the app has sent its whole answer.
|
|
func (l *timeLimits) responseTimedOut() {
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
|
|
if !l.stopped {
|
|
l.refuse(http.StatusGatewayTimeout)
|
|
}
|
|
}
|
|
|
|
// endRequest notes now as the end of the request, unless an end is noted, and
|
|
// returns the end noted.
|
|
func (l *timeLimits) endRequest() time.Time {
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
|
|
if l.requestEnd.IsZero() {
|
|
l.requestEnd = time.Now()
|
|
}
|
|
|
|
return l.requestEnd
|
|
}
|
|
|
|
// stop stops both limits and keeps either from starting later: the app's
|
|
// answer is complete, the connection upgraded, or the request handled.
|
|
func (l *timeLimits) stop() {
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
|
|
l.stopped = true
|
|
stopTimer(l.requestTimer)
|
|
stopTimer(l.responseTimer)
|
|
}
|
|
|
|
// stopTimer stops t, which is nil when its limit is off.
|
|
func stopTimer(t *time.Timer) {
|
|
if t != nil {
|
|
t.Stop()
|
|
}
|
|
}
|