traefik/types/types.go

589 lines
18 KiB
Go
Raw Normal View History

package types
import (
2017-09-14 19:26:02 +00:00
"crypto/tls"
"crypto/x509"
"encoding"
"errors"
"fmt"
2017-08-25 16:22:03 +00:00
"io/ioutil"
"os"
2017-09-14 19:26:02 +00:00
"strconv"
"strings"
2017-08-25 16:22:03 +00:00
"github.com/abronan/valkeyrie/store"
2017-09-09 11:36:03 +00:00
"github.com/containous/flaeg"
"github.com/containous/mux"
2017-08-25 16:22:03 +00:00
"github.com/containous/traefik/log"
traefiktls "github.com/containous/traefik/tls"
2017-01-31 21:55:02 +00:00
"github.com/ryanuber/go-glob"
)
// Backend holds backend configuration.
type Backend struct {
Servers map[string]Server `json:"servers,omitempty"`
CircuitBreaker *CircuitBreaker `json:"circuitBreaker,omitempty"`
LoadBalancer *LoadBalancer `json:"loadBalancer,omitempty"`
MaxConn *MaxConn `json:"maxConn,omitempty"`
2016-11-26 18:48:49 +00:00
HealthCheck *HealthCheck `json:"healthCheck,omitempty"`
2018-01-31 14:32:04 +00:00
Buffering *Buffering `json:"buffering,omitempty"`
}
2016-04-21 22:38:44 +00:00
// MaxConn holds maximum connection configuration
type MaxConn struct {
Amount int64 `json:"amount,omitempty"`
ExtractorFunc string `json:"extractorFunc,omitempty"`
}
// LoadBalancer holds load balancing configuration.
type LoadBalancer struct {
2017-10-10 09:10:02 +00:00
Method string `json:"method,omitempty"`
Sticky bool `json:"sticky,omitempty"` // Deprecated: use Stickiness instead
Stickiness *Stickiness `json:"stickiness,omitempty"`
}
// Stickiness holds sticky session configuration.
type Stickiness struct {
CookieName string `json:"cookieName,omitempty"`
}
// CircuitBreaker holds circuit breaker configuration.
type CircuitBreaker struct {
Expression string `json:"expression,omitempty"`
}
2018-01-31 14:32:04 +00:00
// Buffering holds request/response buffering configuration/
type Buffering struct {
MaxRequestBodyBytes int64 `json:"maxRequestBodyBytes,omitempty"`
MemRequestBodyBytes int64 `json:"memRequestBodyBytes,omitempty"`
MaxResponseBodyBytes int64 `json:"maxResponseBodyBytes,omitempty"`
MemResponseBodyBytes int64 `json:"memResponseBodyBytes,omitempty"`
RetryExpression string `json:"retryExpression,omitempty"`
}
// WhiteList contains white list configuration.
type WhiteList struct {
SourceRange []string `json:"sourceRange,omitempty"`
UseXForwardedFor bool `json:"useXForwardedFor,omitempty" export:"true"`
}
2017-01-31 21:55:02 +00:00
// HealthCheck holds HealthCheck configuration
2016-11-26 18:48:49 +00:00
type HealthCheck struct {
Path string `json:"path,omitempty"`
2017-09-18 13:50:03 +00:00
Port int `json:"port,omitempty"`
2017-02-06 21:59:50 +00:00
Interval string `json:"interval,omitempty"`
2016-11-26 18:48:49 +00:00
}
// Server holds server configuration.
type Server struct {
URL string `json:"url,omitempty"`
Weight int `json:"weight"`
}
// Route holds route configuration.
type Route struct {
Rule string `json:"rule,omitempty"`
}
// ServerRoute holds ServerRoute configuration.
type ServerRoute struct {
Route *mux.Route
StripPrefixes []string
StripPrefixesRegex []string
AddPrefix string
ReplacePath string
ReplacePathRegex string
}
// ErrorPage holds custom error page configuration
type ErrorPage struct {
Status []string `json:"status,omitempty"`
Backend string `json:"backend,omitempty"`
Query string `json:"query,omitempty"`
}
2017-09-09 11:36:03 +00:00
// Rate holds a rate limiting configuration for a specific time period
type Rate struct {
Period flaeg.Duration `json:"period,omitempty"`
Average int64 `json:"average,omitempty"`
Burst int64 `json:"burst,omitempty"`
}
// RateLimit holds a rate limiting configuration for a given frontend
type RateLimit struct {
RateSet map[string]*Rate `json:"rateset,omitempty"`
ExtractorFunc string `json:"extractorFunc,omitempty"`
}
2017-06-13 00:48:21 +00:00
// Headers holds the custom header configuration
type Headers struct {
CustomRequestHeaders map[string]string `json:"customRequestHeaders,omitempty"`
CustomResponseHeaders map[string]string `json:"customResponseHeaders,omitempty"`
AllowedHosts []string `json:"allowedHosts,omitempty"`
HostsProxyHeaders []string `json:"hostsProxyHeaders,omitempty"`
SSLRedirect bool `json:"sslRedirect,omitempty"`
SSLTemporaryRedirect bool `json:"sslTemporaryRedirect,omitempty"`
SSLHost string `json:"sslHost,omitempty"`
SSLProxyHeaders map[string]string `json:"sslProxyHeaders,omitempty"`
STSSeconds int64 `json:"stsSeconds,omitempty"`
STSIncludeSubdomains bool `json:"stsIncludeSubdomains,omitempty"`
STSPreload bool `json:"stsPreload,omitempty"`
ForceSTSHeader bool `json:"forceSTSHeader,omitempty"`
FrameDeny bool `json:"frameDeny,omitempty"`
CustomFrameOptionsValue string `json:"customFrameOptionsValue,omitempty"`
ContentTypeNosniff bool `json:"contentTypeNosniff,omitempty"`
BrowserXSSFilter bool `json:"browserXssFilter,omitempty"`
2018-03-02 13:24:03 +00:00
CustomBrowserXSSValue string `json:"customBrowserXSSValue,omitempty"`
2017-06-13 00:48:21 +00:00
ContentSecurityPolicy string `json:"contentSecurityPolicy,omitempty"`
PublicKey string `json:"publicKey,omitempty"`
ReferrerPolicy string `json:"referrerPolicy,omitempty"`
IsDevelopment bool `json:"isDevelopment,omitempty"`
}
// HasCustomHeadersDefined checks to see if any of the custom header elements have been set
2018-01-02 09:10:04 +00:00
func (h *Headers) HasCustomHeadersDefined() bool {
return h != nil && (len(h.CustomResponseHeaders) != 0 ||
len(h.CustomRequestHeaders) != 0)
2017-06-13 00:48:21 +00:00
}
// HasSecureHeadersDefined checks to see if any of the secure header elements have been set
2018-01-02 09:10:04 +00:00
func (h *Headers) HasSecureHeadersDefined() bool {
return h != nil && (len(h.AllowedHosts) != 0 ||
2017-06-13 00:48:21 +00:00
len(h.HostsProxyHeaders) != 0 ||
h.SSLRedirect ||
h.SSLTemporaryRedirect ||
h.SSLHost != "" ||
len(h.SSLProxyHeaders) != 0 ||
h.STSSeconds != 0 ||
h.STSIncludeSubdomains ||
h.STSPreload ||
h.ForceSTSHeader ||
h.FrameDeny ||
h.CustomFrameOptionsValue != "" ||
h.ContentTypeNosniff ||
h.BrowserXSSFilter ||
2018-03-02 13:24:03 +00:00
h.CustomBrowserXSSValue != "" ||
2017-06-13 00:48:21 +00:00
h.ContentSecurityPolicy != "" ||
h.PublicKey != "" ||
h.ReferrerPolicy != "" ||
2018-01-02 09:10:04 +00:00
h.IsDevelopment)
2017-06-13 00:48:21 +00:00
}
// Frontend holds frontend configuration.
type Frontend struct {
2017-12-21 10:26:03 +00:00
EntryPoints []string `json:"entryPoints,omitempty"`
Backend string `json:"backend,omitempty"`
Routes map[string]Route `json:"routes,omitempty"`
PassHostHeader bool `json:"passHostHeader,omitempty"`
PassTLSCert bool `json:"passTLSCert,omitempty"`
Priority int `json:"priority"`
BasicAuth []string `json:"basicAuth"`
WhitelistSourceRange []string `json:"whitelistSourceRange,omitempty"` // Deprecated
WhiteList *WhiteList `json:"whiteList,omitempty"`
2018-01-02 13:49:11 +00:00
Headers *Headers `json:"headers,omitempty"`
2017-12-21 10:26:03 +00:00
Errors map[string]*ErrorPage `json:"errors,omitempty"`
RateLimit *RateLimit `json:"ratelimit,omitempty"`
Redirect *Redirect `json:"redirect,omitempty"`
2017-12-15 10:48:03 +00:00
}
// Redirect configures a redirection of an entry point to another, or to an URL
type Redirect struct {
EntryPoint string `json:"entryPoint,omitempty"`
Regex string `json:"regex,omitempty"`
Replacement string `json:"replacement,omitempty"`
2018-01-31 18:10:04 +00:00
Permanent bool `json:"permanent,omitempty"`
}
// LoadBalancerMethod holds the method of load balancing to use.
type LoadBalancerMethod uint8
const (
// Wrr (default) = Weighted Round Robin
Wrr LoadBalancerMethod = iota
// Drr = Dynamic Round Robin
Drr
)
var loadBalancerMethodNames = []string{
"Wrr",
"Drr",
}
// NewLoadBalancerMethod create a new LoadBalancerMethod from a given LoadBalancer.
func NewLoadBalancerMethod(loadBalancer *LoadBalancer) (LoadBalancerMethod, error) {
if loadBalancer == nil {
return Wrr, errors.New("no load-balancer defined, fallback to 'wrr' method")
}
if len(loadBalancer.Method) == 0 {
return Wrr, errors.New("no load-balancing method defined, fallback to 'wrr' method")
}
for i, name := range loadBalancerMethodNames {
if strings.EqualFold(name, loadBalancer.Method) {
return LoadBalancerMethod(i), nil
}
}
return Wrr, fmt.Errorf("invalid load-balancing method %q, fallback to 'wrr' method", loadBalancer.Method)
}
// Configurations is for currentConfigurations Map
type Configurations map[string]*Configuration
// Configuration of a provider.
type Configuration struct {
2018-01-23 15:30:07 +00:00
Backends map[string]*Backend `json:"backends,omitempty"`
Frontends map[string]*Frontend `json:"frontends,omitempty"`
2018-08-20 09:16:02 +00:00
TLS []*traefiktls.Configuration `json:"-"`
}
// ConfigMessage hold configuration information exchanged between parts of traefik.
type ConfigMessage struct {
ProviderName string
Configuration *Configuration
}
2017-10-02 08:32:02 +00:00
// Constraint hold a parsed constraint expression
type Constraint struct {
2017-10-02 08:32:02 +00:00
Key string `export:"true"`
// MustMatch is true if operator is "==" or false if operator is "!="
2017-10-02 08:32:02 +00:00
MustMatch bool `export:"true"`
// TODO: support regex
2017-10-02 08:32:02 +00:00
Regex string `export:"true"`
}
// NewConstraint receive a string and return a *Constraint, after checking syntax and parsing the constraint expression
func NewConstraint(exp string) (*Constraint, error) {
sep := ""
constraint := &Constraint{}
if strings.Contains(exp, "==") {
sep = "=="
constraint.MustMatch = true
} else if strings.Contains(exp, "!=") {
sep = "!="
constraint.MustMatch = false
} else {
2017-10-02 08:32:02 +00:00
return nil, errors.New("constraint expression missing valid operator: '==' or '!='")
}
kv := strings.SplitN(exp, sep, 2)
if len(kv) == 2 {
// At the moment, it only supports tags
if kv[0] != "tag" {
2017-10-02 08:32:02 +00:00
return nil, errors.New("constraint must be tag-based. Syntax: tag==us-*")
}
constraint.Key = kv[0]
constraint.Regex = kv[1]
return constraint, nil
}
2017-10-02 08:32:02 +00:00
return nil, fmt.Errorf("incorrect constraint expression: %s", exp)
}
func (c *Constraint) String() string {
if c.MustMatch {
return c.Key + "==" + c.Regex
}
return c.Key + "!=" + c.Regex
}
var _ encoding.TextUnmarshaler = (*Constraint)(nil)
2016-09-20 14:56:29 +00:00
// UnmarshalText define how unmarshal in TOML parsing
func (c *Constraint) UnmarshalText(text []byte) error {
constraint, err := NewConstraint(string(text))
if err != nil {
return err
}
c.Key = constraint.Key
c.MustMatch = constraint.MustMatch
c.Regex = constraint.Regex
return nil
}
var _ encoding.TextMarshaler = (*Constraint)(nil)
// MarshalText encodes the receiver into UTF-8-encoded text and returns the result.
func (c *Constraint) MarshalText() (text []byte, err error) {
return []byte(c.String()), nil
2016-09-20 14:56:29 +00:00
}
// MatchConstraintWithAtLeastOneTag tests a constraint for one single service
func (c *Constraint) MatchConstraintWithAtLeastOneTag(tags []string) bool {
for _, tag := range tags {
if glob.Glob(c.Regex, tag) {
return true
}
}
return false
}
2018-03-05 19:54:04 +00:00
// Set []*Constraint
func (cs *Constraints) Set(str string) error {
exps := strings.Split(str, ",")
if len(exps) == 0 {
2017-10-02 08:32:02 +00:00
return fmt.Errorf("bad Constraint format: %s", str)
}
for _, exp := range exps {
constraint, err := NewConstraint(exp)
if err != nil {
return err
}
*cs = append(*cs, constraint)
}
return nil
}
// Constraints holds a Constraint parser
type Constraints []*Constraint
2018-03-05 19:54:04 +00:00
// Get []*Constraint
func (cs *Constraints) Get() interface{} { return []*Constraint(*cs) }
2018-03-05 19:54:04 +00:00
// String returns []*Constraint in string
func (cs *Constraints) String() string { return fmt.Sprintf("%+v", *cs) }
2018-03-05 19:54:04 +00:00
// SetValue sets []*Constraint into the parser
func (cs *Constraints) SetValue(val interface{}) {
2017-12-18 08:14:03 +00:00
*cs = val.(Constraints)
}
// Type exports the Constraints type as a string
func (cs *Constraints) Type() string {
2017-08-18 00:18:02 +00:00
return "constraint"
}
// Store holds KV store cluster config
type Store struct {
store.Store
2017-10-02 08:32:02 +00:00
// like this "prefix" (without the /)
Prefix string `export:"true"`
}
// Cluster holds cluster config
type Cluster struct {
2017-10-02 08:32:02 +00:00
Node string `description:"Node name" export:"true"`
Store *Store `export:"true"`
}
// Auth holds authentication configuration (BASIC, DIGEST, users)
type Auth struct {
2017-10-02 08:32:02 +00:00
Basic *Basic `export:"true"`
Digest *Digest `export:"true"`
Forward *Forward `export:"true"`
HeaderField string `export:"true"`
}
// Users authentication users
type Users []string
// Basic HTTP basic authentication
type Basic struct {
Users `mapstructure:","`
UsersFile string
}
// Digest HTTP authentication
type Digest struct {
Users `mapstructure:","`
UsersFile string
}
2016-10-14 14:04:09 +00:00
2017-08-25 16:22:03 +00:00
// Forward authentication
type Forward struct {
Address string `description:"Authentication server address"`
2017-10-02 08:32:02 +00:00
TLS *ClientTLS `description:"Enable TLS support" export:"true"`
TrustForwardHeader bool `description:"Trust X-Forwarded-* headers" export:"true"`
2017-08-25 16:22:03 +00:00
}
2016-10-14 14:04:09 +00:00
// CanonicalDomain returns a lower case domain with trim space
func CanonicalDomain(domain string) string {
return strings.ToLower(strings.TrimSpace(domain))
}
// Statistics provides options for monitoring request and response stats
type Statistics struct {
2017-10-02 08:32:02 +00:00
RecentErrors int `description:"Number of recent errors logged" export:"true"`
}
2017-01-12 13:34:54 +00:00
// Metrics provides options to expose and send Traefik metrics to different third party monitoring systems
type Metrics struct {
2017-10-02 08:32:02 +00:00
Prometheus *Prometheus `description:"Prometheus metrics exporter type" export:"true"`
Datadog *Datadog `description:"DataDog metrics exporter type" export:"true"`
StatsD *Statsd `description:"StatsD metrics exporter type" export:"true"`
InfluxDB *InfluxDB `description:"InfluxDB metrics exporter type"`
2017-01-12 13:34:54 +00:00
}
// Prometheus can contain specific configuration used by the Prometheus Metrics exporter
type Prometheus struct {
Buckets Buckets `description:"Buckets for latency metrics" export:"true"`
EntryPoint string `description:"EntryPoint" export:"true"`
2017-01-12 13:34:54 +00:00
}
// Datadog contains address and metrics pushing interval configuration
type Datadog struct {
Address string `description:"DataDog's address"`
2017-10-02 08:32:02 +00:00
PushInterval string `description:"DataDog push interval" export:"true"`
}
// Statsd contains address and metrics pushing interval configuration
type Statsd struct {
Address string `description:"StatsD address"`
PushInterval string `description:"StatsD push interval" export:"true"`
}
// InfluxDB contains address and metrics pushing interval configuration
type InfluxDB struct {
Address string `description:"InfluxDB address"`
PushInterval string `description:"InfluxDB push interval"`
}
2017-01-12 13:34:54 +00:00
// Buckets holds Prometheus Buckets
type Buckets []float64
2018-03-05 19:54:04 +00:00
// Set adds strings elem into the the parser
// it splits str on "," and ";" and apply ParseFloat to string
2017-01-12 13:34:54 +00:00
func (b *Buckets) Set(str string) error {
fargs := func(c rune) bool {
return c == ',' || c == ';'
}
// get function
slice := strings.FieldsFunc(str, fargs)
for _, bucket := range slice {
bu, err := strconv.ParseFloat(bucket, 64)
if err != nil {
return err
}
*b = append(*b, bu)
}
return nil
}
2018-03-05 19:54:04 +00:00
// Get []float64
2017-12-18 08:14:03 +00:00
func (b *Buckets) Get() interface{} { return *b }
2017-01-12 13:34:54 +00:00
2018-03-05 19:54:04 +00:00
// String return slice in a string
2017-01-12 13:34:54 +00:00
func (b *Buckets) String() string { return fmt.Sprintf("%v", *b) }
2018-03-05 19:54:04 +00:00
// SetValue sets []float64 into the parser
2017-01-12 13:34:54 +00:00
func (b *Buckets) SetValue(val interface{}) {
2017-12-18 08:14:03 +00:00
*b = val.(Buckets)
2017-01-12 13:34:54 +00:00
}
2017-05-25 11:25:53 +00:00
2017-08-25 16:22:03 +00:00
// ClientTLS holds TLS specific configurations as client
// CA, Cert and Key can be either path or file contents
type ClientTLS struct {
CA string `description:"TLS CA"`
2017-11-10 09:30:04 +00:00
CAOptional bool `description:"TLS CA.Optional"`
2017-08-25 16:22:03 +00:00
Cert string `description:"TLS cert"`
Key string `description:"TLS key"`
InsecureSkipVerify bool `description:"TLS insecure skip verify"`
}
// CreateTLSConfig creates a TLS config from ClientTLS structures
func (clientTLS *ClientTLS) CreateTLSConfig() (*tls.Config, error) {
var err error
if clientTLS == nil {
log.Warnf("clientTLS is nil")
return nil, nil
}
caPool := x509.NewCertPool()
2017-11-10 09:30:04 +00:00
clientAuth := tls.NoClientCert
2017-08-25 16:22:03 +00:00
if clientTLS.CA != "" {
var ca []byte
if _, errCA := os.Stat(clientTLS.CA); errCA == nil {
ca, err = ioutil.ReadFile(clientTLS.CA)
if err != nil {
2018-03-14 13:12:04 +00:00
return nil, fmt.Errorf("failed to read CA. %s", err)
2017-08-25 16:22:03 +00:00
}
} else {
ca = []byte(clientTLS.CA)
}
caPool.AppendCertsFromPEM(ca)
2017-11-10 09:30:04 +00:00
if clientTLS.CAOptional {
clientAuth = tls.VerifyClientCertIfGiven
} else {
clientAuth = tls.RequireAndVerifyClientCert
}
2017-08-25 16:22:03 +00:00
}
cert := tls.Certificate{}
_, errKeyIsFile := os.Stat(clientTLS.Key)
if !clientTLS.InsecureSkipVerify && (len(clientTLS.Cert) == 0 || len(clientTLS.Key) == 0) {
return nil, fmt.Errorf("TLS Certificate or Key file must be set when TLS configuration is created")
}
if len(clientTLS.Cert) > 0 && len(clientTLS.Key) > 0 {
if _, errCertIsFile := os.Stat(clientTLS.Cert); errCertIsFile == nil {
if errKeyIsFile == nil {
cert, err = tls.LoadX509KeyPair(clientTLS.Cert, clientTLS.Key)
if err != nil {
2018-03-14 13:12:04 +00:00
return nil, fmt.Errorf("failed to load TLS keypair: %v", err)
2017-08-25 16:22:03 +00:00
}
} else {
return nil, fmt.Errorf("tls cert is a file, but tls key is not")
}
} else {
if errKeyIsFile != nil {
cert, err = tls.X509KeyPair([]byte(clientTLS.Cert), []byte(clientTLS.Key))
if err != nil {
2018-03-14 13:12:04 +00:00
return nil, fmt.Errorf("failed to load TLS keypair: %v", err)
2017-08-25 16:22:03 +00:00
}
} else {
2018-03-14 13:12:04 +00:00
return nil, fmt.Errorf("TLS key is a file, but tls cert is not")
2017-08-25 16:22:03 +00:00
}
}
}
TLSConfig := &tls.Config{
Certificates: []tls.Certificate{cert},
RootCAs: caPool,
InsecureSkipVerify: clientTLS.InsecureSkipVerify,
2017-11-10 09:30:04 +00:00
ClientAuth: clientAuth,
2017-08-25 16:22:03 +00:00
}
return TLSConfig, nil
}
2018-03-14 13:12:04 +00:00
// HTTPCodeRanges holds HTTP code ranges
type HTTPCodeRanges [][2]int
// NewHTTPCodeRanges creates HTTPCodeRanges from a given []string.
2018-03-14 13:12:04 +00:00
// Break out the http status code ranges into a low int and high int
// for ease of use at runtime
func NewHTTPCodeRanges(strBlocks []string) (HTTPCodeRanges, error) {
var blocks HTTPCodeRanges
for _, block := range strBlocks {
codes := strings.Split(block, "-")
// if only a single HTTP code was configured, assume the best and create the correct configuration on the user's behalf
2018-03-14 13:12:04 +00:00
if len(codes) == 1 {
codes = append(codes, codes[0])
}
lowCode, err := strconv.Atoi(codes[0])
if err != nil {
return nil, err
}
highCode, err := strconv.Atoi(codes[1])
if err != nil {
return nil, err
}
blocks = append(blocks, [2]int{lowCode, highCode})
}
return blocks, nil
}
// Contains tests whether the passed status code is within
// one of its HTTP code ranges.
func (h HTTPCodeRanges) Contains(statusCode int) bool {
for _, block := range h {
if statusCode >= block[0] && statusCode <= block[1] {
return true
}
}
return false
}