types

Documentation

Index

• Variables
• func CanonicalDomain(domain string) string
• type Auth
• type Backend
• type Basic
• type Buckets
  • func (b *Buckets) Get() interface{}
  • func (b *Buckets) Set(str string) error
  • func (b *Buckets) SetValue(val interface{})
  • func (b *Buckets) String() string
• type CircuitBreaker
• type Cluster
• type ConfigMessage
• type Configuration
• type Constraint
  • func NewConstraint(exp string) (*Constraint, error)
  • func (c *Constraint) MarshalText() (text []byte, err error)
  • func (c *Constraint) MatchConstraintWithAtLeastOneTag(tags []string) bool
  • func (c *Constraint) String() string
  • func (c *Constraint) UnmarshalText(text []byte) error
• type Constraints
  • func (cs *Constraints) Get() interface{}
  • func (cs *Constraints) Set(str string) error
  • func (cs *Constraints) SetValue(val interface{})
  • func (cs *Constraints) String() string
  • func (cs *Constraints) Type() string
• type Digest
• type Frontend
• type HealthCheck
• type LoadBalancer
• type LoadBalancerMethod
  • func NewLoadBalancerMethod(loadBalancer *LoadBalancer) (LoadBalancerMethod, error)
• type MaxConn
• type Metrics
• type Prometheus
• type Route
• type Server
• type Statistics
• type Store
• type Users

Variables

var ErrInvalidLoadBalancerMethod = errors.New("Invalid method, using default")

ErrInvalidLoadBalancerMethod is thrown when the specified load balancing method is invalid.

Functions

func CanonicalDomain

func CanonicalDomain(domain string) string

CanonicalDomain returns a lower case domain with trim space

Types

type Auth

type Auth struct {
	Basic       *Basic
	Digest      *Digest
	HeaderField string
}

Auth holds authentication configuration (BASIC, DIGEST, users)

type Backend

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"`
	HealthCheck    *HealthCheck      `json:"healthCheck,omitempty"`
}

Backend holds backend configuration.

type Basic

type Basic struct {
	Users `mapstructure:","`
}

Basic HTTP basic authentication

type Buckets

type Buckets []float64

Buckets holds Prometheus Buckets

func (*Buckets) Get

func (b *Buckets) Get() interface{}

Get []float64

func (*Buckets) Set

func (b *Buckets) Set(str string) error

Set adds strings elem into the the parser it splits str on "," and ";" and apply ParseFloat to string

func (*Buckets) SetValue

func (b *Buckets) SetValue(val interface{})

SetValue sets []float64 into the parser

func (*Buckets) String

func (b *Buckets) String() string

String return slice in a string

type CircuitBreaker

type CircuitBreaker struct {
	Expression string `json:"expression,omitempty"`
}

CircuitBreaker holds circuit breaker configuration.

type Cluster

type Cluster struct {
	Node  string `description:"Node name"`
	Store *Store
}

Cluster holds cluster config

type ConfigMessage

type ConfigMessage struct {
	ProviderName  string
	Configuration *Configuration
}

ConfigMessage hold configuration information exchanged between parts of traefik.

type Configuration

type Configuration struct {
	Backends  map[string]*Backend  `json:"backends,omitempty"`
	Frontends map[string]*Frontend `json:"frontends,omitempty"`
}

Configuration of a provider.

type Constraint

type Constraint struct {
	Key string
	// MustMatch is true if operator is "==" or false if operator is "!="
	MustMatch bool
	// TODO: support regex
	Regex string
}

Constraint hold a parsed constraint expresssion

func NewConstraint

func NewConstraint(exp string) (*Constraint, error)

NewConstraint receive a string and return a *Constraint, after checking syntax and parsing the constraint expression

func (*Constraint) MarshalText

func (c *Constraint) MarshalText() (text []byte, err error)

MarshalText encodes the receiver into UTF-8-encoded text and returns the result.

func (*Constraint) MatchConstraintWithAtLeastOneTag

func (c *Constraint) MatchConstraintWithAtLeastOneTag(tags []string) bool

MatchConstraintWithAtLeastOneTag tests a constraint for one single service

func (*Constraint) String

func (c *Constraint) String() string

func (*Constraint) UnmarshalText

func (c *Constraint) UnmarshalText(text []byte) error

UnmarshalText define how unmarshal in TOML parsing

type Constraints

type Constraints []*Constraint

Constraints holds a Constraint parser

func (*Constraints) Get

func (cs *Constraints) Get() interface{}

Get []*Constraint

func (*Constraints) Set

func (cs *Constraints) Set(str string) error

Set []*Constraint

func (*Constraints) SetValue

func (cs *Constraints) SetValue(val interface{})

SetValue sets []*Constraint into the parser

func (*Constraints) String

func (cs *Constraints) String() string

String returns []*Constraint in string

func (*Constraints) Type

func (cs *Constraints) Type() string

Type exports the Constraints type as a string

type Digest

type Digest struct {
	Users `mapstructure:","`
}

Digest HTTP authentication

type Frontend

type Frontend struct {
	EntryPoints    []string         `json:"entryPoints,omitempty"`
	Backend        string           `json:"backend,omitempty"`
	Routes         map[string]Route `json:"routes,omitempty"`
	PassHostHeader bool             `json:"passHostHeader,omitempty"`
	Priority       int              `json:"priority"`
}

Frontend holds frontend configuration.

type HealthCheck

type HealthCheck struct {
	URL string `json:"url,omitempty"`
}

HealthCheck holds HealthCheck configuration

type LoadBalancer

type LoadBalancer struct {
	Method string `json:"method,omitempty"`
	Sticky bool   `json:"sticky,omitempty"`
}

LoadBalancer holds load balancing configuration.

type LoadBalancerMethod

type LoadBalancerMethod uint8

LoadBalancerMethod holds the method of load balancing to use.

const (
	// Wrr (default) = Weighted Round Robin
	Wrr LoadBalancerMethod = iota
	// Drr = Dynamic Round Robin
	Drr
)

func NewLoadBalancerMethod

func NewLoadBalancerMethod(loadBalancer *LoadBalancer) (LoadBalancerMethod, error)

NewLoadBalancerMethod create a new LoadBalancerMethod from a given LoadBalancer.

type MaxConn

type MaxConn struct {
	Amount        int64  `json:"amount,omitempty"`
	ExtractorFunc string `json:"extractorFunc,omitempty"`
}

MaxConn holds maximum connection configuration

type Metrics

type Metrics struct {
	Prometheus *Prometheus `description:"Prometheus metrics exporter type"`
}

Metrics provides options to expose and send Traefik metrics to different third party monitoring systems

type Prometheus

type Prometheus struct {
	Buckets Buckets `description:"Buckets for latency metrics"`
}

Prometheus can contain specific configuration used by the Prometheus Metrics exporter

type Route

type Route struct {
	Rule string `json:"rule,omitempty"`
}

Route holds route configuration.

type Server

type Server struct {
	URL    string `json:"url,omitempty"`
	Weight int    `json:"weight"`
}

Server holds server configuration.

type Statistics

type Statistics struct {
	RecentErrors int `description:"Number of recent errors logged"`
}

Statistics provides options for monitoring request and response stats

type Store

type Store struct {
	store.Store
	Prefix string // like this "prefix" (without the /)
}

Store holds KV store cluster config

type Users

type Users []string

Users authentication users