// Code generated by go-bindata.
// sources:
// templates/consul_catalog.tmpl
// templates/docker.tmpl
// templates/ecs.tmpl
// templates/eureka.tmpl
// templates/kubernetes.tmpl
// templates/kv.tmpl
// templates/marathon.tmpl
// templates/mesos.tmpl
// templates/notFound.tmpl
// templates/rancher.tmpl
// DO NOT EDIT!

package gentemplates

import (
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
	"time"
)

type asset struct {
	bytes []byte
	info  os.FileInfo
}

type bindataFileInfo struct {
	name    string
	size    int64
	mode    os.FileMode
	modTime time.Time
}

func (fi bindataFileInfo) Name() string {
	return fi.name
}
func (fi bindataFileInfo) Size() int64 {
	return fi.size
}
func (fi bindataFileInfo) Mode() os.FileMode {
	return fi.mode
}
func (fi bindataFileInfo) ModTime() time.Time {
	return fi.modTime
}
func (fi bindataFileInfo) IsDir() bool {
	return false
}
func (fi bindataFileInfo) Sys() interface{} {
	return nil
}

var _templatesConsul_catalogTmpl = []byte(`[backends]
{{range $service := .Services}}

  {{ $circuitBreaker := getCircuitBreaker $service.Attributes }}
  {{if $circuitBreaker }}
  [backends."backend-{{ getServiceBackendName $service }}".circuitBreaker]
    expression = "{{ $circuitBreaker.Expression }}"
  {{end}}

  {{ $loadBalancer := getLoadBalancer $service.Attributes }}
  {{if $loadBalancer }}
  [backends."backend-{{ getServiceBackendName $service }}".loadBalancer]
    method = "{{ $loadBalancer.Method }}"
    sticky = {{ $loadBalancer.Sticky }}
    {{if $loadBalancer.Stickiness }}
    [backends."backend-{{ getServiceBackendName $service }}".loadBalancer.stickiness]
      cookieName = "{{ $loadBalancer.Stickiness.CookieName }}"
    {{end}}
  {{end}}

  {{ $maxConn := getMaxConn $service.Attributes }}
  {{if $maxConn }}
  [backends."backend-{{ getServiceBackendName $service }}".maxConn]
    extractorFunc = "{{ $maxConn.ExtractorFunc }}"
    amount = {{ $maxConn.Amount }}
  {{end}}

  {{ $healthCheck := getHealthCheck $service.Attributes }}
  {{if $healthCheck }}
  [backends.backend-{{ getServiceBackendName $service }}.healthCheck]
    path = "{{ $healthCheck.Path }}"
    port = {{ $healthCheck.Port }}
    interval = "{{ $healthCheck.Interval }}"
  {{end}}

{{end}}
{{range $index, $node := .Nodes}}

  [backends."backend-{{ getNodeBackendName $node }}".servers."{{ getServerName $node $index }}"]
    url = "{{ getProtocol $node.Service.Tags }}://{{ getBackendAddress $node }}:{{ $node.Service.Port }}"
    weight = {{ getWeight $node.Service.Tags }}

{{end}}

[frontends]
{{range $service := .Services}}

  [frontends."frontend-{{ $service.ServiceName }}"]
    backend = "backend-{{ getServiceBackendName $service }}"
    priority = {{ getPriority $service.Attributes }}
    passHostHeader = {{ getPassHostHeader $service.Attributes }}
    passTLSCert = {{ getPassTLSCert $service.Attributes }}

    entryPoints = [{{range getFrontEndEntryPoints $service.Attributes }}
      "{{.}}",
      {{end}}]

    {{ $whitelistSourceRange := getWhitelistSourceRange $service.Attributes }}
    {{if $whitelistSourceRange }}
    whitelistSourceRange = [{{range $whitelistSourceRange}}
      "{{.}}",
      {{end}}]
    {{end}}

    basicAuth = [{{range getBasicAuth $service.Attributes }}
      "{{.}}",
      {{end}}]

    {{ $redirect := getRedirect $service.Attributes }}
    {{if $redirect }}
    [frontends."frontend-{{ $service.ServiceName }}".redirect]
      entryPoint = "{{ $redirect.EntryPoint }}"
      regex = "{{ $redirect.Regex }}"
      replacement = "{{ $redirect.Replacement }}"
    {{end}}

    {{ if hasErrorPages $service.Attributes }}
    [frontends."frontend-{{ $service.ServiceName }}".errors]
      {{ range $pageName, $page := getErrorPages $service.Attributes }}
      [frontends."frontend-{{ $service.ServiceName }}".errors.{{ $pageName }}]
        status = [{{range $page.Status }}
        "{{.}}",
        {{end}}]
        backend = "{{ $page.Backend }}"
        query = "{{ $page.Query }}"
      {{end}}
    {{end}}

    {{ if hasRateLimit $service.Attributes }}
    {{ $rateLimit := getRateLimit $service.Attributes }}
    [frontends."frontend-{{ $service.ServiceName }}".rateLimit]
      extractorFunc = "{{ $rateLimit.ExtractorFunc }}"

      [frontends."frontend-{{ $service.ServiceName }}".rateLimit.rateSet]
        {{ range $limitName, $limit := $rateLimit.RateSet }}
        [frontends."frontend-{{ $service.ServiceName }}".rateLimit.rateSet.{{ $limitName }}]
          period = "{{ $limit.Period }}"
          average = {{ $limit.Average }}
          burst = {{ $limit.Burst }}
        {{end}}

    {{end}}

    {{ $headers := getHeaders $service.Attributes }}
    {{ if $headers }}
    [frontends."frontend-{{ $service.ServiceName }}".headers]
      SSLRedirect = {{ $headers.SSLRedirect }}
      SSLTemporaryRedirect = {{ $headers.SSLTemporaryRedirect }}
      SSLHost = "{{ $headers.SSLHost }}"
      STSSeconds = {{ $headers.STSSeconds }}
      STSIncludeSubdomains = {{ $headers.STSIncludeSubdomains }}
      STSPreload = {{ $headers.STSPreload }}
      ForceSTSHeader = {{ $headers.ForceSTSHeader }}
      FrameDeny = {{ $headers.FrameDeny }}
      CustomFrameOptionsValue = "{{ $headers.CustomFrameOptionsValue }}"
      ContentTypeNosniff = {{ $headers.ContentTypeNosniff }}
      BrowserXSSFilter = {{ $headers.BrowserXSSFilter }}
      ContentSecurityPolicy = "{{ $headers.ContentSecurityPolicy }}"
      PublicKey = "{{ $headers.PublicKey }}"
      ReferrerPolicy = "{{ $headers.ReferrerPolicy }}"
      IsDevelopment = {{ $headers.IsDevelopment }}

      {{ if $headers.AllowedHosts }}
      AllowedHosts = [{{ range $headers.AllowedHosts }}
        "{{.}}",
        {{end}}]
      {{end}}

      {{ if $headers.HostsProxyHeaders }}
      HostsProxyHeaders = [{{ range $headers.HostsProxyHeaders }}
        "{{.}}",
        {{end}}]
      {{end}}

      {{ if $headers.CustomRequestHeaders }}
      [frontends."frontend-{{ $service.ServiceName }}".headers.customRequestHeaders]
        {{ range $k, $v := $headers.CustomRequestHeaders }}
        {{$k}} = "{{$v}}"
        {{end}}
      {{end}}

      {{ if $headers.CustomResponseHeaders }}
      [frontends."frontend-{{ $service.ServiceName }}".headers.customResponseHeaders]
        {{ range $k, $v := $headers.CustomResponseHeaders }}
        {{$k}} = "{{$v}}"
        {{end}}
      {{end}}

      {{ if $headers.SSLProxyHeaders }}
      [frontends."frontend-{{ $service.ServiceName }}".headers.SSLProxyHeaders]
        {{range $k, $v := $headers.SSLProxyHeaders}}
        {{$k}} = "{{$v}}"
        {{end}}
      {{end}}
    {{end}}

    [frontends."frontend-{{ $service.ServiceName }}".routes."route-host-{{ $service.ServiceName }}"]
      rule = "{{ getFrontendRule $service }}"

{{end}}
`)

func templatesConsul_catalogTmplBytes() ([]byte, error) {
	return _templatesConsul_catalogTmpl, nil
}

func templatesConsul_catalogTmpl() (*asset, error) {
	bytes, err := templatesConsul_catalogTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "templates/consul_catalog.tmpl", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _templatesDockerTmpl = []byte(`{{$backendServers := .Servers}}
[backends]
{{range $backendName, $backend := .Backends}}

  {{if hasCircuitBreakerLabel $backend}}
  [backends.backend-{{$backendName}}.circuitBreaker]
    expression = "{{getCircuitBreakerExpression $backend}}"
  {{end}}

  {{if hasLoadBalancerLabel $backend}}
  [backends.backend-{{$backendName}}.loadBalancer]
    method = "{{getLoadBalancerMethod $backend}}"
    sticky = {{getSticky $backend}}
    {{if hasStickinessLabel $backend}}
    [backends.backend-{{$backendName}}.loadBalancer.stickiness]
      cookieName = "{{getStickinessCookieName $backend}}"
    {{end}}
  {{end}}

  {{if hasMaxConnLabels $backend}}
  [backends.backend-{{$backendName}}.maxConn]
    amount = {{getMaxConnAmount $backend}}
    extractorFunc = "{{getMaxConnExtractorFunc $backend}}"
  {{end}}

  {{if hasHealthCheckLabels $backend}}
  [backends.backend-{{$backendName}}.healthCheck]
    path = "{{getHealthCheckPath $backend}}"
    port = {{getHealthCheckPort $backend}}
    interval = "{{getHealthCheckInterval $backend}}"
  {{end}}

  {{$servers := index $backendServers $backendName}}
  {{range $serverName, $server := $servers}}
    {{if hasServices $server}}
      {{$services := getServiceNames $server}}
      {{range $serviceIndex, $serviceName := $services}}
      [backends.backend-{{getServiceBackend $server $serviceName}}.servers.service-{{$serverName}}]
        url = "{{getServiceProtocol $server $serviceName}}://{{getIPAddress $server}}:{{getServicePort $server $serviceName}}"
        weight = {{getServiceWeight $server $serviceName}}
      {{end}}
    {{else}}
      [backends.backend-{{$backendName}}.servers.server-{{$server.Name | replace "/" "" | replace "." "-"}}]
        url = "{{getProtocol $server}}://{{getIPAddress $server}}:{{getPort $server}}"
        weight = {{getWeight $server}}
    {{end}}
  {{end}}

{{end}}

[frontends]
{{range $frontend, $containers := .Frontends}}
  {{$container := index $containers 0}}

  {{if hasServices $container}}
  {{$services := getServiceNames $container}}

  {{range $serviceIndex, $serviceName := $services}}
  [frontends."frontend-{{getServiceBackend $container $serviceName}}"]
    backend = "backend-{{getServiceBackend $container $serviceName}}"
    priority = {{getServicePriority $container $serviceName}}
    passHostHeader = {{getServicePassHostHeader $container $serviceName}}
    passTLSCert = {{getServicePassTLSCert $container $serviceName}}

    entryPoints = [{{range getServiceEntryPoints $container $serviceName}}
      "{{.}}",
      {{end}}]

    {{if getServiceWhitelistSourceRange $container $serviceName}}
    whitelistSourceRange = [{{range getServiceWhitelistSourceRange $container $serviceName}}
      "{{.}}",
      {{end}}]
    {{end}}

    basicAuth = [{{range getServiceBasicAuth $container $serviceName}}
      "{{.}}",
      {{end}}]

    {{if hasServiceRedirect $container $serviceName}}
    [frontends."frontend-{{getServiceBackend $container $serviceName}}".redirect]
      entryPoint = "{{getServiceRedirectEntryPoint $container $serviceName}}"
      regex = "{{getServiceRedirectRegex $container $serviceName}}"
      replacement = "{{getServiceRedirectReplacement $container $serviceName}}"
    {{end}}

    {{ if hasServiceErrorPages $container $serviceName }}
    [frontends."frontend-{{getServiceBackend $container $serviceName}}".errors]
      {{ range $pageName, $page := getServiceErrorPages $container $serviceName }}
      [frontends."frontend-{{getServiceBackend $container $serviceName}}".errors.{{$pageName}}]
        status = [{{range $page.Status}}
          "{{.}}",
          {{end}}]
        backend = "{{$page.Backend}}"
        query = "{{$page.Query}}"
      {{end}}
    {{end}}

    {{ if hasServiceRateLimits $container $serviceName }}
    [frontends."frontend-{{getServiceBackend $container $serviceName}}".rateLimit]
      extractorFunc = "{{ getRateLimitsExtractorFunc $container $serviceName }}"
      [frontends."frontend-{{getServiceBackend $container $serviceName}}".rateLimit.rateSet]
        {{ range $limitName, $rateLimit := getServiceRateLimits $container $serviceName }}
        [frontends."frontend-{{getServiceBackend $container $serviceName}}".rateLimit.rateSet.{{ $limitName }}]
          period = "{{ $rateLimit.Period }}"
          average = {{ $rateLimit.Average }}
          burst = {{ $rateLimit.Burst }}
        {{end}}
    {{end}}

  [frontends."frontend-{{getServiceBackend $container $serviceName}}".routes."service-{{$serviceName | replace "/" "" | replace "." "-"}}"]
    rule = "{{getServiceFrontendRule $container $serviceName}}"

    {{if hasServiceRequestHeaders $container $serviceName}}
    [frontends."frontend-{{getServiceBackend $container $serviceName}}".headers.customRequestHeaders]
      {{range $k, $v := getServiceRequestHeaders $container $serviceName}}
      {{$k}} = "{{$v}}"
      {{end}}
    {{end}}

    {{if hasServiceResponseHeaders $container $serviceName}}
    [frontends."frontend-{{getServiceBackend $container $serviceName}}".headers.customResponseHeaders]
      {{range $k, $v := getServiceResponseHeaders $container $serviceName}}
      {{$k}} = "{{$v}}"
      {{end}}
    {{end}}

  {{end}} ## end range services

  {{else}}

  [frontends."frontend-{{$frontend}}"]
    backend = "backend-{{getBackend $container}}"
    priority = {{getPriority $container}}
    passHostHeader = {{getPassHostHeader $container}}
    passTLSCert = {{getPassTLSCert $container}}

    entryPoints = [{{range getEntryPoints $container}}
      "{{.}}",
      {{end}}]

    {{if getWhitelistSourceRange $container}}
    whitelistSourceRange = [{{range getWhitelistSourceRange $container}}
      "{{.}}",
      {{end}}]
    {{end}}

    basicAuth = [{{range getBasicAuth $container}}
      "{{.}}",
      {{end}}]

    {{if hasRedirect $container}}
    [frontends."frontend-{{$frontend}}".redirect]
      entryPoint = "{{getRedirectEntryPoint $container}}"
      regex = "{{getRedirectRegex $container}}"
      replacement = "{{getRedirectReplacement $container}}"
    {{end}}

    {{ if hasErrorPages $container }}
    [frontends."frontend-{{$frontend}}".errors]
      {{ range $pageName, $page := getErrorPages $container }}
      [frontends."frontend-{{$frontend}}".errors.{{ $pageName }}]
        status = [{{range $page.Status}}
          "{{.}}",
          {{end}}]
        backend = "{{$page.Backend}}"
        query = "{{$page.Query}}"
      {{end}}
    {{end}}

    {{ if hasRateLimits $container }}
    [frontends."frontend-{{$frontend}}".rateLimit]
      extractorFunc = "{{ getRateLimitsExtractorFunc $container }}"
      [frontends."frontend-{{$frontend}}".rateLimit.rateSet]
        {{ range $limitName, $rateLimit := getRateLimits $container }}
        [frontends."frontend-{{$frontend}}".rateLimit.rateSet.{{ $limitName }}]
          period = "{{ $rateLimit.Period }}"
          average = {{ $rateLimit.Average }}
          burst = {{ $rateLimit.Burst }}
        {{end}}
    {{end}}

    {{ if hasHeaders $container}}
    [frontends."frontend-{{$frontend}}".headers]
      {{if hasSSLRedirectHeaders $container}}
      SSLRedirect = {{getSSLRedirectHeaders $container}}
      {{end}}
      {{if hasSSLTemporaryRedirectHeaders $container}}
      SSLTemporaryRedirect = {{getSSLTemporaryRedirectHeaders $container}}
      {{end}}
      {{if hasSSLHostHeaders $container}}
      SSLHost = "{{getSSLHostHeaders $container}}"
      {{end}}
      {{if hasSTSSecondsHeaders $container}}
      STSSeconds = {{getSTSSecondsHeaders $container}}
      {{end}}
      {{if hasSTSIncludeSubdomainsHeaders $container}}
      STSIncludeSubdomains = {{getSTSIncludeSubdomainsHeaders $container}}
      {{end}}
      {{if hasSTSPreloadHeaders $container}}
      STSPreload = {{getSTSPreloadHeaders $container}}
      {{end}}
      {{if hasForceSTSHeaderHeaders $container}}
      ForceSTSHeader = {{getForceSTSHeaderHeaders $container}}
      {{end}}
      {{if hasFrameDenyHeaders $container}}
      FrameDeny = {{getFrameDenyHeaders $container}}
      {{end}}
      {{if hasCustomFrameOptionsValueHeaders $container}}
      CustomFrameOptionsValue = "{{getCustomFrameOptionsValueHeaders $container}}"
      {{end}}
      {{if hasContentTypeNosniffHeaders $container}}
      ContentTypeNosniff = {{getContentTypeNosniffHeaders $container}}
      {{end}}
      {{if hasBrowserXSSFilterHeaders $container}}
      BrowserXSSFilter = {{getBrowserXSSFilterHeaders $container}}
      {{end}}
      {{if hasContentSecurityPolicyHeaders $container}}
      ContentSecurityPolicy = "{{getContentSecurityPolicyHeaders $container}}"
      {{end}}
      {{if hasPublicKeyHeaders $container}}
      PublicKey = "{{getPublicKeyHeaders $container}}"
      {{end}}
      {{if hasReferrerPolicyHeaders $container}}
      ReferrerPolicy = "{{getReferrerPolicyHeaders $container}}"
      {{end}}
      {{if hasIsDevelopmentHeaders $container}}
      IsDevelopment = {{getIsDevelopmentHeaders $container}}
      {{end}}

      {{if hasAllowedHostsHeaders $container}}
      AllowedHosts = [{{range getAllowedHostsHeaders $container}}
        "{{.}}",
        {{end}}]
      {{end}}

      {{if hasHostsProxyHeaders $container}}
      HostsProxyHeaders = [{{range getHostsProxyHeaders $container}}
        "{{.}}",
        {{end}}]
      {{end}}

      {{if hasRequestHeaders $container}}
        [frontends."frontend-{{$frontend}}".headers.customRequestHeaders]
        {{range $k, $v := getRequestHeaders $container}}
        {{$k}} = "{{$v}}"
        {{end}}
      {{end}}

      {{if hasResponseHeaders $container}}
      [frontends."frontend-{{$frontend}}".headers.customResponseHeaders]
        {{range $k, $v := getResponseHeaders $container}}
        {{$k}} = "{{$v}}"
        {{end}}
      {{end}}

      {{if hasSSLProxyHeaders $container}}
      [frontends."frontend-{{$frontend}}".headers.SSLProxyHeaders]
        {{range $k, $v := getSSLProxyHeaders $container}}
        {{$k}} = "{{$v}}"
        {{end}}
      {{end}}
    {{end}}

    [frontends."frontend-{{$frontend}}".routes."route-frontend-{{$frontend}}"]
      rule = "{{getFrontendRule $container}}"

  {{end}}

{{end}}
`)

func templatesDockerTmplBytes() ([]byte, error) {
	return _templatesDockerTmpl, nil
}

func templatesDockerTmpl() (*asset, error) {
	bytes, err := templatesDockerTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "templates/docker.tmpl", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _templatesEcsTmpl = []byte(`[backends]
{{range $serviceName, $instances := .Services}}

  {{if hasCircuitBreakerLabel $instances}}
  [backends.backend-{{ $serviceName }}.circuitBreaker]
    expression = "{{getCircuitBreakerExpression $instances}}"
  {{end}}

  {{if hasLoadBalancerLabel $instances}}
  [backends.backend-{{ $serviceName }}.loadBalancer]
    method = "{{ getLoadBalancerMethod $instances}}"
    sticky = {{ getSticky $instances}}
    {{if hasStickinessLabel $instances}}
    [backends.backend-{{ $serviceName }}.loadBalancer.stickiness]
      cookieName = "{{getStickinessCookieName $instances}}"
    {{end}}
  {{end}}

  {{if hasMaxConnLabels $instances}}
  [backends.backend-{{ $serviceName }}.maxConn]
    amount = {{getMaxConnAmount $instances}}
    extractorFunc = "{{getMaxConnExtractorFunc $instances}}"
  {{end}}

  {{ if hasHealthCheckLabels $instances }}
  [backends.backend-{{ $serviceName }}.healthCheck]
    path = "{{getHealthCheckPath $instances }}"
    port = {{getHealthCheckPort $instances}}
    interval = "{{getHealthCheckInterval $instances }}"
  {{end}}

  {{range $index, $instance := $instances}}
  [backends.backend-{{ $instance.Name }}.servers.server-{{ $instance.Name }}{{ $instance.ID }}]
    url = "{{ getProtocol $instance }}://{{ getHost $instance }}:{{ getPort $instance }}"
    weight = {{ getWeight $instance}}
  {{end}}

{{end}}

[frontends]
{{range $serviceName, $instances := .Services}}
{{range $instance := filterFrontends $instances}}

  [frontends.frontend-{{ $serviceName }}]
    backend = "backend-{{ $serviceName }}"
    priority = {{ getPriority $instance}}
    passHostHeader = {{ getPassHostHeader $instance}}
    passTLSCert = {{ getPassTLSCert $instance}}

    entryPoints = [{{range  getEntryPoints $instance}}
      "{{.}}",
      {{end}}]

    {{if getWhitelistSourceRange $instance}}
    whitelistSourceRange = [{{range getWhitelistSourceRange $instance}}
      "{{.}}",
      {{end}}]
    {{end}}

    basicAuth = [{{range getBasicAuth $instance}}
      "{{.}}",
      {{end}}]

    {{if hasRedirect $instance}}
    [frontends."frontend-{{ $serviceName }}".redirect]
      entryPoint = "{{getRedirectEntryPoint $instance}}"
      regex = "{{getRedirectRegex $instance}}"
      replacement = "{{getRedirectReplacement $instance}}"
    {{end}}

    {{ if hasErrorPages $instance }}
    [frontends."frontend-{{ $serviceName }}".errors]
      {{ range $pageName, $page := getErrorPages $instance }}
      [frontends."frontend-{{ $serviceName }}".errors.{{ $pageName }}]
        status = [{{range $page.Status}}
          "{{.}}",
          {{end}}]
        backend = "{{$page.Backend}}"
        query = "{{$page.Query}}"
      {{end}}
    {{end}}

    {{ if hasRateLimits $instance }}
    [frontends."frontend-{{ $serviceName }}".rateLimit]
      extractorFunc = "{{ getRateLimitsExtractorFunc $instance }}"
      [frontends."frontend-{{ $serviceName }}".rateLimit.rateSet]
        {{ range $limitName, $rateLimit := getRateLimits $instance }}
        [frontends."frontend-{{ $serviceName }}".rateLimit.rateSet.{{ $limitName }}]
          period = "{{ $rateLimit.Period }}"
          average = {{ $rateLimit.Average }}
          burst = {{ $rateLimit.Burst }}
        {{end}}
    {{end}}

    {{if hasHeaders $instance }}
    [frontends."frontend-{{ $serviceName }}".headers]
      {{if hasSSLRedirectHeaders $instance}}
      SSLRedirect = {{getSSLRedirectHeaders $instance}}
      {{end}}
      {{if hasSSLTemporaryRedirectHeaders $instance}}
      SSLTemporaryRedirect = {{getSSLTemporaryRedirectHeaders $instance}}
      {{end}}
      {{if hasSSLHostHeaders $instance}}
      SSLHost = "{{getSSLHostHeaders $instance}}"
      {{end}}
      {{if hasSTSSecondsHeaders $instance}}
      STSSeconds = {{getSTSSecondsHeaders $instance}}
      {{end}}
      {{if hasSTSIncludeSubdomainsHeaders $instance}}
      STSIncludeSubdomains = {{getSTSIncludeSubdomainsHeaders $instance}}
      {{end}}
      {{if hasSTSPreloadHeaders $instance}}
      STSPreload = {{getSTSPreloadHeaders $instance}}
      {{end}}
      {{if hasForceSTSHeaderHeaders $instance}}
      ForceSTSHeader = {{getForceSTSHeaderHeaders $instance}}
      {{end}}
      {{if hasFrameDenyHeaders $instance}}
      FrameDeny = {{getFrameDenyHeaders $instance}}
      {{end}}
      {{if hasCustomFrameOptionsValueHeaders $instance}}
      CustomFrameOptionsValue = "{{getCustomFrameOptionsValueHeaders $instance}}"
      {{end}}
      {{if hasContentTypeNosniffHeaders $instance}}
      ContentTypeNosniff = {{getContentTypeNosniffHeaders $instance}}
      {{end}}
      {{if hasBrowserXSSFilterHeaders $instance}}
      BrowserXSSFilter = {{getBrowserXSSFilterHeaders $instance}}
      {{end}}
      {{if hasContentSecurityPolicyHeaders $instance}}
      ContentSecurityPolicy = "{{getContentSecurityPolicyHeaders $instance}}"
      {{end}}
      {{if hasPublicKeyHeaders $instance}}
      PublicKey = "{{getPublicKeyHeaders $instance}}"
      {{end}}
      {{if hasReferrerPolicyHeaders $instance}}
      ReferrerPolicy = "{{getReferrerPolicyHeaders $instance}}"
      {{end}}
      {{if hasIsDevelopmentHeaders $instance}}
      IsDevelopment = {{getIsDevelopmentHeaders $instance}}
      {{end}}
      {{if hasRequestHeaders $instance}}
        [frontends."frontend-{{ $serviceName }}".headers.customRequestHeaders]
        {{range $k, $v := getRequestHeaders $instance}}
        {{$k}} = "{{$v}}"
        {{end}}
      {{end}}
      {{if hasResponseHeaders $instance}}
      [frontends."frontend-{{ $serviceName }}".headers.customResponseHeaders]
        {{range $k, $v := getResponseHeaders $instance}}
        {{$k}} = "{{$v}}"
        {{end}}
      {{end}}
      {{if hasAllowedHostsHeaders $instance}}
      [frontends."frontend-{{ $serviceName }}".headers.AllowedHosts]
        {{range getAllowedHostsHeaders $instance}}
        "{{.}}"
        {{end}}
      {{end}}
      {{if hasHostsProxyHeaders $instance}}
      [frontends."frontend-{{ $serviceName }}".headers.HostsProxyHeaders]
        {{range getHostsProxyHeaders $instance}}
        "{{.}}"
        {{end}}
      {{end}}
      {{if hasSSLProxyHeaders $instance}}
      [frontends."frontend-{{ $serviceName }}".headers.SSLProxyHeaders]
        {{range $k, $v := getSSLProxyHeaders $instance}}
        {{$k}} = "{{$v}}"
        {{end}}
      {{end}}
    {{end}}

    [frontends.frontend-{{ $serviceName }}.routes.route-frontend-{{ $serviceName }}]
      rule = "{{getFrontendRule $instance}}"

{{end}}
{{end}}`)

func templatesEcsTmplBytes() ([]byte, error) {
	return _templatesEcsTmpl, nil
}

func templatesEcsTmpl() (*asset, error) {
	bytes, err := templatesEcsTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "templates/ecs.tmpl", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _templatesEurekaTmpl = []byte(`[backends]{{range .Applications}}
    {{ $app := .}}
    {{range .Instances}}
    [backends.backend{{$app.Name}}.servers.server-{{ getInstanceID . }}]
    url = "{{ getProtocol . }}://{{ .IpAddr }}:{{ getPort . }}"
    weight = {{ getWeight . }}
{{end}}{{end}}

[frontends]{{range .Applications}}
  [frontends.frontend{{.Name}}]
    backend = "backend{{.Name}}"
    entryPoints = ["http"]
    [frontends.frontend{{.Name }}.routes.route-host{{.Name}}]
      rule = "Host:{{ .Name | tolower }}"
{{end}}
`)

func templatesEurekaTmplBytes() ([]byte, error) {
	return _templatesEurekaTmpl, nil
}

func templatesEurekaTmpl() (*asset, error) {
	bytes, err := templatesEurekaTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "templates/eureka.tmpl", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _templatesKubernetesTmpl = []byte(`[backends]{{range $backendName, $backend := .Backends}}
    [backends."{{$backendName}}"]
    {{if $backend.CircuitBreaker}}
    [backends."{{$backendName}}".circuitbreaker]
      expression = "{{$backend.CircuitBreaker.Expression}}"
    {{end}}
    [backends."{{$backendName}}".loadbalancer]
      method = "{{$backend.LoadBalancer.Method}}"
      {{if $backend.LoadBalancer.Sticky}}
      sticky = true
      {{end}}
      {{if $backend.LoadBalancer.Stickiness}}
      [backends."{{$backendName}}".loadbalancer.stickiness]
        cookieName = "{{$backend.LoadBalancer.Stickiness.CookieName}}"
      {{end}}
    {{range $serverName, $server := $backend.Servers}}
    [backends."{{$backendName}}".servers."{{$serverName}}"]
    url = "{{$server.URL}}"
    weight = {{$server.Weight}}
    {{end}}
{{end}}

[frontends]{{range $frontendName, $frontend := .Frontends}}
  [frontends."{{$frontendName}}"]
  backend = "{{$frontend.Backend}}"
  priority = {{$frontend.Priority}}
  passHostHeader = {{$frontend.PassHostHeader}}
  entryPoints = [{{range $frontend.EntryPoints}}
    "{{.}}",
    {{end}}]
  basicAuth = [{{range $frontend.BasicAuth}}
      "{{.}}",
  {{end}}]
  whitelistSourceRange = [{{range $frontend.WhitelistSourceRange}}
    "{{.}}",
  {{end}}]

  {{if $frontend.Redirect}}
  [frontends."{{$frontendName}}".redirect]
  entryPoint = "{{$frontend.RedirectEntryPoint}}"
  regex = "{{$frontend.RedirectRegex}}"
  replacement = "{{$frontend.RedirectReplacement}}"
  {{end}}

  {{if $frontend.Headers }}
  [frontends."{{$frontendName}}".headers]
  SSLRedirect = {{$frontend.Headers.SSLRedirect}}
  SSLTemporaryRedirect = {{$frontend.Headers.SSLTemporaryRedirect}}
  SSLHost = "{{$frontend.Headers.SSLHost}}"
  STSSeconds = {{$frontend.Headers.STSSeconds}}
  STSIncludeSubdomains = {{$frontend.Headers.STSIncludeSubdomains}}
  STSPreload = {{$frontend.Headers.STSPreload}}
  ForceSTSHeader = {{$frontend.Headers.ForceSTSHeader}}
  FrameDeny = {{$frontend.Headers.FrameDeny}}
  CustomFrameOptionsValue = "{{$frontend.Headers.CustomFrameOptionsValue}}"
  ContentTypeNosniff = {{$frontend.Headers.ContentTypeNosniff}}
  BrowserXSSFilter = {{$frontend.Headers.BrowserXSSFilter}}
  ContentSecurityPolicy = "{{$frontend.Headers.ContentSecurityPolicy}}"
  PublicKey = "{{$frontend.Headers.PublicKey}}"
  ReferrerPolicy = "{{$frontend.Headers.ReferrerPolicy}}"
  IsDevelopment = {{$frontend.Headers.IsDevelopment}}
  {{if $frontend.Headers.AllowedHosts}}
  AllowedHosts = [{{range $frontend.Headers.AllowedHosts}}
    "{{.}}",
    {{end}}]
  {{end}}
  {{if $frontend.Headers.HostsProxyHeaders}}
  HostsProxyHeaders = [{{range $frontend.Headers.HostsProxyHeaders}}
    "{{.}}",
    {{end}}]
  {{end}}
{{if $frontend.Headers.CustomRequestHeaders}}
    [frontends."{{$frontendName}}".headers.customrequestheaders]
    {{range $k, $v := $frontend.Headers.CustomRequestHeaders}}
    {{$k}} = "{{$v}}"
    {{end}}
{{end}}
{{if $frontend.Headers.CustomResponseHeaders}}
    [frontends."{{$frontendName}}".headers.customresponseheaders]
    {{range $k, $v := $frontend.Headers.CustomResponseHeaders}}
    {{$k}} = "{{$v}}"
    {{end}}
{{end}}
{{if $frontend.Headers.SSLProxyHeaders}}
    [frontends."{{$frontendName}}".headers.SSLProxyHeaders]
    {{range $k, $v := $frontend.Headers.SSLProxyHeaders}}
    {{$k}} = "{{$v}}"
    {{end}}
{{end}}
{{end}}
    {{range $routeName, $route := $frontend.Routes}}
    [frontends."{{$frontendName}}".routes."{{$routeName}}"]
    rule = "{{$route.Rule}}"
    {{end}}
{{end}}`)

func templatesKubernetesTmplBytes() ([]byte, error) {
	return _templatesKubernetesTmpl, nil
}

func templatesKubernetesTmpl() (*asset, error) {
	bytes, err := templatesKubernetesTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "templates/kubernetes.tmpl", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _templatesKvTmpl = []byte(`[backends]
{{range $backend := List .Prefix "/backends/"}}
  {{$backendName := Last $backend}}

  {{$circuitBreaker := Get "" $backend "/circuitbreaker/expression"}}
  {{with $circuitBreaker}}
  [backends."{{$backendName}}".circuitBreaker]
    expression = "{{$circuitBreaker}}"
  {{end}}

  {{$loadBalancer := Get "" $backend "/loadbalancer/method"}}
  {{with $loadBalancer}}
  [backends."{{$backendName}}".loadBalancer]
    method = "{{$loadBalancer}}"
    sticky = {{ getSticky $backend }}
    {{if hasStickinessLabel $backend}}
    [backends."{{$backendName}}".loadBalancer.stickiness]
      cookieName = "{{getStickinessCookieName $backend}}"
    {{end}}
  {{end}}

  {{$maxConnAmt := Get "" $backend "/maxconn/amount"}}
  {{$maxConnExtractorFunc := Get "" $backend "/maxconn/extractorfunc"}}
  {{with $maxConnAmt}}
  {{with $maxConnExtractorFunc}}
  [backends."{{$backendName}}".maxConn]
    amount = {{$maxConnAmt}}
    extractorFunc = "{{$maxConnExtractorFunc}}"
  {{end}}
  {{end}}

  {{$healthCheck := Get "" $backend "/healthcheck/path"}}
  {{with $healthCheck}}
  [backends."{{$backendName}}".healthCheck]
    path = "{{$healthCheck}}"
    interval = "{{ Get "30s" $backend "/healthcheck/interval" }}"
  {{end}}

  {{range $server := ListServers $backend}}
  [backends."{{$backendName}}".servers."{{Last $server}}"]
    url = "{{Get "" $server "/url"}}"
    weight = {{Get "0"  $server "/weight"}}
  {{end}}

{{end}}

[frontends]
{{range $frontend := List .Prefix "/frontends/" }}
  {{$frontendName := Last $frontend}}

  [frontends."{{$frontendName}}"]
    backend = "{{Get "" $frontend "/backend"}}"
    priority = {{Get "0" $frontend "/priority"}}
    passHostHeader = {{Get "true" $frontend "/passHostHeader"}}

    {{$entryPoints := SplitGet $frontend "/entrypoints"}}
    entryPoints = [{{range $entryPoints}}
      "{{.}}",
      {{end}}]

    {{range $route := List $frontend "/routes/"}}
    [frontends."{{$frontendName}}".routes."{{Last $route}}"]
      rule = "{{Get "" $route "/rule"}}"
    {{end}}

{{end}}

{{range $tlsConfiguration := List .Prefix "/tlsconfiguration/"}}

[[tlsConfiguration]]

  {{$entryPoints := SplitGet $tlsConfiguration "/entrypoints"}}
  entryPoints = [{{range $entryPoints}}
    "{{.}}",
    {{end}}]

  [tlsConfiguration.certificate]
    certFile = """{{Get "" $tlsConfiguration "/certificate/certfile"}}"""
    keyFile = """{{Get "" $tlsConfiguration "/certificate/keyfile"}}"""

{{end}}
`)

func templatesKvTmplBytes() ([]byte, error) {
	return _templatesKvTmpl, nil
}

func templatesKvTmpl() (*asset, error) {
	bytes, err := templatesKvTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "templates/kv.tmpl", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _templatesMarathonTmpl = []byte(`{{$apps := .Applications}}

[backends]
{{range $app := $apps}}
{{range $serviceIndex, $serviceName := getServiceNames $app}}

  [backends."{{getBackend $app $serviceName }}"]

    {{ if hasCircuitBreakerLabels $app }}
    [backends."{{getBackend $app $serviceName }}".circuitBreaker]
      expression = "{{getCircuitBreakerExpression $app }}"
    {{end}}

    {{ if hasLoadBalancerLabels $app }}
    [backends."{{getBackend $app $serviceName }}".loadBalancer]
      method = "{{getLoadBalancerMethod $app }}"
      sticky = {{getSticky $app}}
      {{if hasStickinessLabel $app}}
      [backends."{{getBackend $app $serviceName }}".loadBalancer.stickiness]
        cookieName = "{{getStickinessCookieName $app}}"
      {{end}}
    {{end}}

    {{ if hasMaxConnLabels $app }}
    [backends."{{getBackend $app $serviceName }}".maxConn]
      amount = {{getMaxConnAmount $app }}
      extractorFunc = "{{getMaxConnExtractorFunc $app }}"
    {{end}}

    {{ if hasHealthCheckLabels $app }}
    [backends."{{getBackend $app $serviceName }}".healthCheck]
      path = "{{getHealthCheckPath $app }}"
      port = {{getHealthCheckPort $app}}
      interval = "{{getHealthCheckInterval $app }}"
    {{end}}

{{end}}

    {{range $task := $app.Tasks}}
    {{range $serviceIndex, $serviceName := getServiceNames $app}}

    [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}}
    {{end}}

{{end}}

[frontends]
{{range $app := $apps}}
{{range $serviceIndex, $serviceName := getServiceNames .}}

  [frontends."{{ getFrontendName $app $serviceName }}"]
    backend = "{{getBackend $app $serviceName}}"
    priority = {{getPriority $app $serviceName}}
    passHostHeader = {{getPassHostHeader $app $serviceName}}
    passTLSCert = {{getPassTLSCert $app $serviceName}}

    entryPoints = [{{range getEntryPoints $app $serviceName}}
      "{{.}}",
      {{end}}]

    {{if getWhitelistSourceRange $app $serviceName}}
    whitelistSourceRange = [{{range getWhitelistSourceRange $app $serviceName}}
      "{{.}}",
      {{end}}]
    {{end}}

    basicAuth = [{{range getBasicAuth $app $serviceName}}
      "{{.}}",
      {{end}}]

    {{if hasRedirect $app $serviceName}}
    [frontends."{{ getFrontendName $app $serviceName }}".redirect]
      entryPoint = "{{getRedirectEntryPoint $app $serviceName}}"
      regex = "{{getRedirectRegex $app $serviceName}}"
      replacement = "{{getRedirectReplacement $app $serviceName}}"
    {{end}}

    {{ if hasErrorPages $app $serviceName }}
    [frontends."{{ getFrontendName $app $serviceName }}".errors]
      {{ range $pageName, $page := getErrorPages $app $serviceName }}
      [frontends."{{ getFrontendName $app $serviceName }}".errors.{{ $pageName }}]
        status = [{{range $page.Status}}
        "{{.}}",
        {{end}}]
        backend = "{{$page.Backend}}"
        query = "{{$page.Query}}"
      {{end}}
    {{end}}

    {{ if hasRateLimits $app $serviceName }}
    [frontends."{{ getFrontendName $app $serviceName }}".rateLimit]
      extractorFunc = "{{ getRateLimitsExtractorFunc $app $serviceName }}"
      [frontends."{{ getFrontendName $app $serviceName }}".rateLimit.rateSet]
        {{ range $limitName, $rateLimit := getRateLimits $app $serviceName }}
        [frontends."{{ getFrontendName $app $serviceName }}".rateLimit.rateSet.{{ $limitName }}]
        period = "{{ $rateLimit.Period }}"
        average = {{ $rateLimit.Average }}
        burst = {{ $rateLimit.Burst }}
        {{end}}
    {{end}}

  {{if hasHeaders $app $serviceName }}
  [frontends."{{ getFrontendName $app $serviceName }}".headers]
    {{if hasSSLRedirectHeaders $app $serviceName}}
    SSLRedirect = {{getSSLRedirectHeaders $app $serviceName}}
    {{end}}
    {{if hasSSLTemporaryRedirectHeaders $app $serviceName}}
    SSLTemporaryRedirect = {{getSSLTemporaryRedirectHeaders $app $serviceName}}
    {{end}}
    {{if hasSSLHostHeaders $app $serviceName}}
    SSLHost = "{{getSSLHostHeaders $app $serviceName}}"
    {{end}}
    {{if hasSTSSecondsHeaders $app $serviceName}}
    STSSeconds = {{getSTSSecondsHeaders $app $serviceName}}
    {{end}}
    {{if hasSTSIncludeSubdomainsHeaders $app $serviceName}}
    STSIncludeSubdomains = {{getSTSIncludeSubdomainsHeaders $app $serviceName}}
    {{end}}
    {{if hasSTSPreloadHeaders $app $serviceName}}
    STSPreload = {{getSTSPreloadHeaders $app $serviceName}}
    {{end}}
    {{if hasForceSTSHeaderHeaders $app $serviceName}}
    ForceSTSHeader = {{getForceSTSHeaderHeaders $app $serviceName}}
    {{end}}
    {{if hasFrameDenyHeaders $app $serviceName}}
    FrameDeny = {{getFrameDenyHeaders $app $serviceName}}
    {{end}}
    {{if hasCustomFrameOptionsValueHeaders $app $serviceName}}
    CustomFrameOptionsValue = "{{getCustomFrameOptionsValueHeaders $app $serviceName}}"
    {{end}}
    {{if hasContentTypeNosniffHeaders $app $serviceName}}
    ContentTypeNosniff = {{getContentTypeNosniffHeaders $app $serviceName}}
    {{end}}
    {{if hasBrowserXSSFilterHeaders $app $serviceName}}
    BrowserXSSFilter = {{getBrowserXSSFilterHeaders $app $serviceName}}
    {{end}}
    {{if hasContentSecurityPolicyHeaders $app $serviceName}}
    ContentSecurityPolicy = "{{getContentSecurityPolicyHeaders $app $serviceName}}"
    {{end}}
    {{if hasPublicKeyHeaders $app $serviceName}}
    PublicKey = "{{getPublicKeyHeaders $app $serviceName}}"
    {{end}}
    {{if hasReferrerPolicyHeaders $app $serviceName}}
    ReferrerPolicy = "{{getReferrerPolicyHeaders $app $serviceName}}"
    {{end}}
    {{if hasIsDevelopmentHeaders $app $serviceName}}
    IsDevelopment = {{getIsDevelopmentHeaders $app $serviceName}}
    {{end}}

    {{if hasAllowedHostsHeaders $app $serviceName}}
    AllowedHosts = [{{range getAllowedHostsHeaders $app $serviceName}}
      "{{.}}",
      {{end}}]
    {{end}}

    {{if hasHostsProxyHeaders $app $serviceName}}
    HostsProxyHeaders = [{{range getHostsProxyHeaders $app $serviceName}}
      "{{.}}",
      {{end}}]
    {{end}}

    {{if hasRequestHeaders $app $serviceName}}
    [frontends."{{ getFrontendName $app $serviceName }}".headers.customRequestHeaders]
      {{range $k, $v := getRequestHeaders $app $serviceName}}
      {{$k}} = "{{$v}}"
      {{end}}
    {{end}}

    {{if hasResponseHeaders $app $serviceName}}
    [frontends."{{ getFrontendName $app $serviceName }}".headers.customResponseHeaders]
      {{range $k, $v := getResponseHeaders $app $serviceName}}
      {{$k}} = "{{$v}}"
      {{end}}
    {{end}}

    {{if hasSSLProxyHeaders $app $serviceName}}
    [frontends."{{ getFrontendName $app $serviceName }}".headers.SSLProxyHeaders]
      {{range $k, $v := getSSLProxyHeaders $app $serviceName}}
      {{$k}} = "{{$v}}"
      {{end}}
    {{end}}
  {{end}}

  [frontends."{{ getFrontendName $app $serviceName }}".routes."route-host{{$app.ID | replace "/" "-"}}{{getServiceNameSuffix $serviceName }}"]
    rule = "{{getFrontendRule $app $serviceName}}"

{{end}}
{{end}}
`)

func templatesMarathonTmplBytes() ([]byte, error) {
	return _templatesMarathonTmpl, nil
}

func templatesMarathonTmpl() (*asset, error) {
	bytes, err := templatesMarathonTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "templates/marathon.tmpl", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _templatesMesosTmpl = []byte(`{{$apps := .Applications}}
[backends]{{range .Tasks}}
    [backends.backend{{getBackend . $apps}}.servers.server-{{getID .}}]
    url = "{{getProtocol . $apps}}://{{getHost .}}:{{getPort . $apps}}"
    weight = {{getWeight . $apps}}
{{end}}

[frontends]{{range .Applications}}
  [frontends.frontend-{{getFrontEndName .}}]
  backend = "backend{{getFrontendBackend .}}"
  passHostHeader = {{getPassHostHeader .}}
  priority = {{getPriority .}}
  entryPoints = [{{range getEntryPoints .}}
    "{{.}}",
  {{end}}]
    [frontends.frontend-{{getFrontEndName .}}.routes.route-host{{getFrontEndName .}}]
    rule = "{{getFrontendRule .}}"
{{end}}
`)

func templatesMesosTmplBytes() ([]byte, error) {
	return _templatesMesosTmpl, nil
}

func templatesMesosTmpl() (*asset, error) {
	bytes, err := templatesMesosTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "templates/mesos.tmpl", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _templatesNotfoundTmpl = []byte(`<!DOCTYPE html>
<html>
<head>
    <title>Traefik</title>
</head>
<body>
    Ohhhh man, this is bad...
</body>
</html>`)

func templatesNotfoundTmplBytes() ([]byte, error) {
	return _templatesNotfoundTmpl, nil
}

func templatesNotfoundTmpl() (*asset, error) {
	bytes, err := templatesNotfoundTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "templates/notFound.tmpl", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _templatesRancherTmpl = []byte(`{{$backendServers := .Backends}}
[backends]
{{range $backendName, $backend := .Backends}}

  [backends.backend-{{$backendName}}]

  {{if hasCircuitBreakerLabel $backend}}
  [backends.backend-{{$backendName}}.circuitBreaker]
    expression = "{{getCircuitBreakerExpression $backend}}"
  {{end}}

  {{if hasLoadBalancerLabel $backend}}
  [backends.backend-{{$backendName}}.loadBalancer]
    method = "{{getLoadBalancerMethod $backend}}"
    sticky = {{getSticky $backend}}
    {{if hasStickinessLabel $backend}}
    [backends.backend-{{$backendName}}.loadBalancer.stickiness]
      cookieName = "{{getStickinessCookieName $backend}}"
    {{end}}
  {{end}}

  {{if hasMaxConnLabels $backend}}
  [backends.backend-{{$backendName}}.maxConn]
    amount = {{getMaxConnAmount $backend}}
    extractorFunc = "{{getMaxConnExtractorFunc $backend}}"
  {{end}}

  {{if hasHealthCheckLabels $backend}}
  [backends.backend-{{$backendName}}.healthCheck]
    path = "{{getHealthCheckPath $backend}}"
    port = {{getHealthCheckPort $backend}}
    interval = "{{getHealthCheckInterval $backend}}"
  {{end}}

  {{range $index, $ip := $backend.Containers}}
  [backends.backend-{{$backendName}}.servers.server-{{$index}}]
    url = "{{getProtocol $backend}}://{{$ip}}:{{getPort $backend}}"
    weight = {{getWeight $backend}}
  {{end}}

{{end}}

[frontends]
{{range $frontendName, $service := .Frontends}}

  [frontends."frontend-{{$frontendName}}"]
    backend = "backend-{{getBackend $service}}"
    priority = {{getPriority $service}}
    passHostHeader = {{getPassHostHeader $service}}
    passTLSCert = {{getPassTLSCert $service}}

    entryPoints = [{{range getEntryPoints $service}}
      "{{.}}",
      {{end}}]

    {{if getWhitelistSourceRange $service}}
    whitelistSourceRange = [{{range getWhitelistSourceRange $service}}
      "{{.}}",
      {{end}}]
    {{end}}

    basicAuth = [{{range getBasicAuth $service}}
      "{{.}}",
      {{end}}]

    {{if hasRedirect $service}}
    [frontends."frontend-{{$frontendName}}".redirect]
      entryPoint = "{{getRedirectEntryPoint $service}}"
      regex = "{{getRedirectRegex $service}}"
      replacement = "{{getRedirectReplacement $service}}"
    {{end}}

    {{ if hasErrorPages $service }}
    [frontends."frontend-{{$frontendName}}".errors]
      {{ range $pageName, $page := getErrorPages $service }}
      [frontends."frontend-{{$frontendName}}".errors.{{ $pageName }}]
        status = [{{range $page.Status}}
        "{{.}}",
        {{end}}]
        backend = "{{$page.Backend}}"
        query = "{{$page.Query}}"
      {{end}}
    {{end}}

    {{ if hasRateLimits $service }}
    [frontends."frontend-{{$frontendName}}".rateLimit]
      extractorFunc = "{{ getRateLimitsExtractorFunc $service }}"
      [frontends."frontend-{{$frontendName}}".rateLimit.rateSet]
        {{ range $limitName, $rateLimit := getRateLimits $service }}
        [frontends."frontend-{{$frontendName}}".rateLimit.rateSet.{{ $limitName }}]
        period = "{{ $rateLimit.Period }}"
        average = {{ $rateLimit.Average }}
        burst = {{ $rateLimit.Burst }}
      {{end}}
    {{end}}

  {{if hasHeaders $service }}
  [frontends."frontend-{{$frontendName}}".headers]
    SSLRedirect = {{getSSLRedirectHeaders $service}}
    SSLTemporaryRedirect = {{getSSLTemporaryRedirectHeaders $service}}
    SSLHost = "{{getSSLHostHeaders $service}}"
    STSSeconds = {{getSTSSecondsHeaders $service}}
    STSIncludeSubdomains = {{getSTSIncludeSubdomainsHeaders $service}}
    STSPreload = {{getSTSPreloadHeaders $service}}
    ForceSTSHeader = {{getForceSTSHeaderHeaders $service}}
    FrameDeny = {{getFrameDenyHeaders $service}}
    CustomFrameOptionsValue = "{{getCustomFrameOptionsValueHeaders $service}}"
    ContentTypeNosniff = {{getContentTypeNosniffHeaders $service}}
    BrowserXSSFilter = {{getBrowserXSSFilterHeaders $service}}
    ContentSecurityPolicy = "{{getContentSecurityPolicyHeaders $service}}"
    PublicKey = "{{getPublicKeyHeaders $service}}"
    ReferrerPolicy = "{{getReferrerPolicyHeaders $service}}"
    IsDevelopment = {{getIsDevelopmentHeaders $service}}

    AllowedHosts = [{{range getAllowedHostsHeaders $service}}
      "{{.}}",
      {{end}}]

    HostsProxyHeaders = [{{range getHostsProxyHeaders $service}}
      "{{.}}",
      {{end}}]

    {{if hasRequestHeaders $service}}
    [frontends."frontend-{{$frontendName}}".headers.customRequestHeaders]
      {{range $k, $v := getRequestHeaders $service}}
      {{$k}} = "{{$v}}"
      {{end}}
    {{end}}
    {{if hasResponseHeaders $service}}
    [frontends."frontend-{{$frontendName}}".headers.customResponseHeaders]
      {{range $k, $v := getResponseHeaders $service}}
      {{$k}} = "{{$v}}"
      {{end}}
    {{end}}
    {{if hasSSLProxyHeaders $service}}
    [frontends."frontend-{{$frontendName}}".headers.SSLProxyHeaders]
      {{range $k, $v := getSSLProxyHeaders $service}}
      {{$k}} = "{{$v}}"
      {{end}}
    {{end}}
  {{end}}

    [frontends."frontend-{{$frontendName}}".routes."route-frontend-{{$frontendName}}"]
      rule = "{{getFrontendRule $service}}"

{{end}}
`)

func templatesRancherTmplBytes() ([]byte, error) {
	return _templatesRancherTmpl, nil
}

func templatesRancherTmpl() (*asset, error) {
	bytes, err := templatesRancherTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "templates/rancher.tmpl", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

// Asset loads and returns the asset for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func Asset(name string) ([]byte, error) {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[cannonicalName]; ok {
		a, err := f()
		if err != nil {
			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
		}
		return a.bytes, nil
	}
	return nil, fmt.Errorf("Asset %s not found", name)
}

// MustAsset is like Asset but panics when Asset would return an error.
// It simplifies safe initialization of global variables.
func MustAsset(name string) []byte {
	a, err := Asset(name)
	if err != nil {
		panic("asset: Asset(" + name + "): " + err.Error())
	}

	return a
}

// AssetInfo loads and returns the asset info for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func AssetInfo(name string) (os.FileInfo, error) {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[cannonicalName]; ok {
		a, err := f()
		if err != nil {
			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
		}
		return a.info, nil
	}
	return nil, fmt.Errorf("AssetInfo %s not found", name)
}

// AssetNames returns the names of the assets.
func AssetNames() []string {
	names := make([]string, 0, len(_bindata))
	for name := range _bindata {
		names = append(names, name)
	}
	return names
}

// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() (*asset, error){
	"templates/consul_catalog.tmpl": templatesConsul_catalogTmpl,
	"templates/docker.tmpl":         templatesDockerTmpl,
	"templates/ecs.tmpl":            templatesEcsTmpl,
	"templates/eureka.tmpl":         templatesEurekaTmpl,
	"templates/kubernetes.tmpl":     templatesKubernetesTmpl,
	"templates/kv.tmpl":             templatesKvTmpl,
	"templates/marathon.tmpl":       templatesMarathonTmpl,
	"templates/mesos.tmpl":          templatesMesosTmpl,
	"templates/notFound.tmpl":       templatesNotfoundTmpl,
	"templates/rancher.tmpl":        templatesRancherTmpl,
}

// AssetDir returns the file names below a certain
// directory embedded in the file by go-bindata.
// For example if you run go-bindata on data/... and data contains the
// following hierarchy:
//     data/
//       foo.txt
//       img/
//         a.png
//         b.png
// then AssetDir("data") would return []string{"foo.txt", "img"}
// AssetDir("data/img") would return []string{"a.png", "b.png"}
// AssetDir("foo.txt") and AssetDir("notexist") would return an error
// AssetDir("") will return []string{"data"}.
func AssetDir(name string) ([]string, error) {
	node := _bintree
	if len(name) != 0 {
		cannonicalName := strings.Replace(name, "\\", "/", -1)
		pathList := strings.Split(cannonicalName, "/")
		for _, p := range pathList {
			node = node.Children[p]
			if node == nil {
				return nil, fmt.Errorf("Asset %s not found", name)
			}
		}
	}
	if node.Func != nil {
		return nil, fmt.Errorf("Asset %s not found", name)
	}
	rv := make([]string, 0, len(node.Children))
	for childName := range node.Children {
		rv = append(rv, childName)
	}
	return rv, nil
}

type bintree struct {
	Func     func() (*asset, error)
	Children map[string]*bintree
}

var _bintree = &bintree{nil, map[string]*bintree{
	"templates": {nil, map[string]*bintree{
		"consul_catalog.tmpl": {templatesConsul_catalogTmpl, map[string]*bintree{}},
		"docker.tmpl":         {templatesDockerTmpl, map[string]*bintree{}},
		"ecs.tmpl":            {templatesEcsTmpl, map[string]*bintree{}},
		"eureka.tmpl":         {templatesEurekaTmpl, map[string]*bintree{}},
		"kubernetes.tmpl":     {templatesKubernetesTmpl, map[string]*bintree{}},
		"kv.tmpl":             {templatesKvTmpl, map[string]*bintree{}},
		"marathon.tmpl":       {templatesMarathonTmpl, map[string]*bintree{}},
		"mesos.tmpl":          {templatesMesosTmpl, map[string]*bintree{}},
		"notFound.tmpl":       {templatesNotfoundTmpl, map[string]*bintree{}},
		"rancher.tmpl":        {templatesRancherTmpl, map[string]*bintree{}},
	}},
}}

// RestoreAsset restores an asset under the given directory
func RestoreAsset(dir, name string) error {
	data, err := Asset(name)
	if err != nil {
		return err
	}
	info, err := AssetInfo(name)
	if err != nil {
		return err
	}
	err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
	if err != nil {
		return err
	}
	err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
	if err != nil {
		return err
	}
	err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
	if err != nil {
		return err
	}
	return nil
}

// RestoreAssets restores an asset under the given directory recursively
func RestoreAssets(dir, name string) error {
	children, err := AssetDir(name)
	// File
	if err != nil {
		return RestoreAsset(dir, name)
	}
	// Dir
	for _, child := range children {
		err = RestoreAssets(dir, filepath.Join(name, child))
		if err != nil {
			return err
		}
	}
	return nil
}

func _filePath(dir, name string) string {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
}