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() } }