Segments Labels: Rancher & Marathon

2018-03-26 15:32:04 +02:00 · 2018-03-26 15:32:04 +02:00 · 0ea007b26f
commit 0ea007b26f
parent 16bb9b6836
31 changed files with 4288 additions and 3656 deletions
--- a/provider/marathon/deprecated_config.go
+++ b/provider/marathon/deprecated_config.go
@ -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)
+	}
+}