caddy/modules/caddyhttp/timeouts/timeouts.go

// Copyright 2015 Matthew Holt and The Caddy Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package timeouts

import (
	"net/http"
	"time"

	"go.uber.org/zap"

	"github.com/caddyserver/caddy/v2"
	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
)

func init() {
	caddy.RegisterModule(Timeouts{})
}

// Timeouts is a middleware that applies read/write idle timeouts, minimum
// transfer rates, and a write chunk size cap to routes matching this
// handler. They take precedence over the server-wide equivalents, and
// over those of any enclosing timeouts handler, for as long as this
// handler is running. The server-wide read_timeout and write_timeout
// still cap the whole transfer.
type Timeouts struct {
	// How long to allow a read from the request body to stall before
	// aborting the connection, reset on every successful read (like the
	// server-wide read_idle_timeout, but scoped to routes matching this
	// handler). If zero, the server-wide setting applies.
	// EXPERIMENTAL. Subject to change/removal.
	ReadTimeout time.Duration `json:"read_timeout,omitempty"`

	// ReadMinRate requires the client to sustain at least this many
	// bytes/second, averaged from the start of the read, or the
	// connection is aborted (Apache mod_reqtimeout's MinRate). Only
	// takes effect if ReadTimeout is also set.
	// EXPERIMENTAL. Subject to change/removal.
	ReadMinRate int64 `json:"read_min_rate,omitempty"`

	// How long to allow a write to the client to stall before aborting
	// the connection, reset on every successful write (like the
	// server-wide write_idle_timeout, but scoped to routes matching this
	// handler). If zero, the server-wide setting applies.
	// EXPERIMENTAL. Subject to change/removal.
	WriteTimeout time.Duration `json:"write_timeout,omitempty"`

	// WriteMinRate is like ReadMinRate, but for writes to the client.
	// Only takes effect if WriteTimeout is also set.
	// EXPERIMENTAL. Subject to change/removal.
	WriteMinRate int64 `json:"write_min_rate,omitempty"`

	// MaxWriteChunk bounds how many bytes a single underlying write
	// operation is allowed to cover, so WriteTimeout/WriteMinRate can
	// actually apply between chunks of a large response instead of
	// being bounded by one deadline for the whole thing. If zero, the
	// server-wide setting is used, or caddyhttp.DefaultMaxWriteChunk if
	// there is none.
	// EXPERIMENTAL. Subject to change/removal.
	MaxWriteChunk int `json:"max_write_chunk,omitempty"`

	logger *zap.Logger
}

// CaddyModule returns the Caddy module information.
func (Timeouts) CaddyModule() caddy.ModuleInfo {
	return caddy.ModuleInfo{
		ID:  "http.handlers.timeouts",
		New: func() caddy.Module { return new(Timeouts) },
	}
}

func (t *Timeouts) Provision(ctx caddy.Context) error {
	t.logger = ctx.Logger()
	return nil
}

func (t Timeouts) ServeHTTP(w http.ResponseWriter, r *http.Request, next caddyhttp.Handler) error {
	if t.ReadTimeout <= 0 && t.WriteTimeout <= 0 {
		return next.ServeHTTP(w, r)
	}

	// if the request already has idle timeouts, from the server or an
	// enclosing route, override them instead of wrapping again: the
	// wrapper closest to the connection sets the deadline last, so it
	// would take precedence over ours
	idleReader, idleWriter := caddyhttp.IdleTimeoutsFromContext(r.Context())
	var wrapped bool
	var rc *http.ResponseController
	start := time.Now()

	if t.ReadTimeout > 0 && r.Body != nil {
		if idleReader != nil {
			defer idleReader.Override(t.ReadTimeout, t.ReadMinRate)()
		} else {
			//nolint:bodyclose
			rc = http.NewResponseController(w)
			idleReader = &caddyhttp.IdleTimeoutReader{
				ReadCloser: r.Body,
				Ctrl:       rc,
				Deadline: caddyhttp.IdleDeadline{
					Start:   start,
					Timeout: t.ReadTimeout,
					MinRate: t.ReadMinRate,
				},
				Logger:            t.logger,
				DrainDeadline:     r.ProtoMajor == 1 && r.ContentLength != 0,
				ClearBetweenReads: r.ProtoMajor == 2,
			}
			defer idleReader.HandlerDone()
			r.Body = idleReader
			wrapped = true
		}
	}
	if t.WriteTimeout > 0 {
		if idleWriter != nil {
			defer idleWriter.Override(t.WriteTimeout, t.WriteMinRate, t.MaxWriteChunk)()
		} else {
			if rc == nil {
				//nolint:bodyclose
				rc = http.NewResponseController(w)
			}
			idleWriter = &caddyhttp.IdleTimeoutWriter{
				ResponseWriterWrapper: &caddyhttp.ResponseWriterWrapper{ResponseWriter: w},
				Ctrl:                  rc,
				Deadline: caddyhttp.IdleDeadline{
					Start:   start,
					Timeout: t.WriteTimeout,
					MinRate: t.WriteMinRate,
				},
				MaxChunk:           t.MaxWriteChunk,
				Logger:             t.logger,
				ClearBetweenWrites: r.ProtoMajor == 2,
			}
			defer idleWriter.HandlerDone()
			w = idleWriter
			wrapped = true
		}
	}

	// let nested timeouts handlers override the wrappers added here
	if wrapped {
		r = r.WithContext(caddyhttp.ContextWithIdleTimeouts(r.Context(), idleReader, idleWriter))
	}

	return next.ServeHTTP(w, r)
}

// Interface guards
var (
	_ caddy.Provisioner           = (*Timeouts)(nil)
	_ caddyhttp.MiddlewareHandler = (*Timeouts)(nil)
)