rproxy: the two time limits get a type and a file of their own (closes #432)
check / check (push) Waiting to run
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
This commit is contained in:
1 parent
17400f68b8
commit
bb3c8f9351
4 files changed
+367
-163
No files matched your search
@@ -0,0 +1,165 @@
|
||||
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()
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user