Segments Labels: Rancher & Marathon
This commit is contained in:
Ludovic Fernandez
Traefiker Bot
parent
16bb9b6836
commit
0ea007b26f
31 changed files with 4288 additions and 3656 deletions
|
|
@ -12,6 +12,10 @@ const testTaskName = "taskID"
|
|||
|
||||
// Functions related to building applications.
|
||||
|
||||
func withApplications(apps ...marathon.Application) *marathon.Applications {
|
||||
return &marathon.Applications{Apps: apps}
|
||||
}
|
||||
|
||||
func application(ops ...func(*marathon.Application)) marathon.Application {
|
||||
app := marathon.Application{}
|
||||
app.EmptyLabels()
|
||||
|
|
|
|||
|
|
@ -4,12 +4,10 @@ import (
|
|||
"errors"
|
||||
"fmt"
|
||||
"math"
|
||||
"net/url"
|
||||
"strconv"
|
||||
"strings"
|
||||
"text/template"
|
||||
|
||||
"github.com/BurntSushi/ty/fun"
|
||||
"github.com/containous/traefik/log"
|
||||
"github.com/containous/traefik/provider"
|
||||
"github.com/containous/traefik/provider/label"
|
||||
|
|
@ -19,99 +17,79 @@ import (
|
|||
|
||||
const defaultService = ""
|
||||
|
||||
func (p *Provider) buildConfiguration() *types.Configuration {
|
||||
type appData struct {
|
||||
marathon.Application
|
||||
SegmentLabels map[string]string
|
||||
SegmentName string
|
||||
}
|
||||
|
||||
func (p *Provider) buildConfigurationV2(applications *marathon.Applications) *types.Configuration {
|
||||
var MarathonFuncMap = template.FuncMap{
|
||||
"getBackend": p.getBackend,
|
||||
"getDomain": getFuncStringService(label.SuffixDomain, p.Domain), // see https://github.com/containous/traefik/pull/1693
|
||||
"getSubDomain": p.getSubDomain, // see https://github.com/containous/traefik/pull/1693
|
||||
"getDomain": label.GetFuncString(label.TraefikDomain, p.Domain), // see https://github.com/containous/traefik/pull/1693
|
||||
"getSubDomain": p.getSubDomain, // see https://github.com/containous/traefik/pull/1693
|
||||
"getBackendName": p.getBackendName,
|
||||
|
||||
// Backend functions
|
||||
"getBackendServer": p.getBackendServer,
|
||||
"getPort": getPort,
|
||||
"getCircuitBreaker": getCircuitBreaker,
|
||||
"getLoadBalancer": getLoadBalancer,
|
||||
"getMaxConn": getMaxConn,
|
||||
"getHealthCheck": getHealthCheck,
|
||||
"getBuffering": getBuffering,
|
||||
"getCircuitBreaker": label.GetCircuitBreaker,
|
||||
"getLoadBalancer": label.GetLoadBalancer,
|
||||
"getMaxConn": label.GetMaxConn,
|
||||
"getHealthCheck": label.GetHealthCheck,
|
||||
"getBuffering": label.GetBuffering,
|
||||
"getServers": p.getServers,
|
||||
|
||||
// TODO Deprecated [breaking]
|
||||
"getWeight": getFuncIntService(label.SuffixWeight, label.DefaultWeightInt),
|
||||
// TODO Deprecated [breaking]
|
||||
"getProtocol": getFuncStringService(label.SuffixProtocol, label.DefaultProtocol),
|
||||
// TODO Deprecated [breaking]
|
||||
"hasCircuitBreakerLabels": hasFunc(label.TraefikBackendCircuitBreakerExpression),
|
||||
// TODO Deprecated [breaking]
|
||||
"getCircuitBreakerExpression": getFuncString(label.TraefikBackendCircuitBreakerExpression, label.DefaultCircuitBreakerExpression),
|
||||
// TODO Deprecated [breaking]
|
||||
"hasLoadBalancerLabels": hasLoadBalancerLabels,
|
||||
// TODO Deprecated [breaking]
|
||||
"getLoadBalancerMethod": getFuncString(label.TraefikBackendLoadBalancerMethod, label.DefaultBackendLoadBalancerMethod),
|
||||
// TODO Deprecated [breaking]
|
||||
"getSticky": getSticky,
|
||||
// TODO Deprecated [breaking]
|
||||
"hasStickinessLabel": hasFunc(label.TraefikBackendLoadBalancerStickiness),
|
||||
// TODO Deprecated [breaking]
|
||||
"getStickinessCookieName": getFuncString(label.TraefikBackendLoadBalancerStickinessCookieName, ""),
|
||||
// TODO Deprecated [breaking]
|
||||
"hasMaxConnLabels": hasMaxConnLabels,
|
||||
// TODO Deprecated [breaking]
|
||||
"getMaxConnExtractorFunc": getFuncString(label.TraefikBackendMaxConnExtractorFunc, label.DefaultBackendMaxconnExtractorFunc),
|
||||
// TODO Deprecated [breaking]
|
||||
"getMaxConnAmount": getFuncInt64(label.TraefikBackendMaxConnAmount, math.MaxInt64),
|
||||
// TODO Deprecated [breaking]
|
||||
"hasHealthCheckLabels": hasFunc(label.TraefikBackendHealthCheckPath),
|
||||
// TODO Deprecated [breaking]
|
||||
"getHealthCheckPath": getFuncString(label.TraefikBackendHealthCheckPath, ""),
|
||||
// TODO Deprecated [breaking]
|
||||
"getHealthCheckInterval": getFuncString(label.TraefikBackendHealthCheckInterval, ""),
|
||||
|
||||
// Frontend functions
|
||||
"getServiceNames": getServiceNames,
|
||||
"getServiceNameSuffix": getServiceNameSuffix,
|
||||
"getPassHostHeader": getFuncBoolService(label.SuffixFrontendPassHostHeader, label.DefaultPassHostHeaderBool),
|
||||
"getPassTLSCert": getFuncBoolService(label.SuffixFrontendPassTLSCert, label.DefaultPassTLSCert),
|
||||
"getPriority": getFuncIntService(label.SuffixFrontendPriority, label.DefaultFrontendPriorityInt),
|
||||
"getEntryPoints": getFuncSliceStringService(label.SuffixFrontendEntryPoints),
|
||||
"getSegmentNameSuffix": getSegmentNameSuffix,
|
||||
"getFrontendRule": p.getFrontendRule,
|
||||
"getFrontendName": p.getFrontendName,
|
||||
"getBasicAuth": getFuncSliceStringService(label.SuffixFrontendAuthBasic),
|
||||
"getRedirect": getRedirect,
|
||||
"getErrorPages": getErrorPages,
|
||||
"getRateLimit": getRateLimit,
|
||||
"getHeaders": getHeaders,
|
||||
"getWhiteList": getWhiteList,
|
||||
|
||||
// TODO Deprecated [breaking]
|
||||
"getWhitelistSourceRange": getFuncSliceStringService(label.SuffixFrontendWhitelistSourceRange),
|
||||
"getPassHostHeader": label.GetFuncBool(label.TraefikFrontendPassHostHeader, label.DefaultPassHostHeaderBool),
|
||||
"getPassTLSCert": label.GetFuncBool(label.TraefikFrontendPassTLSCert, label.DefaultPassTLSCert),
|
||||
"getPriority": label.GetFuncInt(label.TraefikFrontendPriority, label.DefaultFrontendPriorityInt),
|
||||
"getEntryPoints": label.GetFuncSliceString(label.TraefikFrontendEntryPoints),
|
||||
"getBasicAuth": label.GetFuncSliceString(label.TraefikFrontendAuthBasic),
|
||||
"getRedirect": label.GetRedirect,
|
||||
"getErrorPages": label.GetErrorPages,
|
||||
"getRateLimit": label.GetRateLimit,
|
||||
"getHeaders": label.GetHeaders,
|
||||
"getWhiteList": label.GetWhiteList,
|
||||
}
|
||||
|
||||
v := url.Values{}
|
||||
v.Add("embed", "apps.tasks")
|
||||
v.Add("embed", "apps.deployments")
|
||||
v.Add("embed", "apps.readiness")
|
||||
applications, err := p.marathonClient.Applications(v)
|
||||
if err != nil {
|
||||
log.Errorf("Failed to retrieve Marathon applications: %v", err)
|
||||
return nil
|
||||
}
|
||||
|
||||
filteredApps := fun.Filter(p.applicationFilter, applications.Apps).([]marathon.Application)
|
||||
for i, app := range filteredApps {
|
||||
filteredApps[i].Tasks = fun.Filter(func(task *marathon.Task) bool {
|
||||
filtered := p.taskFilter(*task, app)
|
||||
if filtered {
|
||||
logIllegalServices(*task, app)
|
||||
var apps []*appData
|
||||
for _, app := range applications.Apps {
|
||||
if p.applicationFilter(app) {
|
||||
// Tasks
|
||||
var filteredTasks []*marathon.Task
|
||||
for _, task := range app.Tasks {
|
||||
if p.taskFilter(*task, app) {
|
||||
filteredTasks = append(filteredTasks, task)
|
||||
logIllegalServices(*task, app)
|
||||
}
|
||||
}
|
||||
return filtered
|
||||
}, app.Tasks).([]*marathon.Task)
|
||||
|
||||
if len(filteredTasks) == 0 {
|
||||
log.Warnf("No valid tasks for application %s", app.ID)
|
||||
continue
|
||||
}
|
||||
app.Tasks = filteredTasks
|
||||
|
||||
// segments
|
||||
segmentProperties := label.ExtractTraefikLabels(stringValueMap(app.Labels))
|
||||
for segmentName, labels := range segmentProperties {
|
||||
data := &appData{
|
||||
Application: app,
|
||||
SegmentLabels: labels,
|
||||
SegmentName: segmentName,
|
||||
}
|
||||
apps = append(apps, data)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
templateObjects := struct {
|
||||
Applications []marathon.Application
|
||||
Applications []*appData
|
||||
Domain string
|
||||
}{
|
||||
Applications: filteredApps,
|
||||
Applications: apps,
|
||||
Domain: p.Domain,
|
||||
}
|
||||
|
||||
|
|
@ -124,15 +102,15 @@ func (p *Provider) buildConfiguration() *types.Configuration {
|
|||
|
||||
func (p *Provider) applicationFilter(app marathon.Application) bool {
|
||||
// Filter disabled application.
|
||||
if !label.IsEnabledP(app.Labels, p.ExposedByDefault) {
|
||||
if !label.IsEnabled(stringValueMap(app.Labels), p.ExposedByDefault) {
|
||||
log.Debugf("Filtering disabled Marathon application %s", app.ID)
|
||||
return false
|
||||
}
|
||||
|
||||
// Filter by constraints.
|
||||
constraintTags := label.GetSliceStringValueP(app.Labels, label.TraefikTags)
|
||||
constraintTags := label.GetSliceStringValue(stringValueMap(app.Labels), label.TraefikTags)
|
||||
if p.MarathonLBCompatibility {
|
||||
if haGroup := label.GetStringValueP(app.Labels, labelLbCompatibilityGroup, ""); len(haGroup) > 0 {
|
||||
if haGroup := label.GetStringValue(stringValueMap(app.Labels), labelLbCompatibilityGroup, ""); len(haGroup) > 0 {
|
||||
constraintTags = append(constraintTags, haGroup)
|
||||
}
|
||||
}
|
||||
|
|
@ -164,40 +142,32 @@ func (p *Provider) taskFilter(task marathon.Task, application marathon.Applicati
|
|||
return true
|
||||
}
|
||||
|
||||
// getFrontendRule returns the frontend rule for the specified application, using
|
||||
// its label. If service is provided, it will look for serviceName label before generic one.
|
||||
// It returns a default one (Host) if the label is not present.
|
||||
func (p *Provider) getFrontendRule(application marathon.Application, serviceName string) string {
|
||||
labels := getLabels(application, serviceName)
|
||||
lblFrontendRule := getLabelName(serviceName, label.SuffixFrontendRule)
|
||||
if value := label.GetStringValue(labels, lblFrontendRule, ""); len(value) > 0 {
|
||||
return value
|
||||
}
|
||||
// logIllegalServices logs illegal service configurations.
|
||||
// While we cannot filter on the service level, they will eventually get
|
||||
// rejected once the server configuration is rendered.
|
||||
func logIllegalServices(task marathon.Task, app marathon.Application) {
|
||||
segmentProperties := label.ExtractTraefikLabels(stringValueMap(app.Labels))
|
||||
for segmentName, labels := range segmentProperties {
|
||||
// Check for illegal/missing ports.
|
||||
if _, err := processPorts(app, task, labels); err != nil {
|
||||
log.Warnf("%s has an illegal configuration: no proper port available", identifier(app, task, segmentName))
|
||||
continue
|
||||
}
|
||||
|
||||
if p.MarathonLBCompatibility {
|
||||
if value := label.GetStringValueP(application.Labels, labelLbCompatibility, ""); len(value) > 0 {
|
||||
return "Host:" + value
|
||||
// Check for illegal port label combinations.
|
||||
hasPortLabel := label.Has(labels, label.TraefikPort)
|
||||
hasPortIndexLabel := label.Has(labels, label.TraefikPortIndex)
|
||||
if hasPortLabel && hasPortIndexLabel {
|
||||
log.Warnf("%s has both port and port index specified; port will take precedence", identifier(app, task, segmentName))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func getSegmentNameSuffix(serviceName string) string {
|
||||
if len(serviceName) > 0 {
|
||||
return "Host:" + strings.ToLower(provider.Normalize(serviceName)) + "." + p.getSubDomain(application.ID) + "." + p.Domain
|
||||
return "-service-" + provider.Normalize(serviceName)
|
||||
}
|
||||
return "Host:" + p.getSubDomain(application.ID) + "." + p.Domain
|
||||
}
|
||||
|
||||
func (p *Provider) getBackend(application marathon.Application, serviceName string) string {
|
||||
labels := getLabels(application, serviceName)
|
||||
lblBackend := getLabelName(serviceName, label.SuffixBackend)
|
||||
value := label.GetStringValue(labels, lblBackend, "")
|
||||
if len(value) > 0 {
|
||||
return provider.Normalize("backend" + value)
|
||||
}
|
||||
return provider.Normalize("backend" + application.ID + getServiceNameSuffix(serviceName))
|
||||
}
|
||||
|
||||
func (p *Provider) getFrontendName(application marathon.Application, serviceName string) string {
|
||||
return provider.Normalize("frontend" + application.ID + getServiceNameSuffix(serviceName))
|
||||
return ""
|
||||
}
|
||||
|
||||
func (p *Provider) getSubDomain(name string) string {
|
||||
|
|
@ -210,120 +180,43 @@ func (p *Provider) getSubDomain(name string) string {
|
|||
return strings.Replace(strings.TrimPrefix(name, "/"), "/", "-", -1)
|
||||
}
|
||||
|
||||
func (p *Provider) getBackendServer(task marathon.Task, application marathon.Application) string {
|
||||
if application.IPAddressPerTask == nil || p.ForceTaskHostname {
|
||||
return task.Host
|
||||
}
|
||||
|
||||
numTaskIPAddresses := len(task.IPAddresses)
|
||||
switch numTaskIPAddresses {
|
||||
case 0:
|
||||
log.Errorf("Missing IP address for Marathon application %s on task %s", application.ID, task.ID)
|
||||
return ""
|
||||
case 1:
|
||||
return task.IPAddresses[0].IPAddress
|
||||
default:
|
||||
ipAddressIdx := label.GetIntValueP(application.Labels, labelIPAddressIdx, math.MinInt32)
|
||||
|
||||
if ipAddressIdx == math.MinInt32 {
|
||||
log.Errorf("Found %d task IP addresses but missing IP address index for Marathon application %s on task %s",
|
||||
numTaskIPAddresses, application.ID, task.ID)
|
||||
return ""
|
||||
}
|
||||
if ipAddressIdx < 0 || ipAddressIdx > numTaskIPAddresses {
|
||||
log.Errorf("Cannot use IP address index to select from %d task IP addresses for Marathon application %s on task %s",
|
||||
numTaskIPAddresses, application.ID, task.ID)
|
||||
return ""
|
||||
}
|
||||
|
||||
return task.IPAddresses[ipAddressIdx].IPAddress
|
||||
func (p *Provider) getBackendName(app appData) string {
|
||||
|
||||
value := label.GetStringValue(app.SegmentLabels, label.TraefikBackend, "")
|
||||
if len(value) > 0 {
|
||||
return provider.Normalize("backend" + value)
|
||||
}
|
||||
return provider.Normalize("backend" + app.ID + getSegmentNameSuffix(app.SegmentName))
|
||||
}
|
||||
|
||||
func identifier(app marathon.Application, task marathon.Task, serviceName string) string {
|
||||
id := fmt.Sprintf("Marathon task %s from application %s", task.ID, app.ID)
|
||||
if serviceName != "" {
|
||||
id += fmt.Sprintf(" (service: %s)", serviceName)
|
||||
}
|
||||
return id
|
||||
func (p *Provider) getFrontendName(app appData) string {
|
||||
return provider.Normalize("frontend" + app.ID + getSegmentNameSuffix(app.SegmentName))
|
||||
}
|
||||
|
||||
// getServiceNames returns a list of service names for a given application
|
||||
// An empty name "" will be added if no service specific properties exist,
|
||||
// as an indication that there are no sub-services, but only main application
|
||||
func getServiceNames(application marathon.Application) []string {
|
||||
labelServiceProperties := label.ExtractServicePropertiesP(application.Labels)
|
||||
|
||||
var names []string
|
||||
for k := range labelServiceProperties {
|
||||
names = append(names, k)
|
||||
// getFrontendRule returns the frontend rule for the specified application, using
|
||||
// its label. If service is provided, it will look for serviceName label before generic one.
|
||||
// It returns a default one (Host) if the label is not present.
|
||||
func (p *Provider) getFrontendRule(app appData) string {
|
||||
if value := label.GetStringValue(app.SegmentLabels, label.TraefikFrontendRule, ""); len(value) > 0 {
|
||||
return value
|
||||
}
|
||||
|
||||
// An empty name "" will be added if no service specific properties exist,
|
||||
// as an indication that there are no sub-services, but only main application
|
||||
if len(names) == 0 {
|
||||
names = append(names, defaultService)
|
||||
}
|
||||
return names
|
||||
}
|
||||
|
||||
func getServiceNameSuffix(serviceName string) string {
|
||||
if len(serviceName) > 0 {
|
||||
return "-service-" + provider.Normalize(serviceName)
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// logIllegalServices logs illegal service configurations.
|
||||
// While we cannot filter on the service level, they will eventually get
|
||||
// rejected once the server configuration is rendered.
|
||||
func logIllegalServices(task marathon.Task, application marathon.Application) {
|
||||
for _, serviceName := range getServiceNames(application) {
|
||||
// Check for illegal/missing ports.
|
||||
if _, err := processPorts(application, task, serviceName); err != nil {
|
||||
log.Warnf("%s has an illegal configuration: no proper port available", identifier(application, task, serviceName))
|
||||
continue
|
||||
}
|
||||
|
||||
// Check for illegal port label combinations.
|
||||
labels := getLabels(application, serviceName)
|
||||
hasPortLabel := label.Has(labels, getLabelName(serviceName, label.SuffixPort))
|
||||
hasPortIndexLabel := label.Has(labels, getLabelName(serviceName, label.SuffixPortIndex))
|
||||
if hasPortLabel && hasPortIndexLabel {
|
||||
log.Warnf("%s has both port and port index specified; port will take precedence", identifier(application, task, serviceName))
|
||||
if p.MarathonLBCompatibility {
|
||||
if value := label.GetStringValue(stringValueMap(app.Labels), labelLbCompatibility, ""); len(value) > 0 {
|
||||
return "Host:" + value
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func hasLoadBalancerLabels(application marathon.Application) bool {
|
||||
method := label.HasP(application.Labels, label.TraefikBackendLoadBalancerMethod)
|
||||
sticky := label.HasP(application.Labels, label.TraefikBackendLoadBalancerSticky)
|
||||
stickiness := label.HasP(application.Labels, label.TraefikBackendLoadBalancerStickiness)
|
||||
return method || sticky || stickiness
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func hasMaxConnLabels(application marathon.Application) bool {
|
||||
mca := label.HasP(application.Labels, label.TraefikBackendMaxConnAmount)
|
||||
mcef := label.HasP(application.Labels, label.TraefikBackendMaxConnExtractorFunc)
|
||||
return mca && mcef
|
||||
}
|
||||
|
||||
// TODO: Deprecated
|
||||
// replaced by Stickiness
|
||||
// Deprecated
|
||||
func getSticky(application marathon.Application) bool {
|
||||
if label.HasP(application.Labels, label.TraefikBackendLoadBalancerSticky) {
|
||||
log.Warnf("Deprecated configuration found: %s. Please use %s.", label.TraefikBackendLoadBalancerSticky, label.TraefikBackendLoadBalancerStickiness)
|
||||
if len(app.SegmentName) > 0 {
|
||||
return "Host:" + strings.ToLower(provider.Normalize(app.SegmentName)) + "." + p.getSubDomain(app.ID) + "." + p.Domain
|
||||
}
|
||||
return label.GetBoolValueP(application.Labels, label.TraefikBackendLoadBalancerSticky, false)
|
||||
return "Host:" + p.getSubDomain(app.ID) + "." + p.Domain
|
||||
}
|
||||
|
||||
func getPort(task marathon.Task, application marathon.Application, serviceName string) string {
|
||||
port, err := processPorts(application, task, serviceName)
|
||||
func getPort(task marathon.Task, app appData) string {
|
||||
port, err := processPorts(app.Application, task, app.SegmentLabels)
|
||||
if err != nil {
|
||||
log.Errorf("Unable to process ports for %s: %s", identifier(application, task, serviceName), err)
|
||||
log.Errorf("Unable to process ports for %s: %s", identifier(app.Application, task, app.SegmentName), err)
|
||||
return ""
|
||||
}
|
||||
|
||||
|
|
@ -334,12 +227,9 @@ func getPort(task marathon.Task, application marathon.Application, serviceName s
|
|||
// An explicitly specified port is preferred. If none is specified, it selects
|
||||
// one of the available port. The first such found port is returned unless an
|
||||
// optional index is provided.
|
||||
func processPorts(application marathon.Application, task marathon.Task, serviceName string) (int, error) {
|
||||
labels := getLabels(application, serviceName)
|
||||
lblPort := getLabelName(serviceName, label.SuffixPort)
|
||||
|
||||
if label.Has(labels, lblPort) {
|
||||
port := label.GetIntValue(labels, lblPort, 0)
|
||||
func processPorts(app marathon.Application, task marathon.Task, labels map[string]string) (int, error) {
|
||||
if label.Has(labels, label.TraefikPort) {
|
||||
port := label.GetIntValue(labels, label.TraefikPort, 0)
|
||||
|
||||
if port <= 0 {
|
||||
return 0, fmt.Errorf("explicitly specified port %d must be larger than zero", port)
|
||||
|
|
@ -348,39 +238,39 @@ func processPorts(application marathon.Application, task marathon.Task, serviceN
|
|||
}
|
||||
}
|
||||
|
||||
ports := retrieveAvailablePorts(application, task)
|
||||
ports := retrieveAvailablePorts(app, task)
|
||||
if len(ports) == 0 {
|
||||
return 0, errors.New("no port found")
|
||||
}
|
||||
|
||||
lblPortIndex := getLabelName(serviceName, label.SuffixPortIndex)
|
||||
portIndex := label.GetIntValue(labels, lblPortIndex, 0)
|
||||
portIndex := label.GetIntValue(labels, label.TraefikPortIndex, 0)
|
||||
if portIndex < 0 || portIndex > len(ports)-1 {
|
||||
return 0, fmt.Errorf("index %d must be within range (0, %d)", portIndex, len(ports)-1)
|
||||
}
|
||||
return ports[portIndex], nil
|
||||
}
|
||||
|
||||
func retrieveAvailablePorts(application marathon.Application, task marathon.Task) []int {
|
||||
func retrieveAvailablePorts(app marathon.Application, task marathon.Task) []int {
|
||||
// Using default port configuration
|
||||
if len(task.Ports) > 0 {
|
||||
return task.Ports
|
||||
}
|
||||
|
||||
// Using port definition if available
|
||||
if application.PortDefinitions != nil && len(*application.PortDefinitions) > 0 {
|
||||
if app.PortDefinitions != nil && len(*app.PortDefinitions) > 0 {
|
||||
var ports []int
|
||||
for _, def := range *application.PortDefinitions {
|
||||
for _, def := range *app.PortDefinitions {
|
||||
if def.Port != nil {
|
||||
ports = append(ports, *def.Port)
|
||||
}
|
||||
}
|
||||
return ports
|
||||
}
|
||||
|
||||
// If using IP-per-task using this port definition
|
||||
if application.IPAddressPerTask != nil && len(*(application.IPAddressPerTask.Discovery).Ports) > 0 {
|
||||
if app.IPAddressPerTask != nil && app.IPAddressPerTask.Discovery != nil && len(*(app.IPAddressPerTask.Discovery.Ports)) > 0 {
|
||||
var ports []int
|
||||
for _, def := range *(application.IPAddressPerTask.Discovery).Ports {
|
||||
for _, def := range *(app.IPAddressPerTask.Discovery.Ports) {
|
||||
ports = append(ports, def.Number)
|
||||
}
|
||||
return ports
|
||||
|
|
@ -389,83 +279,19 @@ func retrieveAvailablePorts(application marathon.Application, task marathon.Task
|
|||
return []int{}
|
||||
}
|
||||
|
||||
func getCircuitBreaker(application marathon.Application) *types.CircuitBreaker {
|
||||
circuitBreaker := label.GetStringValueP(application.Labels, label.TraefikBackendCircuitBreakerExpression, "")
|
||||
if len(circuitBreaker) == 0 {
|
||||
return nil
|
||||
func identifier(app marathon.Application, task marathon.Task, segmentName string) string {
|
||||
id := fmt.Sprintf("Marathon task %s from application %s", task.ID, app.ID)
|
||||
if segmentName != "" {
|
||||
id += fmt.Sprintf(" (segment: %s)", segmentName)
|
||||
}
|
||||
return &types.CircuitBreaker{Expression: circuitBreaker}
|
||||
return id
|
||||
}
|
||||
|
||||
func getLoadBalancer(application marathon.Application) *types.LoadBalancer {
|
||||
if !label.HasPrefixP(application.Labels, label.TraefikBackendLoadBalancer) {
|
||||
return nil
|
||||
}
|
||||
|
||||
method := label.GetStringValueP(application.Labels, label.TraefikBackendLoadBalancerMethod, label.DefaultBackendLoadBalancerMethod)
|
||||
|
||||
lb := &types.LoadBalancer{
|
||||
Method: method,
|
||||
Sticky: getSticky(application),
|
||||
}
|
||||
|
||||
if label.GetBoolValueP(application.Labels, label.TraefikBackendLoadBalancerStickiness, false) {
|
||||
cookieName := label.GetStringValueP(application.Labels, label.TraefikBackendLoadBalancerStickinessCookieName, label.DefaultBackendLoadbalancerStickinessCookieName)
|
||||
lb.Stickiness = &types.Stickiness{CookieName: cookieName}
|
||||
}
|
||||
|
||||
return lb
|
||||
}
|
||||
|
||||
func getMaxConn(application marathon.Application) *types.MaxConn {
|
||||
amount := label.GetInt64ValueP(application.Labels, label.TraefikBackendMaxConnAmount, math.MinInt64)
|
||||
extractorFunc := label.GetStringValueP(application.Labels, label.TraefikBackendMaxConnExtractorFunc, label.DefaultBackendMaxconnExtractorFunc)
|
||||
|
||||
if amount == math.MinInt64 || len(extractorFunc) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
return &types.MaxConn{
|
||||
Amount: amount,
|
||||
ExtractorFunc: extractorFunc,
|
||||
}
|
||||
}
|
||||
|
||||
func getHealthCheck(application marathon.Application) *types.HealthCheck {
|
||||
path := label.GetStringValueP(application.Labels, label.TraefikBackendHealthCheckPath, "")
|
||||
if len(path) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
port := label.GetIntValueP(application.Labels, label.TraefikBackendHealthCheckPort, label.DefaultBackendHealthCheckPort)
|
||||
interval := label.GetStringValueP(application.Labels, label.TraefikBackendHealthCheckInterval, "")
|
||||
|
||||
return &types.HealthCheck{
|
||||
Path: path,
|
||||
Port: port,
|
||||
Interval: interval,
|
||||
}
|
||||
}
|
||||
|
||||
func getBuffering(application marathon.Application) *types.Buffering {
|
||||
if !label.HasPrefixP(application.Labels, label.TraefikBackendBuffering) {
|
||||
return nil
|
||||
}
|
||||
|
||||
return &types.Buffering{
|
||||
MaxRequestBodyBytes: label.GetInt64ValueP(application.Labels, label.TraefikBackendBufferingMaxRequestBodyBytes, 0),
|
||||
MaxResponseBodyBytes: label.GetInt64ValueP(application.Labels, label.TraefikBackendBufferingMaxResponseBodyBytes, 0),
|
||||
MemRequestBodyBytes: label.GetInt64ValueP(application.Labels, label.TraefikBackendBufferingMemRequestBodyBytes, 0),
|
||||
MemResponseBodyBytes: label.GetInt64ValueP(application.Labels, label.TraefikBackendBufferingMemResponseBodyBytes, 0),
|
||||
RetryExpression: label.GetStringValueP(application.Labels, label.TraefikBackendBufferingRetryExpression, ""),
|
||||
}
|
||||
}
|
||||
|
||||
func (p *Provider) getServers(application marathon.Application, serviceName string) map[string]types.Server {
|
||||
func (p *Provider) getServers(app appData) map[string]types.Server {
|
||||
var servers map[string]types.Server
|
||||
|
||||
for _, task := range application.Tasks {
|
||||
host := p.getBackendServer(*task, application)
|
||||
for _, task := range app.Tasks {
|
||||
host := p.getBackendServer(*task, app)
|
||||
if len(host) == 0 {
|
||||
continue
|
||||
}
|
||||
|
|
@ -474,197 +300,45 @@ func (p *Provider) getServers(application marathon.Application, serviceName stri
|
|||
servers = make(map[string]types.Server)
|
||||
}
|
||||
|
||||
labels := getLabels(application, serviceName)
|
||||
port := getPort(*task, app)
|
||||
protocol := label.GetStringValue(app.SegmentLabels, label.TraefikProtocol, label.DefaultProtocol)
|
||||
|
||||
port := getPort(*task, application, serviceName)
|
||||
protocol := label.GetStringValue(labels, getLabelName(serviceName, label.SuffixProtocol), label.DefaultProtocol)
|
||||
|
||||
serverName := provider.Normalize("server-" + task.ID + getServiceNameSuffix(serviceName))
|
||||
serverName := provider.Normalize("server-" + task.ID + getSegmentNameSuffix(app.SegmentName))
|
||||
servers[serverName] = types.Server{
|
||||
URL: fmt.Sprintf("%s://%s:%v", protocol, host, port),
|
||||
Weight: label.GetIntValue(labels, getLabelName(serviceName, label.SuffixWeight), label.DefaultWeightInt),
|
||||
Weight: label.GetIntValue(app.SegmentLabels, label.TraefikWeight, label.DefaultWeightInt),
|
||||
}
|
||||
}
|
||||
|
||||
return servers
|
||||
}
|
||||
|
||||
func getWhiteList(application marathon.Application, serviceName string) *types.WhiteList {
|
||||
labels := getLabels(application, serviceName)
|
||||
func (p *Provider) getBackendServer(task marathon.Task, app appData) string {
|
||||
if app.IPAddressPerTask == nil || p.ForceTaskHostname {
|
||||
return task.Host
|
||||
}
|
||||
|
||||
ranges := label.GetSliceStringValue(labels, getLabelName(serviceName, label.SuffixFrontendWhiteListSourceRange))
|
||||
if len(ranges) > 0 {
|
||||
return &types.WhiteList{
|
||||
SourceRange: ranges,
|
||||
UseXForwardedFor: label.GetBoolValue(labels, getLabelName(serviceName, label.SuffixFrontendWhiteListUseXForwardedFor), false),
|
||||
numTaskIPAddresses := len(task.IPAddresses)
|
||||
switch numTaskIPAddresses {
|
||||
case 0:
|
||||
log.Errorf("Missing IP address for Marathon application %s on task %s", app.ID, task.ID)
|
||||
return ""
|
||||
case 1:
|
||||
return task.IPAddresses[0].IPAddress
|
||||
default:
|
||||
ipAddressIdx := label.GetIntValue(stringValueMap(app.Labels), labelIPAddressIdx, math.MinInt32)
|
||||
|
||||
if ipAddressIdx == math.MinInt32 {
|
||||
log.Errorf("Found %d task IP addresses but missing IP address index for Marathon application %s on task %s",
|
||||
numTaskIPAddresses, app.ID, task.ID)
|
||||
return ""
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func getRedirect(application marathon.Application, serviceName string) *types.Redirect {
|
||||
labels := getLabels(application, serviceName)
|
||||
|
||||
permanent := label.GetBoolValue(labels, getLabelName(serviceName, label.SuffixFrontendRedirectPermanent), false)
|
||||
|
||||
if label.Has(labels, getLabelName(serviceName, label.SuffixFrontendRedirectEntryPoint)) {
|
||||
return &types.Redirect{
|
||||
EntryPoint: label.GetStringValue(labels, getLabelName(serviceName, label.SuffixFrontendRedirectEntryPoint), ""),
|
||||
Permanent: permanent,
|
||||
if ipAddressIdx < 0 || ipAddressIdx > numTaskIPAddresses {
|
||||
log.Errorf("Cannot use IP address index to select from %d task IP addresses for Marathon application %s on task %s",
|
||||
numTaskIPAddresses, app.ID, task.ID)
|
||||
return ""
|
||||
}
|
||||
}
|
||||
|
||||
if label.Has(labels, getLabelName(serviceName, label.SuffixFrontendRedirectRegex)) &&
|
||||
label.Has(labels, getLabelName(serviceName, label.SuffixFrontendRedirectReplacement)) {
|
||||
return &types.Redirect{
|
||||
Regex: label.GetStringValue(labels, getLabelName(serviceName, label.SuffixFrontendRedirectRegex), ""),
|
||||
Replacement: label.GetStringValue(labels, getLabelName(serviceName, label.SuffixFrontendRedirectReplacement), ""),
|
||||
Permanent: permanent,
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func getErrorPages(application marathon.Application, serviceName string) map[string]*types.ErrorPage {
|
||||
labels := getLabels(application, serviceName)
|
||||
prefix := getLabelName(serviceName, label.BaseFrontendErrorPage)
|
||||
|
||||
if len(serviceName) > 0 {
|
||||
return label.ParseErrorPages(labels, prefix, label.RegexpBaseFrontendErrorPage)
|
||||
}
|
||||
return label.ParseErrorPages(labels, prefix, label.RegexpFrontendErrorPage)
|
||||
}
|
||||
|
||||
func getRateLimit(application marathon.Application, serviceName string) *types.RateLimit {
|
||||
labels := getLabels(application, serviceName)
|
||||
|
||||
extractorFunc := label.GetStringValue(labels, getLabelName(serviceName, label.SuffixFrontendRateLimitExtractorFunc), "")
|
||||
if len(extractorFunc) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
limits := getRateSet(labels, serviceName)
|
||||
if len(limits) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
return &types.RateLimit{
|
||||
ExtractorFunc: extractorFunc,
|
||||
RateSet: limits,
|
||||
}
|
||||
}
|
||||
|
||||
func getRateSet(labels map[string]string, serviceName string) map[string]*types.Rate {
|
||||
rateSetPrefix := getLabelName(serviceName, label.BaseFrontendRateLimit)
|
||||
|
||||
if len(serviceName) > 0 {
|
||||
return label.ParseRateSets(labels, rateSetPrefix, label.RegexpBaseFrontendRateLimit)
|
||||
}
|
||||
return label.ParseRateSets(labels, rateSetPrefix, label.RegexpFrontendRateLimit)
|
||||
}
|
||||
|
||||
func getHeaders(application marathon.Application, serviceName string) *types.Headers {
|
||||
labels := getLabels(application, serviceName)
|
||||
|
||||
headers := &types.Headers{
|
||||
CustomRequestHeaders: label.GetMapValue(labels, getLabelName(serviceName, label.SuffixFrontendRequestHeaders)),
|
||||
CustomResponseHeaders: label.GetMapValue(labels, getLabelName(serviceName, label.SuffixFrontendResponseHeaders)),
|
||||
SSLProxyHeaders: label.GetMapValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersSSLProxyHeaders)),
|
||||
AllowedHosts: label.GetSliceStringValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersAllowedHosts)),
|
||||
HostsProxyHeaders: label.GetSliceStringValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersHostsProxyHeaders)),
|
||||
STSSeconds: label.GetInt64Value(labels, getLabelName(serviceName, label.SuffixFrontendHeadersSTSSeconds), 0),
|
||||
SSLRedirect: label.GetBoolValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersSSLRedirect), false),
|
||||
SSLTemporaryRedirect: label.GetBoolValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersSSLTemporaryRedirect), false),
|
||||
STSIncludeSubdomains: label.GetBoolValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersSTSIncludeSubdomains), false),
|
||||
STSPreload: label.GetBoolValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersSTSPreload), false),
|
||||
ForceSTSHeader: label.GetBoolValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersForceSTSHeader), false),
|
||||
FrameDeny: label.GetBoolValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersFrameDeny), false),
|
||||
ContentTypeNosniff: label.GetBoolValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersContentTypeNosniff), false),
|
||||
BrowserXSSFilter: label.GetBoolValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersBrowserXSSFilter), false),
|
||||
IsDevelopment: label.GetBoolValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersIsDevelopment), false),
|
||||
SSLHost: label.GetStringValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersSSLHost), ""),
|
||||
CustomFrameOptionsValue: label.GetStringValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersCustomFrameOptionsValue), ""),
|
||||
ContentSecurityPolicy: label.GetStringValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersContentSecurityPolicy), ""),
|
||||
PublicKey: label.GetStringValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersPublicKey), ""),
|
||||
ReferrerPolicy: label.GetStringValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersReferrerPolicy), ""),
|
||||
CustomBrowserXSSValue: label.GetStringValue(labels, getLabelName(serviceName, label.SuffixFrontendHeadersCustomBrowserXSSValue), ""),
|
||||
}
|
||||
|
||||
if !headers.HasSecureHeadersDefined() && !headers.HasCustomHeadersDefined() {
|
||||
return nil
|
||||
}
|
||||
|
||||
return headers
|
||||
}
|
||||
|
||||
// Label functions
|
||||
|
||||
func getLabels(application marathon.Application, serviceName string) map[string]string {
|
||||
if len(serviceName) > 0 {
|
||||
return label.ExtractServicePropertiesP(application.Labels)[serviceName]
|
||||
}
|
||||
|
||||
if application.Labels != nil {
|
||||
return *application.Labels
|
||||
}
|
||||
|
||||
return make(map[string]string)
|
||||
}
|
||||
|
||||
func getLabelName(serviceName string, suffix string) string {
|
||||
if len(serviceName) != 0 {
|
||||
return suffix
|
||||
}
|
||||
return label.Prefix + suffix
|
||||
}
|
||||
|
||||
func hasFunc(labelName string) func(application marathon.Application) bool {
|
||||
return func(application marathon.Application) bool {
|
||||
return label.HasP(application.Labels, labelName)
|
||||
}
|
||||
}
|
||||
|
||||
func getFuncStringService(labelName string, defaultValue string) func(application marathon.Application, serviceName string) string {
|
||||
return func(application marathon.Application, serviceName string) string {
|
||||
labels := getLabels(application, serviceName)
|
||||
lbName := getLabelName(serviceName, labelName)
|
||||
return label.GetStringValue(labels, lbName, defaultValue)
|
||||
}
|
||||
}
|
||||
|
||||
func getFuncBoolService(labelName string, defaultValue bool) func(application marathon.Application, serviceName string) bool {
|
||||
return func(application marathon.Application, serviceName string) bool {
|
||||
labels := getLabels(application, serviceName)
|
||||
lbName := getLabelName(serviceName, labelName)
|
||||
return label.GetBoolValue(labels, lbName, defaultValue)
|
||||
}
|
||||
}
|
||||
|
||||
func getFuncIntService(labelName string, defaultValue int) func(application marathon.Application, serviceName string) int {
|
||||
return func(application marathon.Application, serviceName string) int {
|
||||
labels := getLabels(application, serviceName)
|
||||
lbName := getLabelName(serviceName, labelName)
|
||||
return label.GetIntValue(labels, lbName, defaultValue)
|
||||
}
|
||||
}
|
||||
|
||||
func getFuncSliceStringService(labelName string) func(application marathon.Application, serviceName string) []string {
|
||||
return func(application marathon.Application, serviceName string) []string {
|
||||
labels := getLabels(application, serviceName)
|
||||
return label.GetSliceStringValue(labels, getLabelName(serviceName, labelName))
|
||||
}
|
||||
}
|
||||
|
||||
func getFuncString(labelName string, defaultValue string) func(application marathon.Application) string {
|
||||
return func(application marathon.Application) string {
|
||||
return label.GetStringValueP(application.Labels, labelName, defaultValue)
|
||||
}
|
||||
}
|
||||
|
||||
func getFuncInt64(labelName string, defaultValue int64) func(application marathon.Application) int64 {
|
||||
return func(application marathon.Application) int64 {
|
||||
return label.GetInt64ValueP(application.Labels, labelName, defaultValue)
|
||||
return task.IPAddresses[ipAddressIdx].IPAddress
|
||||
}
|
||||
}
|
||||
|
|
|
|||
13
provider/marathon/config_root.go
Normal file
13
provider/marathon/config_root.go
Normal file
|
|
@ -0,0 +1,13 @@
|
|||
package marathon
|
||||
|
||||
import (
|
||||
"github.com/containous/traefik/types"
|
||||
"github.com/gambol99/go-marathon"
|
||||
)
|
||||
|
||||
func (p *Provider) buildConfiguration(applications *marathon.Applications) *types.Configuration {
|
||||
if p.TemplateVersion == 1 {
|
||||
return p.buildConfigurationV1(applications)
|
||||
}
|
||||
return p.buildConfigurationV2(applications)
|
||||
}
|
||||
File diff suppressed because it is too large
Load diff
8
provider/marathon/convert_types.go
Normal file
8
provider/marathon/convert_types.go
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
package marathon
|
||||
|
||||
func stringValueMap(mp *map[string]string) map[string]string {
|
||||
if mp != nil {
|
||||
return *mp
|
||||
}
|
||||
return make(map[string]string)
|
||||
}
|
||||
425
provider/marathon/deprecated_config.go
Normal file
425
provider/marathon/deprecated_config.go
Normal file
|
|
@ -0,0 +1,425 @@
|
|||
package marathon
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"math"
|
||||
"strconv"
|
||||
"strings"
|
||||
"text/template"
|
||||
|
||||
"github.com/BurntSushi/ty/fun"
|
||||
"github.com/containous/traefik/log"
|
||||
"github.com/containous/traefik/provider"
|
||||
"github.com/containous/traefik/provider/label"
|
||||
"github.com/containous/traefik/types"
|
||||
"github.com/gambol99/go-marathon"
|
||||
)
|
||||
|
||||
func (p *Provider) buildConfigurationV1(applications *marathon.Applications) *types.Configuration {
|
||||
var MarathonFuncMap = template.FuncMap{
|
||||
"getBackend": p.getBackendNameV1,
|
||||
"getDomain": getFuncStringServiceV1(label.SuffixDomain, p.Domain), // see https://github.com/containous/traefik/pull/1693
|
||||
"getSubDomain": p.getSubDomain, // see https://github.com/containous/traefik/pull/1693
|
||||
|
||||
// Backend functions
|
||||
"getBackendServer": p.getBackendServerV1,
|
||||
"getPort": getPortV1,
|
||||
"getServers": p.getServersV1,
|
||||
|
||||
"getWeight": getFuncIntServiceV1(label.SuffixWeight, label.DefaultWeightInt),
|
||||
"getProtocol": getFuncStringServiceV1(label.SuffixProtocol, label.DefaultProtocol),
|
||||
"hasCircuitBreakerLabels": hasFuncV1(label.TraefikBackendCircuitBreakerExpression),
|
||||
"getCircuitBreakerExpression": getFuncStringV1(label.TraefikBackendCircuitBreakerExpression, label.DefaultCircuitBreakerExpression),
|
||||
"hasLoadBalancerLabels": hasLoadBalancerLabelsV1,
|
||||
"getLoadBalancerMethod": getFuncStringV1(label.TraefikBackendLoadBalancerMethod, label.DefaultBackendLoadBalancerMethod),
|
||||
"getSticky": getStickyV1,
|
||||
"hasStickinessLabel": hasFuncV1(label.TraefikBackendLoadBalancerStickiness),
|
||||
"getStickinessCookieName": getFuncStringV1(label.TraefikBackendLoadBalancerStickinessCookieName, ""),
|
||||
"hasMaxConnLabels": hasMaxConnLabelsV1,
|
||||
"getMaxConnExtractorFunc": getFuncStringV1(label.TraefikBackendMaxConnExtractorFunc, label.DefaultBackendMaxconnExtractorFunc),
|
||||
"getMaxConnAmount": getFuncInt64V1(label.TraefikBackendMaxConnAmount, math.MaxInt64),
|
||||
"hasHealthCheckLabels": hasFuncV1(label.TraefikBackendHealthCheckPath),
|
||||
"getHealthCheckPath": getFuncStringV1(label.TraefikBackendHealthCheckPath, ""),
|
||||
"getHealthCheckInterval": getFuncStringV1(label.TraefikBackendHealthCheckInterval, ""),
|
||||
|
||||
// Frontend functions
|
||||
"getServiceNames": getServiceNamesV1,
|
||||
"getServiceNameSuffix": getSegmentNameSuffix,
|
||||
"getPassHostHeader": getFuncBoolServiceV1(label.SuffixFrontendPassHostHeader, label.DefaultPassHostHeaderBool),
|
||||
"getPassTLSCert": getFuncBoolServiceV1(label.SuffixFrontendPassTLSCert, label.DefaultPassTLSCert),
|
||||
"getPriority": getFuncIntServiceV1(label.SuffixFrontendPriority, label.DefaultFrontendPriorityInt),
|
||||
"getEntryPoints": getFuncSliceStringServiceV1(label.SuffixFrontendEntryPoints),
|
||||
"getFrontendRule": p.getFrontendRuleV1,
|
||||
"getFrontendName": p.getFrontendNameV1,
|
||||
"getBasicAuth": getFuncSliceStringServiceV1(label.SuffixFrontendAuthBasic),
|
||||
"getWhitelistSourceRange": getFuncSliceStringServiceV1(label.SuffixFrontendWhitelistSourceRange),
|
||||
"getWhiteList": getWhiteListV1,
|
||||
}
|
||||
|
||||
filteredApps := fun.Filter(p.applicationFilter, applications.Apps).([]marathon.Application)
|
||||
for i, app := range filteredApps {
|
||||
filteredApps[i].Tasks = fun.Filter(func(task *marathon.Task) bool {
|
||||
filtered := p.taskFilter(*task, app)
|
||||
if filtered {
|
||||
logIllegalServicesV1(*task, app)
|
||||
}
|
||||
return filtered
|
||||
}, app.Tasks).([]*marathon.Task)
|
||||
}
|
||||
|
||||
templateObjects := struct {
|
||||
Applications []marathon.Application
|
||||
Domain string
|
||||
}{
|
||||
Applications: filteredApps,
|
||||
Domain: p.Domain,
|
||||
}
|
||||
|
||||
configuration, err := p.GetConfiguration("templates/marathon-v1.tmpl", MarathonFuncMap, templateObjects)
|
||||
if err != nil {
|
||||
log.Errorf("Failed to render Marathon configuration template: %v", err)
|
||||
}
|
||||
return configuration
|
||||
}
|
||||
|
||||
// logIllegalServicesV1 logs illegal service configurations.
|
||||
// While we cannot filter on the service level, they will eventually get
|
||||
// rejected once the server configuration is rendered.
|
||||
// Deprecated
|
||||
func logIllegalServicesV1(task marathon.Task, app marathon.Application) {
|
||||
for _, serviceName := range getServiceNamesV1(app) {
|
||||
// Check for illegal/missing ports.
|
||||
if _, err := processPortsV1(app, task, serviceName); err != nil {
|
||||
log.Warnf("%s has an illegal configuration: no proper port available", identifierV1(app, task, serviceName))
|
||||
continue
|
||||
}
|
||||
|
||||
// Check for illegal port label combinations.
|
||||
labels := getLabelsV1(app, serviceName)
|
||||
hasPortLabel := label.Has(labels, getLabelNameV1(serviceName, label.SuffixPort))
|
||||
hasPortIndexLabel := label.Has(labels, getLabelNameV1(serviceName, label.SuffixPortIndex))
|
||||
if hasPortLabel && hasPortIndexLabel {
|
||||
log.Warnf("%s has both port and port index specified; port will take precedence", identifierV1(app, task, serviceName))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func (p *Provider) getBackendNameV1(application marathon.Application, serviceName string) string {
|
||||
labels := getLabelsV1(application, serviceName)
|
||||
lblBackend := getLabelNameV1(serviceName, label.SuffixBackend)
|
||||
value := label.GetStringValue(labels, lblBackend, "")
|
||||
if len(value) > 0 {
|
||||
return provider.Normalize("backend" + value)
|
||||
}
|
||||
return provider.Normalize("backend" + application.ID + getSegmentNameSuffix(serviceName))
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func (p *Provider) getFrontendNameV1(application marathon.Application, serviceName string) string {
|
||||
return provider.Normalize("frontend" + application.ID + getSegmentNameSuffix(serviceName))
|
||||
}
|
||||
|
||||
// getFrontendRuleV1 returns the frontend rule for the specified application, using
|
||||
// its label. If service is provided, it will look for serviceName label before generic one.
|
||||
// It returns a default one (Host) if the label is not present.
|
||||
// Deprecated
|
||||
func (p *Provider) getFrontendRuleV1(application marathon.Application, serviceName string) string {
|
||||
labels := getLabelsV1(application, serviceName)
|
||||
lblFrontendRule := getLabelNameV1(serviceName, label.SuffixFrontendRule)
|
||||
if value := label.GetStringValue(labels, lblFrontendRule, ""); len(value) > 0 {
|
||||
return value
|
||||
}
|
||||
|
||||
if p.MarathonLBCompatibility {
|
||||
if value := label.GetStringValue(stringValueMap(application.Labels), labelLbCompatibility, ""); len(value) > 0 {
|
||||
return "Host:" + value
|
||||
}
|
||||
}
|
||||
|
||||
if len(serviceName) > 0 {
|
||||
return "Host:" + strings.ToLower(provider.Normalize(serviceName)) + "." + p.getSubDomain(application.ID) + "." + p.Domain
|
||||
}
|
||||
return "Host:" + p.getSubDomain(application.ID) + "." + p.Domain
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func (p *Provider) getBackendServerV1(task marathon.Task, application marathon.Application) string {
|
||||
if application.IPAddressPerTask == nil || p.ForceTaskHostname {
|
||||
return task.Host
|
||||
}
|
||||
|
||||
numTaskIPAddresses := len(task.IPAddresses)
|
||||
switch numTaskIPAddresses {
|
||||
case 0:
|
||||
log.Errorf("Missing IP address for Marathon application %s on task %s", application.ID, task.ID)
|
||||
return ""
|
||||
case 1:
|
||||
return task.IPAddresses[0].IPAddress
|
||||
default:
|
||||
ipAddressIdx := label.GetIntValue(stringValueMap(application.Labels), labelIPAddressIdx, math.MinInt32)
|
||||
|
||||
if ipAddressIdx == math.MinInt32 {
|
||||
log.Errorf("Found %d task IP addresses but missing IP address index for Marathon application %s on task %s",
|
||||
numTaskIPAddresses, application.ID, task.ID)
|
||||
return ""
|
||||
}
|
||||
if ipAddressIdx < 0 || ipAddressIdx > numTaskIPAddresses {
|
||||
log.Errorf("Cannot use IP address index to select from %d task IP addresses for Marathon application %s on task %s",
|
||||
numTaskIPAddresses, application.ID, task.ID)
|
||||
return ""
|
||||
}
|
||||
|
||||
return task.IPAddresses[ipAddressIdx].IPAddress
|
||||
}
|
||||
}
|
||||
|
||||
// getServiceNamesV1 returns a list of service names for a given application
|
||||
// An empty name "" will be added if no service specific properties exist,
|
||||
// as an indication that there are no sub-services, but only main application
|
||||
// Deprecated
|
||||
func getServiceNamesV1(application marathon.Application) []string {
|
||||
labelServiceProperties := label.ExtractServicePropertiesP(application.Labels)
|
||||
|
||||
var names []string
|
||||
for k := range labelServiceProperties {
|
||||
names = append(names, k)
|
||||
}
|
||||
|
||||
// An empty name "" will be added if no service specific properties exist,
|
||||
// as an indication that there are no sub-services, but only main application
|
||||
if len(names) == 0 {
|
||||
names = append(names, defaultService)
|
||||
}
|
||||
return names
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func identifierV1(app marathon.Application, task marathon.Task, serviceName string) string {
|
||||
id := fmt.Sprintf("Marathon task %s from application %s", task.ID, app.ID)
|
||||
if serviceName != "" {
|
||||
id += fmt.Sprintf(" (service: %s)", serviceName)
|
||||
}
|
||||
return id
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func hasLoadBalancerLabelsV1(application marathon.Application) bool {
|
||||
method := label.Has(stringValueMap(application.Labels), label.TraefikBackendLoadBalancerMethod)
|
||||
sticky := label.Has(stringValueMap(application.Labels), label.TraefikBackendLoadBalancerSticky)
|
||||
stickiness := label.Has(stringValueMap(application.Labels), label.TraefikBackendLoadBalancerStickiness)
|
||||
return method || sticky || stickiness
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func hasMaxConnLabelsV1(application marathon.Application) bool {
|
||||
mca := label.Has(stringValueMap(application.Labels), label.TraefikBackendMaxConnAmount)
|
||||
mcef := label.Has(stringValueMap(application.Labels), label.TraefikBackendMaxConnExtractorFunc)
|
||||
return mca && mcef
|
||||
}
|
||||
|
||||
// TODO: Deprecated
|
||||
// replaced by Stickiness
|
||||
// Deprecated
|
||||
func getStickyV1(application marathon.Application) bool {
|
||||
if label.Has(stringValueMap(application.Labels), label.TraefikBackendLoadBalancerSticky) {
|
||||
log.Warnf("Deprecated configuration found: %s. Please use %s.", label.TraefikBackendLoadBalancerSticky, label.TraefikBackendLoadBalancerStickiness)
|
||||
}
|
||||
return label.GetBoolValue(stringValueMap(application.Labels), label.TraefikBackendLoadBalancerSticky, false)
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func getPortV1(task marathon.Task, application marathon.Application, serviceName string) string {
|
||||
port, err := processPortsV1(application, task, serviceName)
|
||||
if err != nil {
|
||||
log.Errorf("Unable to process ports for %s: %s", identifierV1(application, task, serviceName), err)
|
||||
return ""
|
||||
}
|
||||
|
||||
return strconv.Itoa(port)
|
||||
}
|
||||
|
||||
// processPortsV1 returns the configured port.
|
||||
// An explicitly specified port is preferred. If none is specified, it selects
|
||||
// one of the available port. The first such found port is returned unless an
|
||||
// optional index is provided.
|
||||
// Deprecated
|
||||
func processPortsV1(application marathon.Application, task marathon.Task, serviceName string) (int, error) {
|
||||
labels := getLabelsV1(application, serviceName)
|
||||
lblPort := getLabelNameV1(serviceName, label.SuffixPort)
|
||||
|
||||
if label.Has(labels, lblPort) {
|
||||
port := label.GetIntValue(labels, lblPort, 0)
|
||||
|
||||
if port <= 0 {
|
||||
return 0, fmt.Errorf("explicitly specified port %d must be larger than zero", port)
|
||||
} else if port > 0 {
|
||||
return port, nil
|
||||
}
|
||||
}
|
||||
|
||||
ports := retrieveAvailablePortsV1(application, task)
|
||||
if len(ports) == 0 {
|
||||
return 0, errors.New("no port found")
|
||||
}
|
||||
|
||||
lblPortIndex := getLabelNameV1(serviceName, label.SuffixPortIndex)
|
||||
portIndex := label.GetIntValue(labels, lblPortIndex, 0)
|
||||
if portIndex < 0 || portIndex > len(ports)-1 {
|
||||
return 0, fmt.Errorf("index %d must be within range (0, %d)", portIndex, len(ports)-1)
|
||||
}
|
||||
return ports[portIndex], nil
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func retrieveAvailablePortsV1(application marathon.Application, task marathon.Task) []int {
|
||||
// Using default port configuration
|
||||
if len(task.Ports) > 0 {
|
||||
return task.Ports
|
||||
}
|
||||
|
||||
// Using port definition if available
|
||||
if application.PortDefinitions != nil && len(*application.PortDefinitions) > 0 {
|
||||
var ports []int
|
||||
for _, def := range *application.PortDefinitions {
|
||||
if def.Port != nil {
|
||||
ports = append(ports, *def.Port)
|
||||
}
|
||||
}
|
||||
return ports
|
||||
}
|
||||
// If using IP-per-task using this port definition
|
||||
if application.IPAddressPerTask != nil && len(*(application.IPAddressPerTask.Discovery).Ports) > 0 {
|
||||
var ports []int
|
||||
for _, def := range *(application.IPAddressPerTask.Discovery).Ports {
|
||||
ports = append(ports, def.Number)
|
||||
}
|
||||
return ports
|
||||
}
|
||||
|
||||
return []int{}
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func (p *Provider) getServersV1(application marathon.Application, serviceName string) map[string]types.Server {
|
||||
var servers map[string]types.Server
|
||||
|
||||
for _, task := range application.Tasks {
|
||||
host := p.getBackendServerV1(*task, application)
|
||||
if len(host) == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
if servers == nil {
|
||||
servers = make(map[string]types.Server)
|
||||
}
|
||||
|
||||
labels := getLabelsV1(application, serviceName)
|
||||
|
||||
port := getPortV1(*task, application, serviceName)
|
||||
protocol := label.GetStringValue(labels, getLabelNameV1(serviceName, label.SuffixProtocol), label.DefaultProtocol)
|
||||
|
||||
serverName := provider.Normalize("server-" + task.ID + getSegmentNameSuffix(serviceName))
|
||||
servers[serverName] = types.Server{
|
||||
URL: fmt.Sprintf("%s://%s:%v", protocol, host, port),
|
||||
Weight: label.GetIntValue(labels, getLabelNameV1(serviceName, label.SuffixWeight), label.DefaultWeightInt),
|
||||
}
|
||||
}
|
||||
|
||||
return servers
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func getWhiteListV1(application marathon.Application, serviceName string) *types.WhiteList {
|
||||
labels := getLabelsV1(application, serviceName)
|
||||
|
||||
ranges := label.GetSliceStringValue(labels, getLabelNameV1(serviceName, label.SuffixFrontendWhiteListSourceRange))
|
||||
if len(ranges) > 0 {
|
||||
return &types.WhiteList{
|
||||
SourceRange: ranges,
|
||||
UseXForwardedFor: label.GetBoolValue(labels, getLabelNameV1(serviceName, label.SuffixFrontendWhiteListUseXForwardedFor), false),
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Label functions
|
||||
|
||||
// Deprecated
|
||||
func getLabelsV1(application marathon.Application, serviceName string) map[string]string {
|
||||
if len(serviceName) > 0 {
|
||||
return label.ExtractServicePropertiesP(application.Labels)[serviceName]
|
||||
}
|
||||
|
||||
if application.Labels != nil {
|
||||
return *application.Labels
|
||||
}
|
||||
|
||||
return make(map[string]string)
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func getLabelNameV1(serviceName string, suffix string) string {
|
||||
if len(serviceName) != 0 {
|
||||
return suffix
|
||||
}
|
||||
return label.Prefix + suffix
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func hasFuncV1(labelName string) func(application marathon.Application) bool {
|
||||
return func(application marathon.Application) bool {
|
||||
return label.Has(stringValueMap(application.Labels), labelName)
|
||||
}
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func getFuncStringServiceV1(labelName string, defaultValue string) func(application marathon.Application, serviceName string) string {
|
||||
return func(application marathon.Application, serviceName string) string {
|
||||
labels := getLabelsV1(application, serviceName)
|
||||
lbName := getLabelNameV1(serviceName, labelName)
|
||||
return label.GetStringValue(labels, lbName, defaultValue)
|
||||
}
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func getFuncBoolServiceV1(labelName string, defaultValue bool) func(application marathon.Application, serviceName string) bool {
|
||||
return func(application marathon.Application, serviceName string) bool {
|
||||
labels := getLabelsV1(application, serviceName)
|
||||
lbName := getLabelNameV1(serviceName, labelName)
|
||||
return label.GetBoolValue(labels, lbName, defaultValue)
|
||||
}
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func getFuncIntServiceV1(labelName string, defaultValue int) func(application marathon.Application, serviceName string) int {
|
||||
return func(application marathon.Application, serviceName string) int {
|
||||
labels := getLabelsV1(application, serviceName)
|
||||
lbName := getLabelNameV1(serviceName, labelName)
|
||||
return label.GetIntValue(labels, lbName, defaultValue)
|
||||
}
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func getFuncSliceStringServiceV1(labelName string) func(application marathon.Application, serviceName string) []string {
|
||||
return func(application marathon.Application, serviceName string) []string {
|
||||
labels := getLabelsV1(application, serviceName)
|
||||
return label.GetSliceStringValue(labels, getLabelNameV1(serviceName, labelName))
|
||||
}
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func getFuncStringV1(labelName string, defaultValue string) func(application marathon.Application) string {
|
||||
return func(application marathon.Application) string {
|
||||
return label.GetStringValue(stringValueMap(application.Labels), labelName, defaultValue)
|
||||
}
|
||||
}
|
||||
|
||||
// Deprecated
|
||||
func getFuncInt64V1(labelName string, defaultValue int64) func(application marathon.Application) int64 {
|
||||
return func(application marathon.Application) int64 {
|
||||
return label.GetInt64Value(stringValueMap(application.Labels), labelName, defaultValue)
|
||||
}
|
||||
}
|
||||
762
provider/marathon/deprecated_config_test.go
Normal file
762
provider/marathon/deprecated_config_test.go
Normal file
|
|
@ -0,0 +1,762 @@
|
|||
package marathon
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/containous/traefik/provider/label"
|
||||
"github.com/containous/traefik/types"
|
||||
"github.com/gambol99/go-marathon"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestGetConfigurationAPIErrorsV1(t *testing.T) {
|
||||
fakeClient := newFakeClient(true, marathon.Applications{})
|
||||
|
||||
p := &Provider{
|
||||
marathonClient: fakeClient,
|
||||
}
|
||||
p.TemplateVersion = 1
|
||||
|
||||
actualConfig := p.getConfiguration()
|
||||
fakeClient.AssertExpectations(t)
|
||||
|
||||
if actualConfig != nil {
|
||||
t.Errorf("configuration should have been nil, got %v", actualConfig)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildConfigurationV1(t *testing.T) {
|
||||
testCases := []struct {
|
||||
desc string
|
||||
application marathon.Application
|
||||
expectedFrontends map[string]*types.Frontend
|
||||
expectedBackends map[string]*types.Backend
|
||||
}{
|
||||
{
|
||||
desc: "simple application",
|
||||
application: application(
|
||||
appPorts(80),
|
||||
withTasks(localhostTask(taskPorts(80))),
|
||||
),
|
||||
expectedFrontends: map[string]*types.Frontend{
|
||||
"frontend-app": {
|
||||
Backend: "backend-app",
|
||||
Routes: map[string]types.Route{
|
||||
"route-host-app": {
|
||||
Rule: "Host:app.marathon.localhost",
|
||||
},
|
||||
},
|
||||
PassHostHeader: true,
|
||||
BasicAuth: []string{},
|
||||
EntryPoints: []string{},
|
||||
},
|
||||
},
|
||||
expectedBackends: map[string]*types.Backend{
|
||||
"backend-app": {
|
||||
Servers: map[string]types.Server{
|
||||
"server-task": {
|
||||
URL: "http://localhost:80",
|
||||
Weight: 0,
|
||||
},
|
||||
},
|
||||
CircuitBreaker: nil,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "filtered task",
|
||||
application: application(
|
||||
appPorts(80),
|
||||
withTasks(localhostTask(taskPorts(80), state(taskStateStaging))),
|
||||
),
|
||||
expectedFrontends: map[string]*types.Frontend{
|
||||
"frontend-app": {
|
||||
Backend: "backend-app",
|
||||
Routes: map[string]types.Route{
|
||||
"route-host-app": {
|
||||
Rule: "Host:app.marathon.localhost",
|
||||
},
|
||||
},
|
||||
PassHostHeader: true,
|
||||
BasicAuth: []string{},
|
||||
EntryPoints: []string{},
|
||||
},
|
||||
},
|
||||
expectedBackends: map[string]*types.Backend{
|
||||
"backend-app": {},
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "max connection extractor function label only",
|
||||
application: application(
|
||||
appPorts(80),
|
||||
withTasks(localhostTask(taskPorts(80))),
|
||||
|
||||
withLabel(label.TraefikBackendMaxConnExtractorFunc, "client.ip"),
|
||||
),
|
||||
expectedFrontends: map[string]*types.Frontend{
|
||||
"frontend-app": {
|
||||
Backend: "backend-app",
|
||||
Routes: map[string]types.Route{
|
||||
"route-host-app": {
|
||||
Rule: "Host:app.marathon.localhost",
|
||||
},
|
||||
},
|
||||
PassHostHeader: true,
|
||||
BasicAuth: []string{},
|
||||
EntryPoints: []string{},
|
||||
},
|
||||
},
|
||||
expectedBackends: map[string]*types.Backend{
|
||||
"backend-app": {
|
||||
Servers: map[string]types.Server{
|
||||
"server-task": {
|
||||
URL: "http://localhost:80",
|
||||
Weight: 0,
|
||||
},
|
||||
},
|
||||
MaxConn: nil,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "multiple ports",
|
||||
application: application(
|
||||
appPorts(80, 81),
|
||||
withTasks(localhostTask(taskPorts(80, 81))),
|
||||
),
|
||||
expectedFrontends: map[string]*types.Frontend{
|
||||
"frontend-app": {
|
||||
Backend: "backend-app",
|
||||
Routes: map[string]types.Route{
|
||||
"route-host-app": {
|
||||
Rule: "Host:app.marathon.localhost",
|
||||
},
|
||||
},
|
||||
PassHostHeader: true,
|
||||
BasicAuth: []string{},
|
||||
EntryPoints: []string{},
|
||||
},
|
||||
},
|
||||
expectedBackends: map[string]*types.Backend{
|
||||
"backend-app": {
|
||||
Servers: map[string]types.Server{
|
||||
"server-task": {
|
||||
URL: "http://localhost:80",
|
||||
Weight: 0,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "with all labels",
|
||||
application: application(
|
||||
appPorts(80),
|
||||
withTasks(task(host("127.0.0.1"), taskPorts(80))),
|
||||
|
||||
withLabel(label.TraefikPort, "666"),
|
||||
withLabel(label.TraefikProtocol, "https"),
|
||||
withLabel(label.TraefikWeight, "12"),
|
||||
|
||||
withLabel(label.TraefikBackend, "foobar"),
|
||||
|
||||
withLabel(label.TraefikBackendCircuitBreakerExpression, "NetworkErrorRatio() > 0.5"),
|
||||
withLabel(label.TraefikBackendHealthCheckPath, "/health"),
|
||||
withLabel(label.TraefikBackendHealthCheckInterval, "6"),
|
||||
withLabel(label.TraefikBackendLoadBalancerMethod, "drr"),
|
||||
withLabel(label.TraefikBackendLoadBalancerSticky, "true"),
|
||||
withLabel(label.TraefikBackendLoadBalancerStickiness, "true"),
|
||||
withLabel(label.TraefikBackendLoadBalancerStickinessCookieName, "chocolate"),
|
||||
withLabel(label.TraefikBackendMaxConnAmount, "666"),
|
||||
withLabel(label.TraefikBackendMaxConnExtractorFunc, "client.ip"),
|
||||
|
||||
withLabel(label.TraefikFrontendAuthBasic, "test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/,test2:$apr1$d9hr9HBB$4HxwgUir3HP4EsggP/QNo0"),
|
||||
withLabel(label.TraefikFrontendEntryPoints, "http,https"),
|
||||
withLabel(label.TraefikFrontendPassHostHeader, "true"),
|
||||
withLabel(label.TraefikFrontendPriority, "666"),
|
||||
withLabel(label.TraefikFrontendRule, "Host:traefik.io"),
|
||||
),
|
||||
expectedFrontends: map[string]*types.Frontend{
|
||||
"frontend-app": {
|
||||
EntryPoints: []string{
|
||||
"http",
|
||||
"https",
|
||||
},
|
||||
Backend: "backendfoobar",
|
||||
Routes: map[string]types.Route{
|
||||
"route-host-app": {
|
||||
Rule: "Host:traefik.io",
|
||||
},
|
||||
},
|
||||
PassHostHeader: true,
|
||||
Priority: 666,
|
||||
BasicAuth: []string{
|
||||
"test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/",
|
||||
"test2:$apr1$d9hr9HBB$4HxwgUir3HP4EsggP/QNo0",
|
||||
},
|
||||
},
|
||||
},
|
||||
expectedBackends: map[string]*types.Backend{
|
||||
"backendfoobar": {
|
||||
Servers: map[string]types.Server{
|
||||
"server-task": {
|
||||
URL: "https://127.0.0.1:666",
|
||||
Weight: 12,
|
||||
},
|
||||
},
|
||||
CircuitBreaker: &types.CircuitBreaker{
|
||||
Expression: "NetworkErrorRatio() > 0.5",
|
||||
},
|
||||
LoadBalancer: &types.LoadBalancer{
|
||||
Method: "drr",
|
||||
Sticky: true,
|
||||
Stickiness: &types.Stickiness{
|
||||
CookieName: "chocolate",
|
||||
},
|
||||
},
|
||||
MaxConn: &types.MaxConn{
|
||||
Amount: 666,
|
||||
ExtractorFunc: "client.ip",
|
||||
},
|
||||
HealthCheck: &types.HealthCheck{
|
||||
Path: "/health",
|
||||
Interval: "6",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range testCases {
|
||||
test := test
|
||||
t.Run(test.desc, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
test.application.ID = "/app"
|
||||
|
||||
for _, task := range test.application.Tasks {
|
||||
task.ID = "task"
|
||||
if task.State == "" {
|
||||
task.State = "TASK_RUNNING"
|
||||
}
|
||||
}
|
||||
|
||||
p := &Provider{
|
||||
Domain: "marathon.localhost",
|
||||
ExposedByDefault: true,
|
||||
}
|
||||
|
||||
actualConfig := p.buildConfigurationV1(withApplications(test.application))
|
||||
|
||||
assert.NotNil(t, actualConfig)
|
||||
assert.Equal(t, test.expectedBackends, actualConfig.Backends)
|
||||
assert.Equal(t, test.expectedFrontends, actualConfig.Frontends)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildConfigurationServicesV1(t *testing.T) {
|
||||
testCases := []struct {
|
||||
desc string
|
||||
application marathon.Application
|
||||
expectedFrontends map[string]*types.Frontend
|
||||
expectedBackends map[string]*types.Backend
|
||||
}{
|
||||
{
|
||||
desc: "multiple ports with services",
|
||||
application: application(
|
||||
appPorts(80, 81),
|
||||
withTasks(localhostTask(taskPorts(80, 81))),
|
||||
|
||||
withLabel(label.TraefikBackendMaxConnAmount, "1000"),
|
||||
withLabel(label.TraefikBackendMaxConnExtractorFunc, "client.ip"),
|
||||
withServiceLabel(label.TraefikPort, "80", "web"),
|
||||
withServiceLabel(label.TraefikPort, "81", "admin"),
|
||||
withLabel("traefik..port", "82"), // This should be ignored, as it fails to match the servicesPropertiesRegexp regex.
|
||||
withServiceLabel(label.TraefikFrontendRule, "Host:web.app.marathon.localhost", "web"),
|
||||
withServiceLabel(label.TraefikFrontendRule, "Host:admin.app.marathon.localhost", "admin"),
|
||||
),
|
||||
expectedFrontends: map[string]*types.Frontend{
|
||||
"frontend-app-service-web": {
|
||||
Backend: "backend-app-service-web",
|
||||
Routes: map[string]types.Route{
|
||||
`route-host-app-service-web`: {
|
||||
Rule: "Host:web.app.marathon.localhost",
|
||||
},
|
||||
},
|
||||
PassHostHeader: true,
|
||||
BasicAuth: []string{},
|
||||
EntryPoints: []string{},
|
||||
},
|
||||
"frontend-app-service-admin": {
|
||||
Backend: "backend-app-service-admin",
|
||||
Routes: map[string]types.Route{
|
||||
`route-host-app-service-admin`: {
|
||||
Rule: "Host:admin.app.marathon.localhost",
|
||||
},
|
||||
},
|
||||
PassHostHeader: true,
|
||||
BasicAuth: []string{},
|
||||
EntryPoints: []string{},
|
||||
},
|
||||
},
|
||||
expectedBackends: map[string]*types.Backend{
|
||||
"backend-app-service-web": {
|
||||
Servers: map[string]types.Server{
|
||||
"server-task-service-web": {
|
||||
URL: "http://localhost:80",
|
||||
Weight: 0,
|
||||
},
|
||||
},
|
||||
MaxConn: &types.MaxConn{
|
||||
Amount: 1000,
|
||||
ExtractorFunc: "client.ip",
|
||||
},
|
||||
},
|
||||
"backend-app-service-admin": {
|
||||
Servers: map[string]types.Server{
|
||||
"server-task-service-admin": {
|
||||
URL: "http://localhost:81",
|
||||
Weight: 0,
|
||||
},
|
||||
},
|
||||
MaxConn: &types.MaxConn{
|
||||
Amount: 1000,
|
||||
ExtractorFunc: "client.ip",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "when all labels are set",
|
||||
application: application(
|
||||
appPorts(80, 81),
|
||||
withTasks(localhostTask(taskPorts(80, 81))),
|
||||
|
||||
withLabel(label.TraefikBackendCircuitBreakerExpression, "NetworkErrorRatio() > 0.5"),
|
||||
withLabel(label.TraefikBackendHealthCheckPath, "/health"),
|
||||
withLabel(label.TraefikBackendHealthCheckInterval, "6"),
|
||||
withLabel(label.TraefikBackendLoadBalancerMethod, "drr"),
|
||||
withLabel(label.TraefikBackendLoadBalancerSticky, "true"),
|
||||
withLabel(label.TraefikBackendLoadBalancerStickiness, "true"),
|
||||
withLabel(label.TraefikBackendLoadBalancerStickinessCookieName, "chocolate"),
|
||||
withLabel(label.TraefikBackendMaxConnAmount, "666"),
|
||||
withLabel(label.TraefikBackendMaxConnExtractorFunc, "client.ip"),
|
||||
|
||||
withServiceLabel(label.TraefikPort, "80", "containous"),
|
||||
withServiceLabel(label.TraefikProtocol, "https", "containous"),
|
||||
withServiceLabel(label.TraefikWeight, "12", "containous"),
|
||||
|
||||
withServiceLabel(label.TraefikFrontendAuthBasic, "test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/,test2:$apr1$d9hr9HBB$4HxwgUir3HP4EsggP/QNo0", "containous"),
|
||||
withServiceLabel(label.TraefikFrontendEntryPoints, "http,https", "containous"),
|
||||
withServiceLabel(label.TraefikFrontendPassHostHeader, "true", "containous"),
|
||||
withServiceLabel(label.TraefikFrontendPriority, "666", "containous"),
|
||||
withServiceLabel(label.TraefikFrontendRule, "Host:traefik.io", "containous"),
|
||||
),
|
||||
expectedFrontends: map[string]*types.Frontend{
|
||||
"frontend-app-service-containous": {
|
||||
EntryPoints: []string{
|
||||
"http",
|
||||
"https",
|
||||
},
|
||||
Backend: "backend-app-service-containous",
|
||||
Routes: map[string]types.Route{
|
||||
"route-host-app-service-containous": {
|
||||
Rule: "Host:traefik.io",
|
||||
},
|
||||
},
|
||||
PassHostHeader: true,
|
||||
Priority: 666,
|
||||
BasicAuth: []string{
|
||||
"test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/",
|
||||
"test2:$apr1$d9hr9HBB$4HxwgUir3HP4EsggP/QNo0",
|
||||
},
|
||||
},
|
||||
},
|
||||
expectedBackends: map[string]*types.Backend{
|
||||
"backend-app-service-containous": {
|
||||
Servers: map[string]types.Server{
|
||||
"server-task-service-containous": {
|
||||
URL: "https://localhost:80",
|
||||
Weight: 12,
|
||||
},
|
||||
},
|
||||
CircuitBreaker: &types.CircuitBreaker{
|
||||
Expression: "NetworkErrorRatio() > 0.5",
|
||||
},
|
||||
LoadBalancer: &types.LoadBalancer{
|
||||
Method: "drr",
|
||||
Sticky: true,
|
||||
Stickiness: &types.Stickiness{
|
||||
CookieName: "chocolate",
|
||||
},
|
||||
},
|
||||
MaxConn: &types.MaxConn{
|
||||
Amount: 666,
|
||||
ExtractorFunc: "client.ip",
|
||||
},
|
||||
HealthCheck: &types.HealthCheck{
|
||||
Path: "/health",
|
||||
Interval: "6",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range testCases {
|
||||
test := test
|
||||
t.Run(test.desc, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
test.application.ID = "/app"
|
||||
|
||||
for _, task := range test.application.Tasks {
|
||||
task.ID = "task"
|
||||
if task.State == "" {
|
||||
task.State = "TASK_RUNNING"
|
||||
}
|
||||
}
|
||||
|
||||
p := &Provider{
|
||||
Domain: "marathon.localhost",
|
||||
ExposedByDefault: true,
|
||||
}
|
||||
|
||||
actualConfig := p.buildConfigurationV1(withApplications(test.application))
|
||||
|
||||
assert.NotNil(t, actualConfig)
|
||||
assert.Equal(t, test.expectedBackends, actualConfig.Backends)
|
||||
assert.Equal(t, test.expectedFrontends, actualConfig.Frontends)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetPortV1(t *testing.T) {
|
||||
testCases := []struct {
|
||||
desc string
|
||||
application marathon.Application
|
||||
task marathon.Task
|
||||
serviceName string
|
||||
expected string
|
||||
}{
|
||||
{
|
||||
desc: "port missing",
|
||||
application: application(),
|
||||
task: task(),
|
||||
expected: "",
|
||||
},
|
||||
{
|
||||
desc: "numeric port",
|
||||
application: application(withLabel(label.TraefikPort, "80")),
|
||||
task: task(),
|
||||
expected: "80",
|
||||
},
|
||||
{
|
||||
desc: "string port",
|
||||
application: application(withLabel(label.TraefikPort, "foobar")),
|
||||
task: task(taskPorts(80)),
|
||||
expected: "",
|
||||
},
|
||||
{
|
||||
desc: "negative port",
|
||||
application: application(withLabel(label.TraefikPort, "-1")),
|
||||
task: task(taskPorts(80)),
|
||||
expected: "",
|
||||
},
|
||||
{
|
||||
desc: "task port available",
|
||||
application: application(),
|
||||
task: task(taskPorts(80)),
|
||||
expected: "80",
|
||||
},
|
||||
{
|
||||
desc: "port definition available",
|
||||
application: application(
|
||||
portDefinition(443),
|
||||
),
|
||||
task: task(),
|
||||
expected: "443",
|
||||
},
|
||||
{
|
||||
desc: "IP-per-task port available",
|
||||
application: application(ipAddrPerTask(8000)),
|
||||
task: task(),
|
||||
expected: "8000",
|
||||
},
|
||||
{
|
||||
desc: "multiple task ports available",
|
||||
application: application(),
|
||||
task: task(taskPorts(80, 443)),
|
||||
expected: "80",
|
||||
},
|
||||
{
|
||||
desc: "numeric port index specified",
|
||||
application: application(withLabel(label.TraefikPortIndex, "1")),
|
||||
task: task(taskPorts(80, 443)),
|
||||
expected: "443",
|
||||
},
|
||||
{
|
||||
desc: "string port index specified",
|
||||
application: application(withLabel(label.TraefikPortIndex, "foobar")),
|
||||
task: task(taskPorts(80)),
|
||||
expected: "80",
|
||||
},
|
||||
{
|
||||
desc: "port and port index specified",
|
||||
application: application(
|
||||
withLabel(label.TraefikPort, "80"),
|
||||
withLabel(label.TraefikPortIndex, "1"),
|
||||
),
|
||||
task: task(taskPorts(80, 443)),
|
||||
expected: "80",
|
||||
},
|
||||
{
|
||||
desc: "task and application ports specified",
|
||||
application: application(appPorts(9999)),
|
||||
task: task(taskPorts(7777)),
|
||||
expected: "7777",
|
||||
},
|
||||
{
|
||||
desc: "multiple task ports with service index available",
|
||||
application: application(withLabel(label.Prefix+"http.portIndex", "0")),
|
||||
task: task(taskPorts(80, 443)),
|
||||
serviceName: "http",
|
||||
expected: "80",
|
||||
},
|
||||
{
|
||||
desc: "multiple task ports with service port available",
|
||||
application: application(withLabel(label.Prefix+"https.port", "443")),
|
||||
task: task(taskPorts(80, 443)),
|
||||
serviceName: "https",
|
||||
expected: "443",
|
||||
},
|
||||
{
|
||||
desc: "multiple task ports with services but default port available",
|
||||
application: application(withLabel(label.Prefix+"http.weight", "100")),
|
||||
task: task(taskPorts(80, 443)),
|
||||
serviceName: "http",
|
||||
expected: "80",
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range testCases {
|
||||
test := test
|
||||
t.Run(test.desc, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
actual := getPortV1(test.task, test.application, test.serviceName)
|
||||
|
||||
assert.Equal(t, test.expected, actual)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetFrontendRuleV1(t *testing.T) {
|
||||
testCases := []struct {
|
||||
desc string
|
||||
application marathon.Application
|
||||
serviceName string
|
||||
expected string
|
||||
marathonLBCompatibility bool
|
||||
}{
|
||||
{
|
||||
desc: "label missing",
|
||||
application: application(appID("test")),
|
||||
marathonLBCompatibility: true,
|
||||
expected: "Host:test.marathon.localhost",
|
||||
},
|
||||
{
|
||||
desc: "HAProxy vhost available and LB compat disabled",
|
||||
application: application(
|
||||
appID("test"),
|
||||
withLabel("HAPROXY_0_VHOST", "foo.bar"),
|
||||
),
|
||||
marathonLBCompatibility: false,
|
||||
expected: "Host:test.marathon.localhost",
|
||||
},
|
||||
{
|
||||
desc: "HAProxy vhost available and LB compat enabled",
|
||||
application: application(withLabel("HAPROXY_0_VHOST", "foo.bar")),
|
||||
marathonLBCompatibility: true,
|
||||
expected: "Host:foo.bar",
|
||||
},
|
||||
{
|
||||
desc: "frontend rule available",
|
||||
|
||||
application: application(
|
||||
withLabel(label.TraefikFrontendRule, "Host:foo.bar"),
|
||||
withLabel("HAPROXY_0_VHOST", "unused"),
|
||||
),
|
||||
marathonLBCompatibility: true,
|
||||
expected: "Host:foo.bar",
|
||||
},
|
||||
{
|
||||
desc: "service label existing",
|
||||
application: application(withServiceLabel(label.TraefikFrontendRule, "Host:foo.bar", "app")),
|
||||
serviceName: "app",
|
||||
marathonLBCompatibility: true,
|
||||
expected: "Host:foo.bar",
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range testCases {
|
||||
test := test
|
||||
t.Run(test.desc, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
p := &Provider{
|
||||
Domain: "marathon.localhost",
|
||||
MarathonLBCompatibility: test.marathonLBCompatibility,
|
||||
}
|
||||
|
||||
actual := p.getFrontendRuleV1(test.application, test.serviceName)
|
||||
|
||||
assert.Equal(t, test.expected, actual)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetBackendV1(t *testing.T) {
|
||||
testCases := []struct {
|
||||
desc string
|
||||
application marathon.Application
|
||||
serviceName string
|
||||
expected string
|
||||
}{
|
||||
{
|
||||
desc: "label missing",
|
||||
application: application(appID("/group/app")),
|
||||
expected: "backend-group-app",
|
||||
},
|
||||
{
|
||||
desc: "label existing",
|
||||
application: application(withLabel(label.TraefikBackend, "bar")),
|
||||
expected: "backendbar",
|
||||
},
|
||||
{
|
||||
desc: "service label existing",
|
||||
application: application(withServiceLabel(label.TraefikBackend, "bar", "app")),
|
||||
serviceName: "app",
|
||||
expected: "backendbar",
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range testCases {
|
||||
test := test
|
||||
t.Run(test.desc, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
p := &Provider{}
|
||||
|
||||
actual := p.getBackendNameV1(test.application, test.serviceName)
|
||||
|
||||
assert.Equal(t, test.expected, actual)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetBackendServerV1(t *testing.T) {
|
||||
host := "host"
|
||||
testCases := []struct {
|
||||
desc string
|
||||
application marathon.Application
|
||||
task marathon.Task
|
||||
forceTaskHostname bool
|
||||
expectedServer string
|
||||
}{
|
||||
{
|
||||
desc: "application without IP-per-task",
|
||||
application: application(),
|
||||
expectedServer: host,
|
||||
},
|
||||
{
|
||||
desc: "task hostname override",
|
||||
application: application(ipAddrPerTask(8000)),
|
||||
forceTaskHostname: true,
|
||||
expectedServer: host,
|
||||
},
|
||||
{
|
||||
desc: "task IP address missing",
|
||||
application: application(ipAddrPerTask(8000)),
|
||||
task: task(),
|
||||
expectedServer: "",
|
||||
},
|
||||
{
|
||||
desc: "single task IP address",
|
||||
application: application(ipAddrPerTask(8000)),
|
||||
task: task(ipAddresses("1.1.1.1")),
|
||||
expectedServer: "1.1.1.1",
|
||||
},
|
||||
{
|
||||
desc: "multiple task IP addresses without index label",
|
||||
application: application(ipAddrPerTask(8000)),
|
||||
task: task(ipAddresses("1.1.1.1", "2.2.2.2")),
|
||||
expectedServer: "",
|
||||
},
|
||||
{
|
||||
desc: "multiple task IP addresses with invalid index label",
|
||||
application: application(
|
||||
withLabel("traefik.ipAddressIdx", "invalid"),
|
||||
ipAddrPerTask(8000),
|
||||
),
|
||||
task: task(ipAddresses("1.1.1.1", "2.2.2.2")),
|
||||
expectedServer: "",
|
||||
},
|
||||
{
|
||||
desc: "multiple task IP addresses with valid index label",
|
||||
application: application(
|
||||
withLabel("traefik.ipAddressIdx", "1"),
|
||||
ipAddrPerTask(8000),
|
||||
),
|
||||
task: task(ipAddresses("1.1.1.1", "2.2.2.2")),
|
||||
expectedServer: "2.2.2.2",
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range testCases {
|
||||
test := test
|
||||
t.Run(test.desc, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
p := &Provider{ForceTaskHostname: test.forceTaskHostname}
|
||||
test.task.Host = host
|
||||
|
||||
actualServer := p.getBackendServerV1(test.task, test.application)
|
||||
|
||||
assert.Equal(t, test.expectedServer, actualServer)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetStickyV1(t *testing.T) {
|
||||
testCases := []struct {
|
||||
desc string
|
||||
application marathon.Application
|
||||
expected bool
|
||||
}{
|
||||
{
|
||||
desc: "label missing",
|
||||
application: application(),
|
||||
expected: false,
|
||||
},
|
||||
{
|
||||
desc: "label existing",
|
||||
application: application(withLabel(label.TraefikBackendLoadBalancerSticky, "true")),
|
||||
expected: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range testCases {
|
||||
test := test
|
||||
t.Run(test.desc, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
actual := getStickyV1(test.application)
|
||||
if actual != test.expected {
|
||||
t.Errorf("actual %v, expected %v", actual, test.expected)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
24
provider/marathon/fake_client_test.go
Normal file
24
provider/marathon/fake_client_test.go
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
package marathon
|
||||
|
||||
import (
|
||||
"errors"
|
||||
|
||||
"github.com/containous/traefik/provider/marathon/mocks"
|
||||
"github.com/gambol99/go-marathon"
|
||||
"github.com/stretchr/testify/mock"
|
||||
)
|
||||
|
||||
type fakeClient struct {
|
||||
mocks.Marathon
|
||||
}
|
||||
|
||||
func newFakeClient(applicationsError bool, applications marathon.Applications) *fakeClient {
|
||||
// create an instance of our test object
|
||||
fakeClient := new(fakeClient)
|
||||
if applicationsError {
|
||||
fakeClient.On("Applications", mock.Anything).Return(nil, errors.New("fake Marathon server error"))
|
||||
} else {
|
||||
fakeClient.On("Applications", mock.Anything).Return(&applications, nil)
|
||||
}
|
||||
return fakeClient
|
||||
}
|
||||
|
|
@ -3,6 +3,7 @@ package marathon
|
|||
import (
|
||||
"net"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"time"
|
||||
|
||||
"github.com/cenk/backoff"
|
||||
|
|
@ -128,7 +129,8 @@ func (p *Provider) Provide(configurationChan chan<- types.ConfigMessage, pool *s
|
|||
return
|
||||
case event := <-update:
|
||||
log.Debugf("Received provider event %s", event)
|
||||
configuration := p.buildConfiguration()
|
||||
|
||||
configuration := p.getConfiguration()
|
||||
if configuration != nil {
|
||||
configurationChan <- types.ConfigMessage{
|
||||
ProviderName: "marathon",
|
||||
|
|
@ -139,7 +141,8 @@ func (p *Provider) Provide(configurationChan chan<- types.ConfigMessage, pool *s
|
|||
}
|
||||
})
|
||||
}
|
||||
configuration := p.buildConfiguration()
|
||||
|
||||
configuration := p.getConfiguration()
|
||||
configurationChan <- types.ConfigMessage{
|
||||
ProviderName: "marathon",
|
||||
Configuration: configuration,
|
||||
|
|
@ -156,3 +159,22 @@ func (p *Provider) Provide(configurationChan chan<- types.ConfigMessage, pool *s
|
|||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (p *Provider) getConfiguration() *types.Configuration {
|
||||
applications, err := p.getApplications()
|
||||
if err != nil {
|
||||
log.Errorf("Failed to retrieve Marathon applications: %v", err)
|
||||
return nil
|
||||
}
|
||||
|
||||
return p.buildConfiguration(applications)
|
||||
}
|
||||
|
||||
func (p *Provider) getApplications() (*marathon.Applications, error) {
|
||||
v := url.Values{}
|
||||
v.Add("embed", "apps.tasks")
|
||||
v.Add("embed", "apps.deployments")
|
||||
v.Add("embed", "apps.readiness")
|
||||
|
||||
return p.marathonClient.Applications(v)
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue