middlewares

Documentation

Index

• Constants
• func NegroniRecoverHandler() negroni.Handler
• func NewSecure(headers types.Headers) *secure.Secure
• func RecoverHandler(next http.Handler) http.Handler
• type AddPrefix
  • func (s *AddPrefix) ServeHTTP(w http.ResponseWriter, r *http.Request)
  • func (s *AddPrefix) SetHandler(Handler http.Handler)
• type CircuitBreaker
  • func NewCircuitBreaker(next http.Handler, expression string, options ...cbreaker.CircuitBreakerOption) (*CircuitBreaker, error)
  • func (cb *CircuitBreaker) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)
• type Compress
  • func (c *Compress) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)
• type DefaultNetErrorRecorder
  • func (DefaultNetErrorRecorder) Record(ctx context.Context)
• type EmptyBackendHandler
  • func NewEmptyBackendHandler(lb healthcheck.LoadBalancer, next http.Handler) *EmptyBackendHandler
  • func (h *EmptyBackendHandler) ServeHTTP(rw http.ResponseWriter, r *http.Request)
• type ErrorPagesHandler
  • func NewErrorPagesHandler(errorPage types.ErrorPage, backendURL string) (*ErrorPagesHandler, error)
  • func (ep *ErrorPagesHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, next http.HandlerFunc)
• type HandlerSwitcher
  • func NewHandlerSwitcher(newHandler *mux.Router) (hs *HandlerSwitcher)
  • func (hs *HandlerSwitcher) GetHandler() (newHandler *mux.Router)
  • func (hs *HandlerSwitcher) ServeHTTP(rw http.ResponseWriter, r *http.Request)
  • func (hs *HandlerSwitcher) UpdateHandler(newHandler *mux.Router)
• type HeaderOptions
• type HeaderStruct
  • func NewHeader(options ...HeaderOptions) *HeaderStruct
  • func NewHeaderFromStruct(headers types.Headers) *HeaderStruct
  • func (s *HeaderStruct) Handler(h http.Handler) http.Handler
  • func (s *HeaderStruct) Process(w http.ResponseWriter, r *http.Request)
  • func (s *HeaderStruct) ServeHTTP(w http.ResponseWriter, r *http.Request, next http.HandlerFunc)
• type IPWhitelister
  • func NewIPWhitelister(whitelistStrings []string) (*IPWhitelister, error)
  • func (whitelister *IPWhitelister) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)
• type MetricsRetryListener
  • func (m *MetricsRetryListener) Retried(req *http.Request, attempt int)
• type MetricsWrapper
  • func NewMetricsWrapper(registry metrics.Registry, service string) *MetricsWrapper
  • func (m *MetricsWrapper) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)
• type NetErrorRecorder
• type ReplacePath
  • func (s *ReplacePath) ServeHTTP(w http.ResponseWriter, r *http.Request)
• type Retry
  • func NewRetry(attempts int, next http.Handler, listener RetryListener) *Retry
  • func (retry *Retry) ServeHTTP(rw http.ResponseWriter, r *http.Request)
• type RetryListener
  • func NewMetricsRetryListener(retryMetrics retryMetrics, backendName string) RetryListener
• type RetryListeners
  • func (l RetryListeners) Retried(req *http.Request, attempt int)
• type Rewrite
  • func NewRewrite(regex, replacement string, redirect bool) (*Rewrite, error)
  • func (rewrite *Rewrite) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)
• type Routes
  • func NewRoutes(router *mux.Router) *Routes
  • func (router *Routes) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)
• type Stateful
• type Stats
• type StatsRecorder
  • func NewStatsRecorder(numRecentErrors int) *StatsRecorder
  • func (s *StatsRecorder) Data() *Stats
  • func (s *StatsRecorder) ServeHTTP(w http.ResponseWriter, r *http.Request, next http.HandlerFunc)
• type StripPrefix
  • func (s *StripPrefix) ServeHTTP(w http.ResponseWriter, r *http.Request)
  • func (s *StripPrefix) SetHandler(Handler http.Handler)
• type StripPrefixRegex
  • func NewStripPrefixRegex(handler http.Handler, prefixes []string) *StripPrefixRegex
  • func (s *StripPrefixRegex) ServeHTTP(w http.ResponseWriter, r *http.Request)
  • func (s *StripPrefixRegex) SetHandler(Handler http.Handler)

Constants

const ForwardedPrefixHeader = "X-Forwarded-Prefix"

ForwardedPrefixHeader is the default header to set prefix

const ReplacedPathHeader = "X-Replaced-Path"

ReplacedPathHeader is the default header to set the old path to

Functions

func NegroniRecoverHandler

func NegroniRecoverHandler() negroni.Handler

NegroniRecoverHandler recovers from a panic in negroni handlers

func NewSecure

func NewSecure(headers types.Headers) *secure.Secure

NewSecure constructs a new Secure instance with supplied options.

func RecoverHandler

func RecoverHandler(next http.Handler) http.Handler

RecoverHandler recovers from a panic in http handlers

Types

type AddPrefix

type AddPrefix struct {
	Handler http.Handler
	Prefix  string
}

AddPrefix is a middleware used to add prefix to an URL request

func (*AddPrefix) ServeHTTP

func (s *AddPrefix) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (*AddPrefix) SetHandler

func (s *AddPrefix) SetHandler(Handler http.Handler)

SetHandler sets handler

type CircuitBreaker

type CircuitBreaker struct {
	// contains filtered or unexported fields
}

CircuitBreaker holds the oxy circuit breaker.

func NewCircuitBreaker

func NewCircuitBreaker(next http.Handler, expression string, options ...cbreaker.CircuitBreakerOption) (*CircuitBreaker, error)

NewCircuitBreaker returns a new CircuitBreaker.

func (*CircuitBreaker) ServeHTTP

func (cb *CircuitBreaker) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)

type Compress

type Compress struct{}

Compress is a middleware that allows redirection

func (*Compress) ServeHTTP

func (c *Compress) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)

ServerHTTP is a function used by Negroni

type DefaultNetErrorRecorder

type DefaultNetErrorRecorder struct{}

DefaultNetErrorRecorder is the default NetErrorRecorder implementation.

func (DefaultNetErrorRecorder) Record

func (DefaultNetErrorRecorder) Record(ctx context.Context)

Record is recording network errors by setting the context value for the defaultNetErrCtxKey to true.

type EmptyBackendHandler

type EmptyBackendHandler struct {
	// contains filtered or unexported fields
}

EmptyBackendHandler is a middlware that checks whether the current Backend has at least one active Server in respect to the healthchecks and if this is not the case, it will stop the middleware chain and respond with 503.

func NewEmptyBackendHandler

func NewEmptyBackendHandler(lb healthcheck.LoadBalancer, next http.Handler) *EmptyBackendHandler

NewEmptyBackendHandler creates a new EmptyBackendHandler instance.

func (*EmptyBackendHandler) ServeHTTP

func (h *EmptyBackendHandler) ServeHTTP(rw http.ResponseWriter, r *http.Request)

ServeHTTP responds with 503 when there is no active Server and otherwise invokes the next handler in the middleware chain.

type ErrorPagesHandler

type ErrorPagesHandler struct {
	HTTPCodeRanges [][2]int
	BackendURL     string
	// contains filtered or unexported fields
}

ErrorPagesHandler is a middleware that provides the custom error pages

func NewErrorPagesHandler

func NewErrorPagesHandler(errorPage types.ErrorPage, backendURL string) (*ErrorPagesHandler, error)

NewErrorPagesHandler initializes the utils.ErrorHandler for the custom error pages

func (*ErrorPagesHandler) ServeHTTP

func (ep *ErrorPagesHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, next http.HandlerFunc)

type HandlerSwitcher

type HandlerSwitcher struct {
	// contains filtered or unexported fields
}

HandlerSwitcher allows hot switching of http.ServeMux

func NewHandlerSwitcher

func NewHandlerSwitcher(newHandler *mux.Router) (hs *HandlerSwitcher)

NewHandlerSwitcher builds a new instance of HandlerSwitcher

func (*HandlerSwitcher) GetHandler

func (hs *HandlerSwitcher) GetHandler() (newHandler *mux.Router)

GetHandler returns the current http.ServeMux

func (*HandlerSwitcher) ServeHTTP

func (hs *HandlerSwitcher) ServeHTTP(rw http.ResponseWriter, r *http.Request)

func (*HandlerSwitcher) UpdateHandler

func (hs *HandlerSwitcher) UpdateHandler(newHandler *mux.Router)

UpdateHandler safely updates the current http.ServeMux with a new one

type HeaderOptions

type HeaderOptions struct {
	// If Custom request headers are set, these will be added to the request
	CustomRequestHeaders map[string]string
	// If Custom response headers are set, these will be added to the ResponseWriter
	CustomResponseHeaders map[string]string
}

HeaderOptions is a struct for specifying configuration options for the headers middleware.

type HeaderStruct

type HeaderStruct struct {
	// contains filtered or unexported fields
}

HeaderStruct is a middleware that helps setup a few basic security features. A single headerOptions struct can be provided to configure which features should be enabled, and the ability to override a few of the default values.

func NewHeader

func NewHeader(options ...HeaderOptions) *HeaderStruct

NewHeader constructs a new header instance with supplied options.

func NewHeaderFromStruct

func NewHeaderFromStruct(headers types.Headers) *HeaderStruct

NewHeaderFromStruct constructs a new header instance from supplied frontend header struct.

func (*HeaderStruct) Handler

func (s *HeaderStruct) Handler(h http.Handler) http.Handler

Handler implements the http.HandlerFunc for integration with the standard net/http lib.

func (*HeaderStruct) Process

func (s *HeaderStruct) Process(w http.ResponseWriter, r *http.Request)

Process runs the actual checks and returns an error if the middleware chain should stop.

func (*HeaderStruct) ServeHTTP

func (s *HeaderStruct) ServeHTTP(w http.ResponseWriter, r *http.Request, next http.HandlerFunc)

type IPWhitelister

type IPWhitelister struct {
	// contains filtered or unexported fields
}

IPWhitelister is a middleware that provides Checks of the Requesting IP against a set of Whitelists

func NewIPWhitelister

func NewIPWhitelister(whitelistStrings []string) (*IPWhitelister, error)

NewIPWhitelister builds a new IPWhitelister given a list of CIDR-Strings to whitelist

func (*IPWhitelister) ServeHTTP

func (whitelister *IPWhitelister) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)

type MetricsRetryListener

type MetricsRetryListener struct {
	// contains filtered or unexported fields
}

MetricsRetryListener is an implementation of the RetryListener interface to record RequestMetrics about retry attempts.

func (*MetricsRetryListener) Retried

func (m *MetricsRetryListener) Retried(req *http.Request, attempt int)

Retried tracks the retry in the RequestMetrics implementation.

type MetricsWrapper

type MetricsWrapper struct {
	// contains filtered or unexported fields
}

MetricsWrapper is a Negroni compatible Handler which relies on a given Metrics implementation to expose and monitor Traefik Metrics.

func NewMetricsWrapper

func NewMetricsWrapper(registry metrics.Registry, service string) *MetricsWrapper

NewMetricsWrapper return a MetricsWrapper struct with a given Metrics implementation

func (*MetricsWrapper) ServeHTTP

func (m *MetricsWrapper) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)

type NetErrorRecorder

type NetErrorRecorder interface {
	// Record can be used to signal the retry middleware that an network error happened
	// and therefore the request should be retried.
	Record(ctx context.Context)
}

NetErrorRecorder is an interface to record net errors.

type ReplacePath

type ReplacePath struct {
	Handler http.Handler
	Path    string
}

ReplacePath is a middleware used to replace the path of a URL request

func (*ReplacePath) ServeHTTP

func (s *ReplacePath) ServeHTTP(w http.ResponseWriter, r *http.Request)

type Retry

type Retry struct {
	// contains filtered or unexported fields
}

Retry is a middleware that retries requests

func NewRetry

func NewRetry(attempts int, next http.Handler, listener RetryListener) *Retry

NewRetry returns a new Retry instance

func (*Retry) ServeHTTP

func (retry *Retry) ServeHTTP(rw http.ResponseWriter, r *http.Request)

type RetryListener

type RetryListener interface {
	// Retried will be called when a retry happens, with the request attempt passed to it.
	// For the first retry this will be attempt 2.
	Retried(req *http.Request, attempt int)
}

RetryListener is used to inform about retry attempts.

func NewMetricsRetryListener

func NewMetricsRetryListener(retryMetrics retryMetrics, backendName string) RetryListener

NewMetricsRetryListener instantiates a MetricsRetryListener with the given retryMetrics.

type RetryListeners

type RetryListeners []RetryListener

RetryListeners is a convenience type to construct a list of RetryListener and notify each of them about a retry attempt.

func (RetryListeners) Retried

func (l RetryListeners) Retried(req *http.Request, attempt int)

Retried exists to implement the RetryListener interface. It calls Retried on each of its slice entries.

type Rewrite

type Rewrite struct {
	// contains filtered or unexported fields
}

Rewrite is a middleware that allows redirections

func NewRewrite

func NewRewrite(regex, replacement string, redirect bool) (*Rewrite, error)

NewRewrite creates a Rewrite middleware

func (*Rewrite) ServeHTTP

func (rewrite *Rewrite) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)

type Routes

type Routes struct {
	// contains filtered or unexported fields
}

Routes holds the gorilla mux routes (for the API & co).

func NewRoutes

func NewRoutes(router *mux.Router) *Routes

NewRoutes return a Routes based on the given router.

func (*Routes) ServeHTTP

func (router *Routes) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)

type Stateful

type Stateful interface {
	http.ResponseWriter
	http.Hijacker
	http.Flusher
	http.CloseNotifier
}

Stateful interface groups all http interfaces that must be implemented by a stateful middleware (ie: recorders)

type Stats

type Stats struct {
	RecentErrors []*statsError `json:"recent_errors"`
}

Stats includes all of the stats gathered by the recorder.

type StatsRecorder

type StatsRecorder struct {
	// contains filtered or unexported fields
}

StatsRecorder is an optional middleware that records more details statistics about requests and how they are processed. This currently consists of recent requests that have caused errors (4xx and 5xx status codes), making it easy to pinpoint problems.

func NewStatsRecorder

func NewStatsRecorder(numRecentErrors int) *StatsRecorder

NewStatsRecorder returns a new StatsRecorder

func (*StatsRecorder) Data

func (s *StatsRecorder) Data() *Stats

Data returns a copy of the statistics that have been gathered.

func (*StatsRecorder) ServeHTTP

func (s *StatsRecorder) ServeHTTP(w http.ResponseWriter, r *http.Request, next http.HandlerFunc)

ServeHTTP silently extracts information from the request and response as it is processed. If the response is 4xx or 5xx, add it to the list of 10 most recent errors.

type StripPrefix

type StripPrefix struct {
	Handler  http.Handler
	Prefixes []string
}

StripPrefix is a middleware used to strip prefix from an URL request

func (*StripPrefix) ServeHTTP

func (s *StripPrefix) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (*StripPrefix) SetHandler

func (s *StripPrefix) SetHandler(Handler http.Handler)

SetHandler sets handler

type StripPrefixRegex

type StripPrefixRegex struct {
	Handler http.Handler
	// contains filtered or unexported fields
}

StripPrefixRegex is a middleware used to strip prefix from an URL request

func NewStripPrefixRegex

func NewStripPrefixRegex(handler http.Handler, prefixes []string) *StripPrefixRegex

NewStripPrefixRegex builds a new StripPrefixRegex given a handler and prefixes

func (*StripPrefixRegex) ServeHTTP

func (s *StripPrefixRegex) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (*StripPrefixRegex) SetHandler

func (s *StripPrefixRegex) SetHandler(Handler http.Handler)

SetHandler sets handler