refactor(marathon): rewrite configuration system.

autogen/gentemplates/gen.go

@@ -589,7 +589,7 @@ var _templatesMarathonTmpl = []byte(`{{$apps := .Applications}}
 {{range $app := $apps}}
 {{range $task := $app.Tasks}}
 {{range $serviceIndex, $serviceName := getServiceNames $app}}
-    [backends."backend{{getBackend $app $serviceName}}".servers."server-{{$task.ID | replace "." "-"}}{{getServiceNameSuffix $serviceName }}"]
+    [backends."{{getBackend $app $serviceName}}".servers."server-{{$task.ID | replace "." "-"}}{{getServiceNameSuffix $serviceName }}"]
     url = "{{getProtocol $app $serviceName}}://{{getBackendServer $task $app}}:{{getPort $task $app $serviceName}}"
     weight = {{getWeight $app $serviceName}}
 {{end}}
@@ -598,27 +598,27 @@ var _templatesMarathonTmpl = []byte(`{{$apps := .Applications}}
 
 {{range $app := $apps}}
 {{range $serviceIndex, $serviceName := getServiceNames $app}}
-[backends."backend{{getBackend $app $serviceName }}"]
+[backends."{{getBackend $app $serviceName }}"]
 {{ if hasMaxConnLabels $app }}
-      [backends."backend{{getBackend $app $serviceName }}".maxconn]
+      [backends."{{getBackend $app $serviceName }}".maxconn]
         amount = {{getMaxConnAmount $app }}
         extractorfunc = "{{getMaxConnExtractorFunc $app }}"
 {{end}}
 {{ if hasLoadBalancerLabels $app }}
-      [backends."backend{{getBackend $app $serviceName }}".loadbalancer]
+      [backends."{{getBackend $app $serviceName }}".loadbalancer]
         method = "{{getLoadBalancerMethod $app }}"
         sticky = {{getSticky $app}}
         {{if hasStickinessLabel $app}}
-        [backends."backend{{getBackend $app $serviceName }}".loadbalancer.stickiness]
+        [backends."{{getBackend $app $serviceName }}".loadbalancer.stickiness]
           cookieName = "{{getStickinessCookieName $app}}"
         {{end}}
 {{end}}
 {{ if hasCircuitBreakerLabels $app }}
-      [backends."backend{{getBackend $app $serviceName }}".circuitbreaker]
+      [backends."{{getBackend $app $serviceName }}".circuitbreaker]
         expression = "{{getCircuitBreakerExpression $app }}"
 {{end}}
 {{ if hasHealthCheckLabels $app }}
-      [backends."backend{{getBackend $app $serviceName }}".healthcheck]
+      [backends."{{getBackend $app $serviceName }}".healthcheck]
         path = "{{getHealthCheckPath $app }}"
         interval = "{{getHealthCheckInterval $app }}"
 {{end}}
@@ -627,7 +627,7 @@ var _templatesMarathonTmpl = []byte(`{{$apps := .Applications}}
 
 [frontends]{{range $app := $apps}}{{range $serviceIndex, $serviceName := getServiceNames .}}
   [frontends."{{ getFrontendName $app $serviceName }}"]
-  backend = "backend{{getBackend $app $serviceName}}"
+  backend = "{{getBackend $app $serviceName}}"
   passHostHeader = {{getPassHostHeader $app $serviceName}}
   priority = {{getPriority $app $serviceName}}
   entryPoints = [{{range getEntryPoints $app $serviceName}}

integration/marathon_test.go

@@ -7,7 +7,7 @@ import (
 	"time"
 
 	"github.com/containous/traefik/integration/try"
-	"github.com/containous/traefik/types"
+	"github.com/containous/traefik/provider/label"
 	marathon "github.com/gambol99/go-marathon"
 	"github.com/go-check/check"
 	checker "github.com/vdemeester/shakers"
@@ -109,7 +109,7 @@ func (s *MarathonSuite) TestConfigurationUpdate(c *check.C) {
 		Name("/whoami").
 		CPU(0.1).
 		Memory(32).
-		AddLabel(types.LabelFrontendRule, "PathPrefix:/service")
+		AddLabel(label.TraefikFrontendRule, "PathPrefix:/service")
 	app.Container.Docker.Bridged().
 		Expose(80).
 		Container("emilevauge/whoami")
@@ -126,7 +126,7 @@ func (s *MarathonSuite) TestConfigurationUpdate(c *check.C) {
 		Name("/whoami").
 		CPU(0.1).
 		Memory(32).
-		AddLabel(types.ServiceLabel(types.LabelFrontendRule, "app"), "PathPrefix:/app")
+		AddLabel(label.GetServiceLabel(label.TraefikFrontendRule, "app"), "PathPrefix:/app")
 	app.Container.Docker.Bridged().
 		Expose(80).
 		Container("emilevauge/whoami")

provider/marathon/builder_test.go

@@ -4,11 +4,11 @@ import (
 	"strings"
 	"time"
 
-	"github.com/containous/traefik/types"
+	"github.com/containous/traefik/provider/label"
 	"github.com/gambol99/go-marathon"
 )
 
-const testTaskName string = "taskID"
+const testTaskName = "taskID"
 
 // Functions related to building applications.
 
@@ -38,7 +38,7 @@ func appPorts(ports ...int) func(*marathon.Application) {
 	}
 }
 
-func label(key, value string) func(*marathon.Application) {
+func withLabel(key, value string) func(*marathon.Application) {
 	return func(app *marathon.Application) {
 		app.AddLabel(key, value)
 	}
@@ -55,9 +55,9 @@ func labelWithService(key, value string, serviceName string) func(*marathon.Appl
 		panic("serviceName can not be empty")
 	}
 
-	property := strings.TrimPrefix(key, types.LabelPrefix)
+	property := strings.TrimPrefix(key, label.Prefix)
 	return func(app *marathon.Application) {
-		app.AddLabel(types.LabelPrefix+serviceName+"."+property, value)
+		app.AddLabel(label.Prefix+serviceName+"."+property, value)
 	}
 }
 

provider/marathon/config.go

@@ -0,0 +1,416 @@
+package marathon
+
+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"
+	"github.com/containous/traefik/types"
+	"github.com/gambol99/go-marathon"
+)
+
+func (p *Provider) buildConfiguration() *types.Configuration {
+	var MarathonFuncMap = template.FuncMap{
+		"getBackend":                  p.getBackend,
+		"getBackendServer":            p.getBackendServer,
+		"getPort":                     getPort,
+		"getWeight":                   getFuncStringService(label.TraefikWeight, label.DefaultWeight),
+		"getDomain":                   getFuncStringService(label.TraefikDomain, p.Domain), // FIXME DEAD?
+		"getSubDomain":                p.getSubDomain,                                      // FIXME DEAD ?
+		"getProtocol":                 getFuncStringService(label.TraefikProtocol, label.DefaultProtocol),
+		"getPassHostHeader":           getFuncStringService(label.TraefikFrontendPassHostHeader, label.DefaultPassHostHeader),
+		"getPriority":                 getFuncStringService(label.TraefikFrontendPriority, label.DefaultFrontendPriority),
+		"getEntryPoints":              getFuncSliceStringService(label.TraefikFrontendEntryPoints),
+		"getFrontendRule":             p.getFrontendRule,
+		"getFrontendName":             p.getFrontendName,
+		"hasCircuitBreakerLabels":     hasFunc(label.TraefikBackendCircuitBreakerExpression),
+		"hasLoadBalancerLabels":       hasLoadBalancerLabels,
+		"hasMaxConnLabels":            hasMaxConnLabels,
+		"getMaxConnExtractorFunc":     getFuncString(label.TraefikBackendMaxConnExtractorFunc, label.DefaultBackendMaxconnExtractorFunc),
+		"getMaxConnAmount":            getFuncInt64(label.TraefikBackendMaxConnAmount, math.MaxInt64),
+		"getLoadBalancerMethod":       getFuncString(label.TraefikBackendLoadBalancerMethod, label.DefaultBackendLoadBalancerMethod),
+		"getCircuitBreakerExpression": getFuncString(label.TraefikBackendCircuitBreakerExpression, label.DefaultCircuitBreakerExpression),
+		"getSticky":                   getSticky,
+		"hasStickinessLabel":          hasFunc(label.TraefikBackendLoadBalancerStickiness),
+		"getStickinessCookieName":     getFuncString(label.TraefikBackendLoadBalancerStickinessCookieName, ""),
+		"hasHealthCheckLabels":        hasFunc(label.TraefikBackendHealthCheckPath),
+		"getHealthCheckPath":          getFuncString(label.TraefikBackendHealthCheckPath, ""),
+		"getHealthCheckInterval":      getFuncString(label.TraefikBackendHealthCheckInterval, ""),
+		"getBasicAuth":                getFuncSliceStringService(label.TraefikFrontendAuthBasic),
+		"getServiceNames":             getServiceNames,
+		"getServiceNameSuffix":        getServiceNameSuffix,
+	}
+
+	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)
+			}
+			return filtered
+		}, app.Tasks).([]*marathon.Task)
+	}
+
+	templateObjects := struct {
+		Applications []marathon.Application
+		Domain       string // FIXME DEAD ?
+	}{
+		Applications: filteredApps,
+		Domain:       p.Domain, // FIXME DEAD ?
+	}
+
+	configuration, err := p.GetConfiguration("templates/marathon.tmpl", MarathonFuncMap, templateObjects)
+	if err != nil {
+		log.Errorf("Failed to render Marathon configuration template: %v", err)
+	}
+	return configuration
+}
+
+func (p *Provider) applicationFilter(app marathon.Application) bool {
+	// Filter disabled application.
+	if !label.IsEnabledP(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)
+	if p.MarathonLBCompatibility {
+		if haGroup := label.GetStringValueP(app.Labels, labelLbCompatibilityGroup, ""); len(haGroup) > 0 {
+			constraintTags = append(constraintTags, haGroup)
+		}
+	}
+	if p.FilterMarathonConstraints && app.Constraints != nil {
+		for _, constraintParts := range *app.Constraints {
+			constraintTags = append(constraintTags, strings.Join(constraintParts, ":"))
+		}
+	}
+	if ok, failingConstraint := p.MatchConstraints(constraintTags); !ok {
+		if failingConstraint != nil {
+			log.Debugf("Filtering Marathon application %s pruned by %q constraint", app.ID, failingConstraint.String())
+		}
+		return false
+	}
+
+	return true
+}
+
+func (p *Provider) taskFilter(task marathon.Task, application marathon.Application) bool {
+	if task.State != string(taskStateRunning) {
+		return false
+	}
+
+	// Filter task with existing, bad health check results.
+	if application.HasHealthChecks() {
+		if task.HasHealthCheckResults() {
+			for _, healthCheck := range task.HealthCheckResults {
+				if !healthCheck.Alive {
+					log.Debugf("Filtering Marathon task %s from application %s with bad health check", task.ID, application.ID)
+					return false
+				}
+			}
+		}
+	}
+
+	if ready := p.readyChecker.Do(task, application); !ready {
+		log.Infof("Filtering unready task %s from application %s", task.ID, application.ID)
+		return false
+	}
+
+	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
+	}
+
+	if p.MarathonLBCompatibility {
+		if value := label.GetStringValueP(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
+}
+
+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 "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))
+}
+
+func (p *Provider) getSubDomain(name string) string {
+	if p.GroupsAsSubDomains {
+		splitedName := strings.Split(strings.TrimPrefix(name, "/"), "/")
+		provider.ReverseStringSlice(&splitedName)
+		reverseName := strings.Join(splitedName, ".")
+		return reverseName
+	}
+	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 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
+}
+
+// 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)
+	}
+
+	// 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, "")
+	}
+	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))
+		}
+	}
+}
+
+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
+}
+
+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
+// Deprecated replaced by Stickiness
+func getSticky(application marathon.Application) string {
+	if label.HasP(application.Labels, label.TraefikBackendLoadBalancerSticky) {
+		log.Warnf("Deprecated configuration found: %s. Please use %s.", label.TraefikBackendLoadBalancerSticky, label.TraefikBackendLoadBalancerStickiness)
+	}
+	return label.GetStringValueP(application.Labels, label.TraefikBackendLoadBalancerSticky, "false")
+}
+
+func getPort(task marathon.Task, application marathon.Application, serviceName string) string {
+	port, err := processPorts(application, task, serviceName)
+	if err != nil {
+		log.Errorf("Unable to process ports for %s: %s", identifier(application, task, serviceName), err)
+		return ""
+	}
+
+	return strconv.Itoa(port)
+}
+
+// processPorts 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.
+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)
+
+		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 := retrieveAvailablePorts(application, task)
+	if len(ports) == 0 {
+		return 0, errors.New("no port found")
+	}
+
+	lblPortIndex := getLabelName(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
+}
+
+func retrieveAvailablePorts(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{}
+}
+
+// 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 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)
+	}
+}

provider/marathon/marathon.go

@@ -1,19 +1,10 @@
 package marathon
 
 import (
-	"errors"
-	"fmt"
-	"math"
 	"net"
 	"net/http"
-	"net/url"
-	"regexp"
-	"strconv"
-	"strings"
-	"text/template"
 	"time"
 
-	"github.com/BurntSushi/ty/fun"
 	"github.com/Sirupsen/logrus"
 	"github.com/cenk/backoff"
 	"github.com/containous/flaeg"
@@ -44,11 +35,13 @@ const (
 	taskStateStaging TaskState = "TASK_STAGING"
 )
 
-var _ provider.Provider = (*Provider)(nil)
+const (
+	labelIPAddressIdx         = "traefik.ipAddressIdx"
+	labelLbCompatibilityGroup = "HAPROXY_GROUP"
+	labelLbCompatibility      = "HAPROXY_0_VHOST"
+)
 
-// Regexp used to extract the name of the service and the name of the property for this service
+var _ provider.Provider = (*Provider)(nil)
-// All properties are under the format traefik.<servicename>.frontend.*= except the port/portIndex/weight/protocol/backend directly after traefik.<servicename>.
-var servicesPropertiesRegexp = regexp.MustCompile(`^traefik\.(?P<service_name>.+?)\.(?P<property_name>port|portIndex|weight|protocol|backend|frontend\.(.*))$`)
 
 // Provider holds configuration of the provider.
 type Provider struct {
@@ -135,7 +128,7 @@ func (p *Provider) Provide(configurationChan chan<- types.ConfigMessage, pool *s
 						return
 					case event := <-update:
 						log.Debugf("Received provider event %s", event)
-						configuration := p.loadMarathonConfig()
+						configuration := p.buildConfiguration()
 						if configuration != nil {
 							configurationChan <- types.ConfigMessage{
 								ProviderName:  "marathon",
@@ -146,7 +139,7 @@ func (p *Provider) Provide(configurationChan chan<- types.ConfigMessage, pool *s
 				}
 			})
 		}
-		configuration := p.loadMarathonConfig()
+		configuration := p.buildConfiguration()
 		configurationChan <- types.ConfigMessage{
 			ProviderName:  "marathon",
 			Configuration: configuration,
@@ -163,537 +156,3 @@ func (p *Provider) Provide(configurationChan chan<- types.ConfigMessage, pool *s
 	}
 	return nil
 }
-
-func (p *Provider) loadMarathonConfig() *types.Configuration {
-	var MarathonFuncMap = template.FuncMap{
-		"getBackend":                  p.getBackend,
-		"getBackendServer":            p.getBackendServer,
-		"getPort":                     p.getPort,
-		"getWeight":                   p.getWeight,
-		"getDomain":                   p.getDomain,
-		"getSubDomain":                p.getSubDomain,
-		"getProtocol":                 p.getProtocol,
-		"getPassHostHeader":           p.getPassHostHeader,
-		"getPriority":                 p.getPriority,
-		"getEntryPoints":              p.getEntryPoints,
-		"getFrontendRule":             p.getFrontendRule,
-		"getFrontendName":             p.getFrontendName,
-		"hasCircuitBreakerLabels":     p.hasCircuitBreakerLabels,
-		"hasLoadBalancerLabels":       p.hasLoadBalancerLabels,
-		"hasMaxConnLabels":            p.hasMaxConnLabels,
-		"getMaxConnExtractorFunc":     p.getMaxConnExtractorFunc,
-		"getMaxConnAmount":            p.getMaxConnAmount,
-		"getLoadBalancerMethod":       p.getLoadBalancerMethod,
-		"getCircuitBreakerExpression": p.getCircuitBreakerExpression,
-		"getSticky":                   p.getSticky,
-		"hasStickinessLabel":          p.hasStickinessLabel,
-		"getStickinessCookieName":     p.getStickinessCookieName,
-		"hasHealthCheckLabels":        p.hasHealthCheckLabels,
-		"getHealthCheckPath":          p.getHealthCheckPath,
-		"getHealthCheckInterval":      p.getHealthCheckInterval,
-		"hasServices":                 p.hasServices,
-		"getServiceNames":             p.getServiceNames,
-		"getServiceNameSuffix":        p.getServiceNameSuffix,
-		"getBasicAuth":                p.getBasicAuth,
-	}
-
-	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: %s", 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 {
-				p.logIllegalServices(*task, app)
-			}
-			return filtered
-		}, app.Tasks).([]*marathon.Task)
-	}
-
-	templateObjects := struct {
-		Applications []marathon.Application
-		Domain       string
-	}{
-		filteredApps,
-		p.Domain,
-	}
-
-	configuration, err := p.GetConfiguration("templates/marathon.tmpl", MarathonFuncMap, templateObjects)
-	if err != nil {
-		log.Errorf("failed to render Marathon configuration template: %s", err)
-	}
-	return configuration
-}
-
-func (p *Provider) applicationFilter(app marathon.Application) bool {
-	// Filter disabled application.
-	if !isApplicationEnabled(app, p.ExposedByDefault) {
-		log.Debugf("Filtering disabled Marathon application %s", app.ID)
-		return false
-	}
-
-	// Filter by constraints.
-	label, _ := p.getAppLabel(app, types.LabelTags)
-	constraintTags := strings.Split(label, ",")
-	if p.MarathonLBCompatibility {
-		if label, ok := p.getAppLabel(app, "HAPROXY_GROUP"); ok {
-			constraintTags = append(constraintTags, label)
-		}
-	}
-	if p.FilterMarathonConstraints && app.Constraints != nil {
-		for _, constraintParts := range *app.Constraints {
-			constraintTags = append(constraintTags, strings.Join(constraintParts, ":"))
-		}
-	}
-	if ok, failingConstraint := p.MatchConstraints(constraintTags); !ok {
-		if failingConstraint != nil {
-			log.Debugf("Filtering Marathon application %v pruned by '%v' constraint", app.ID, failingConstraint.String())
-		}
-		return false
-	}
-
-	return true
-}
-
-func (p *Provider) taskFilter(task marathon.Task, application marathon.Application) bool {
-	if task.State != string(taskStateRunning) {
-		return false
-	}
-
-	// Filter task with existing, bad health check results.
-	if application.HasHealthChecks() {
-		if task.HasHealthCheckResults() {
-			for _, healthcheck := range task.HealthCheckResults {
-				if !healthcheck.Alive {
-					log.Debugf("Filtering Marathon task %s from application %s with bad health check", task.ID, application.ID)
-					return false
-				}
-			}
-		}
-	}
-
-	if ready := p.readyChecker.Do(task, application); !ready {
-		log.Infof("Filtering unready task %s from application %s", task.ID, application.ID)
-		return false
-	}
-
-	return true
-}
-
-func isApplicationEnabled(application marathon.Application, exposedByDefault bool) bool {
-	return exposedByDefault && (*application.Labels)[types.LabelEnable] != "false" || (*application.Labels)[types.LabelEnable] == "true"
-}
-
-// 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 (p *Provider) logIllegalServices(task marathon.Task, application marathon.Application) {
-	for _, serviceName := range p.getServiceNames(application) {
-		// Check for illegal/missing ports.
-		if _, err := p.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.
-		_, hasPortLabel := p.getLabel(application, types.LabelPort, serviceName)
-		_, hasPortIndexLabel := p.getLabel(application, types.LabelPortIndex, serviceName)
-		if hasPortLabel && hasPortIndexLabel {
-			log.Warnf("%s has both port and port index specified; port will take precedence", identifier(application, task, serviceName))
-		}
-	}
-}
-
-//servicePropertyValues is a map of services properties
-//an example value is: weight=42
-type servicePropertyValues map[string]string
-
-//serviceProperties is a map of service properties per service, which we can get with label[serviceName][propertyName]. It yields a property value.
-type serviceProperties map[string]servicePropertyValues
-
-//hasServices checks if there are service-defining labels for the given application
-func (p *Provider) hasServices(application marathon.Application) bool {
-	return len(extractServiceProperties(application.Labels)) > 0
-}
-
-//extractServiceProperties extracts the service labels for the given application
-func extractServiceProperties(labels *map[string]string) serviceProperties {
-	v := make(serviceProperties)
-
-	if labels != nil {
-		for label, value := range *labels {
-			matches := servicesPropertiesRegexp.FindStringSubmatch(label)
-			if matches == nil {
-				continue
-			}
-
-			// According to the regex, match index 1 is "service_name" and match index 2 is the "property_name"
-			serviceName := matches[1]
-			propertyName := matches[2]
-			if _, ok := v[serviceName]; !ok {
-				v[serviceName] = make(servicePropertyValues)
-			}
-			v[serviceName][propertyName] = value
-		}
-	}
-
-	return v
-}
-
-//getServiceProperty returns the property for a service label searching in all labels of the given application
-func getServiceProperty(application marathon.Application, serviceName string, property string) (string, bool) {
-	value, ok := extractServiceProperties(application.Labels)[serviceName][property]
-	return value, ok
-}
-
-//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 (p *Provider) getServiceNames(application marathon.Application) []string {
-	labelServiceProperties := extractServiceProperties(application.Labels)
-	var names []string
-
-	for k := range labelServiceProperties {
-		names = append(names, k)
-	}
-	if len(names) == 0 {
-		names = append(names, "")
-	}
-	return names
-}
-
-func (p *Provider) getServiceNameSuffix(serviceName string) string {
-	if len(serviceName) > 0 {
-		serviceName = strings.Replace(serviceName, "/", "-", -1)
-		serviceName = strings.Replace(serviceName, ".", "-", -1)
-		return "-service-" + serviceName
-	}
-	return ""
-}
-
-//getAppLabel is a convenience function to get application label, when no serviceName is available
-//it is identical to calling getLabel(application, label, "")
-func (p *Provider) getAppLabel(application marathon.Application, label string) (string, bool) {
-	return p.getLabel(application, label, "")
-}
-
-//getLabel returns a string value of a corresponding `label` argument
-//  If serviceName is non-empty, we look for a service label. If none exists or serviceName is empty, we look for an application label.
-func (p *Provider) getLabel(application marathon.Application, label string, serviceName string) (string, bool) {
-	if len(serviceName) > 0 {
-		property := strings.TrimPrefix(label, types.LabelPrefix)
-		if value, ok := getServiceProperty(application, serviceName, property); ok {
-			return value, true
-		}
-	}
-	for key, value := range *application.Labels {
-		if key == label {
-			return value, true
-		}
-	}
-	return "", false
-}
-
-func (p *Provider) getPort(task marathon.Task, application marathon.Application, serviceName string) string {
-	port, err := p.processPorts(application, task, serviceName)
-	if err != nil {
-		log.Errorf("Unable to process ports for %s: %s", identifier(application, task, serviceName), err)
-		return ""
-	}
-
-	return strconv.Itoa(port)
-}
-
-func (p *Provider) getWeight(application marathon.Application, serviceName string) string {
-	if label, ok := p.getLabel(application, types.LabelWeight, serviceName); ok {
-		return label
-	}
-	return "0"
-}
-
-func (p *Provider) getDomain(application marathon.Application) string {
-	if label, ok := p.getAppLabel(application, types.LabelDomain); ok {
-		return label
-	}
-	return p.Domain
-}
-
-func (p *Provider) getProtocol(application marathon.Application, serviceName string) string {
-	if label, ok := p.getLabel(application, types.LabelProtocol, serviceName); ok {
-		return label
-	}
-	return "http"
-}
-
-func (p *Provider) getSticky(application marathon.Application) string {
-	if sticky, ok := p.getAppLabel(application, types.LabelBackendLoadbalancerSticky); ok {
-		log.Warnf("Deprecated configuration found: %s. Please use %s.", types.LabelBackendLoadbalancerSticky, types.LabelBackendLoadbalancerStickiness)
-		return sticky
-	}
-	return "false"
-}
-
-func (p *Provider) hasStickinessLabel(application marathon.Application) bool {
-	labelStickiness, okStickiness := p.getAppLabel(application, types.LabelBackendLoadbalancerStickiness)
-	return okStickiness && len(labelStickiness) > 0 && strings.EqualFold(strings.TrimSpace(labelStickiness), "true")
-}
-
-func (p *Provider) getStickinessCookieName(application marathon.Application) string {
-	if label, ok := p.getAppLabel(application, types.LabelBackendLoadbalancerStickinessCookieName); ok {
-		return label
-	}
-	return ""
-}
-
-func (p *Provider) getPassHostHeader(application marathon.Application, serviceName string) string {
-	if passHostHeader, ok := p.getLabel(application, types.LabelFrontendPassHostHeader, serviceName); ok {
-		return passHostHeader
-	}
-	return "true"
-}
-
-func (p *Provider) getPriority(application marathon.Application, serviceName string) string {
-	if priority, ok := p.getLabel(application, types.LabelFrontendPriority, serviceName); ok {
-		return priority
-	}
-	return "0"
-}
-
-func (p *Provider) getEntryPoints(application marathon.Application, serviceName string) []string {
-	if entryPoints, ok := p.getLabel(application, types.LabelFrontendEntryPoints, serviceName); ok {
-		return strings.Split(entryPoints, ",")
-	}
-	return []string{}
-}
-
-// 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 {
-	if label, ok := p.getLabel(application, types.LabelFrontendRule, serviceName); ok {
-		return label
-	}
-	if p.MarathonLBCompatibility {
-		if label, ok := p.getAppLabel(application, "HAPROXY_0_VHOST"); ok {
-			return "Host:" + label
-		}
-	}
-	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
-}
-
-func (p *Provider) getBackend(application marathon.Application, serviceName string) string {
-	if label, ok := p.getLabel(application, types.LabelBackend, serviceName); ok {
-		return label
-	}
-	return strings.Replace(application.ID, "/", "-", -1) + p.getServiceNameSuffix(serviceName)
-}
-
-func (p *Provider) getFrontendName(application marathon.Application, serviceName string) string {
-	appName := strings.Replace(application.ID, "/", "-", -1)
-	return "frontend" + appName + p.getServiceNameSuffix(serviceName)
-}
-
-func (p *Provider) getSubDomain(name string) string {
-	if p.GroupsAsSubDomains {
-		splitedName := strings.Split(strings.TrimPrefix(name, "/"), "/")
-		provider.ReverseStringSlice(&splitedName)
-		reverseName := strings.Join(splitedName, ".")
-		return reverseName
-	}
-	return strings.Replace(strings.TrimPrefix(name, "/"), "/", "-", -1)
-}
-
-func (p *Provider) hasCircuitBreakerLabels(application marathon.Application) bool {
-	_, ok := p.getAppLabel(application, types.LabelBackendCircuitbreakerExpression)
-	return ok
-}
-
-func (p *Provider) hasLoadBalancerLabels(application marathon.Application) bool {
-	_, errMethod := p.getAppLabel(application, types.LabelBackendLoadbalancerMethod)
-	_, errSticky := p.getAppLabel(application, types.LabelBackendLoadbalancerSticky)
-	return errMethod || errSticky
-}
-
-func (p *Provider) hasMaxConnLabels(application marathon.Application) bool {
-	if _, ok := p.getAppLabel(application, types.LabelBackendMaxconnAmount); !ok {
-		return false
-	}
-	_, ok := p.getAppLabel(application, types.LabelBackendMaxconnExtractorfunc)
-	return ok
-}
-
-func (p *Provider) getMaxConnAmount(application marathon.Application) int64 {
-	if label, ok := p.getAppLabel(application, types.LabelBackendMaxconnAmount); ok {
-		i, errConv := strconv.ParseInt(label, 10, 64)
-		if errConv != nil {
-			log.Errorf("Unable to parse traefik.backend.maxconn.amount %s", label)
-			return math.MaxInt64
-		}
-		return i
-	}
-	return math.MaxInt64
-}
-
-func (p *Provider) getMaxConnExtractorFunc(application marathon.Application) string {
-	if label, ok := p.getAppLabel(application, types.LabelBackendMaxconnExtractorfunc); ok {
-		return label
-	}
-	return "request.host"
-}
-
-func (p *Provider) getLoadBalancerMethod(application marathon.Application) string {
-	if label, ok := p.getAppLabel(application, types.LabelBackendLoadbalancerMethod); ok {
-		return label
-	}
-	return "wrr"
-}
-
-func (p *Provider) getCircuitBreakerExpression(application marathon.Application) string {
-	if label, ok := p.getAppLabel(application, types.LabelBackendCircuitbreakerExpression); ok {
-		return label
-	}
-	return "NetworkErrorRatio() > 1"
-}
-
-func (p *Provider) hasHealthCheckLabels(application marathon.Application) bool {
-	return p.getHealthCheckPath(application) != ""
-}
-
-func (p *Provider) getHealthCheckPath(application marathon.Application) string {
-	if label, ok := p.getAppLabel(application, types.LabelBackendHealthcheckPath); ok {
-		return label
-	}
-	return ""
-}
-
-func (p *Provider) getHealthCheckInterval(application marathon.Application) string {
-	if label, ok := p.getAppLabel(application, types.LabelBackendHealthcheckInterval); ok {
-		return label
-	}
-	return ""
-}
-
-func (p *Provider) getBasicAuth(application marathon.Application, serviceName string) []string {
-	if basicAuth, ok := p.getLabel(application, types.LabelFrontendAuthBasic, serviceName); ok {
-		return strings.Split(basicAuth, ",")
-	}
-
-	return []string{}
-}
-
-// processPorts 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.
-func (p *Provider) processPorts(application marathon.Application, task marathon.Task, serviceName string) (int, error) {
-	if portLabel, ok := p.getLabel(application, types.LabelPort, serviceName); ok {
-		port, err := strconv.Atoi(portLabel)
-		switch {
-		case err != nil:
-			return 0, fmt.Errorf("failed to parse port label %q: %s", portLabel, err)
-		case port <= 0:
-			return 0, fmt.Errorf("explicitly specified port %d must be larger than zero", port)
-		}
-		return port, nil
-	}
-
-	ports := retrieveAvailablePorts(application, task)
-	if len(ports) == 0 {
-		return 0, errors.New("no port found")
-	}
-
-	portIndex := 0
-	if portIndexLabel, ok := p.getLabel(application, types.LabelPortIndex, serviceName); ok {
-		var err error
-		portIndex, err = parseIndex(portIndexLabel, len(ports))
-		if err != nil {
-			return 0, fmt.Errorf("cannot use port index to select from %d ports: %s", len(ports), err)
-		}
-	}
-	return ports[portIndex], nil
-}
-
-func retrieveAvailablePorts(application marathon.Application, task marathon.Task) []int {
-	// Using default port configuration
-	if task.Ports != nil && 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{}
-}
-
-func (p *Provider) getBackendServer(task marathon.Task, application marathon.Application) string {
-	numTaskIPAddresses := len(task.IPAddresses)
-	switch {
-	case application.IPAddressPerTask == nil || p.ForceTaskHostname:
-		return task.Host
-	case numTaskIPAddresses == 0:
-		log.Errorf("Missing IP address for Marathon application %s on task %s", application.ID, task.ID)
-		return ""
-	case numTaskIPAddresses == 1:
-		return task.IPAddresses[0].IPAddress
-	default:
-		ipAddressIdxStr, ok := p.getAppLabel(application, "traefik.ipAddressIdx")
-		if !ok {
-			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 ""
-		}
-
-		ipAddressIdx, err := parseIndex(ipAddressIdxStr, numTaskIPAddresses)
-		if err != nil {
-			log.Errorf("Cannot use IP address index to select from %d task IP addresses for Marathon application %s on task %s: %s", numTaskIPAddresses, application.ID, task.ID, err)
-			return ""
-		}
-
-		return task.IPAddresses[ipAddressIdx].IPAddress
-	}
-}
-
-func parseIndex(index string, length int) (int, error) {
-	parsed, err := strconv.Atoi(index)
-	switch {
-	case err != nil:
-		return 0, fmt.Errorf("failed to parse index %q: %s", index, err)
-	case parsed < 0, parsed > length-1:
-		return 0, fmt.Errorf("index %d must be within range (0, %d)", parsed, length-1)
-	}
-
-	return parsed, nil
-}
-
-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
-}

provider/marathon/readiness.go

@@ -11,11 +11,11 @@ const (
 	// readinessCheckDefaultTimeout is the default timeout for a readiness
 	// check if no check timeout is specified on the application spec. This
 	// should really never be the case, but better be safe than sorry.
-	readinessCheckDefaultTimeout time.Duration = 10 * time.Second
+	readinessCheckDefaultTimeout = 10 * time.Second
 	// readinessCheckSafetyMargin is some buffer duration to account for
 	// small offsets in readiness check execution.
-	readinessCheckSafetyMargin time.Duration = 5 * time.Second
+	readinessCheckSafetyMargin = 5 * time.Second
-	readinessLogHeader         string        = "Marathon readiness check: "
+	readinessLogHeader         = "Marathon readiness check: "
 )
 
 type readinessChecker struct {

provider/marathon/readiness_test.go

@@ -20,7 +20,7 @@ func TestDisabledReadinessChecker(t *testing.T) {
 		readinessCheckResult(testTaskName, false),
 	)
 
-	if ready := rc.Do(tsk, app); ready == false {
+	if ready := rc.Do(tsk, app); !ready {
 		t.Error("expected ready = true")
 	}
 }

templates/marathon.tmpl

@@ -3,7 +3,7 @@
 {{range $app := $apps}}
 {{range $task := $app.Tasks}}
 {{range $serviceIndex, $serviceName := getServiceNames $app}}
-    [backends."backend{{getBackend $app $serviceName}}".servers."server-{{$task.ID | replace "." "-"}}{{getServiceNameSuffix $serviceName }}"]
+    [backends."{{getBackend $app $serviceName}}".servers."server-{{$task.ID | replace "." "-"}}{{getServiceNameSuffix $serviceName }}"]
     url = "{{getProtocol $app $serviceName}}://{{getBackendServer $task $app}}:{{getPort $task $app $serviceName}}"
     weight = {{getWeight $app $serviceName}}
 {{end}}
@@ -12,27 +12,27 @@
 
 {{range $app := $apps}}
 {{range $serviceIndex, $serviceName := getServiceNames $app}}
-[backends."backend{{getBackend $app $serviceName }}"]
+[backends."{{getBackend $app $serviceName }}"]
 {{ if hasMaxConnLabels $app }}
-      [backends."backend{{getBackend $app $serviceName }}".maxconn]
+      [backends."{{getBackend $app $serviceName }}".maxconn]
         amount = {{getMaxConnAmount $app }}
         extractorfunc = "{{getMaxConnExtractorFunc $app }}"
 {{end}}
 {{ if hasLoadBalancerLabels $app }}
-      [backends."backend{{getBackend $app $serviceName }}".loadbalancer]
+      [backends."{{getBackend $app $serviceName }}".loadbalancer]
         method = "{{getLoadBalancerMethod $app }}"
         sticky = {{getSticky $app}}
         {{if hasStickinessLabel $app}}
-        [backends."backend{{getBackend $app $serviceName }}".loadbalancer.stickiness]
+        [backends."{{getBackend $app $serviceName }}".loadbalancer.stickiness]
           cookieName = "{{getStickinessCookieName $app}}"
         {{end}}
 {{end}}
 {{ if hasCircuitBreakerLabels $app }}
-      [backends."backend{{getBackend $app $serviceName }}".circuitbreaker]
+      [backends."{{getBackend $app $serviceName }}".circuitbreaker]
         expression = "{{getCircuitBreakerExpression $app }}"
 {{end}}
 {{ if hasHealthCheckLabels $app }}
-      [backends."backend{{getBackend $app $serviceName }}".healthcheck]
+      [backends."{{getBackend $app $serviceName }}".healthcheck]
         path = "{{getHealthCheckPath $app }}"
         interval = "{{getHealthCheckInterval $app }}"
 {{end}}
@@ -41,7 +41,7 @@
 
 [frontends]{{range $app := $apps}}{{range $serviceIndex, $serviceName := getServiceNames .}}
   [frontends."{{ getFrontendName $app $serviceName }}"]
-  backend = "backend{{getBackend $app $serviceName}}"
+  backend = "{{getBackend $app $serviceName}}"
   passHostHeader = {{getPassHostHeader $app $serviceName}}
   priority = {{getPriority $app $serviceName}}
   entryPoints = [{{range getEntryPoints $app $serviceName}}