Merge pull request #250 from containous/bump-beta-semver

Bump to beta, using semver

.dockerignore

@@ -0,0 +1,3 @@
+dist/
+vendor/
+!dist/traefik

.github/CONTRIBUTING.md

@@ -0,0 +1,78 @@
+# Contributing
+
+### Building
+
+You need either [Docker](https://github.com/docker/docker) and `make`, or `go` and `glide` in order to build traefik.
+
+#### Setting up your `go` environment
+
+- You need `go` v1.5
+- You need to set `export GO15VENDOREXPERIMENT=1` environment variable
+- You need `go-bindata` to be able to use `go generate` command (needed to build) : `go get github.com/jteeuwen/go-bindata/...`.
+- If you clone Træfɪk into something like `~/go/src/github.com/traefik`, your `GOPATH` variable will have to be set to `~/go`: export `GOPATH=~/go`.
+
+#### Using `Docker` and `Makefile`
+
+You need to run the `binary` target. This will create binaries for Linux platform in the `dist` folder.
+
+```bash
+$ make binary
+docker build -t "traefik-dev:no-more-godep-ever" -f build.Dockerfile .
+Sending build context to Docker daemon 295.3 MB
+Step 0 : FROM golang:1.5
+ ---> 8c6473912976
+Step 1 : RUN go get github.com/Masterminds/glide
+[...]
+docker run --rm  -v "/var/run/docker.sock:/var/run/docker.sock" -it -e OS_ARCH_ARG -e OS_PLATFORM_ARG -e TESTFLAGS -v "/home/emile/dev/go/src/github.com/containous/traefik/"dist":/go/src/github.com/containous/traefik/"dist"" "traefik-dev:no-more-godep-ever" ./script/make.sh generate binary
+---> Making bundle: generate (in .)
+removed 'gen.go'
+
+---> Making bundle: binary (in .)
+
+$ ls dist/
+traefik*
+```
+
+#### Using `glide`
+
+The idea behind `glide` is the following :
+
+- when checkout(ing) a project, **run `glide up --quick`** to install
+  (`go get …`) the dependencies in the `GOPATH`.
+- if you need another dependency, import and use it in
+  the source, and **run `glide get github.com/Masterminds/cookoo`** to save it in
+  `vendor` and add it to your `glide.yaml`.
+
+```bash
+$ glide up --quick
+# generate
+$ go generate
+# Simple go build
+$ go build
+# Using gox to build multiple platform
+$ gox "linux darwin" "386 amd64 arm" \
+    -output="dist/traefik_{{.OS}}-{{.Arch}}"
+# run other commands like tests
+$ go test ./...
+ok      _/home/vincent/src/github/vdemeester/traefik    0.004s
+```
+
+### Tests
+
+You can run unit tests using the `test-unit` target and the
+integration test using the `test-integration` target.
+
+```bash
+$ make test-unit
+docker build -t "traefik-dev:your-feature-branch" -f build.Dockerfile .
+# […]
+docker run --rm -it -e OS_ARCH_ARG -e OS_PLATFORM_ARG -e TESTFLAGS -v "/home/vincent/src/github/vdemeester/traefik/dist:/go/src/github.com/containous/traefik/dist" "traefik-dev:your-feature-branch" ./script/make.sh generate test-unit
+---> Making bundle: generate (in .)
+removed 'gen.go'
+
+---> Making bundle: test-unit (in .)
++ go test -cover -coverprofile=cover.out .
+ok      github.com/containous/traefik   0.005s  coverage: 4.1% of statements
+
+Test success
+```

.gitignore

@@ -5,5 +5,7 @@ log
 *.iml
 traefik
 traefik.toml
-
+*.test
 vendor/
+static/
+glide.lock

.travis.yml

@@ -0,0 +1,27 @@
+env:
+  REPO: $TRAVIS_REPO_SLUG
+  VERSION: v1.0.0-beta.$TRAVIS_BUILD_NUMBER
+
+sudo: required
+
+services:
+  - docker
+
+install:
+  - sudo service docker stop
+  - sudo curl https://get.docker.com/builds/Linux/x86_64/docker-1.10.1 -o /usr/bin/docker
+  - sudo chmod +x /usr/bin/docker
+  - sudo service docker start
+
+before_script:
+  - make validate
+  - make binary
+
+script:
+  - make test-unit
+  - make test-integration
+  - make crossbinary
+  - make image
+
+after_success:
+ - make deploy

Dockerfile

@@ -1,4 +1,5 @@
 FROM scratch
 COPY script/ca-certificates.crt /etc/ssl/certs/
 COPY dist/traefik /
+EXPOSE 80
 ENTRYPOINT ["/traefik"]

LICENSE.md

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Emile Vauge, emile@vauge.com
+Copyright (c) 2016 Containous SAS, Emile Vauge, emile@vauge.com
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+THE SOFTWARE.

Makefile

@@ -3,27 +3,33 @@
 TRAEFIK_ENVS := \
 	-e OS_ARCH_ARG \
 	-e OS_PLATFORM_ARG \
-	-e TESTFLAGS
+	-e TESTFLAGS \
+	-e VERSION
+
+SRCS = $(shell git ls-files '*.go' | grep -v '^external/')
 
 BIND_DIR := "dist"
-TRAEFIK_MOUNT := -v "$(CURDIR)/$(BIND_DIR):/go/src/github.com/emilevauge/traefik/$(BIND_DIR)"
+TRAEFIK_MOUNT := -v "$(CURDIR)/$(BIND_DIR):/go/src/github.com/containous/traefik/$(BIND_DIR)"
 
 GIT_BRANCH := $(shell git rev-parse --abbrev-ref HEAD 2>/dev/null)
 TRAEFIK_DEV_IMAGE := traefik-dev$(if $(GIT_BRANCH),:$(GIT_BRANCH))
 REPONAME := $(shell echo $(REPO) | tr '[:upper:]' '[:lower:]')
-TRAEFIK_IMAGE := $(if $(REPONAME),$(REPONAME),"emilevauge/traefik")
+TRAEFIK_IMAGE := $(if $(REPONAME),$(REPONAME),"containous/traefik")
 INTEGRATION_OPTS := $(if $(MAKE_DOCKER_HOST),-e "DOCKER_HOST=$(MAKE_DOCKER_HOST)", -v "/var/run/docker.sock:/var/run/docker.sock")
 
-DOCKER_RUN_TRAEFIK := docker run $(if $(CIRCLECI),,--rm) $(INTEGRATION_OPTS) -it $(TRAEFIK_ENVS) $(TRAEFIK_MOUNT) "$(TRAEFIK_DEV_IMAGE)"
+DOCKER_RUN_TRAEFIK := docker run $(INTEGRATION_OPTS) -it $(TRAEFIK_ENVS) $(TRAEFIK_MOUNT) "$(TRAEFIK_DEV_IMAGE)"
 
 print-%: ; @echo $*=$($*)
 
 default: binary
 
-binary: build
+all: generate-webui build
+	$(DOCKER_RUN_TRAEFIK) ./script/make.sh
+
+binary: generate-webui build
 	$(DOCKER_RUN_TRAEFIK) ./script/make.sh generate binary
 
-crossbinary: build
+crossbinary: generate-webui build
 	$(DOCKER_RUN_TRAEFIK) ./script/make.sh generate crossbinary
 
 test: build
@@ -36,7 +42,7 @@ test-integration: build
 	$(DOCKER_RUN_TRAEFIK) ./script/make.sh generate test-integration
 
 validate: build
-	$(DOCKER_RUN_TRAEFIK) ./script/make.sh validate-gofmt validate-govet
+	$(DOCKER_RUN_TRAEFIK) ./script/make.sh validate-gofmt validate-govet validate-golint
 
 validate-gofmt: build
 	$(DOCKER_RUN_TRAEFIK) ./script/make.sh validate-gofmt
@@ -44,9 +50,15 @@ validate-gofmt: build
 validate-govet: build
 	$(DOCKER_RUN_TRAEFIK) ./script/make.sh validate-govet
 
+validate-golint: build
+	$(DOCKER_RUN_TRAEFIK) ./script/make.sh validate-golint
+
 build: dist
 	docker build -t "$(TRAEFIK_DEV_IMAGE)" -f build.Dockerfile .
 
+build-webui:
+	docker build -t traefik-webui -f webui/Dockerfile webui
+
 build-no-cache: dist
 	docker build --no-cache -t "$(TRAEFIK_DEV_IMAGE)" -f build.Dockerfile .
 
@@ -63,3 +75,19 @@ run-dev:
 	go generate
 	go build
 	./traefik
+
+generate-webui: build-webui
+	if [ ! -d "static" ]; then \
+		mkdir -p static; \
+		docker run --rm -v "$$PWD/static":'/src/static' traefik-webui gulp; \
+		echo 'For more informations show `webui/readme.md`' > $$PWD/static/DONT-EDIT-FILES-IN-THIS-DIRECTORY.md; \
+	fi
+
+lint:
+	$(foreach file,$(SRCS),golint $(file) || exit;)
+
+fmt:
+	gofmt -s -l -w $(SRCS)
+
+deploy:
+	./script/deploy.sh

README.md

@@ -1,32 +1,38 @@
-![Træfɪk](http://traefik.github.io/traefik.logo.svg  "Træfɪk")
-___
 
-[![Circle CI](https://circleci.com/gh/emilevauge/traefik.svg?style=shield&circle-token=:circle-token)](https://circleci.com/gh/emilevauge/traefik)
-[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/EmileVauge/traefik/blob/master/LICENSE.md)
+<p align="center">
+<img src="http://traefik.github.io/traefik.logo.svg" alt="Træfɪk" title="Træfɪk" />
+</p>
+
+[![Build Status](https://travis-ci.org/containous/traefik.svg?branch=master)](https://travis-ci.org/containous/traefik)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)](https://github.com/containous/traefik/blob/master/LICENSE.md)
 [![Join the chat at https://traefik.herokuapp.com](https://img.shields.io/badge/style-register-green.svg?style=social&label=Slack)](https://traefik.herokuapp.com)
+[![Twitter](https://img.shields.io/twitter/follow/traefikproxy.svg?style=social)](https://twitter.com/intent/follow?screen_name=traefikproxy)
+
 
 
 Træfɪk is a modern HTTP reverse proxy and load balancer made to deploy microservices with ease.
-It supports several backends ([Docker :whale:](https://www.docker.com/), [Mesos/Marathon](https://mesosphere.github.io/marathon/), [Consul](https://consul.io/), [Etcd](https://coreos.com/etcd/), [Zookeeper](https://zookeeper.apache.org), [BoltDB](https://github.com/boltdb/bolt), Rest API, file...) to manage its configuration automatically and dynamically.
+It supports several backends ([Docker :whale:](https://www.docker.com/), [Mesos/Marathon](https://mesosphere.github.io/marathon/), [Consul](https://www.consul.io/), [Etcd](https://coreos.com/etcd/), [Zookeeper](https://zookeeper.apache.org), [BoltDB](https://github.com/boltdb/bolt), Rest API, file...) to manage its configuration automatically and dynamically.
 
 
 ## Features
 
+- [It's fast](docs/index.md#benchmarks)
 - No dependency hell, single binary made with go
 - Simple json Rest API
 - Simple TOML file configuration
 - Multiple backends supported: Docker, Mesos/Marathon, Consul, Etcd, and more to come
 - Watchers for backends, can listen change in backends to apply a new configuration automatically
 - Hot-reloading of configuration. No need to restart the process
-- Graceful shutdown http connections during hot-reloads
+- Graceful shutdown http connections
 - Circuit breakers on backends
 - Round Robin, rebalancer load-balancers
 - Rest Metrics
-- Tiny docker image included
+- Tiny docker image included [![Image Layers](https://badge.imagelayers.io/containous/traefik:latest.svg)](https://imagelayers.io/?images=containous/traefik:latest)
 - SSL backends support
 - SSL frontend support
 - Clean AngularJS Web UI
 - Websocket support
+- HTTP/2 support
 
 ## Demo
 
@@ -43,113 +49,64 @@ You can access to a simple HTML frontend of Træfik.
 
 ## Plumbing
 
-- [Oxy](https://github.com/mailgun/oxy/): an awsome proxy library made by Mailgun guys
+- [Oxy](https://github.com/vulcand/oxy): an awsome proxy library made by Mailgun guys
 - [Gorilla mux](https://github.com/gorilla/mux): famous request router
 - [Negroni](https://github.com/codegangsta/negroni): web middlewares made simple
 - [Manners](https://github.com/mailgun/manners): graceful shutdown of http.Handler servers
 
 ## Quick start
 
-- The simple way: grab the latest binary from the [releases](https://github.com/emilevauge/traefik/releases) page and just run it with the [sample configuration file](https://raw.githubusercontent.com/EmileVauge/traefik/master/traefik.sample.toml):
+- The simple way: grab the latest binary from the [releases](https://github.com/containous/traefik/releases) page and just run it with the [sample configuration file](https://raw.githubusercontent.com/containous/traefik/master/traefik.sample.toml):
 
 ```shell
-./traefik traefik.toml
+./traefik -c traefik.toml
 ```
 
 - Use the tiny Docker image:
 
 ```shell
-docker run -d -p 8080:8080 -p 80:80 -v $PWD/traefik.toml:/traefik.toml emilevauge/traefik
+docker run -d -p 8080:8080 -p 80:80 -v $PWD/traefik.toml:/etc/traefik/traefik.toml containous/traefik
 ```
 
 - From sources:
 
 ```shell
-git clone https://github.com/EmileVauge/traefik
+git clone https://github.com/containous/traefik
 ```
 
 ## Documentation
 
 You can find the complete documentation [here](docs/index.md).
 
-## Benchmarks
-
-Refer to the [benchmarks section](docs/index.md#benchmarks) in the documentation.
-
 ## Contributing
 
-### Building
+Please refer to [this section](.github/CONTRIBUTING.md).
 
-You need either [Docker](https://github.com/docker/docker) and `make`, or `go` and `glide` in order to build traefik.
+## Træfɪk here and there
 
-#### Setting up your `go` environment
-- You need `go` v1.5
-- You need to set `export GO15VENDOREXPERIMENT=1` environment variable
-- If you clone Træfɪk into something like `~/go/src/github.com/traefik`, your `GOPATH` variable will have to be set to `~/go`: export `GOPATH=~/go`.
+These projects use Træfɪk internally. If your company uses Træfɪk, we would be glad to get your feedback :) Contact us on [![Join the chat at https://traefik.herokuapp.com](https://img.shields.io/badge/style-register-green.svg?style=social&label=Slack)](https://traefik.herokuapp.com)
 
-#### Using `Docker` and `Makefile`
+- Project [Mantl](https://mantl.io/) from Cisco
 
-You need to run the `binary` target. This will create binaries for
-linux platform in the `dist` folder.
+![Web UI Providers](docs/img/mantl-logo.png)
+> Mantl is a modern platform for rapidly deploying globally distributed services. A container orchestrator, docker, a network stack, something to pool your logs, something to monitor health, a sprinkle of service discovery and some automation.
 
-```bash
-$ make binary
-docker build -t "traefik-dev:no-more-godep-ever" -f build.Dockerfile .
-Sending build context to Docker daemon 295.3 MB
-Step 0 : FROM golang:1.5
- ---> 8c6473912976
-Step 1 : RUN go get github.com/Masterminds/glide
-[...]
-docker run --rm  -v "/var/run/docker.sock:/var/run/docker.sock" -it -e OS_ARCH_ARG -e OS_PLATFORM_ARG -e TESTFLAGS -v "/home/emile/dev/go/src/github.com/emilevauge/traefik/"dist":/go/src/github.com/emilevauge/traefik/"dist"" "traefik-dev:no-more-godep-ever" ./script/make.sh generate binary
----> Making bundle: generate (in .)
-removed 'gen.go'
+- Project [Apollo](http://capgemini.github.io/devops/apollo/) from Cap Gemini
 
----> Making bundle: binary (in .)
+![Web UI Providers](docs/img/apollo-logo.png)
+> Apollo is an open source project to aid with building and deploying IAAS and PAAS services. It is particularly geared towards managing containerized applications across multiple hosts, and big data type workloads. Apollo leverages other open source components to provide basic mechanisms for deployment, maintenance, and scaling of infrastructure and applications.
 
-$ ls dist/
-traefik*
-```
+## Partners
 
-#### Using `glide`
+[![Zenika](docs/img/zenika.logo.png)](https://zenika.com)
 
-The idea behind `glide` is the following :
+Zenika is one of the leading providers of professional Open Source services and agile methodologies in
+Europe. We provide consulting, development, training and support for the world’s leading Open Source
+software products.
 
-- when checkout(ing) a project, **run `glide up`** to install
-  (`go get …`) the dependencies in the `GOPATH`.
-- if you need another dependency, import and use it in
-  the source, and **run `glide get github.com/Masterminds/cookoo`** to save it in
-  `vendor` and add it to your `glide.yaml`.
 
-```bash
-$ glide up --update-vendored
-# generate
-$ go generate
-# Simple go build
-$ go build
-# Using gox to build multiple platform
-$ gox "linux darwin" "386 amd64 arm" \
-    -output="dist/traefik_{{.OS}}-{{.Arch}}"
-# run other commands like tests
-$ go test ./...
-ok      _/home/vincent/src/github/vdemeester/traefik    0.004s
-```
 
-### Tests
+[![Asteris](docs/img/asteris.logo.png)](https://aster.is)
 
-You can run unit tests using the `test-unit` target and the
-integration test using the `test-integration` target.
-
-```bash
-$ make test-unit
-docker build -t "traefik-dev:your-feature-branch" -f build.Dockerfile .
-# […]
-docker run --rm -it -e OS_ARCH_ARG -e OS_PLATFORM_ARG -e TESTFLAGS -v "/home/vincent/src/github/vdemeester/traefik/dist:/go/src/github.com/emilevauge/traefik/dist" "traefik-dev:your-feature-branch" ./script/make.sh generate test-unit
----> Making bundle: generate (in .)
-removed 'gen.go'
-
----> Making bundle: test-unit (in .)
-+ go test -cover -coverprofile=cover.out .
-ok      github.com/emilevauge/traefik   0.005s  coverage: 4.1% of statements
-
-Test success
-```
+Founded in 2014, Asteris creates next-generation infrastructure software for the modern datacenter. Asteris writes software that makes it easy for companies to implement continuous delivery and realtime data pipelines. We support the HashiCorp stack, along with Kubernetes, Apache Mesos, Spark and Kafka. We're core committers on mantl.io, consul-cli and mesos-consul.
+.

adapters.go

@@ -4,42 +4,31 @@ Copyright
 package main
 
 import (
-	log "github.com/Sirupsen/logrus"
-	"github.com/gorilla/mux"
-	"github.com/mailgun/oxy/utils"
 	"net/http"
+
+	log "github.com/Sirupsen/logrus"
 )
 
+// OxyLogger implements oxy Logger interface with logrus.
 type OxyLogger struct {
 }
 
+// Infof logs specified string as Debug level in logrus.
 func (oxylogger *OxyLogger) Infof(format string, args ...interface{}) {
 	log.Debugf(format, args...)
 }
 
+// Warningf logs specified string as Warning level in logrus.
 func (oxylogger *OxyLogger) Warningf(format string, args ...interface{}) {
 	log.Warningf(format, args...)
 }
 
+// Errorf logs specified string as Error level in logrus.
 func (oxylogger *OxyLogger) Errorf(format string, args ...interface{}) {
 	log.Errorf(format, args...)
 }
 
-type ErrorHandler struct {
-}
-
-func (e *ErrorHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, err error) {
-	log.Error("server error ", err.Error())
-	utils.DefaultHandler.ServeHTTP(w, req, err)
-}
-
 func notFoundHandler(w http.ResponseWriter, r *http.Request) {
 	http.NotFound(w, r)
 	//templatesRenderer.HTML(w, http.StatusNotFound, "notFound", nil)
 }
-
-func LoadDefaultConfig(globalConfiguration *GlobalConfiguration) *mux.Router {
-	router := mux.NewRouter()
-	router.NotFoundHandler = http.HandlerFunc(notFoundHandler)
-	return router
-}

boltdb.go

@@ -1,14 +0,0 @@
-package main
-
-type BoltDbProvider struct {
-	Watch      bool
-	Endpoint   string
-	Prefix     string
-	Filename   string
-	KvProvider *KvProvider
-}
-
-func (provider *BoltDbProvider) Provide(configurationChan chan<- configMessage) error {
-	provider.KvProvider = NewBoltDbProvider(provider)
-	return provider.KvProvider.provide(configurationChan)
-}

build.Dockerfile

@@ -1,11 +1,14 @@
-FROM golang:1.5
+FROM golang:1.6.0-alpine
+
+RUN apk update && apk add git bash gcc
 
 RUN go get github.com/Masterminds/glide
 RUN go get github.com/mitchellh/gox
-RUN go get github.com/tcnksm/ghr
+RUN go get github.com/jteeuwen/go-bindata/...
+RUN go get github.com/golang/lint/golint
 
 # Which docker version to test on
-ENV DOCKER_VERSION 1.6.2
+ENV DOCKER_VERSION 1.10.1
 
 # enable GO15VENDOREXPERIMENT
 ENV GO15VENDOREXPERIMENT 1
@@ -18,9 +21,9 @@ RUN set -ex; \
 # Set the default Docker to be run
 RUN ln -s /usr/local/bin/docker-${DOCKER_VERSION} /usr/local/bin/docker
 
-WORKDIR /go/src/github.com/emilevauge/traefik
+WORKDIR /go/src/github.com/containous/traefik
 
 COPY glide.yaml glide.yaml
-RUN glide up
+RUN glide up --quick
 
-COPY . /go/src/github.com/emilevauge/traefik
+COPY . /go/src/github.com/containous/traefik

cmd.go

@@ -0,0 +1,214 @@
+/*
+Copyright
+*/
+package main
+
+import (
+	"encoding/json"
+	fmtlog "log"
+	"os"
+	"strings"
+	"time"
+
+	log "github.com/Sirupsen/logrus"
+	"github.com/containous/traefik/middlewares"
+	"github.com/containous/traefik/provider"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	"net/http"
+)
+
+var traefikCmd = &cobra.Command{
+	Use:   "traefik",
+	Short: "traefik, a modern reverse proxy",
+	Long: `traefik is a modern HTTP reverse proxy and load balancer made to deploy microservices with ease.
+Complete documentation is available at http://traefik.io`,
+	Run: func(cmd *cobra.Command, args []string) {
+		run()
+	},
+}
+var versionCmd = &cobra.Command{
+	Use:   "version",
+	Short: "Print version",
+	Long:  `Print version`,
+	Run: func(cmd *cobra.Command, args []string) {
+		fmtlog.Println(Version + " built on the " + BuildDate)
+		os.Exit(0)
+	},
+}
+
+var arguments = struct {
+	GlobalConfiguration
+	web           bool
+	file          bool
+	docker        bool
+	dockerTLS     bool
+	marathon      bool
+	consul        bool
+	consulTLS     bool
+	consulCatalog bool
+	zookeeper     bool
+	etcd          bool
+	etcdTLS       bool
+	boltdb        bool
+}{
+	GlobalConfiguration{
+		EntryPoints: make(EntryPoints),
+		Docker: &provider.Docker{
+			TLS: &provider.DockerTLS{},
+		},
+		File:     &provider.File{},
+		Web:      &WebProvider{},
+		Marathon: &provider.Marathon{},
+		Consul: &provider.Consul{
+			Kv: provider.Kv{
+				TLS: &provider.KvTLS{},
+			},
+		},
+		ConsulCatalog: &provider.ConsulCatalog{},
+		Zookeeper:     &provider.Zookepper{},
+		Etcd: &provider.Etcd{
+			Kv: provider.Kv{
+				TLS: &provider.KvTLS{},
+			},
+		},
+		Boltdb: &provider.BoltDb{},
+	},
+	false,
+	false,
+	false,
+	false,
+	false,
+	false,
+	false,
+	false,
+	false,
+	false,
+	false,
+	false,
+}
+
+func init() {
+	traefikCmd.AddCommand(versionCmd)
+	traefikCmd.PersistentFlags().StringP("configFile", "c", "", "Configuration file to use (TOML, JSON, YAML, HCL).")
+	traefikCmd.PersistentFlags().StringP("graceTimeOut", "g", "10", "Timeout in seconds. Duration to give active requests a chance to finish during hot-reloads")
+	traefikCmd.PersistentFlags().String("accessLogsFile", "log/access.log", "Access logs file")
+	traefikCmd.PersistentFlags().String("traefikLogsFile", "log/traefik.log", "Traefik logs file")
+	traefikCmd.PersistentFlags().Var(&arguments.EntryPoints, "entryPoints", "Entrypoints definition using format: --entryPoints='Name:http Address::8000 Redirect.EntryPoint:https' --entryPoints='Name:https Address::4442 TLS:tests/traefik.crt,tests/traefik.key'")
+	traefikCmd.PersistentFlags().Var(&arguments.DefaultEntryPoints, "defaultEntryPoints", "Entrypoints to be used by frontends that do not specify any entrypoint")
+	traefikCmd.PersistentFlags().StringP("logLevel", "l", "ERROR", "Log level")
+	traefikCmd.PersistentFlags().DurationVar(&arguments.ProvidersThrottleDuration, "providersThrottleDuration", time.Duration(2*time.Second), "Backends throttle duration: minimum duration between 2 events from providers before applying a new configuration. It avoids unnecessary reloads if multiples events are sent in a short amount of time.")
+	traefikCmd.PersistentFlags().Int("maxIdleConnsPerHost", 0, "If non-zero, controls the maximum idle (keep-alive) to keep per-host.  If zero, DefaultMaxIdleConnsPerHost is used")
+
+	traefikCmd.PersistentFlags().BoolVar(&arguments.web, "web", false, "Enable Web backend")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Web.Address, "web.address", ":8080", "Web administration port")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Web.CertFile, "web.cerFile", "", "SSL certificate")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Web.KeyFile, "web.keyFile", "", "SSL certificate")
+	traefikCmd.PersistentFlags().BoolVar(&arguments.Web.ReadOnly, "web.readOnly", false, "Enable read only API")
+
+	traefikCmd.PersistentFlags().BoolVar(&arguments.file, "file", false, "Enable File backend")
+	traefikCmd.PersistentFlags().BoolVar(&arguments.File.Watch, "file.watch", true, "Watch provider")
+	traefikCmd.PersistentFlags().StringVar(&arguments.File.Filename, "file.filename", "", "Override default configuration template. For advanced users :)")
+
+	traefikCmd.PersistentFlags().BoolVar(&arguments.docker, "docker", false, "Enable Docker backend")
+	traefikCmd.PersistentFlags().BoolVar(&arguments.Docker.Watch, "docker.watch", true, "Watch provider")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Docker.Filename, "docker.filename", "", "Override default configuration template. For advanced users :)")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Docker.Endpoint, "docker.endpoint", "unix:///var/run/docker.sock", "Docker server endpoint. Can be a tcp or a unix socket endpoint")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Docker.Domain, "docker.domain", "", "Default domain used")
+	traefikCmd.PersistentFlags().BoolVar(&arguments.dockerTLS, "docker.tls", false, "Enable Docker TLS support")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Docker.TLS.CA, "docker.tls.ca", "", "TLS CA")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Docker.TLS.Cert, "docker.tls.cert", "", "TLS cert")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Docker.TLS.Key, "docker.tls.key", "", "TLS key")
+	traefikCmd.PersistentFlags().BoolVar(&arguments.Docker.TLS.InsecureSkipVerify, "docker.tls.insecureSkipVerify", false, "TLS insecure skip verify")
+
+	traefikCmd.PersistentFlags().BoolVar(&arguments.marathon, "marathon", false, "Enable Marathon backend")
+	traefikCmd.PersistentFlags().BoolVar(&arguments.Marathon.Watch, "marathon.watch", true, "Watch provider")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Marathon.Filename, "marathon.filename", "", "Override default configuration template. For advanced users :)")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Marathon.Endpoint, "marathon.endpoint", "http://127.0.0.1:8080", "Marathon server endpoint. You can also specify multiple endpoint for Marathon")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Marathon.Domain, "marathon.domain", "", "Default domain used")
+
+	traefikCmd.PersistentFlags().BoolVar(&arguments.consul, "consul", false, "Enable Consul backend")
+	traefikCmd.PersistentFlags().BoolVar(&arguments.Consul.Watch, "consul.watch", true, "Watch provider")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Consul.Filename, "consul.filename", "", "Override default configuration template. For advanced users :)")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Consul.Endpoint, "consul.endpoint", "127.0.0.1:8500", "Comma sepparated Consul server endpoints")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Consul.Prefix, "consul.prefix", "/traefik", "Prefix used for KV store")
+	traefikCmd.PersistentFlags().BoolVar(&arguments.consulTLS, "consul.tls", false, "Enable Consul TLS support")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Consul.TLS.CA, "consul.tls.ca", "", "TLS CA")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Consul.TLS.Cert, "consul.tls.cert", "", "TLS cert")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Consul.TLS.Key, "consul.tls.key", "", "TLS key")
+	traefikCmd.PersistentFlags().BoolVar(&arguments.Consul.TLS.InsecureSkipVerify, "consul.tls.insecureSkipVerify", false, "TLS insecure skip verify")
+
+	traefikCmd.PersistentFlags().BoolVar(&arguments.consulCatalog, "consulCatalog", false, "Enable Consul catalog backend")
+	traefikCmd.PersistentFlags().StringVar(&arguments.ConsulCatalog.Domain, "consulCatalog.domain", "", "Default domain used")
+	traefikCmd.PersistentFlags().StringVar(&arguments.ConsulCatalog.Endpoint, "consulCatalog.endpoint", "127.0.0.1:8500", "Consul server endpoint")
+
+	traefikCmd.PersistentFlags().BoolVar(&arguments.zookeeper, "zookeeper", false, "Enable Zookeeper backend")
+	traefikCmd.PersistentFlags().BoolVar(&arguments.Zookeeper.Watch, "zookeeper.watch", true, "Watch provider")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Zookeeper.Filename, "zookeeper.filename", "", "Override default configuration template. For advanced users :)")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Zookeeper.Endpoint, "zookeeper.endpoint", "127.0.0.1:2181", "Comma sepparated Zookeeper server endpoints")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Zookeeper.Prefix, "zookeeper.prefix", "/traefik", "Prefix used for KV store")
+
+	traefikCmd.PersistentFlags().BoolVar(&arguments.etcd, "etcd", false, "Enable Etcd backend")
+	traefikCmd.PersistentFlags().BoolVar(&arguments.Etcd.Watch, "etcd.watch", true, "Watch provider")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Etcd.Filename, "etcd.filename", "", "Override default configuration template. For advanced users :)")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Etcd.Endpoint, "etcd.endpoint", "127.0.0.1:4001", "Comma sepparated Etcd server endpoints")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Etcd.Prefix, "etcd.prefix", "/traefik", "Prefix used for KV store")
+	traefikCmd.PersistentFlags().BoolVar(&arguments.etcdTLS, "etcd.tls", false, "Enable Etcd TLS support")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Etcd.TLS.CA, "etcd.tls.ca", "", "TLS CA")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Etcd.TLS.Cert, "etcd.tls.cert", "", "TLS cert")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Etcd.TLS.Key, "etcd.tls.key", "", "TLS key")
+	traefikCmd.PersistentFlags().BoolVar(&arguments.Etcd.TLS.InsecureSkipVerify, "etcd.tls.insecureSkipVerify", false, "TLS insecure skip verify")
+
+	traefikCmd.PersistentFlags().BoolVar(&arguments.boltdb, "boltdb", false, "Enable Boltdb backend")
+	traefikCmd.PersistentFlags().BoolVar(&arguments.Boltdb.Watch, "boltdb.watch", true, "Watch provider")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Boltdb.Filename, "boltdb.filename", "", "Override default configuration template. For advanced users :)")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Boltdb.Endpoint, "boltdb.endpoint", "127.0.0.1:4001", "Boltdb server endpoint")
+	traefikCmd.PersistentFlags().StringVar(&arguments.Boltdb.Prefix, "boltdb.prefix", "/traefik", "Prefix used for KV store")
+
+	viper.BindPFlag("configFile", traefikCmd.PersistentFlags().Lookup("configFile"))
+	viper.BindPFlag("graceTimeOut", traefikCmd.PersistentFlags().Lookup("graceTimeOut"))
+	//viper.BindPFlag("defaultEntryPoints", traefikCmd.PersistentFlags().Lookup("defaultEntryPoints"))
+	viper.BindPFlag("logLevel", traefikCmd.PersistentFlags().Lookup("logLevel"))
+	// TODO: wait for this issue to be corrected: https://github.com/spf13/viper/issues/105
+	viper.BindPFlag("providersThrottleDuration", traefikCmd.PersistentFlags().Lookup("providersThrottleDuration"))
+	viper.BindPFlag("maxIdleConnsPerHost", traefikCmd.PersistentFlags().Lookup("maxIdleConnsPerHost"))
+	viper.SetDefault("providersThrottleDuration", time.Duration(2*time.Second))
+	viper.SetDefault("logLevel", "ERROR")
+}
+
+func run() {
+	fmtlog.SetFlags(fmtlog.Lshortfile | fmtlog.LstdFlags)
+
+	// load global configuration
+	globalConfiguration := LoadConfiguration()
+
+	http.DefaultTransport.(*http.Transport).MaxIdleConnsPerHost = globalConfiguration.MaxIdleConnsPerHost
+	loggerMiddleware := middlewares.NewLogger(globalConfiguration.AccessLogsFile)
+	defer loggerMiddleware.Close()
+
+	// logging
+	level, err := log.ParseLevel(strings.ToLower(globalConfiguration.LogLevel))
+	if err != nil {
+		log.Fatal("Error getting level", err)
+	}
+	log.SetLevel(level)
+
+	if len(globalConfiguration.TraefikLogsFile) > 0 {
+		fi, err := os.OpenFile(globalConfiguration.TraefikLogsFile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
+		defer fi.Close()
+		if err != nil {
+			log.Fatal("Error opening file", err)
+		} else {
+			log.SetOutput(fi)
+			log.SetFormatter(&log.TextFormatter{DisableColors: true, FullTimestamp: true, DisableSorting: true})
+		}
+	} else {
+		log.SetFormatter(&log.TextFormatter{FullTimestamp: true, DisableSorting: true})
+	}
+	jsonConf, _ := json.Marshal(globalConfiguration)
+	log.Debugf("Global configuration loaded %s", string(jsonConf))
+	server := NewServer(*globalConfiguration)
+	server.Start()
+	defer server.Close()
+	log.Info("Shutting down")
+}

configuration.go

@@ -2,111 +2,285 @@ package main
 
 import (
 	"errors"
+	"fmt"
+	fmtlog "log"
+	"regexp"
 	"strings"
 	"time"
+
+	"github.com/containous/traefik/provider"
+	"github.com/containous/traefik/types"
+	"github.com/mitchellh/mapstructure"
+	"github.com/spf13/viper"
 )
 
+// GlobalConfiguration holds global configuration (with providers, etc.).
+// It's populated from the traefik configuration file passed as an argument to the binary.
 type GlobalConfiguration struct {
-	Port                      string
 	GraceTimeOut              int64
 	AccessLogsFile            string
 	TraefikLogsFile           string
-	CertFile, KeyFile         string
 	LogLevel                  string
+	EntryPoints               EntryPoints
+	DefaultEntryPoints        DefaultEntryPoints
 	ProvidersThrottleDuration time.Duration
-	Docker                    *DockerProvider
-	File                      *FileProvider
+	MaxIdleConnsPerHost       int
+	Docker                    *provider.Docker
+	File                      *provider.File
 	Web                       *WebProvider
-	Marathon                  *MarathonProvider
-	Consul                    *ConsulProvider
-	Etcd                      *EtcdProvider
-	Zookeeper                 *ZookepperProvider
-	Boltdb                    *BoltDbProvider
+	Marathon                  *provider.Marathon
+	Consul                    *provider.Consul
+	ConsulCatalog             *provider.ConsulCatalog
+	Etcd                      *provider.Etcd
+	Zookeeper                 *provider.Zookepper
+	Boltdb                    *provider.BoltDb
 }
 
-func NewGlobalConfiguration() *GlobalConfiguration {
-	globalConfiguration := new(GlobalConfiguration)
-	// default values
-	globalConfiguration.Port = ":80"
-	globalConfiguration.GraceTimeOut = 10
-	globalConfiguration.LogLevel = "ERROR"
-	globalConfiguration.ProvidersThrottleDuration = time.Duration(2 * time.Second)
+// DefaultEntryPoints holds default entry points
+type DefaultEntryPoints []string
 
-	return globalConfiguration
+// String is the method to format the flag's value, part of the flag.Value interface.
+// The String method's output will be used in diagnostics.
+func (dep *DefaultEntryPoints) String() string {
+	return fmt.Sprintf("%#v", dep)
 }
 
-// Backend configuration
-type Backend struct {
-	Servers        map[string]Server `json:"servers,omitempty"`
-	CircuitBreaker *CircuitBreaker   `json:"circuitBreaker,omitempty"`
-	LoadBalancer   *LoadBalancer     `json:"loadBalancer,omitempty"`
+// Set is the method to set the flag value, part of the flag.Value interface.
+// Set's argument is a string to be parsed to set the flag.
+// It's a comma-separated list, so we split it.
+func (dep *DefaultEntryPoints) Set(value string) error {
+	entrypoints := strings.Split(value, ",")
+	if len(entrypoints) == 0 {
+		return errors.New("Bad DefaultEntryPoints format: " + value)
+	}
+	for _, entrypoint := range entrypoints {
+		*dep = append(*dep, entrypoint)
+	}
+	return nil
 }
 
-// LoadBalancer configuration
-type LoadBalancer struct {
-	Method string `json:"method,omitempty"`
+// Type is type of the struct
+func (dep *DefaultEntryPoints) Type() string {
+	return fmt.Sprint("defaultentrypoints²")
 }
 
-// CircuitBreaker configuration
-type CircuitBreaker struct {
-	Expression string `json:"expression,omitempty"`
+// EntryPoints holds entry points configuration of the reverse proxy (ip, port, TLS...)
+type EntryPoints map[string]*EntryPoint
+
+// String is the method to format the flag's value, part of the flag.Value interface.
+// The String method's output will be used in diagnostics.
+func (ep *EntryPoints) String() string {
+	return ""
 }
 
-// Server configuration
-type Server struct {
-	URL    string `json:"url,omitempty"`
-	Weight int    `json:"weight,omitempty"`
-}
-
-// Route configuration
-type Route struct {
-	Rule  string `json:"rule,omitempty"`
-	Value string `json:"value,omitempty"`
-}
-
-// Frontend configuration
-type Frontend struct {
-	Backend string           `json:"backend,omitempty"`
-	Routes  map[string]Route `json:"routes,omitempty"`
-}
-
-// Configuration of a provider
-type Configuration struct {
-	Backends  map[string]*Backend  `json:"backends,omitempty"`
-	Frontends map[string]*Frontend `json:"frontends,omitempty"`
-}
-
-// Load Balancer Method
-type LoadBalancerMethod uint8
-
-const (
-	// wrr (default) = Weighted Round Robin
-	wrr LoadBalancerMethod = iota
-	// drr = Dynamic Round Robin
-	drr
-)
-
-var loadBalancerMethodNames = []string{
-	"wrr",
-	"drr",
-}
-
-func NewLoadBalancerMethod(loadBalancer *LoadBalancer) (LoadBalancerMethod, error) {
-	if loadBalancer != nil {
-		for i, name := range loadBalancerMethodNames {
-			if strings.EqualFold(name, loadBalancer.Method) {
-				return LoadBalancerMethod(i), nil
-			}
+// Set is the method to set the flag value, part of the flag.Value interface.
+// Set's argument is a string to be parsed to set the flag.
+// It's a comma-separated list, so we split it.
+func (ep *EntryPoints) Set(value string) error {
+	regex := regexp.MustCompile("(?:Name:(?P<Name>\\S*))\\s*(?:Address:(?P<Address>\\S*))?\\s*(?:TLS:(?P<TLS>\\S*))?\\s*(?:Redirect.EntryPoint:(?P<RedirectEntryPoint>\\S*))?\\s*(?:Redirect.Regex:(?P<RedirectRegex>\\S*))?\\s*(?:Redirect.Replacement:(?P<RedirectReplacement>\\S*))?")
+	match := regex.FindAllStringSubmatch(value, -1)
+	if match == nil {
+		return errors.New("Bad EntryPoints format: " + value)
+	}
+	matchResult := match[0]
+	result := make(map[string]string)
+	for i, name := range regex.SubexpNames() {
+		if i != 0 {
+			result[name] = matchResult[i]
 		}
 	}
-	return wrr, ErrInvalidLoadBalancerMethod
+	var tls *TLS
+	if len(result["TLS"]) > 0 {
+		certs := Certificates{}
+		certs.Set(result["TLS"])
+		tls = &TLS{
+			Certificates: certs,
+		}
+	}
+	var redirect *Redirect
+	if len(result["RedirectEntryPoint"]) > 0 || len(result["RedirectRegex"]) > 0 || len(result["RedirectReplacement"]) > 0 {
+		redirect = &Redirect{
+			EntryPoint:  result["RedirectEntryPoint"],
+			Regex:       result["RedirectRegex"],
+			Replacement: result["RedirectReplacement"],
+		}
+	}
+
+	(*ep)[result["Name"]] = &EntryPoint{
+		Address:  result["Address"],
+		TLS:      tls,
+		Redirect: redirect,
+	}
+
+	return nil
 }
 
-var ErrInvalidLoadBalancerMethod = errors.New("Invalid method, using default")
-
-type configMessage struct {
-	providerName  string
-	configuration *Configuration
+// Type is type of the struct
+func (ep *EntryPoints) Type() string {
+	return fmt.Sprint("entrypoints²")
 }
 
-type configs map[string]*Configuration
+// EntryPoint holds an entry point configuration of the reverse proxy (ip, port, TLS...)
+type EntryPoint struct {
+	Network  string
+	Address  string
+	TLS      *TLS
+	Redirect *Redirect
+}
+
+// Redirect configures a redirection of an entry point to another, or to an URL
+type Redirect struct {
+	EntryPoint  string
+	Regex       string
+	Replacement string
+}
+
+// TLS configures TLS for an entry point
+type TLS struct {
+	Certificates Certificates
+}
+
+// Certificates defines traefik certificates type
+type Certificates []Certificate
+
+// String is the method to format the flag's value, part of the flag.Value interface.
+// The String method's output will be used in diagnostics.
+func (certs *Certificates) String() string {
+	if len(*certs) == 0 {
+		return ""
+	}
+	return (*certs)[0].CertFile + "," + (*certs)[0].KeyFile
+}
+
+// Set is the method to set the flag value, part of the flag.Value interface.
+// Set's argument is a string to be parsed to set the flag.
+// It's a comma-separated list, so we split it.
+func (certs *Certificates) Set(value string) error {
+	files := strings.Split(value, ",")
+	if len(files) != 2 {
+		return errors.New("Bad certificates format: " + value)
+	}
+	*certs = append(*certs, Certificate{
+		CertFile: files[0],
+		KeyFile:  files[1],
+	})
+	return nil
+}
+
+// Type is type of the struct
+func (certs *Certificates) Type() string {
+	return fmt.Sprint("certificates")
+}
+
+// Certificate holds a SSL cert/key pair
+type Certificate struct {
+	CertFile string
+	KeyFile  string
+}
+
+// NewGlobalConfiguration returns a GlobalConfiguration with default values.
+func NewGlobalConfiguration() *GlobalConfiguration {
+	return new(GlobalConfiguration)
+}
+
+// LoadConfiguration returns a GlobalConfiguration.
+func LoadConfiguration() *GlobalConfiguration {
+	configuration := NewGlobalConfiguration()
+	viper.SetEnvPrefix("traefik")
+	viper.SetConfigType("toml")
+	viper.AutomaticEnv()
+	if len(viper.GetString("configFile")) > 0 {
+		viper.SetConfigFile(viper.GetString("configFile"))
+	} else {
+		viper.SetConfigName("traefik") // name of config file (without extension)
+	}
+	viper.AddConfigPath("/etc/traefik/")   // path to look for the config file in
+	viper.AddConfigPath("$HOME/.traefik/") // call multiple times to add many search paths
+	viper.AddConfigPath(".")               // optionally look for config in the working directory
+	if err := viper.ReadInConfig(); err != nil {
+		fmtlog.Fatalf("Error reading file: %s", err)
+	}
+
+	if len(arguments.EntryPoints) > 0 {
+		viper.Set("entryPoints", arguments.EntryPoints)
+	}
+	if len(arguments.DefaultEntryPoints) > 0 {
+		viper.Set("defaultEntryPoints", arguments.DefaultEntryPoints)
+	}
+	if arguments.web {
+		viper.Set("web", arguments.Web)
+	}
+	if arguments.file {
+		viper.Set("file", arguments.File)
+	}
+	if !arguments.dockerTLS {
+		arguments.Docker.TLS = nil
+	}
+	if arguments.docker {
+		viper.Set("docker", arguments.Docker)
+	}
+	if arguments.marathon {
+		viper.Set("marathon", arguments.Marathon)
+	}
+	if !arguments.consulTLS {
+		arguments.Consul.TLS = nil
+	}
+	if arguments.consul {
+		viper.Set("consul", arguments.Consul)
+	}
+	if arguments.consulCatalog {
+		viper.Set("consulCatalog", arguments.ConsulCatalog)
+	}
+	if arguments.zookeeper {
+		viper.Set("zookeeper", arguments.Zookeeper)
+	}
+	if !arguments.etcdTLS {
+		arguments.Etcd.TLS = nil
+	}
+	if arguments.etcd {
+		viper.Set("etcd", arguments.Etcd)
+	}
+	if arguments.boltdb {
+		viper.Set("boltdb", arguments.Boltdb)
+	}
+	if err := unmarshal(&configuration); err != nil {
+		fmtlog.Fatalf("Error reading file: %s", err)
+	}
+
+	if len(configuration.EntryPoints) == 0 {
+		configuration.EntryPoints = make(map[string]*EntryPoint)
+		configuration.EntryPoints["http"] = &EntryPoint{
+			Address: ":80",
+		}
+		configuration.DefaultEntryPoints = []string{"http"}
+	}
+
+	if configuration.File != nil && len(configuration.File.Filename) == 0 {
+		// no filename, setting to global config file
+		configuration.File.Filename = viper.ConfigFileUsed()
+	}
+
+	return configuration
+}
+
+func unmarshal(rawVal interface{}) error {
+	config := &mapstructure.DecoderConfig{
+		DecodeHook:       mapstructure.StringToTimeDurationHookFunc(),
+		Metadata:         nil,
+		Result:           rawVal,
+		WeaklyTypedInput: true,
+	}
+
+	decoder, err := mapstructure.NewDecoder(config)
+	if err != nil {
+		return err
+	}
+
+	err = decoder.Decode(viper.AllSettings())
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+type configs map[string]*types.Configuration

consul.go

@@ -1,14 +0,0 @@
-package main
-
-type ConsulProvider struct {
-	Watch      bool
-	Endpoint   string
-	Prefix     string
-	Filename   string
-	KvProvider *KvProvider
-}
-
-func (provider *ConsulProvider) Provide(configurationChan chan<- configMessage) error {
-	provider.KvProvider = NewConsulProvider(provider)
-	return provider.KvProvider.provide(configurationChan)
-}

contrib/systemd/traefik.service

@@ -0,0 +1,6 @@
+[Unit]
+Description=Traefik
+
+[Service]
+ExecStart=/usr/bin/traefik /etc/traefik.toml
+Restart=on-failure

docker.go

@@ -1,239 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"errors"
-	"strconv"
-	"strings"
-	"text/template"
-	"time"
-
-	"fmt"
-	"github.com/BurntSushi/toml"
-	"github.com/BurntSushi/ty/fun"
-	log "github.com/Sirupsen/logrus"
-	"github.com/cenkalti/backoff"
-	"github.com/fsouza/go-dockerclient"
-)
-
-type DockerProvider struct {
-	Watch    bool
-	Endpoint string
-	Filename string
-	Domain   string
-}
-
-func (provider *DockerProvider) Provide(configurationChan chan<- configMessage) error {
-	if dockerClient, err := docker.NewClient(provider.Endpoint); err != nil {
-		log.Errorf("Failed to create a client for docker, error: %s", err)
-		return err
-	} else {
-		err := dockerClient.Ping()
-		if err != nil {
-			log.Errorf("Docker connection error %+v", err)
-			return err
-		}
-		log.Debug("Docker connection established")
-		if provider.Watch {
-			dockerEvents := make(chan *docker.APIEvents)
-			dockerClient.AddEventListener(dockerEvents)
-			log.Debug("Docker listening")
-			go func() {
-				operation := func() error {
-					for {
-						event := <-dockerEvents
-						if event == nil {
-							return errors.New("Docker event nil")
-							//							log.Fatalf("Docker connection error")
-						}
-						if event.Status == "start" || event.Status == "die" {
-							log.Debugf("Docker event receveived %+v", event)
-							configuration := provider.loadDockerConfig(dockerClient)
-							if configuration != nil {
-								configurationChan <- configMessage{"docker", configuration}
-							}
-						}
-					}
-				}
-				notify := func(err error, time time.Duration) {
-					log.Errorf("Docker connection error %+v, retrying in %s", err, time)
-				}
-				err := backoff.RetryNotify(operation, backoff.NewExponentialBackOff(), notify)
-				if err != nil {
-					log.Fatalf("Cannot connect to docker server %+v", err)
-				}
-			}()
-		}
-
-		configuration := provider.loadDockerConfig(dockerClient)
-		configurationChan <- configMessage{"docker", configuration}
-	}
-	return nil
-}
-
-func (provider *DockerProvider) loadDockerConfig(dockerClient *docker.Client) *Configuration {
-	var DockerFuncMap = template.FuncMap{
-		"getBackend": func(container docker.Container) string {
-			if label, err := provider.getLabel(container, "traefik.backend"); err == nil {
-				return label
-			}
-			return provider.getEscapedName(container.Name)
-		},
-		"getPort": func(container docker.Container) string {
-			if label, err := provider.getLabel(container, "traefik.port"); err == nil {
-				return label
-			}
-			for key := range container.NetworkSettings.Ports {
-				return key.Port()
-			}
-			return ""
-		},
-		"getWeight": func(container docker.Container) string {
-			if label, err := provider.getLabel(container, "traefik.weight"); err == nil {
-				return label
-			}
-			return "0"
-		},
-		"getDomain": func(container docker.Container) string {
-			if label, err := provider.getLabel(container, "traefik.domain"); err == nil {
-				return label
-			}
-			return provider.Domain
-		},
-		"getProtocol": func(container docker.Container) string {
-			if label, err := provider.getLabel(container, "traefik.protocol"); err == nil {
-				return label
-			}
-			return "http"
-		},
-		"getFrontendValue": provider.GetFrontendValue,
-		"getFrontendRule":  provider.GetFrontendRule,
-		"replace": func(s1 string, s2 string, s3 string) string {
-			return strings.Replace(s3, s1, s2, -1)
-		},
-	}
-	configuration := new(Configuration)
-	containerList, _ := dockerClient.ListContainers(docker.ListContainersOptions{})
-	containersInspected := []docker.Container{}
-	frontends := map[string][]docker.Container{}
-
-	// get inspect containers
-	for _, container := range containerList {
-		containerInspected, _ := dockerClient.InspectContainer(container.ID)
-		containersInspected = append(containersInspected, *containerInspected)
-	}
-
-	// filter containers
-	filteredContainers := fun.Filter(func(container docker.Container) bool {
-		if len(container.NetworkSettings.Ports) == 0 {
-			log.Debugf("Filtering container without port %s", container.Name)
-			return false
-		}
-		_, err := strconv.Atoi(container.Config.Labels["traefik.port"])
-		if len(container.NetworkSettings.Ports) > 1 && err != nil {
-			log.Debugf("Filtering container with more than 1 port and no traefik.port label %s", container.Name)
-			return false
-		}
-		if container.Config.Labels["traefik.enable"] == "false" {
-			log.Debugf("Filtering disabled container %s", container.Name)
-			return false
-		}
-
-		if _, err := provider.getLabels(container, []string{"traefik.frontend.rule", "traefik.frontend.value"}); err != nil {
-			log.Debugf("Filtering bad labeled container %s", container.Name)
-			return false
-		}
-
-		return true
-	}, containersInspected).([]docker.Container)
-
-	for _, container := range filteredContainers {
-		frontends[provider.getFrontendName(container)] = append(frontends[provider.getFrontendName(container)], container)
-	}
-
-	templateObjects := struct {
-		Containers []docker.Container
-		Frontends  map[string][]docker.Container
-		Domain     string
-	}{
-		filteredContainers,
-		frontends,
-		provider.Domain,
-	}
-	tmpl := template.New(provider.Filename).Funcs(DockerFuncMap)
-	if len(provider.Filename) > 0 {
-		_, err := tmpl.ParseFiles(provider.Filename)
-		if err != nil {
-			log.Error("Error reading file", err)
-			return nil
-		}
-	} else {
-		buf, err := Asset("templates/docker.tmpl")
-		if err != nil {
-			log.Error("Error reading file", err)
-		}
-		_, err = tmpl.Parse(string(buf))
-		if err != nil {
-			log.Error("Error reading file", err)
-			return nil
-		}
-	}
-
-	var buffer bytes.Buffer
-	err := tmpl.Execute(&buffer, templateObjects)
-	if err != nil {
-		log.Error("Error with docker template", err)
-		return nil
-	}
-
-	if _, err := toml.Decode(buffer.String(), configuration); err != nil {
-		log.Error("Error creating docker configuration ", err)
-		return nil
-	}
-	return configuration
-}
-
-func (provider *DockerProvider) getFrontendName(container docker.Container) string {
-	// Replace '.' with '-' in quoted keys because of this issue https://github.com/BurntSushi/toml/issues/78
-	frontendName := fmt.Sprintf("%s-%s", provider.GetFrontendRule(container), provider.GetFrontendValue(container))
-	return strings.Replace(frontendName, ".", "-", -1)
-}
-
-func (provider *DockerProvider) getEscapedName(name string) string {
-	return strings.Replace(name, "/", "", -1)
-}
-
-func (provider *DockerProvider) getLabel(container docker.Container, label string) (string, error) {
-	for key, value := range container.Config.Labels {
-		if key == label {
-			return value, nil
-		}
-	}
-	return "", errors.New("Label not found:" + label)
-}
-
-func (provider *DockerProvider) getLabels(container docker.Container, labels []string) (map[string]string, error) {
-	foundLabels := map[string]string{}
-	for _, label := range labels {
-		if foundLabel, err := provider.getLabel(container, label); err != nil {
-			return nil, errors.New("Label not found: " + label)
-		} else {
-			foundLabels[label] = foundLabel
-		}
-	}
-	return foundLabels, nil
-}
-
-func (provider *DockerProvider) GetFrontendValue(container docker.Container) string {
-	if label, err := provider.getLabel(container, "traefik.frontend.value"); err == nil {
-		return label
-	}
-	return provider.getEscapedName(container.Name) + "." + provider.Domain
-}
-
-func (provider *DockerProvider) GetFrontendRule(container docker.Container) string {
-	if label, err := provider.getLabel(container, "traefik.frontend.rule"); err == nil {
-		return label
-	}
-	return "Host"
-}

docs/index.md

@@ -5,15 +5,18 @@ ___
 # <a id="top"></a> Documentation
 
 - [Basics](#basics)
+- [Launch configuration](#launch)
 - [Global configuration](#global)
 - [File backend](#file)
 - [API backend](#api)
 - [Docker backend](#docker)
 - [Mesos/Marathon backend](#marathon)
 - [Consul backend](#consul)
+- [Consul catalog backend](#consulcatalog)
 - [Etcd backend](#etcd)
 - [Zookeeper backend](#zk)
 - [Boltdb backend](#boltdb)
+- [Atomic configuration changes](#atomicconfig)
 - [Benchmarks](#benchmarks)
 
 
@@ -34,10 +37,13 @@ Frontends can be defined using the following rules:
 - `Host`: Host adds a matcher for the URL host. It accepts a template with zero or more URL variables enclosed by `{}`. Variables can define an optional regexp pattern to be matched: `www.traefik.io`, `{subdomain:[a-z]+}.traefik.io`
 - `Methods`: Methods adds a matcher for HTTP methods. It accepts a sequence of one or more methods to be matched, e.g.: `GET`, `POST`, `PUT`
 - `Path`: Path adds a matcher for the URL path. It accepts a template with zero or more URL variables enclosed by `{}`. The template must start with a `/`. For exemple `/products/` `/articles/{category}/{id:[0-9]+}`
+- `PathStrip`: Same as `Path` but strip the given prefix from the request URL's Path.
 - `PathPrefix`: PathPrefix adds a matcher for the URL path prefix. This matches if the given template is a prefix of the full URL path.
+- `PathPrefixStrip`: Same as `PathPrefix` but strip the given prefix from the request URL's Path.
 
 
  A frontend is a set of rules that forwards the incoming http traffic to a backend.
+ You can optionally enable `passHostHeader` to forward client `Host` header to the backend.
 
 ### HTTP Backends
 
@@ -58,6 +64,111 @@ For example:
 - `LatencyAtQuantileMS(50.0) > 50`
 - `ResponseCodeRatio(500, 600, 0, 600) > 0.5`
 
+
+## <a id="launch"></a> Launch configuration
+
+Træfɪk can be configured using a TOML file configuration, arguments, or both.
+By default, Træfɪk will try to find a `traefik.toml` in the following places:
+- `/etc/traefik/`
+- `$HOME/.traefik/`
+- `.` the working directory
+
+You can override this by setting a `configFile` argument:
+
+```bash
+$ traefik --configFile=foo/bar/myconfigfile.toml
+```
+
+Træfɪk uses the following precedence order. Each item takes precedence over the item below it:
+
+- arguments
+- configuration file
+- default
+
+It means that arguments overrides configuration file.
+Each argument is described in the help section:
+```bash
+$ traefik --help
+traefik is a modern HTTP reverse proxy and load balancer made to deploy microservices with ease.
+Complete documentation is available at http://traefik.io
+
+Usage:
+  traefik [flags]
+  traefik [command]
+
+Available Commands:
+  version     Print version
+
+Flags:
+      --accessLogsFile string                Access logs file (default "log/access.log")
+      --boltdb                               Enable Boltdb backend
+      --boltdb.endpoint string               Boltdb server endpoint (default "127.0.0.1:4001")
+      --boltdb.filename string               Override default configuration template. For advanced users :)
+      --boltdb.prefix string                 Prefix used for KV store (default "/traefik")
+      --boltdb.watch                         Watch provider (default true)
+  -c, --configFile string                    Configuration file to use (TOML, JSON, YAML, HCL).
+      --consul                               Enable Consul backend
+      --consul.endpoint string               Comma sepparated Consul server endpoints (default "127.0.0.1:8500")
+      --consul.filename string               Override default configuration template. For advanced users :)
+      --consul.prefix string                 Prefix used for KV store (default "/traefik")
+      --consul.tls                           Enable Consul TLS support
+      --consul.tls.ca string                 TLS CA
+      --consul.tls.cert string               TLS cert
+      --consul.tls.insecureSkipVerify        TLS insecure skip verify
+      --consul.tls.key string                TLS key
+      --consul.watch                         Watch provider (default true)
+      --consulCatalog                        Enable Consul catalog backend
+      --consulCatalog.domain string          Default domain used
+      --consulCatalog.endpoint string        Consul server endpoint (default "127.0.0.1:8500")
+      --defaultEntryPoints value             Entrypoints to be used by frontends that do not specify any entrypoint (default &main.DefaultEntryPoints(nil))
+      --docker                               Enable Docker backend
+      --docker.domain string                 Default domain used
+      --docker.endpoint string               Docker server endpoint. Can be a tcp or a unix socket endpoint (default "unix:///var/run/docker.sock")
+      --docker.filename string               Override default configuration template. For advanced users :)
+      --docker.tls                           Enable Docker TLS support
+      --docker.tls.ca string                 TLS CA
+      --docker.tls.cert string               TLS cert
+      --docker.tls.insecureSkipVerify        TLS insecure skip verify
+      --docker.tls.key string                TLS key
+      --docker.watch                         Watch provider (default true)
+      --entryPoints value                    Entrypoints definition using format: --entryPoints='Name:http Address::8000 Redirect.EntryPoint:https' --entryPoints='Name:https Address::4442 TLS:tests/traefik.crt,tests/traefik.key'
+      --etcd                                 Enable Etcd backend
+      --etcd.endpoint string                 Comma sepparated Etcd server endpoints (default "127.0.0.1:4001")
+      --etcd.filename string                 Override default configuration template. For advanced users :)
+      --etcd.prefix string                   Prefix used for KV store (default "/traefik")
+      --etcd.tls                             Enable Etcd TLS support
+      --etcd.tls.ca string                   TLS CA
+      --etcd.tls.cert string                 TLS cert
+      --etcd.tls.insecureSkipVerify          TLS insecure skip verify
+      --etcd.tls.key string                  TLS key
+      --etcd.watch                           Watch provider (default true)
+      --file                                 Enable File backend
+      --file.filename string                 Override default configuration template. For advanced users :)
+      --file.watch                           Watch provider (default true)
+  -g, --graceTimeOut string                  Timeout in seconds. Duration to give active requests a chance to finish during hot-reloads (default "10")
+  -l, --logLevel string                      Log level (default "ERROR")
+      --marathon                             Enable Marathon backend
+      --marathon.domain string               Default domain used
+      --marathon.endpoint string             Marathon server endpoint. You can also specify multiple endpoint for Marathon (default "http://127.0.0.1:8080")
+      --marathon.filename string             Override default configuration template. For advanced users :)
+      --marathon.watch                       Watch provider (default true)
+      --maxIdleConnsPerHost int              If non-zero, controls the maximum idle (keep-alive) to keep per-host.  If zero, DefaultMaxIdleConnsPerHost is used
+      --providersThrottleDuration duration   Backends throttle duration: minimum duration between 2 events from providers before applying a new configuration. It avoids unnecessary reloads if multiples events are sent in a short amount of time. (default 2s)
+      --traefikLogsFile string               Traefik logs file (default "log/traefik.log")
+      --web                                  Enable Web backend
+      --web.address string                   Web administration port (default ":8080")
+      --web.cerFile string                   SSL certificate
+      --web.keyFile string                   SSL certificate
+      --web.readOnly                         Enable read only API
+      --zookeeper                            Enable Zookeeper backend
+      --zookeeper.endpoint string            Comma sepparated Zookeeper server endpoints (default "127.0.0.1:2181")
+      --zookeeper.filename string            Override default configuration template. For advanced users :)
+      --zookeeper.prefix string              Prefix used for KV store (default "/traefik")
+      --zookeeper.watch                      Watch provider (default true)
+
+Use "traefik [command] --help" for more information about a command.
+```
+
 ## <a id="global"></a> Global configuration
 
 ```toml
@@ -66,12 +177,45 @@ For example:
 # Global configuration
 ################################################################
 
-# Reverse proxy port
+# Entrypoints definition
 #
 # Optional
-# Default: ":80"
+# Default:
+# [entryPoints]
+#   [entryPoints.http]
+#   address = ":80"
 #
-# port = ":80"
+# To redirect an http entrypoint to an https entrypoint (with SNI support):
+# [entryPoints]
+#   [entryPoints.http]
+#   address = ":80"
+#     [entryPoints.http.redirect]
+#       entryPoint = "https"
+#   [entryPoints.https]
+#   address = ":443"
+#     [entryPoints.https.tls]
+#       [[entryPoints.https.tls.certificates]]
+#       CertFile = "integration/fixtures/https/snitest.com.cert"
+#       KeyFile = "integration/fixtures/https/snitest.com.key"
+#       [[entryPoints.https.tls.certificates]]
+#       CertFile = "integration/fixtures/https/snitest.org.cert"
+#       KeyFile = "integration/fixtures/https/snitest.org.key"
+#
+# To redirect an entrypoint rewriting the URL:
+# [entryPoints]
+#   [entryPoints.http]
+#   address = ":80"
+#     [entryPoints.http.redirect]
+#       regex = "^http://localhost/(.*)"
+#       replacement = "http://mydomain/$1"
+
+# Entrypoints to be used by frontends that do not specify any entrypoint.
+# Each frontend can specify its own entrypoints.
+#
+# Optional
+# Default: ["http"]
+#
+# defaultEntryPoints = ["http", "https"]
 
 # Timeout in seconds.
 # Duration to give active requests a chance to finish during hot-reloads
@@ -101,13 +245,6 @@ For example:
 #
 # logLevel = "ERROR"
 
-# SSL certificate and key used
-#
-# Optional
-#
-# CertFile = "traefik.crt"
-# KeyFile = "traefik.key"
-
 # Backends throttle duration: minimum duration between 2 events from providers
 # before applying a new configuration. It avoids unnecessary reloads if multiples events
 # are sent in a short amount of time.
@@ -117,6 +254,14 @@ For example:
 #
 # ProvidersThrottleDuration = "5s"
 
+# If non-zero, controls the maximum idle (keep-alive) to keep per-host.  If zero, DefaultMaxIdleConnsPerHost is used.
+# If you encounter 'too many open files' errors, you can either change this value, or change `ulimit` value.
+#
+# Optional
+# Default: http.DefaultMaxIdleConnsPerHost
+#
+# MaxIdleConnsPerHost = 200
+
 ```
 
 
@@ -128,7 +273,21 @@ Like any other reverse proxy, Træfɪk can be configured with a file. You have t
 
 ```toml
 # traefik.toml
-port = ":80"
+defaultEntryPoints = ["http", "https"]
+[entryPoints]
+  [entryPoints.http]
+  address = ":80"
+    [entryPoints.http.redirect]
+      entryPoint = "https"
+  [entryPoints.https]
+  address = ":443"
+    [entryPoints.https.tls]
+      [[entryPoints.https.tls.certificates]]
+      CertFile = "integration/fixtures/https/snitest.com.cert"
+      KeyFile = "integration/fixtures/https/snitest.com.key"
+      [[entryPoints.https.tls.certificates]]
+      CertFile = "integration/fixtures/https/snitest.org.cert"
+      KeyFile = "integration/fixtures/https/snitest.org.key"
 graceTimeOut = 10
 logLevel = "DEBUG"
 
@@ -163,7 +322,14 @@ logLevel = "DEBUG"
     value = "test.localhost"
   [frontends.frontend2]
   backend = "backend1"
-    [frontends.frontend2.routes.test_2]
+  passHostHeader = true
+  entrypoints = ["https"] # overrides defaultEntryPoints
+    [frontends.frontend2.routes.test_1]
+    rule = "Host"
+    value = "{subdomain:[a-z]+}.localhost"
+  [frontends.frontend3]
+  entrypoints = ["http", "https"] # overrides defaultEntryPoints
+  backend = "backend2"
     rule = "Path"
     value = "/test"
 ```
@@ -172,7 +338,20 @@ logLevel = "DEBUG"
 
 ```toml
 # traefik.toml
-port = ":80"
+[entryPoints]
+  [entryPoints.http]
+  address = ":80"
+    [entryPoints.http.redirect]
+      entryPoint = "https"
+  [entryPoints.https]
+  address = ":443"
+    [entryPoints.https.tls]
+      [[entryPoints.https.tls.certificates]]
+      CertFile = "integration/fixtures/https/snitest.com.cert"
+      KeyFile = "integration/fixtures/https/snitest.com.key"
+      [[entryPoints.https.tls.certificates]]
+      CertFile = "integration/fixtures/https/snitest.org.cert"
+      KeyFile = "integration/fixtures/https/snitest.org.key"
 graceTimeOut = 10
 logLevel = "DEBUG"
 
@@ -210,10 +389,16 @@ filename = "rules.toml"
     value = "test.localhost"
   [frontends.frontend2]
   backend = "backend1"
-    [frontends.frontend2.routes.test_2]
+  passHostHeader = true
+  entrypoints = ["https"] # overrides defaultEntryPoints
+    [frontends.frontend2.routes.test_1]
+    rule = "Host"
+    value = "{subdomain:[a-z]+}.localhost"
+  [frontends.frontend3]
+  entrypoints = ["http", "https"] # overrides defaultEntryPoints
+  backend = "backend2"
     rule = "Path"
     value = "/test"
-
 ```
 
 If you want Træfɪk to watch file changes automatically, just add:
@@ -238,6 +423,11 @@ address = ":8080"
 #
 # CertFile = "traefik.crt"
 # KeyFile = "traefik.key"
+#
+# Set REST API to read-only mode
+#
+# Optional
+# ReadOnly = false
 ```
 
 - `/`: provides a simple HTML frontend of Træfik
@@ -401,6 +591,14 @@ watch = true
 # Optional
 #
 # filename = "docker.tmpl"
+
+# Enable docker TLS connection
+#
+#  [docker.tls]
+#  ca = "/etc/ssl/ca.crt"
+#  cert = "/etc/ssl/docker.crt"
+#  key = "/etc/ssl/docker.key"
+#  insecureskipverify = true
 ```
 
 Labels can be used on containers to override default behaviour:
@@ -411,7 +609,9 @@ Labels can be used on containers to override default behaviour:
 - `traefik.weight=10`: assign this weight to the container
 - `traefik.enable=false`: disable this container in Træfɪk
 - `traefik.frontend.rule=Host`: override the default frontend rule (Default: Host). See [frontends](#frontends).
-- `traefik.frontend.value=test.example.com`: override the default frontend value (Default: `{containerName}.{domain}`) See [frontends](#frontends).
+- `traefik.frontend.value=test.example.com`: override the default frontend value (Default: `{containerName}.{domain}`) See [frontends](#frontends). Must be associated with label traefik.frontend.rule.
+- `traefik.frontend.passHostHeader=true`: forward client `Host` header to the backend.
+- `traefik.frontend.entryPoints=http,https`: assign this frontend to entry points `http` and `https`. Overrides `defaultEntryPoints`.
 * `traefik.domain=traefik.localhost`: override the default domain
 
 
@@ -439,12 +639,6 @@ Træfɪk can be configured to use Marathon as a backend configuration:
 #
 endpoint = "http://127.0.0.1:8080"
 
-# Network interface used to call Marathon web services
-# Optional
-# Default: "eth0"
-#
-# networkInterface = "eth0"
-
 # Enable watch Marathon changes
 #
 # Optional
@@ -463,17 +657,35 @@ domain = "marathon.localhost"
 # Optional
 #
 # filename = "marathon.tmpl"
+
+# Enable Marathon basic authentication
+#
+# Optional
+#
+#  [marathon.basic]
+#  httpBasicAuthUser = "foo"
+#  httpBasicPassword = "bar"
+
+# TLS client configuration. https://golang.org/pkg/crypto/tls/#Config
+#
+# Optional
+#
+# [marathon.TLS]
+# InsecureSkipVerify = true
 ```
 
 Labels can be used on containers to override default behaviour:
 
 - `traefik.backend=foo`: assign the application to `foo` backend
-- `traefik.port=80`: register this port. Useful when the application exposes multiples ports.
+- `traefik.portIndex=1`: register port by index in the application's ports array. Useful when the application exposes multiple ports.
+- `traefik.port=80`: register the explicit application port value. Cannot be used alongside `traefik.portIndex`.
 - `traefik.protocol=https`: override the default `http` protocol
 - `traefik.weight=10`: assign this weight to the application
 - `traefik.enable=false`: disable this application in Træfɪk
 - `traefik.frontend.rule=Host`: override the default frontend rule (Default: Host). See [frontends](#frontends).
-- `traefik.frontend.value=test.example.com`: override the default frontend value (Default: `{appName}.{domain}`) See [frontends](#frontends).
+- `traefik.frontend.value=test.example.com`: override the default frontend value (Default: `{appName}.{domain}`) See [frontends](#frontends). Must be associated with label traefik.frontend.rule.
+- `traefik.frontend.passHostHeader=true`: forward client `Host` header to the backend.
+- `traefik.frontend.entryPoints=http,https`: assign this frontend to entry points `http` and `https`. Overrides `defaultEntryPoints`.
 * `traefik.domain=traefik.localhost`: override the default domain
 
 ## <a id="consul"></a> Consul backend
@@ -495,7 +707,7 @@ Træfɪk can be configured to use Consul as a backend configuration:
 #
 # Required
 #
-endpoint = "http://127.0.0.1:8500"
+endpoint = "127.0.0.1:8500"
 
 # Enable watch Consul changes
 #
@@ -514,6 +726,16 @@ prefix = "traefik"
 # Optional
 #
 # filename = "consul.tmpl"
+
+# Enable consul TLS connection
+#
+# Optional
+#
+# [consul.tls]
+# ca = "/etc/ssl/ca.crt"
+# cert = "/etc/ssl/consul.crt"
+# key = "/etc/ssl/consul.key"
+# insecureskipverify = true
 ```
 
 The Keys-Values structure should look (using `prefix = "/traefik"`):
@@ -551,6 +773,8 @@ The Keys-Values structure should look (using `prefix = "/traefik"`):
 | Key                                                | Value      |
 |----------------------------------------------------|------------|
 | `/traefik/frontends/frontend2/backend`             | `backend1` |
+| `/traefik/frontends/frontend2/passHostHeader`      | `true`     |
+| `/traefik/frontends/frontend2/entrypoints`         |`http,https`|
 | `/traefik/frontends/frontend2/routes/test_2/rule`  | `Path`     |
 | `/traefik/frontends/frontend2/routes/test_2/value` | `/test`    |
 
@@ -593,6 +817,16 @@ Træfɪk can be configured to use Etcd as a backend configuration:
 # Optional
 #
 # filename = "etcd.tmpl"
+
+# Enable etcd TLS connection
+#
+# Optional
+#
+# [etcd.tls]
+# ca = "/etc/ssl/ca.crt"
+# cert = "/etc/ssl/etcd.crt"
+# key = "/etc/ssl/etcd.key"
+# insecureskipverify = true
 ```
 
 The Keys-Values structure should look (using `prefix = "/traefik"`):
@@ -630,10 +864,43 @@ The Keys-Values structure should look (using `prefix = "/traefik"`):
 | Key                                                | Value      |
 |----------------------------------------------------|------------|
 | `/traefik/frontends/frontend2/backend`             | `backend1` |
+| `/traefik/frontends/frontend2/passHostHeader`      | `true`     |
+| `/traefik/frontends/frontend2/entrypoints`         |`http,https`|
 | `/traefik/frontends/frontend2/routes/test_2/rule`  | `Path`     |
 | `/traefik/frontends/frontend2/routes/test_2/value` | `/test`    |
 
 
+## <a id="consulcatalog"></a> Consul catalog backend
+
+Træfɪk can be configured to use service discovery catalog of Consul as a backend configuration:
+
+```toml
+################################################################
+# Consul Catalog configuration backend
+################################################################
+
+# Enable Consul Catalog configuration backend
+#
+# Optional
+#
+[consulCatalog]
+
+# Consul server endpoint
+#
+# Required
+#
+endpoint = "127.0.0.1:8500"
+
+# Default domain used.
+#
+# Optional
+#
+domain = "consul.localhost"
+```
+
+This backend will create routes matching on hostname based on the service name
+used in consul.
+
 ## <a id="zk"></a> Zookeeper backend
 
 Træfɪk can be configured to use Zookeeper as a backend configuration:
@@ -708,6 +975,8 @@ The Keys-Values structure should look (using `prefix = "/traefik"`):
 | Key                                                | Value      |
 |----------------------------------------------------|------------|
 | `/traefik/frontends/frontend2/backend`             | `backend1` |
+| `/traefik/frontends/frontend2/passHostHeader`      | `true`     |
+| `/traefik/frontends/frontend2/entrypoints`         |`http,https`|
 | `/traefik/frontends/frontend2/routes/test_2/rule`  | `Path`     |
 | `/traefik/frontends/frontend2/routes/test_2/value` | `/test`    |
 
@@ -752,131 +1021,112 @@ Træfɪk can be configured to use BoltDB as a backend configuration:
 # filename = "boltdb.tmpl"
 ```
 
+## <a id="atomicconfig"></a> Atomic configuration changes
+
+The [Etcd](https://github.com/coreos/etcd/issues/860) and [Consul](https://github.com/hashicorp/consul/issues/886) backends do not support updating multiple keys atomically. As a result, it may be possible for Træfɪk to read an intermediate configuration state despite judicious use of the `--providersThrottleDuration` flag. To solve this problem, Træfɪk supports a special key called `/traefik/alias`. If set, Træfɪk use the value as an alternative key prefix.
+
+Given the key structure below, Træfɪk will use the `http://172.17.0.2:80` as its only backend (frontend keys have been omitted for brevity).
+
+| Key                                                                     | Value                       |
+|-------------------------------------------------------------------------|-----------------------------|
+| `/traefik/alias`                                                        | `/traefik_configurations/1` |
+| `/traefik_configurations/1/backends/backend1/servers/server1/url`       | `http://172.17.0.2:80`      |
+| `/traefik_configurations/1/backends/backend1/servers/server1/weight`    | `10`                        |
+
+When an atomic configuration change is required, you may write a new configuration at an alternative prefix. Here, although the `/traefik_configurations/2/...` keys have been set, the old configuration is still active because the `/traefik/alias` key still points to `/traefik_configurations/1`:
+
+| Key                                                                     | Value                       |
+|-------------------------------------------------------------------------|-----------------------------|
+| `/traefik/alias`                                                        | `/traefik_configurations/1` |
+| `/traefik_configurations/1/backends/backend1/servers/server1/url`       | `http://172.17.0.2:80`      |
+| `/traefik_configurations/1/backends/backend1/servers/server1/weight`    | `10`                        |
+| `/traefik_configurations/2/backends/backend1/servers/server1/url`       | `http://172.17.0.2:80`      |
+| `/traefik_configurations/2/backends/backend1/servers/server1/weight`    | `5`                        |
+| `/traefik_configurations/2/backends/backend1/servers/server2/url`       | `http://172.17.0.3:80`      |
+| `/traefik_configurations/2/backends/backend1/servers/server2/weight`    | `5`                        |
+
+Once the `/traefik/alias` key is updated, the new `/traefik_configurations/2` configuration becomes active atomically. Here, we have a 50% balance between the `http://172.17.0.3:80` and the `http://172.17.0.4:80` hosts while no traffic is sent to the `172.17.0.2:80` host:
+
+| Key                                                                     | Value                       |
+|-------------------------------------------------------------------------|-----------------------------|
+| `/traefik/alias`                                                        | `/traefik_configurations/2` |
+| `/traefik_configurations/1/backends/backend1/servers/server1/url`       | `http://172.17.0.2:80`      |
+| `/traefik_configurations/1/backends/backend1/servers/server1/weight`    | `10`                        |
+| `/traefik_configurations/2/backends/backend1/servers/server1/url`       | `http://172.17.0.3:80`      |
+| `/traefik_configurations/2/backends/backend1/servers/server1/weight`    | `5`                        |
+| `/traefik_configurations/2/backends/backend1/servers/server2/url`       | `http://172.17.0.4:80`      |
+| `/traefik_configurations/2/backends/backend1/servers/server2/weight`    | `5`                        |
+
+Note that Træfɪk *will not watch for key changes in the `/traefik_configurations` prefix*. It will only watch for changes in the `/traefik` prefix. Further, if the `/traefik/alias` key is set, all other sibling keys with the `/traefik` prefix are ignored.
+
 
 ## <a id="benchmarks"></a> Benchmarks
 
-Here are some early Benchmarks between Nginx and Træfɪk acting as simple load balancers between two servers.
+Here are some early Benchmarks between Nginx, HA-Proxy and Træfɪk acting as simple load balancers between two servers.
 
 - Nginx:
 
 ```sh
-$ docker run -d -e VIRTUAL_HOST=test1.localhost emilevauge/whoami
-$ docker run -d -e VIRTUAL_HOST=test1.localhost emilevauge/whoami
+$ docker run -d -e VIRTUAL_HOST=test.nginx.localhost emilevauge/whoami
+$ docker run -d -e VIRTUAL_HOST=test.nginx.localhost emilevauge/whoami
 $ docker run --log-driver=none -d -p 80:80 -v /var/run/docker.sock:/tmp/docker.sock:ro jwilder/nginx-proxy
-$ ab -n 20000 -c 20  -r http://test1.localhost/
-This is ApacheBench, Version 2.3 <$Revision: 1528965 $>
-Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
-Licensed to The Apache Software Foundation, http://www.apache.org/
+$ wrk -t12 -c400 -d60s -H "Host: test.nginx.localhost" --latency http://127.0.0.1:80
+Running 1m test @ http://127.0.0.1:80
+  12 threads and 400 connections
+  Thread Stats   Avg      Stdev     Max   +/- Stdev
+    Latency   162.61ms  203.34ms   1.72s    91.07%
+    Req/Sec   277.57    107.67   790.00     67.53%
+  Latency Distribution
+     50%  128.19ms
+     75%  218.22ms
+     90%  342.12ms
+     99%    1.08s 
+  197991 requests in 1.00m, 82.32MB read
+  Socket errors: connect 0, read 0, write 0, timeout 18
+Requests/sec:   3296.04
+Transfer/sec:      1.37MB
+```
 
-Benchmarking test1.localhost (be patient)
-Completed 2000 requests
-Completed 4000 requests
-Completed 6000 requests
-Completed 8000 requests
-Completed 10000 requests
-Completed 12000 requests
-Completed 14000 requests
-Completed 16000 requests
-Completed 18000 requests
-Completed 20000 requests
-Finished 20000 requests
+- HA-Proxy:
 
-
-Server Software:        nginx/1.9.2
-Server Hostname:        test1.localhost
-Server Port:            80
-
-Document Path:          /
-Document Length:        287 bytes
-
-Concurrency Level:      20
-Time taken for tests:   5.874 seconds
-Complete requests:      20000
-Failed requests:        0
-Total transferred:      8900000 bytes
-HTML transferred:       5740000 bytes
-Requests per second:    3404.97 [#/sec] (mean)
-Time per request:       5.874 [ms] (mean)
-Time per request:       0.294 [ms] (mean, across all concurrent requests)
-Transfer rate:          1479.70 [Kbytes/sec] received
-
-Connection Times (ms)
-              min  mean[+/-sd] median   max
-Connect:        0    0   0.1      0       2
-Processing:     0    6   2.4      6      35
-Waiting:        0    5   2.3      5      33
-Total:          0    6   2.4      6      36
-
-Percentage of the requests served within a certain time (ms)
-  50%      6
-  66%      6
-  75%      7
-  80%      7
-  90%      9
-  95%     10
-  98%     12
-  99%     13
- 100%     36 (longest request)
+```
+$ docker run -d --name web1 -e VIRTUAL_HOST=test.haproxy.localhost emilevauge/whoami
+$ docker run -d --name web2 -e VIRTUAL_HOST=test.haproxy.localhost emilevauge/whoami
+$ docker run -d -p 80:80 --link web1:web1 --link web2:web2 dockercloud/haproxy
+$ wrk -t12 -c400 -d60s -H "Host: test.haproxy.localhost" --latency http://127.0.0.1:80
+Running 1m test @ http://127.0.0.1:80
+  12 threads and 400 connections
+  Thread Stats   Avg      Stdev     Max   +/- Stdev
+    Latency   158.08ms  187.88ms   1.75s    89.61%
+    Req/Sec   281.33    120.47     0.98k    65.88%
+  Latency Distribution
+     50%  121.77ms
+     75%  227.10ms
+     90%  351.98ms
+     99%    1.01s 
+  200462 requests in 1.00m, 59.65MB read
+Requests/sec:   3337.66
+Transfer/sec:      0.99MB
 ```
 
 - Træfɪk:
 
 ```sh
-$ docker run -d -l traefik.backend=test1 -l traefik.host=test1 emilevauge/whoami
-$ docker run -d -l traefik.backend=test1 -l traefik.host=test1 emilevauge/whoami
-docker run -d -p 8080:8080 -p 80:80 -v $PWD/traefik.toml:/traefik.toml -v /var/run/docker.sock:/var/run/docker.sock emilevauge/traefik
-$ ab -n 20000 -c 20  -r http://test1.docker.localhost/
-This is ApacheBench, Version 2.3 <$Revision: 1528965 $>
-Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
-Licensed to The Apache Software Foundation, http://www.apache.org/
-
-Benchmarking test1.docker.localhost (be patient)
-Completed 2000 requests
-Completed 4000 requests
-Completed 6000 requests
-Completed 8000 requests
-Completed 10000 requests
-Completed 12000 requests
-Completed 14000 requests
-Completed 16000 requests
-Completed 18000 requests
-Completed 20000 requests
-Finished 20000 requests
-
-
-Server Software:        .
-Server Hostname:        test1.docker.localhost
-Server Port:            80
-
-Document Path:          /
-Document Length:        312 bytes
-
-Concurrency Level:      20
-Time taken for tests:   6.545 seconds
-Complete requests:      20000
-Failed requests:        0
-Total transferred:      8600000 bytes
-HTML transferred:       6240000 bytes
-Requests per second:    3055.60 [#/sec] (mean)
-Time per request:       6.545 [ms] (mean)
-Time per request:       0.327 [ms] (mean, across all concurrent requests)
-Transfer rate:          1283.11 [Kbytes/sec] received
-
-Connection Times (ms)
-              min  mean[+/-sd] median   max
-Connect:        0    0   0.2      0       7
-Processing:     1    6   2.2      6      22
-Waiting:        1    6   2.1      6      21
-Total:          1    7   2.2      6      22
-
-Percentage of the requests served within a certain time (ms)
-  50%      6
-  66%      7
-  75%      8
-  80%      8
-  90%      9
-  95%     10
-  98%     11
-  99%     13
- 100%     22 (longest request)
+$ docker run -d -l traefik.backend=test1 -l traefik.frontend.rule=Host -l traefik.frontend.value=test.traefik.localhost emilevauge/whoami
+$ docker run -d -l traefik.backend=test1 -l traefik.frontend.rule=Host -l traefik.frontend.value=test.traefik.localhost emilevauge/whoami
+$ docker run -d -p 8080:8080 -p 80:80 -v $PWD/traefik.toml:/traefik.toml -v /var/run/docker.sock:/var/run/docker.sock containous/traefik
+$ wrk -t12 -c400 -d60s -H "Host: test.traefik.localhost" --latency http://127.0.0.1:80
+Running 1m test @ http://127.0.0.1:80
+  12 threads and 400 connections
+  Thread Stats   Avg      Stdev     Max   +/- Stdev
+    Latency   132.93ms  121.89ms   1.20s    66.62%
+    Req/Sec   280.95    104.88   740.00     68.26%
+  Latency Distribution
+     50%  128.71ms
+     75%  214.15ms
+     90%  281.45ms
+     99%  498.44ms
+  200734 requests in 1.00m, 80.02MB read
+Requests/sec:   3340.13
+Transfer/sec:      1.33MB
 ```

etcd.go

@@ -1,14 +0,0 @@
-package main
-
-type EtcdProvider struct {
-	Watch      bool
-	Endpoint   string
-	Prefix     string
-	Filename   string
-	KvProvider *KvProvider
-}
-
-func (provider *EtcdProvider) Provide(configurationChan chan<- configMessage) error {
-	provider.KvProvider = NewEtcdProvider(provider)
-	return provider.KvProvider.provide(configurationChan)
-}

file_test.go

@@ -1 +0,0 @@
-package main

generate.go

@@ -2,9 +2,8 @@
 Copyright
 */
 
-//go:generate go get github.com/jteeuwen/go-bindata/...
-//go:generate rm -vf gen.go
-//go:generate go-bindata -o gen.go static/... templates/...
+//go:generate rm -vf autogen/gen.go
+//go:generate go-bindata -pkg autogen -o autogen/gen.go ./static/... ./templates/...
 
 //go:generate mkdir -p vendor/github.com/docker/docker/autogen/dockerversion
 //go:generate cp script/dockerversion vendor/github.com/docker/docker/autogen/dockerversion/dockerversion.go

glide.yaml

@@ -43,7 +43,7 @@ import:
   - package: github.com/alecthomas/units
     ref:     6b4e7dc5e3143b85ea77909c72caf89416fc2915
   - package: github.com/gambol99/go-marathon
-    ref:     0ba31bcb0d7633ba1888d744c42990eb15281cf1
+    ref:     ade11d1dc2884ee1f387078fc28509559b6235d1
   - package: github.com/mailgun/predicate
     ref:     cb0bff91a7ab7cf7571e661ff883fc997bc554a3
   - package: github.com/thoas/stats
@@ -57,7 +57,7 @@ import:
   - package: github.com/flynn/go-shlex
     ref:     3f9db97f856818214da2e1057f8ad84803971cff
   - package: github.com/fsouza/go-dockerclient
-    ref:     0239034d42f665efa17fd77c39f891c2f9f32922
+    ref:     a49c8269a6899cae30da1f8a4b82e0ce945f9967
   - package: github.com/boltdb/bolt
     ref:     51f99c862475898df9773747d3accd05a7ca33c1
   - package: gopkg.in/mgo.v2
@@ -124,7 +124,7 @@ import:
   - package: gopkg.in/alecthomas/kingpin.v2
     ref:     639879d6110b1b0409410c7b737ef0bb18325038
   - package: github.com/docker/libcompose
-    ref:     79ef5d150f053a5b12f16b02d8844ed7cf33611a
+    ref:     d3089811c119a211469a9cc93caea684d937e5d3
     subpackages:
       - docker
       - logger
@@ -136,9 +136,32 @@ import:
   - package: gopkg.in/fsnotify.v1
     ref:     96c060f6a6b7e0d6f75fddd10efeaca3e5d1bcb0
   - package: github.com/mailgun/manners
-    ref:     37136f736785d7c6aa3b9a27b4b2dd1028ca6d79
+    ref:     fada45142db3f93097ca917da107aa3fad0ffcb5
   - package: github.com/gorilla/context
     ref:     215affda49addc4c8ef7e2534915df2c8c35c6cd
   - package: github.com/codahale/hdrhistogram
     ref:     954f16e8b9ef0e5d5189456aa4c1202758e04f17
   - package: github.com/gorilla/websocket
+  - package: github.com/donovanhide/eventsource
+    ref:     d8a3071799b98cacd30b6da92f536050ccfe6da4
+  - package: github.com/golang/glog
+    ref:     fca8c8854093a154ff1eb580aae10276ad6b1b5f
+  - package: github.com/spf13/cast
+    ref: ee7b3e0353166ab1f3a605294ac8cd2b77953778
+  - package: github.com/mitchellh/mapstructure
+  - package: github.com/spf13/jwalterweatherman
+  - package: github.com/spf13/pflag
+  - package: github.com/wendal/errors
+  - package: github.com/hashicorp/hcl
+  - package: github.com/kr/pretty
+  - package: github.com/magiconair/properties
+  - package: github.com/kr/text
+  - package: github.com/spf13/viper
+    ref: a212099cbe6fbe8d07476bfda8d2d39b6ff8f325
+  - package: github.com/spf13/cobra
+    subpackages:
+    - /cobra
+  - package: github.com/google/go-querystring/query
+  - package: github.com/vulcand/vulcand/plugin/rewrite
+  - package: github.com/stretchr/testify/mock
+

integration/basic_test.go

@@ -1,24 +1,27 @@
 package main
 
 import (
-	"fmt"
 	"net/http"
 	"os/exec"
 	"time"
 
+	"fmt"
 	checker "github.com/vdemeester/shakers"
 	check "gopkg.in/check.v1"
 )
 
+// SimpleSuite
+type SimpleSuite struct{ BaseSuite }
+
 func (s *SimpleSuite) TestNoOrInexistentConfigShouldFail(c *check.C) {
 	cmd := exec.Command(traefikBinary)
 	output, err := cmd.CombinedOutput()
 
 	c.Assert(err, checker.NotNil)
-	c.Assert(string(output), checker.Contains, "Error reading file: open traefik.toml: no such file or directory")
+	c.Assert(string(output), checker.Contains, "Error reading file: open : no such file or directory")
 
 	nonExistentFile := "non/existent/file.toml"
-	cmd = exec.Command(traefikBinary, nonExistentFile)
+	cmd = exec.Command(traefikBinary, "--configFile="+nonExistentFile)
 	output, err = cmd.CombinedOutput()
 
 	c.Assert(err, checker.NotNil)
@@ -26,26 +29,39 @@ func (s *SimpleSuite) TestNoOrInexistentConfigShouldFail(c *check.C) {
 }
 
 func (s *SimpleSuite) TestInvalidConfigShouldFail(c *check.C) {
-	cmd := exec.Command(traefikBinary, "fixtures/invalid_configuration.toml")
+	cmd := exec.Command(traefikBinary, "--configFile=fixtures/invalid_configuration.toml")
 	output, err := cmd.CombinedOutput()
 
 	c.Assert(err, checker.NotNil)
-	c.Assert(string(output), checker.Contains, "Error reading file: Near line 1")
+	c.Assert(string(output), checker.Contains, "Error reading file: While parsing config: Near line 1")
 }
 
 func (s *SimpleSuite) TestSimpleDefaultConfig(c *check.C) {
-	cmd := exec.Command(traefikBinary, "fixtures/simple_default.toml")
+	cmd := exec.Command(traefikBinary, "--configFile=fixtures/simple_default.toml")
 	err := cmd.Start()
 	c.Assert(err, checker.IsNil)
+	defer cmd.Process.Kill()
 
 	time.Sleep(500 * time.Millisecond)
 	// TODO validate : run on 80
-	resp, err := http.Get("http://127.0.0.1/")
+	resp, err := http.Get("http://127.0.0.1:8000/")
 
-	// Expected a 404 as we did not comfigure anything
-	c.Assert(err, checker.IsNil)
-	c.Assert(resp.StatusCode, checker.Equals, 404)
-
-	killErr := cmd.Process.Kill()
-	c.Assert(killErr, checker.IsNil)
+	// Expected no response as we did not configure anything
+	c.Assert(resp, checker.IsNil)
+	c.Assert(err, checker.NotNil)
+	c.Assert(err.Error(), checker.Contains, fmt.Sprintf("getsockopt: connection refused"))
+}
+
+func (s *SimpleSuite) TestWithWebConfig(c *check.C) {
+	cmd := exec.Command(traefikBinary, "--configFile=fixtures/simple_web.toml")
+	err := cmd.Start()
+	c.Assert(err, checker.IsNil)
+	defer cmd.Process.Kill()
+
+	time.Sleep(500 * time.Millisecond)
+
+	resp, err := http.Get("http://127.0.0.1:8080/api")
+	// Expected a 200
+	c.Assert(err, checker.IsNil)
+	c.Assert(resp.StatusCode, checker.Equals, 200)
 }

integration/consul_catalog_test.go

@@ -0,0 +1,132 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"os/exec"
+	"time"
+
+	"github.com/docker/docker/opts"
+	"github.com/fsouza/go-dockerclient"
+	"github.com/hashicorp/consul/api"
+	checker "github.com/vdemeester/shakers"
+	check "gopkg.in/check.v1"
+)
+
+// Consul catalog test suites
+type ConsulCatalogSuite struct {
+	BaseSuite
+	consulIP     string
+	consulClient *api.Client
+	dockerClient *docker.Client
+}
+
+func (s *ConsulCatalogSuite) GetContainer(name string) (*docker.Container, error) {
+	return s.dockerClient.InspectContainer(name)
+}
+
+func (s *ConsulCatalogSuite) SetUpSuite(c *check.C) {
+	dockerHost := os.Getenv("DOCKER_HOST")
+	if dockerHost == "" {
+		// FIXME Handle windows -- see if dockerClient already handle that or not
+		dockerHost = fmt.Sprintf("unix://%s", opts.DefaultUnixSocket)
+	}
+	// Make sure we can speak to docker
+	dockerClient, err := docker.NewClient(dockerHost)
+	c.Assert(err, checker.IsNil, check.Commentf("Error connecting to docker daemon"))
+	s.dockerClient = dockerClient
+
+	s.createComposeProject(c, "consul_catalog")
+	err = s.composeProject.Up()
+	c.Assert(err, checker.IsNil, check.Commentf("Error starting project"))
+
+	consul, err := s.GetContainer("integration-test-consul_catalog_consul_1")
+	c.Assert(err, checker.IsNil, check.Commentf("Error finding consul container"))
+
+	s.consulIP = consul.NetworkSettings.IPAddress
+	config := api.DefaultConfig()
+	config.Address = s.consulIP + ":8500"
+	consulClient, err := api.NewClient(config)
+	if err != nil {
+		c.Fatalf("Error creating consul client")
+	}
+	s.consulClient = consulClient
+
+	// Wait for consul to elect itself leader
+	time.Sleep(2000 * time.Millisecond)
+}
+
+func (s *ConsulCatalogSuite) registerService(name string, address string, port int) error {
+	catalog := s.consulClient.Catalog()
+	_, err := catalog.Register(
+		&api.CatalogRegistration{
+			Node:    address,
+			Address: address,
+			Service: &api.AgentService{
+				ID:      name,
+				Service: name,
+				Address: address,
+				Port:    port,
+			},
+		},
+		&api.WriteOptions{},
+	)
+	return err
+}
+
+func (s *ConsulCatalogSuite) deregisterService(name string, address string) error {
+	catalog := s.consulClient.Catalog()
+	_, err := catalog.Deregister(
+		&api.CatalogDeregistration{
+			Node:      address,
+			Address:   address,
+			ServiceID: name,
+		},
+		&api.WriteOptions{},
+	)
+	return err
+}
+
+func (s *ConsulCatalogSuite) TestSimpleConfiguration(c *check.C) {
+	cmd := exec.Command(traefikBinary, "--consulCatalog", "--consulCatalog.endpoint="+s.consulIP+":8500", "--configFile=fixtures/consul_catalog/simple.toml")
+	err := cmd.Start()
+	c.Assert(err, checker.IsNil)
+	defer cmd.Process.Kill()
+
+	time.Sleep(500 * time.Millisecond)
+	// TODO validate : run on 80
+	resp, err := http.Get("http://127.0.0.1:8000/")
+
+	// Expected a 404 as we did not configure anything
+	c.Assert(err, checker.IsNil)
+	c.Assert(resp.StatusCode, checker.Equals, 404)
+}
+
+func (s *ConsulCatalogSuite) TestSingleService(c *check.C) {
+	cmd := exec.Command(traefikBinary, "--consulCatalog", "--consulCatalog.endpoint="+s.consulIP+":8500", "--consulCatalog.domain=consul.localhost", "--configFile=fixtures/consul_catalog/simple.toml")
+	err := cmd.Start()
+	c.Assert(err, checker.IsNil)
+	defer cmd.Process.Kill()
+
+	nginx, err := s.GetContainer("integration-test-consul_catalog_nginx_1")
+	c.Assert(err, checker.IsNil, check.Commentf("Error finding nginx container"))
+
+	err = s.registerService("test", nginx.NetworkSettings.IPAddress, 80)
+	c.Assert(err, checker.IsNil, check.Commentf("Error registering service"))
+	defer s.deregisterService("test", nginx.NetworkSettings.IPAddress)
+
+	time.Sleep(5000 * time.Millisecond)
+	client := &http.Client{}
+	req, err := http.NewRequest("GET", "http://127.0.0.1:8000/", nil)
+	c.Assert(err, checker.IsNil)
+	req.Host = "test.consul.localhost"
+	resp, err := client.Do(req)
+
+	c.Assert(err, checker.IsNil)
+	c.Assert(resp.StatusCode, checker.Equals, 200)
+
+	_, err = ioutil.ReadAll(resp.Body)
+	c.Assert(err, checker.IsNil)
+}

integration/consul_test.go

@@ -5,23 +5,23 @@ import (
 	"os/exec"
 	"time"
 
+	"fmt"
 	checker "github.com/vdemeester/shakers"
 	check "gopkg.in/check.v1"
 )
 
 func (s *ConsulSuite) TestSimpleConfiguration(c *check.C) {
-	cmd := exec.Command(traefikBinary, "fixtures/consul/simple.toml")
+	cmd := exec.Command(traefikBinary, "--configFile=fixtures/consul/simple.toml")
 	err := cmd.Start()
 	c.Assert(err, checker.IsNil)
+	defer cmd.Process.Kill()
 
 	time.Sleep(500 * time.Millisecond)
 	// TODO validate : run on 80
-	resp, err := http.Get("http://127.0.0.1/")
+	resp, err := http.Get("http://127.0.0.1:8000/")
 
-	// Expected a 404 as we did not comfigure anything
-	c.Assert(err, checker.IsNil)
-	c.Assert(resp.StatusCode, checker.Equals, 404)
-
-	killErr := cmd.Process.Kill()
-	c.Assert(killErr, checker.IsNil)
+	// Expected no response as we did not configure anything
+	c.Assert(resp, checker.IsNil)
+	c.Assert(err, checker.NotNil)
+	c.Assert(err.Error(), checker.Contains, fmt.Sprintf("getsockopt: connection refused"))
 }

integration/docker_test.go

@@ -1,31 +1,251 @@
 package main
 
 import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
 	"net/http"
 	"os"
 	"os/exec"
 	"time"
 
+	"github.com/docker/docker/opts"
+	"github.com/docker/docker/pkg/namesgenerator"
+	"github.com/fsouza/go-dockerclient"
 	checker "github.com/vdemeester/shakers"
 	check "gopkg.in/check.v1"
 )
 
+var (
+	// Label added to started container to identify them as part of the integration test
+	TestLabel = "io.traefik.test"
+
+	// Images to have or pull before the build in order to make it work
+	// FIXME handle this offline but loading them before build
+	RequiredImages = map[string]string{
+		"swarm": "1.0.0",
+		"nginx": "1",
+	}
+)
+
+// Docker test suites
+type DockerSuite struct {
+	BaseSuite
+	client *docker.Client
+}
+
+func (s *DockerSuite) startContainer(c *check.C, image string, args ...string) string {
+	return s.startContainerWithConfig(c, docker.CreateContainerOptions{
+		Config: &docker.Config{
+			Image: image,
+			Cmd:   args,
+		},
+	})
+}
+
+func (s *DockerSuite) startContainerWithLabels(c *check.C, image string, labels map[string]string, args ...string) string {
+	return s.startContainerWithConfig(c, docker.CreateContainerOptions{
+		Config: &docker.Config{
+			Image:  image,
+			Cmd:    args,
+			Labels: labels,
+		},
+	})
+}
+
+func (s *DockerSuite) startContainerWithConfig(c *check.C, config docker.CreateContainerOptions) string {
+	if config.Name == "" {
+		config.Name = namesgenerator.GetRandomName(10)
+	}
+	if config.Config.Labels == nil {
+		config.Config.Labels = map[string]string{}
+	}
+	config.Config.Labels[TestLabel] = "true"
+
+	container, err := s.client.CreateContainer(config)
+	c.Assert(err, checker.IsNil, check.Commentf("Error creating a container using config %v", config))
+
+	err = s.client.StartContainer(container.ID, &docker.HostConfig{})
+	c.Assert(err, checker.IsNil, check.Commentf("Error starting container %v", container))
+
+	return container.Name
+}
+
+func (s *DockerSuite) SetUpSuite(c *check.C) {
+	dockerHost := os.Getenv("DOCKER_HOST")
+	if dockerHost == "" {
+		// FIXME Handle windows -- see if dockerClient already handle that or not
+		dockerHost = fmt.Sprintf("unix://%s", opts.DefaultUnixSocket)
+	}
+	// Make sure we can speak to docker
+	dockerClient, err := docker.NewClient(dockerHost)
+	c.Assert(err, checker.IsNil, check.Commentf("Error connecting to docker daemon"))
+
+	s.client = dockerClient
+	c.Assert(s.client.Ping(), checker.IsNil)
+
+	// Pull required images
+	for repository, tag := range RequiredImages {
+		image := fmt.Sprintf("%s:%s", repository, tag)
+		_, err := s.client.InspectImage(image)
+		if err != nil {
+			if err != docker.ErrNoSuchImage {
+				c.Fatalf("Error while inspect image %s", image)
+			}
+			err = s.client.PullImage(docker.PullImageOptions{
+				Repository: repository,
+				Tag:        tag,
+			}, docker.AuthConfiguration{})
+			c.Assert(err, checker.IsNil, check.Commentf("Error while pulling image %s", image))
+		}
+	}
+}
+
+func (s *DockerSuite) cleanContainers(c *check.C) {
+	// Clean the mess, a.k.a. the running containers with the right label
+	containerList, err := s.client.ListContainers(docker.ListContainersOptions{
+		Filters: map[string][]string{
+			"label": {fmt.Sprintf("%s=true", TestLabel)},
+		},
+	})
+	c.Assert(err, checker.IsNil, check.Commentf("Error listing containers started by traefik"))
+
+	for _, container := range containerList {
+		err = s.client.KillContainer(docker.KillContainerOptions{
+			ID: container.ID,
+		})
+		c.Assert(err, checker.IsNil, check.Commentf("Error killing container %v", container))
+		if os.Getenv("CIRCLECI") == "" {
+			// On circleci, we won't delete them — it errors out for now >_<
+			err = s.client.RemoveContainer(docker.RemoveContainerOptions{
+				ID:            container.ID,
+				RemoveVolumes: true,
+			})
+			c.Assert(err, checker.IsNil, check.Commentf("Error removing container %v", container))
+		}
+	}
+}
+
+func (s *DockerSuite) TearDownTest(c *check.C) {
+	s.cleanContainers(c)
+}
+
+func (s *DockerSuite) TearDownSuite(c *check.C) {
+	// Call cleanContainers, just in case (?)
+	// s.cleanContainers(c)
+}
+
 func (s *DockerSuite) TestSimpleConfiguration(c *check.C) {
 	file := s.adaptFileForHost(c, "fixtures/docker/simple.toml")
 	defer os.Remove(file)
 
-	cmd := exec.Command(traefikBinary, file)
+	cmd := exec.Command(traefikBinary, "--configFile="+file)
 	err := cmd.Start()
 	c.Assert(err, checker.IsNil)
+	defer cmd.Process.Kill()
 
 	time.Sleep(500 * time.Millisecond)
 	// TODO validate : run on 80
-	resp, err := http.Get("http://127.0.0.1/")
+	resp, err := http.Get("http://127.0.0.1:8000/")
 
+	c.Assert(err, checker.IsNil)
 	// Expected a 404 as we did not comfigure anything
+	c.Assert(resp.StatusCode, checker.Equals, 404)
+}
+
+func (s *DockerSuite) TestDefaultDockerContainers(c *check.C) {
+	file := s.adaptFileForHost(c, "fixtures/docker/simple.toml")
+	defer os.Remove(file)
+	name := s.startContainer(c, "swarm:1.0.0", "manage", "token://blablabla")
+
+	// Start traefik
+	cmd := exec.Command(traefikBinary, "--configFile="+file)
+	err := cmd.Start()
+	c.Assert(err, checker.IsNil)
+	defer cmd.Process.Kill()
+
+	// FIXME Need to wait than 500 milliseconds more (for swarm or traefik to boot up ?)
+	time.Sleep(1500 * time.Millisecond)
+
+	client := &http.Client{}
+	req, err := http.NewRequest("GET", "http://127.0.0.1:8000/version", nil)
+	c.Assert(err, checker.IsNil)
+	req.Host = fmt.Sprintf("%s.docker.localhost", name)
+	resp, err := client.Do(req)
+
+	c.Assert(err, checker.IsNil)
+	c.Assert(resp.StatusCode, checker.Equals, 200)
+
+	body, err := ioutil.ReadAll(resp.Body)
+	c.Assert(err, checker.IsNil)
+
+	var version map[string]interface{}
+
+	c.Assert(json.Unmarshal(body, &version), checker.IsNil)
+	c.Assert(version["Version"], checker.Equals, "swarm/1.0.0")
+}
+
+func (s *DockerSuite) TestDockerContainersWithLabels(c *check.C) {
+	file := s.adaptFileForHost(c, "fixtures/docker/simple.toml")
+	defer os.Remove(file)
+	// Start a container with some labels
+	labels := map[string]string{
+		"traefik.frontend.rule":  "Host",
+		"traefik.frontend.value": "my.super.host",
+	}
+	s.startContainerWithLabels(c, "swarm:1.0.0", labels, "manage", "token://blabla")
+
+	// Start traefik
+	cmd := exec.Command(traefikBinary, "--configFile="+file)
+	err := cmd.Start()
+	c.Assert(err, checker.IsNil)
+	defer cmd.Process.Kill()
+
+	// FIXME Need to wait than 500 milliseconds more (for swarm or traefik to boot up ?)
+	time.Sleep(1500 * time.Millisecond)
+
+	client := &http.Client{}
+	req, err := http.NewRequest("GET", "http://127.0.0.1:8000/version", nil)
+	c.Assert(err, checker.IsNil)
+	req.Host = fmt.Sprintf("my.super.host")
+	resp, err := client.Do(req)
+
+	c.Assert(err, checker.IsNil)
+	c.Assert(resp.StatusCode, checker.Equals, 200)
+
+	body, err := ioutil.ReadAll(resp.Body)
+	c.Assert(err, checker.IsNil)
+
+	var version map[string]interface{}
+
+	c.Assert(json.Unmarshal(body, &version), checker.IsNil)
+	c.Assert(version["Version"], checker.Equals, "swarm/1.0.0")
+}
+
+func (s *DockerSuite) TestDockerContainersWithOneMissingLabels(c *check.C) {
+	file := s.adaptFileForHost(c, "fixtures/docker/simple.toml")
+	defer os.Remove(file)
+	// Start a container with some labels
+	labels := map[string]string{
+		"traefik.frontend.value": "my.super.host",
+	}
+	s.startContainerWithLabels(c, "swarm:1.0.0", labels, "manage", "token://blabla")
+
+	// Start traefik
+	cmd := exec.Command(traefikBinary, "--configFile="+file)
+	err := cmd.Start()
+	c.Assert(err, checker.IsNil)
+	defer cmd.Process.Kill()
+
+	// FIXME Need to wait than 500 milliseconds more (for swarm or traefik to boot up ?)
+	time.Sleep(1500 * time.Millisecond)
+
+	client := &http.Client{}
+	req, err := http.NewRequest("GET", "http://127.0.0.1:8000/version", nil)
+	c.Assert(err, checker.IsNil)
+	req.Host = fmt.Sprintf("my.super.host")
+	resp, err := client.Do(req)
+
 	c.Assert(err, checker.IsNil)
 	c.Assert(resp.StatusCode, checker.Equals, 404)
-
-	killErr := cmd.Process.Kill()
-	c.Assert(killErr, checker.IsNil)
 }

integration/etcd_test.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"net/http"
+	"os/exec"
+	"time"
+
+	"fmt"
+	checker "github.com/vdemeester/shakers"
+	check "gopkg.in/check.v1"
+)
+
+func (s *EtcdSuite) TestSimpleConfiguration(c *check.C) {
+	cmd := exec.Command(traefikBinary, "--configFile=fixtures/etcd/simple.toml")
+	err := cmd.Start()
+	c.Assert(err, checker.IsNil)
+	defer cmd.Process.Kill()
+
+	time.Sleep(1000 * time.Millisecond)
+	// TODO validate : run on 80
+	resp, err := http.Get("http://127.0.0.1:8000/")
+
+	// Expected no response as we did not configure anything
+	c.Assert(resp, checker.IsNil)
+	c.Assert(err, checker.NotNil)
+	c.Assert(err.Error(), checker.Contains, fmt.Sprintf("getsockopt: connection refused"))
+}

integration/file_test.go

@@ -10,34 +10,30 @@ import (
 )
 
 func (s *FileSuite) TestSimpleConfiguration(c *check.C) {
-	cmd := exec.Command(traefikBinary, "fixtures/file/simple.toml")
+	cmd := exec.Command(traefikBinary, "--configFile=fixtures/file/simple.toml")
 	err := cmd.Start()
 	c.Assert(err, checker.IsNil)
+	defer cmd.Process.Kill()
 
-	time.Sleep(500 * time.Millisecond)
-	resp, err := http.Get("http://127.0.0.1/")
+	time.Sleep(1000 * time.Millisecond)
+	resp, err := http.Get("http://127.0.0.1:8000/")
 
 	// Expected a 404 as we did not configure anything
 	c.Assert(err, checker.IsNil)
 	c.Assert(resp.StatusCode, checker.Equals, 404)
-
-	killErr := cmd.Process.Kill()
-	c.Assert(killErr, checker.IsNil)
 }
 
 // #56 regression test, make sure it does not fail
 func (s *FileSuite) TestSimpleConfigurationNoPanic(c *check.C) {
-	cmd := exec.Command(traefikBinary, "fixtures/file/56-simple-panic.toml")
+	cmd := exec.Command(traefikBinary, "--configFile=fixtures/file/56-simple-panic.toml")
 	err := cmd.Start()
 	c.Assert(err, checker.IsNil)
+	defer cmd.Process.Kill()
 
-	time.Sleep(500 * time.Millisecond)
-	resp, err := http.Get("http://127.0.0.1/")
+	time.Sleep(1000 * time.Millisecond)
+	resp, err := http.Get("http://127.0.0.1:8000/")
 
 	// Expected a 404 as we did not configure anything
 	c.Assert(err, checker.IsNil)
 	c.Assert(resp.StatusCode, checker.Equals, 404)
-
-	killErr := cmd.Process.Kill()
-	c.Assert(killErr, checker.IsNil)
 }

integration/fixtures/consul/simple.toml

@@ -1,11 +1,9 @@
-# Reverse proxy port
-#
-# Optional
-# Default: ":80"
-#
-# port = ":80"
-#
-# LogLevel
+defaultEntryPoints = ["http"]
+
+[entryPoints]
+  [entryPoints.http]
+  address = ":8000"
+
 logLevel = "DEBUG"
 
 [consul]

integration/fixtures/consul_catalog/simple.toml

@@ -0,0 +1,9 @@
+defaultEntryPoints = ["http"]
+logLevel = "DEBUG"
+
+[entryPoints]
+  [entryPoints.http]
+  address = ":8000"
+
+[consulCatalog]
+domain = "consul.localhost"

integration/fixtures/docker/simple.toml

@@ -1,11 +1,9 @@
-# Reverse proxy port
-#
-# Optional
-# Default: ":80"
-#
-# port = ":80"
-#
-# LogLevel
+defaultEntryPoints = ["http"]
+
+[entryPoints]
+  [entryPoints.http]
+  address = ":8000"
+
 logLevel = "DEBUG"
 
 [docker]

integration/fixtures/etcd/simple.toml

@@ -0,0 +1,10 @@
+defaultEntryPoints = ["http"]
+
+[entryPoints]
+  [entryPoints.http]
+  address = ":8000"
+
+logLevel = "DEBUG"
+
+[etcd]
+  endpoint = "127.0.0.1:4003,127.0.0.1:4002,127.0.0.1:4001"

integration/fixtures/file/56-simple-panic.toml

@@ -1,11 +1,9 @@
-# Reverse proxy port
-#
-# Optional
-# Default: ":80"
-#
-# port = ":80"
-#
-# LogLevel
+defaultEntryPoints = ["http"]
+
+[entryPoints]
+  [entryPoints.http]
+  address = ":8000"
+
 logLevel = "DEBUG"
 
 [file]

integration/fixtures/file/simple.toml

@@ -1,11 +1,9 @@
-# Reverse proxy port
-#
-# Optional
-# Default: ":80"
-#
-# port = ":80"
-#
-# LogLevel
+defaultEntryPoints = ["http"]
+
+[entryPoints]
+  [entryPoints.http]
+  address = ":8000"
+
 logLevel = "DEBUG"
 
 [file]

integration/fixtures/https/https_sni.toml

@@ -0,0 +1,36 @@
+logLevel = "DEBUG"
+
+defaultEntryPoints = ["https"]
+
+[entryPoints]
+  [entryPoints.https]
+  address = ":4443"
+    [entryPoints.https.tls]
+     [[entryPoints.https.tls.certificates]]
+     CertFile = "fixtures/https/snitest.com.cert"
+     KeyFile = "fixtures/https/snitest.com.key"
+     [[entryPoints.https.tls.certificates]]
+     CertFile = "fixtures/https/snitest.org.cert"
+     KeyFile = "fixtures/https/snitest.org.key"
+
+[file]
+
+[backends]
+  [backends.backend1]
+    [backends.backend1.servers.server1]
+    url = "http://127.0.0.1:9010"
+  [backends.backend2]
+    [backends.backend2.servers.server1]
+    url = "http://127.0.0.1:9020"
+
+[frontends]
+  [frontends.frontend1]
+  backend = "backend1"
+    [frontends.frontend1.routes.test_1]
+    rule = "Host"
+    value = "snitest.com"
+  [frontends.frontend2]
+  backend = "backend2"
+    [frontends.frontend2.routes.test_2]
+    rule = "Host"
+    value = "snitest.org"

integration/fixtures/https/snitest.com.cert

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIC/zCCAeegAwIBAgIJAL858pci5XyjMA0GCSqGSIb3DQEBBQUAMBYxFDASBgNV
+BAMMC3NuaXRlc3QuY29tMB4XDTE1MTEyMzIyMDU1NloXDTI1MTEyMDIyMDU1Nlow
+FjEUMBIGA1UEAwwLc25pdGVzdC5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw
+ggEKAoIBAQDVF25wEroSIUO/dNgHxlyt8pZFVpJ8fNaJw7cnlZ1JP2hLuEbmjAFT
+dHqS8wKDNYHktsBEOUfN/qbk0AiGb+SvhQw6kfM/QSj9fXVQ7KhYP9XYOekTOH7d
+M0Z2L3RGgqs8z+83exOOnAFVvIJCMZJXEeijV6iJlmpCcJa0Kg/JHlxhoWTEeZuU
+G+hITafk1yWOKorTCPlMhB30wuQoWfbHP+3G0bsERLXFiMANE8EtQu8+ZhfseBUh
+5Tu5gIC4Fnria7mRixAZeEiAblFP9h0vrNRcP3nmuVz0tHPIeQsJQiEhxaZ09oUW
+h9WqTsYCP1821+SVazM9oFRTpy6chZyTAgMBAAGjUDBOMB0GA1UdDgQWBBSz9mbX
+ia1TM5FG4Zgagaet24S8HDAfBgNVHSMEGDAWgBSz9mbXia1TM5FG4Zgagaet24S8
+HDAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4IBAQB79W8XTxlozh9w/W7T
+5vDev67G4T/wetABSb68CRrqojt78PMJuS89JarA8I3ts00O+0JYnsHxp+9qC7pf
+jWHcDSiLwRUMu7MXW/KIen1EB8BQNA0xWbAiQaWYPHzsBlX48+9wBe0HTDx7Lcxb
+OsmnXHBF5fd2EY+R8qJu+PyTDDL1WLItFJpzHiFiGiYF8Tyic3kkPjje6eIOxRmT
+hq+qbwApzbzz6h/VD5xR3zBDFBo2Xs5tdP264KIw/YXDpaXVBiJ5DDjQ3dtJw1G5
+yzgrHQZWJN8Gs8ZZgGdgRf7PHox8xEZtqPiMkChDz6T7Ha3U0xYN6TZGNZOR6DHs
+K9/8
+-----END CERTIFICATE-----

integration/fixtures/https/snitest.com.key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpQIBAAKCAQEA1RducBK6EiFDv3TYB8ZcrfKWRVaSfHzWicO3J5WdST9oS7hG
+5owBU3R6kvMCgzWB5LbARDlHzf6m5NAIhm/kr4UMOpHzP0Eo/X11UOyoWD/V2Dnp
+Ezh+3TNGdi90RoKrPM/vN3sTjpwBVbyCQjGSVxHoo1eoiZZqQnCWtCoPyR5cYaFk
+xHmblBvoSE2n5NcljiqK0wj5TIQd9MLkKFn2xz/txtG7BES1xYjADRPBLULvPmYX
+7HgVIeU7uYCAuBZ64mu5kYsQGXhIgG5RT/YdL6zUXD955rlc9LRzyHkLCUIhIcWm
+dPaFFofVqk7GAj9fNtfklWszPaBUU6cunIWckwIDAQABAoIBABAdQYDAKcoNMe5c
+i6mq2n9dBPghX9qCJkcswcEAk3BilySCvvnYRJFnEY3jSqFZfoUpPMjr+/4b78sF
+4F8qPwT27sHPH7H833ir8B86hlCGI0nCt1l4wD9CDWYKmKRsZT6oCtMLP6NdMMyn
+AMK4tPRYqlsP2fLtqQN1ODBPrfnraoNHtOVE784iBCD5dewICA5RIQG2i/d2+CGF
++bahFqUXVCqHoxBz4AVvrRFL99VcP7P2iZyk6hDQ7fci7Xay8Wb/HutRxuqvF0aU
+bG6Enk6CCtNZHLwNPp4Hqft0Udvg2tG8okYwbEmoEO40nQsCSzRCpq5Uvzi+LX1k
+LykQ6+ECgYEA7x8vQoyOK60Q3LPpJFGDec2+XJPoesTfJTT6idaP7ukUL8p3FsUo
+9vtxRRfhSOdPoAINmrL0TyMekO2B6zXx0pmWVpMrFwZW6zMwZAnLp/w+3USpbGCy
+K12IIwvRYzTzKwoMTVAKTXm36b6oqr2La4bTdJR7REY6G374FrJb/H0CgYEA5CHk
+Ym0h7cf00fw9UEHRfzUZxmCfRWY6K8InOuHdLi+u4TiyXzs8x5s0e/DN/raNmTGx
+QO81UzuS3nKwc4n5QyXjVnhzR5DbbSACDwHtdnxZByL0D1KvPjtRF8F+rWXViXv2
+TM7UiOmn6R375FPSAPxeyMx8Womc3EnAAfLWGk8CgYEAv8I2WBv3dzcWqqbsdF+a
+G/fOjNdgO/PdLy1JLXiPfHwV4C1xSyVZMJd7wnjgBWLaC+sZldGk8kGrpXWSFlnw
+T38zfMIQcCp5Uax/RfpFA7XZhAAoDe2NdBFRtyknBXPU/dLVArsJSBAwWJa5FBNk
+1xoMQRVBtQLMXnh341utQNECgYEA4o1R2/ka16NaWmpPjXM/lD9skFgF84p4vFn8
+UXpaB3LtDdcbNH2Ed4mHToouWAR8jCUQLTcg0r53tRdaafMcKfXnVUka2nhdoHpH
+8RVt99u3IeIxU0I+q+OGPbw3jAV0UStcxpwj7q9zw4q2SuJ+y+HUUz7XQ6Yjs5Q9
+7PF2c/sCgYEAhdVn5gZ5FvYKrBi46t3pxPsWK476HmQEVHVi5+od7wg+araDelAe
+8QE8hc8qdZGbjdB/AHSPCeUxfO2vnpsCoSRs29o6pDvQuqvHYs+M53l5LEYeOjof
+t6J/DK5Pim2CAFjYFcZk8/Gyl5HjTw3PpdWxoPD5v2Xw3bbY57IIbm4=
+-----END RSA PRIVATE KEY-----

integration/fixtures/https/snitest.org.cert

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIC/zCCAeegAwIBAgIJALAYHG/vGqWEMA0GCSqGSIb3DQEBBQUAMBYxFDASBgNV
+BAMMC3NuaXRlc3Qub3JnMB4XDTE1MTEyMzIyMDU0NFoXDTI1MTEyMDIyMDU0NFow
+FjEUMBIGA1UEAwwLc25pdGVzdC5vcmcwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw
+ggEKAoIBAQC8b2Qv68Xnv4wgJ6HNupxABSUA5KXmv9g7pwwsFMSOK15o2qGFzx/x
+9loIi5pMIYIy4SVwJNrYUi772nCYMqSIVXlwct/CE70j2Jb2geIHu3jHbFWXruWb
+W1tGGUYzvnsOUziPE3rLWa/NObNYLLlUKJaxfHrxnpuKpQUsXzoLl25cJEVr4jg2
+ZITpdraxaBLisdlWY7EwwHBLu2nxH5Rn+nIjenFfdUwKF9s5dGy63tfBc8LX9yJk
++kOwy1al/Wxa0DUb6rSt0QDCcD+rXnjk2zWPtsHz1btwtqM+FLtN5z0Lmnx7DF3C
+tCf1TMzduzZ6aeHk77zc664ZQun5cH33AgMBAAGjUDBOMB0GA1UdDgQWBBRn/nNz
+PUsmDKmKv3GGo3km5KKvUDAfBgNVHSMEGDAWgBRn/nNzPUsmDKmKv3GGo3km5KKv
+UDAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4IBAQBkuutIcbBdESgvNLLr
+k/8HUDuFm72lYHZFE+c76CxqYN52w02NCTiq1InoDUvqZXb/StATBwRRduTUPCj9
+KUkC7pOjAFxjzjExsHrtZSq01WinrxNI+qSKvI8jFngMHnwN1omTt7/D7nxeW5Of
+FJTkElnxtELAGHoIwZ+bKprnexefpn9UW84VJvJ2crSR63vBvdTrgsrEGW6kQj1I
+62laDpax4+x8t2h+sfG6uNIA1cFrG8Sk+O2Bi3ogB7Y/4e8r6WA23IRP+aSv0J2b
+k5fvuuXbIc979pQOoO03zG0S7Wpmpsw+9dQB9TOxGITOLfCZwEuIhnv+M9lLqCks
+7H2A
+-----END CERTIFICATE-----

integration/fixtures/https/snitest.org.key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEAvG9kL+vF57+MICehzbqcQAUlAOSl5r/YO6cMLBTEjiteaNqh
+hc8f8fZaCIuaTCGCMuElcCTa2FIu+9pwmDKkiFV5cHLfwhO9I9iW9oHiB7t4x2xV
+l67lm1tbRhlGM757DlM4jxN6y1mvzTmzWCy5VCiWsXx68Z6biqUFLF86C5duXCRF
+a+I4NmSE6Xa2sWgS4rHZVmOxMMBwS7tp8R+UZ/pyI3pxX3VMChfbOXRsut7XwXPC
+1/ciZPpDsMtWpf1sWtA1G+q0rdEAwnA/q1545Ns1j7bB89W7cLajPhS7Tec9C5p8
+ewxdwrQn9UzM3bs2emnh5O+83OuuGULp+XB99wIDAQABAoIBAGOn9bByXQQnhZAr
+5aLMIn6pOdyzEBptM4q42fMmOJ2HyjJiDjKaTCbHRu5mBoBk6FrIP+iDVUo6jKad
+7BZSEjoYGlWiKzyU+97NWWmdX1D/kOzHGq1RzhTPyAHWtA4Bm0sEMFFa2AJbuGIt
+NfBYFtuva6MKVmsamuBETewdoLEnxzzDFcuOaxXRfTC/ikWcYyB4KEWA5fjroUQC
+Llo9/UTGTkh1Hynv9AXY6Qia/RbrIQjKveKCRj6PjxyE/qN9qfmngczz2pK0hRhL
+Z+K06y8G+Yj1I1zm5jNg1kakVQKoBsnaYkmIUBUSmWv6ERotedOWtOAMlOKa+0l2
+DS7Ou2ECgYEA91doi+3XrMVsgyTEm/ArzEyRUfM5dCSvBCRFhO7QQp2OYAbjJk5S
+pmdpqmwTsXNNMU+XNkWCLug5pk0PTJwP0mVLE2fLYqCCXoyaMltQ0Yk2gaun/RwE
+w5EfyMwOQakLFY/ODvduQfyNpaoWgFz4/WPNTVNCGs04LepSGKaFNy0CgYEAwwgV
+jKeFA+QZGooTInyk07ZlAbenEPu/c2y3UUFxclP0CjP2/VBOpz9B62vhzCKbjD1c
+/L3x1CKC4n4lbeyHi4vrF69LX9SHr1Jm0SUtyKeV3g0EAzIWI0HFhVUkMvtbibQ4
+HXrLVCJO77xetQ7RQszss1z9g3WotAAiBMiQgDMCgYBTLjoilOIrYFmV4Q+dwa95
+DWbxwHJZ9NxG8EvQ4N95B7OR578Matqwy6ZlgeM9kiErrDCWN9oIHGEG5HN4uCM6
+BoaxB/8GNCSj13Uj6kHLtfF2ulvMa1fOzUd7J+TDgC4SGkKaFewmlOCuDf1zPdEe
+pimtD4rzqIB0MJFbaOT0IQKBgDBPjlb7IB3ooLdMQJUoXwP6iGa2gXHZioEjCv3b
+wihZ13e3i5UQEYuoRcH1RUd1wyYoBSKuQnsT2WwVZ1wlXSYaELAbQgaI9NtfBA0G
+sqKjsKICg13vSECPiEgQ4Rin3vLra4MR6c/7d6Y2+RbMhtWPQYrkm/+2Y4XDCqo4
+rGK1AoGAOFZ3RVhuwXzFdKNe32LM1wm1eZ7waxjI4bQS2xUN/3C/uWS7A3LaSlc3
+eRG3DaVpez4DQVupZDHMgxJUYqqKynUj6GD1YiaxGROj3TYCu6e7OxyhalhCllSu
+w/X5M802XqzLjeec5zHoZDfknnAkgR9MsxZYmZPFaDyL6GOKUB8=
+-----END RSA PRIVATE KEY-----

integration/fixtures/marathon/simple.toml

@@ -1,11 +1,9 @@
-# Reverse proxy port
-#
-# Optional
-# Default: ":80"
-#
-# port = ":80"
-#
-# LogLevel
+defaultEntryPoints = ["http"]
+
+[entryPoints]
+  [entryPoints.http]
+  address = ":8000"
+
 logLevel = "DEBUG"
 
 [marathon]

integration/fixtures/simple_default.toml

@@ -1,9 +1,5 @@
-# Reverse proxy port
-#
-# Optional
-# Default: ":80"
-#
-# port = ":80"
-#
-# LogLevel
-logLevel = "DEBUG"
+defaultEntryPoints = ["http"]
+
+[entryPoints]
+  [entryPoints.http]
+  address = ":8000"

integration/fixtures/simple_web.toml

@@ -0,0 +1,9 @@
+logLevel = "DEBUG"
+defaultEntryPoints = ["http"]
+
+[entryPoints]
+  [entryPoints.http]
+  address = ":8000"
+
+[web]
+address = ":8080"

integration/https_test.go

@@ -0,0 +1,110 @@
+package main
+
+import (
+	"crypto/tls"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"os/exec"
+	"time"
+
+	checker "github.com/vdemeester/shakers"
+	check "gopkg.in/check.v1"
+)
+
+// HTTPSSuite
+type HTTPSSuite struct{ BaseSuite }
+
+// TestWithSNIConfigHandshake involves a client sending a SNI hostname of
+// "snitest.com", which happens to match the CN of 'snitest.com.crt'. The test
+// verifies that traefik presents the correct certificate.
+func (s *HTTPSSuite) TestWithSNIConfigHandshake(c *check.C) {
+	cmd := exec.Command(traefikBinary, "--configFile=fixtures/https/https_sni.toml")
+	err := cmd.Start()
+	c.Assert(err, checker.IsNil)
+	defer cmd.Process.Kill()
+
+	time.Sleep(500 * time.Millisecond)
+
+	tlsConfig := &tls.Config{
+		InsecureSkipVerify: true,
+		ServerName:         "snitest.com",
+	}
+	conn, err := tls.Dial("tcp", "127.0.0.1:4443", tlsConfig)
+	c.Assert(err, checker.IsNil, check.Commentf("failed to connect to server"))
+
+	defer conn.Close()
+	err = conn.Handshake()
+	c.Assert(err, checker.IsNil, check.Commentf("TLS handshake error"))
+
+	cs := conn.ConnectionState()
+	err = cs.PeerCertificates[0].VerifyHostname("snitest.com")
+	c.Assert(err, checker.IsNil, check.Commentf("certificate did not match SNI servername"))
+}
+
+// TestWithSNIConfigRoute involves a client sending HTTPS requests with
+// SNI hostnames of "snitest.org" and "snitest.com". The test verifies
+// that traefik routes the requests to the expected backends.
+func (s *HTTPSSuite) TestWithSNIConfigRoute(c *check.C) {
+	cmd := exec.Command(traefikBinary, "--configFile=fixtures/https/https_sni.toml")
+	err := cmd.Start()
+	c.Assert(err, checker.IsNil)
+	defer cmd.Process.Kill()
+
+	backend1 := startTestServer("9010", 204)
+	backend2 := startTestServer("9020", 205)
+	defer backend1.Close()
+	defer backend2.Close()
+
+	time.Sleep(2000 * time.Millisecond)
+
+	tr1 := &http.Transport{
+		TLSClientConfig: &tls.Config{
+			InsecureSkipVerify: true,
+			ServerName:         "snitest.com",
+		},
+	}
+	tr2 := &http.Transport{
+		TLSClientConfig: &tls.Config{
+			InsecureSkipVerify: true,
+			ServerName:         "snitest.org",
+		},
+	}
+
+	client := &http.Client{Transport: tr1}
+	req, _ := http.NewRequest("GET", "https://127.0.0.1:4443/", nil)
+	req.Host = "snitest.com"
+	req.Header.Set("Host", "snitest.com")
+	req.Header.Set("Accept", "*/*")
+	resp, err := client.Do(req)
+	c.Assert(err, checker.IsNil)
+	// Expected a 204 (from backend1)
+	c.Assert(resp.StatusCode, checker.Equals, 204)
+
+	client = &http.Client{Transport: tr2}
+	req, _ = http.NewRequest("GET", "https://127.0.0.1:4443/", nil)
+	req.Host = "snitest.org"
+	req.Header.Set("Host", "snitest.org")
+	req.Header.Set("Accept", "*/*")
+	resp, err = client.Do(req)
+	c.Assert(err, checker.IsNil)
+	// Expected a 205 (from backend2)
+	c.Assert(resp.StatusCode, checker.Equals, 205)
+}
+
+func startTestServer(port string, statusCode int) (ts *httptest.Server) {
+	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(statusCode)
+	})
+	listener, err := net.Listen("tcp", "127.0.0.1:"+port)
+	if err != nil {
+		panic(err)
+	}
+
+	ts = &httptest.Server{
+		Listener: listener,
+		Config:   &http.Server{Handler: handler},
+	}
+	ts.Start()
+	return
+}

integration/integration_test.go

@@ -10,9 +10,9 @@ import (
 	"testing"
 	"text/template"
 
+	"github.com/containous/traefik/integration/utils"
 	"github.com/docker/libcompose/docker"
 	"github.com/docker/libcompose/project"
-	"github.com/emilevauge/traefik/integration/utils"
 
 	checker "github.com/vdemeester/shakers"
 	check "gopkg.in/check.v1"
@@ -24,17 +24,17 @@ func Test(t *testing.T) {
 
 func init() {
 	check.Suite(&SimpleSuite{})
+	check.Suite(&HTTPSSuite{})
 	check.Suite(&FileSuite{})
 	check.Suite(&DockerSuite{})
 	check.Suite(&ConsulSuite{})
+	check.Suite(&ConsulCatalogSuite{})
+	check.Suite(&EtcdSuite{})
 	check.Suite(&MarathonSuite{})
 }
 
 var traefikBinary = "../dist/traefik"
 
-// SimpleSuite
-type SimpleSuite struct{ BaseSuite }
-
 // File test suites
 type FileSuite struct{ BaseSuite }
 
@@ -44,17 +44,6 @@ func (s *FileSuite) SetUpSuite(c *check.C) {
 	s.composeProject.Up()
 }
 
-// Docker test suites
-type DockerSuite struct{ BaseSuite }
-
-func (s *DockerSuite) SetUpSuite(c *check.C) {
-	// Make sure we can speak to docker
-}
-
-func (s *DockerSuite) TearDownSuite(c *check.C) {
-	// Clean the mess
-}
-
 // Consul test suites (using libcompose)
 type ConsulSuite struct{ BaseSuite }
 
@@ -62,6 +51,13 @@ func (s *ConsulSuite) SetUpSuite(c *check.C) {
 	s.createComposeProject(c, "consul")
 }
 
+// Etcd test suites (using libcompose)
+type EtcdSuite struct{ BaseSuite }
+
+func (s *EtcdSuite) SetUpSuite(c *check.C) {
+	s.createComposeProject(c, "etcd")
+}
+
 // Marathon test suites (using libcompose)
 type MarathonSuite struct{ BaseSuite }
 
@@ -93,13 +89,18 @@ func (s *BaseSuite) TearDownSuite(c *check.C) {
 func (s *BaseSuite) createComposeProject(c *check.C, name string) {
 	composeProject, err := docker.NewProject(&docker.Context{
 		Context: project.Context{
-			ComposeFile: fmt.Sprintf("resources/compose/%s.yml", name),
+			ComposeFiles: []string{
+				fmt.Sprintf("resources/compose/%s.yml", name),
+			},
 			ProjectName: fmt.Sprintf("integration-test-%s", name),
 		},
 	})
 	c.Assert(err, checker.IsNil)
 	s.composeProject = composeProject
 
+	err = composeProject.Create()
+	c.Assert(err, checker.IsNil)
+
 	s.started = make(chan bool)
 	s.stopped = make(chan bool)
 	s.deleted = make(chan bool)
@@ -109,7 +110,8 @@ func (s *BaseSuite) createComposeProject(c *check.C, name string) {
 
 	composeProject.AddListener(s.listenChan)
 
-	composeProject.Start()
+	err = composeProject.Start()
+	c.Assert(err, checker.IsNil)
 
 	// Wait for compose to start
 	<-s.started

integration/marathon_test.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"fmt"
 	"net/http"
 	"os/exec"
 	"time"
@@ -10,18 +11,17 @@ import (
 )
 
 func (s *MarathonSuite) TestSimpleConfiguration(c *check.C) {
-	cmd := exec.Command(traefikBinary, "fixtures/marathon/simple.toml")
+	cmd := exec.Command(traefikBinary, "--configFile=fixtures/marathon/simple.toml")
 	err := cmd.Start()
 	c.Assert(err, checker.IsNil)
+	defer cmd.Process.Kill()
 
 	time.Sleep(500 * time.Millisecond)
 	// TODO validate : run on 80
-	resp, err := http.Get("http://127.0.0.1/")
+	resp, err := http.Get("http://127.0.0.1:8000/")
 
-	// Expected a 404 as we did not configure anything
-	c.Assert(err, checker.IsNil)
-	c.Assert(resp.StatusCode, checker.Equals, 404)
-
-	killErr := cmd.Process.Kill()
-	c.Assert(killErr, checker.IsNil)
+	// Expected no response as we did not configure anything
+	c.Assert(resp, checker.IsNil)
+	c.Assert(err, checker.NotNil)
+	c.Assert(err.Error(), checker.Contains, fmt.Sprintf("getsockopt: connection refused"))
 }

integration/resources/compose/consul_catalog.yml

@@ -0,0 +1,17 @@
+consul:
+  image: progrium/consul
+  command: -server -bootstrap -log-level debug -ui-dir /ui
+  ports:
+    - "8400:8400"
+    - "8500:8500"
+    - "8600:53/udp"
+  expose:
+    - "8300"
+    - "8301"
+    - "8301/udp"
+    - "8302"
+    - "8302/udp"
+nginx:
+  image: nginx
+  ports:
+    - "8881:80"

integration/resources/compose/etcd.yml

@@ -0,0 +1,30 @@
+etcd1:
+  image: quay.io/coreos/etcd:v2.2.0
+  net: "host"
+  command: >
+    --name etcd1
+    --listen-peer-urls http://localhost:7001
+    --listen-client-urls http://localhost:4001
+    --initial-advertise-peer-urls http://localhost:7001
+    --advertise-client-urls http://localhost:4001
+    --initial-cluster etcd1=http://localhost:7001,etcd2=http://localhost:7002,etcd3=http://localhost:7003
+etcd2:
+  image: quay.io/coreos/etcd:v2.2.0
+  net: "host"
+  command: >
+    --name etcd2
+    --listen-peer-urls http://localhost:7002
+    --listen-client-urls http://localhost:4002
+    --initial-advertise-peer-urls http://localhost:7002
+    --advertise-client-urls http://localhost:4002
+    --initial-cluster etcd1=http://localhost:7001,etcd2=http://localhost:7002,etcd3=http://localhost:7003
+etcd3:
+  image: quay.io/coreos/etcd:v2.2.0
+  net: "host"
+  command: >
+    --name etcd3
+    --listen-peer-urls http://localhost:7003
+    --listen-client-urls http://localhost:4003
+    --initial-advertise-peer-urls http://localhost:7003
+    --advertise-client-urls http://localhost:4003
+    --initial-cluster etcd1=http://localhost:7001,etcd2=http://localhost:7002,etcd3=http://localhost:7003

integration/resources/compose/marathon.yml

@@ -3,7 +3,7 @@ zk:
   net: host
   environment:
     ZK_CONFIG: tickTime=2000,initLimit=10,syncLimit=5,maxClientCnxns=128,forceSync=no,clientPort=2181
-    ZK_ID: 1
+    ZK_ID: " 1"
 
 master:
   image: mesosphere/mesos-master:0.23.0-1.0.ubuntu1404
@@ -12,7 +12,7 @@ master:
     MESOS_ZK: zk://127.0.0.1:2181/mesos
     MESOS_HOSTNAME: 127.0.0.1
     MESOS_IP: 127.0.0.1
-    MESOS_QUORUM: 1
+    MESOS_QUORUM: " 1"
     MESOS_CLUSTER: docker-compose
     MESOS_WORK_DIR: /var/lib/mesos
 

kv.go

@@ -1,196 +0,0 @@
-/*
-Copyright
-*/
-package main
-
-import (
-	"bytes"
-	"github.com/docker/libkv"
-	"github.com/docker/libkv/store/boltdb"
-	"github.com/docker/libkv/store/consul"
-	"github.com/docker/libkv/store/etcd"
-	"github.com/docker/libkv/store/zookeeper"
-	"strings"
-	"text/template"
-
-	"errors"
-	"github.com/BurntSushi/toml"
-	"github.com/BurntSushi/ty/fun"
-	log "github.com/Sirupsen/logrus"
-	"github.com/docker/libkv/store"
-	"time"
-)
-
-type KvProvider struct {
-	Watch     bool
-	Endpoint  string
-	Prefix    string
-	Filename  string
-	StoreType store.Backend
-	kvclient  store.Store
-}
-
-func NewConsulProvider(provider *ConsulProvider) *KvProvider {
-	kvProvider := new(KvProvider)
-	kvProvider.Watch = provider.Watch
-	kvProvider.Endpoint = provider.Endpoint
-	kvProvider.Prefix = provider.Prefix
-	kvProvider.Filename = provider.Filename
-	kvProvider.StoreType = store.CONSUL
-	return kvProvider
-}
-
-func NewEtcdProvider(provider *EtcdProvider) *KvProvider {
-	kvProvider := new(KvProvider)
-	kvProvider.Watch = provider.Watch
-	kvProvider.Endpoint = provider.Endpoint
-	kvProvider.Prefix = provider.Prefix
-	kvProvider.Filename = provider.Filename
-	kvProvider.StoreType = store.ETCD
-	return kvProvider
-}
-
-func NewZkProvider(provider *ZookepperProvider) *KvProvider {
-	kvProvider := new(KvProvider)
-	kvProvider.Watch = provider.Watch
-	kvProvider.Endpoint = provider.Endpoint
-	kvProvider.Prefix = provider.Prefix
-	kvProvider.Filename = provider.Filename
-	kvProvider.StoreType = store.ZK
-	return kvProvider
-}
-
-func NewBoltDbProvider(provider *BoltDbProvider) *KvProvider {
-	kvProvider := new(KvProvider)
-	kvProvider.Watch = provider.Watch
-	kvProvider.Endpoint = provider.Endpoint
-	kvProvider.Prefix = provider.Prefix
-	kvProvider.Filename = provider.Filename
-	kvProvider.StoreType = store.BOLTDB
-	return kvProvider
-}
-
-func (provider *KvProvider) provide(configurationChan chan<- configMessage) error {
-	switch provider.StoreType {
-	case store.CONSUL:
-		consul.Register()
-	case store.ETCD:
-		etcd.Register()
-	case store.ZK:
-		zookeeper.Register()
-	case store.BOLTDB:
-		boltdb.Register()
-	default:
-		return errors.New("Invalid kv store: " + string(provider.StoreType))
-	}
-	kv, err := libkv.NewStore(
-		provider.StoreType,
-		[]string{provider.Endpoint},
-		&store.Config{
-			ConnectionTimeout: 30 * time.Second,
-			Bucket:            "traefik",
-		},
-	)
-	if err != nil {
-		return err
-	}
-	if _, err := kv.List(""); err != nil {
-		return err
-	}
-	provider.kvclient = kv
-	if provider.Watch {
-		stopCh := make(chan struct{})
-		chanKeys, err := kv.WatchTree(provider.Prefix, stopCh)
-		if err != nil {
-			return err
-		}
-		go func() {
-			for {
-				<-chanKeys
-				configuration := provider.loadConfig()
-				if configuration != nil {
-					configurationChan <- configMessage{string(provider.StoreType), configuration}
-				}
-				defer close(stopCh)
-			}
-		}()
-	}
-	configuration := provider.loadConfig()
-	configurationChan <- configMessage{string(provider.StoreType), configuration}
-	return nil
-}
-
-func (provider *KvProvider) loadConfig() *Configuration {
-	configuration := new(Configuration)
-	templateObjects := struct {
-		Prefix string
-	}{
-		provider.Prefix,
-	}
-	var KvFuncMap = template.FuncMap{
-		"List": func(keys ...string) []string {
-			joinedKeys := strings.Join(keys, "")
-			keysPairs, err := provider.kvclient.List(joinedKeys)
-			if err != nil {
-				log.Error("Error getting keys: ", joinedKeys, err)
-				return nil
-			}
-			directoryKeys := make(map[string]string)
-			for _, key := range keysPairs {
-				directory := strings.Split(strings.TrimPrefix(key.Key, strings.TrimPrefix(joinedKeys, "/")), "/")[0]
-				directoryKeys[directory] = joinedKeys + directory
-			}
-			return fun.Values(directoryKeys).([]string)
-		},
-		"Get": func(keys ...string) string {
-			joinedKeys := strings.Join(keys, "")
-			keyPair, err := provider.kvclient.Get(joinedKeys)
-			if err != nil {
-				log.Debug("Error getting key: ", joinedKeys, err)
-				return ""
-			} else if keyPair == nil {
-				return ""
-			}
-			return string(keyPair.Value)
-		},
-		"Last": func(key string) string {
-			splittedKey := strings.Split(key, "/")
-			return splittedKey[len(splittedKey)-1]
-		},
-	}
-
-	tmpl := template.New(provider.Filename).Funcs(KvFuncMap)
-	if len(provider.Filename) > 0 {
-		_, err := tmpl.ParseFiles(provider.Filename)
-		if err != nil {
-			log.Error("Error reading file", err)
-			return nil
-		}
-	} else {
-		buf, err := Asset("templates/kv.tmpl")
-		if err != nil {
-			log.Error("Error reading file", err)
-		}
-		_, err = tmpl.Parse(string(buf))
-		if err != nil {
-			log.Error("Error reading file", err)
-			return nil
-		}
-	}
-
-	var buffer bytes.Buffer
-
-	err := tmpl.Execute(&buffer, templateObjects)
-	if err != nil {
-		log.Error("Error with kv template:", err)
-		return nil
-	}
-
-	if _, err := toml.Decode(buffer.String(), configuration); err != nil {
-		log.Error("Error creating kv configuration:", err)
-		log.Error(buffer.String())
-		return nil
-	}
-
-	return configuration
-}

marathon.go

@@ -1,230 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"strconv"
-	"strings"
-	"text/template"
-
-	"errors"
-	"github.com/BurntSushi/toml"
-	"github.com/BurntSushi/ty/fun"
-	log "github.com/Sirupsen/logrus"
-	"github.com/gambol99/go-marathon"
-)
-
-type MarathonProvider struct {
-	Watch            bool
-	Endpoint         string
-	marathonClient   marathon.Marathon
-	Domain           string
-	Filename         string
-	NetworkInterface string
-}
-
-func (provider *MarathonProvider) Provide(configurationChan chan<- configMessage) error {
-	config := marathon.NewDefaultConfig()
-	config.URL = provider.Endpoint
-	config.EventsInterface = provider.NetworkInterface
-	client, err := marathon.NewClient(config)
-	if err != nil {
-		log.Errorf("Failed to create a client for marathon, error: %s", err)
-		return err
-	}
-	provider.marathonClient = client
-	update := make(marathon.EventsChannel, 5)
-	if provider.Watch {
-		if err := client.AddEventsListener(update, marathon.EVENTS_APPLICATIONS); err != nil {
-			log.Errorf("Failed to register for subscriptions, %s", err)
-		} else {
-			go func() {
-				for {
-					event := <-update
-					log.Debug("Marathon event receveived", event)
-					configuration := provider.loadMarathonConfig()
-					if configuration != nil {
-						configurationChan <- configMessage{"marathon", configuration}
-					}
-				}
-			}()
-		}
-	}
-
-	configuration := provider.loadMarathonConfig()
-	configurationChan <- configMessage{"marathon", configuration}
-	return nil
-}
-
-func (provider *MarathonProvider) loadMarathonConfig() *Configuration {
-	var MarathonFuncMap = template.FuncMap{
-		"getPort": func(task marathon.Task) string {
-			for _, port := range task.Ports {
-				return strconv.Itoa(port)
-			}
-			return ""
-		},
-		"getWeight": func(task marathon.Task, applications []marathon.Application) string {
-			application, errApp := getApplication(task, applications)
-			if errApp != nil {
-				log.Errorf("Unable to get marathon application from task %s", task.AppID)
-				return "0"
-			}
-			if label, err := provider.getLabel(application, "traefik.weight"); err == nil {
-				return label
-			}
-			return "0"
-		},
-		"getDomain": func(application marathon.Application) string {
-			if label, err := provider.getLabel(application, "traefik.domain"); err == nil {
-				return label
-			}
-			return provider.Domain
-		},
-		"replace": func(s1 string, s2 string, s3 string) string {
-			return strings.Replace(s3, s1, s2, -1)
-		},
-		"getProtocol": func(task marathon.Task, applications []marathon.Application) string {
-			application, errApp := getApplication(task, applications)
-			if errApp != nil {
-				log.Errorf("Unable to get marathon application from task %s", task.AppID)
-				return "http"
-			}
-			if label, err := provider.getLabel(application, "traefik.protocol"); err == nil {
-				return label
-			}
-			return "http"
-		},
-		"getFrontendValue": provider.GetFrontendValue,
-		"getFrontendRule":  provider.GetFrontendRule,
-	}
-	configuration := new(Configuration)
-
-	applications, err := provider.marathonClient.Applications(nil)
-	if err != nil {
-		log.Errorf("Failed to create a client for marathon, error: %s", err)
-		return nil
-	}
-
-	tasks, err := provider.marathonClient.AllTasks()
-	if err != nil {
-		log.Errorf("Failed to create a client for marathon, error: %s", err)
-		return nil
-	}
-
-	//filter tasks
-	filteredTasks := fun.Filter(func(task marathon.Task) bool {
-		if len(task.Ports) == 0 {
-			log.Debug("Filtering marathon task without port", task.AppID)
-			return false
-		}
-		application, errApp := getApplication(task, applications.Apps)
-		if errApp != nil {
-			log.Errorf("Unable to get marathon application from task %s", task.AppID)
-			return false
-		}
-		_, err := strconv.Atoi(application.Labels["traefik.port"])
-		if len(application.Ports) > 1 && err != nil {
-			log.Debug("Filtering marathon task with more than 1 port and no traefik.port label", task.AppID)
-			return false
-		}
-		if application.Labels["traefik.enable"] == "false" {
-			log.Debug("Filtering disabled marathon task", task.AppID)
-			return false
-		}
-		return true
-	}, tasks.Tasks).([]marathon.Task)
-
-	//filter apps
-	filteredApps := fun.Filter(func(app marathon.Application) bool {
-		//get ports from app tasks
-		if !fun.Exists(func(task marathon.Task) bool {
-			if task.AppID == app.ID {
-				return true
-			}
-			return false
-		}, filteredTasks) {
-			return false
-		}
-		return true
-	}, applications.Apps).([]marathon.Application)
-
-	templateObjects := struct {
-		Applications []marathon.Application
-		Tasks        []marathon.Task
-		Domain       string
-	}{
-		filteredApps,
-		filteredTasks,
-		provider.Domain,
-	}
-
-	tmpl := template.New(provider.Filename).Funcs(MarathonFuncMap)
-	if len(provider.Filename) > 0 {
-		_, err := tmpl.ParseFiles(provider.Filename)
-		if err != nil {
-			log.Error("Error reading file", err)
-			return nil
-		}
-	} else {
-		buf, err := Asset("templates/marathon.tmpl")
-		if err != nil {
-			log.Error("Error reading file", err)
-		}
-		_, err = tmpl.Parse(string(buf))
-		if err != nil {
-			log.Error("Error reading file", err)
-			return nil
-		}
-	}
-
-	var buffer bytes.Buffer
-
-	err = tmpl.Execute(&buffer, templateObjects)
-	if err != nil {
-		log.Error("Error with marathon template:", err)
-		return nil
-	}
-
-	if _, err := toml.Decode(buffer.String(), configuration); err != nil {
-		log.Error("Error creating marathon configuration:", err)
-		return nil
-	}
-
-	return configuration
-}
-
-func getApplication(task marathon.Task, apps []marathon.Application) (marathon.Application, error) {
-	for _, application := range apps {
-		if application.ID == task.AppID {
-			return application, nil
-		}
-	}
-	return marathon.Application{}, errors.New("Application not found: " + task.AppID)
-}
-
-func (provider *MarathonProvider) getLabel(application marathon.Application, label string) (string, error) {
-	for key, value := range application.Labels {
-		if key == label {
-			return value, nil
-		}
-	}
-	return "", errors.New("Label not found:" + label)
-}
-
-func (provider *MarathonProvider) getEscapedName(name string) string {
-	return strings.Replace(name, "/", "", -1)
-}
-
-func (provider *MarathonProvider) GetFrontendValue(application marathon.Application) string {
-	if label, err := provider.getLabel(application, "traefik.frontend.value"); err == nil {
-		return label
-	}
-	return provider.getEscapedName(application.ID) + "." + provider.Domain
-}
-
-func (provider *MarathonProvider) GetFrontendRule(application marathon.Application) string {
-	if label, err := provider.getLabel(application, "traefik.frontend.rule"); err == nil {
-		return label
-	}
-	return "Host"
-}

middlewares/StripPrefix.go

@@ -0,0 +1,22 @@
+package middlewares
+
+import (
+	"net/http"
+	"strings"
+)
+
+// StripPrefix is a middleware used to strip prefix from an URL request
+type StripPrefix struct {
+	Handler http.Handler
+	Prefix  string
+}
+
+func (s *StripPrefix) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if p := strings.TrimPrefix(r.URL.Path, s.Prefix); len(p) < len(r.URL.Path) {
+		r.URL.Path = p
+		r.RequestURI = r.URL.RequestURI()
+		s.Handler.ServeHTTP(w, r)
+	} else {
+		http.NotFound(w, r)
+	}
+}

middlewares/cbreaker.go

@@ -1,6 +1,3 @@
-/*
-Copyright
-*/
 package middlewares
 
 import (
@@ -9,10 +6,12 @@ import (
 	"github.com/mailgun/oxy/cbreaker"
 )
 
+// CircuitBreaker holds the oxy circuit breaker.
 type CircuitBreaker struct {
 	circuitBreaker *cbreaker.CircuitBreaker
 }
 
+// NewCircuitBreaker returns a new CircuitBreaker.
 func NewCircuitBreaker(next http.Handler, expression string, options ...cbreaker.CircuitBreakerOption) *CircuitBreaker {
 	circuitBreaker, _ := cbreaker.New(next, expression, options...)
 	return &CircuitBreaker{circuitBreaker}

middlewares/handlerSwitcher.go

@@ -0,0 +1,40 @@
+package middlewares
+
+import (
+	"github.com/gorilla/mux"
+	"net/http"
+	"sync"
+)
+
+// HandlerSwitcher allows hot switching of http.ServeMux
+type HandlerSwitcher struct {
+	handler     *mux.Router
+	handlerLock *sync.Mutex
+}
+
+// NewHandlerSwitcher builds a new instance of HandlerSwitcher
+func NewHandlerSwitcher(newHandler *mux.Router) (hs *HandlerSwitcher) {
+	return &HandlerSwitcher{
+		handler:     newHandler,
+		handlerLock: &sync.Mutex{},
+	}
+}
+
+func (hs *HandlerSwitcher) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	hs.handlerLock.Lock()
+	handlerBackup := hs.handler
+	hs.handlerLock.Unlock()
+	handlerBackup.ServeHTTP(rw, r)
+}
+
+// GetHandler returns the current http.ServeMux
+func (hs *HandlerSwitcher) GetHandler() (newHandler *mux.Router) {
+	return hs.handler
+}
+
+// UpdateHandler safely updates the current http.ServeMux with a new one
+func (hs *HandlerSwitcher) UpdateHandler(newHandler *mux.Router) {
+	hs.handlerLock.Lock()
+	hs.handler = newHandler
+	defer hs.handlerLock.Unlock()
+}

middlewares/logger.go

@@ -1,6 +1,3 @@
-/*
-Copyright
-*/
 package middlewares
 
 import (
@@ -16,7 +13,7 @@ type Logger struct {
 	file *os.File
 }
 
-// NewLogger returns a new Logger instance
+// NewLogger returns a new Logger instance.
 func NewLogger(file string) *Logger {
 	if len(file) > 0 {
 		fi, err := os.OpenFile(file, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
@@ -36,6 +33,7 @@ func (l *Logger) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.Ha
 	}
 }
 
+// Close closes the logger (i.e. the file).
 func (l *Logger) Close() {
 	l.file.Close()
 }

middlewares/rewrite.go

@@ -0,0 +1,31 @@
+package middlewares
+
+import (
+	log "github.com/Sirupsen/logrus"
+	"github.com/vulcand/vulcand/plugin/rewrite"
+	"net/http"
+)
+
+// Rewrite is a middleware that allows redirections
+type Rewrite struct {
+	rewriter *rewrite.Rewrite
+}
+
+// NewRewrite creates a Rewrite middleware
+func NewRewrite(regex, replacement string, redirect bool) (*Rewrite, error) {
+	rewriter, err := rewrite.NewRewrite(regex, replacement, false, redirect)
+	if err != nil {
+		return nil, err
+	}
+	return &Rewrite{rewriter: rewriter}, nil
+}
+
+//
+func (rewrite *Rewrite) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
+	handler, err := rewrite.rewriter.NewHandler(next)
+	if err != nil {
+		log.Error("Error in rewrite middleware ", err)
+		return
+	}
+	handler.ServeHTTP(rw, r)
+}

middlewares/routes.go

@@ -1,6 +1,3 @@
-/*
-Copyright
-*/
 package middlewares
 
 import (
@@ -11,10 +8,12 @@ import (
 	"github.com/gorilla/mux"
 )
 
+// Routes holds the gorilla mux routes (for the API & co).
 type Routes struct {
 	router *mux.Router
 }
 
+// NewRoutes return a Routes based on the given router.
 func NewRoutes(router *mux.Router) *Routes {
 	return &Routes{router}
 }

middlewares/websocket.go

@@ -1,20 +1,20 @@
-/*
-Copyright
-*/
 package middlewares
 
 import (
-	log "github.com/Sirupsen/logrus"
-	"github.com/mailgun/oxy/roundrobin"
 	"net/http"
 	"strings"
 	"time"
+
+	log "github.com/Sirupsen/logrus"
+	"github.com/mailgun/oxy/roundrobin"
 )
 
+// WebsocketUpgrader holds Websocket configuration.
 type WebsocketUpgrader struct {
 	rr *roundrobin.RoundRobin
 }
 
+// NewWebsocketUpgrader returns a new WebsocketUpgrader.
 func NewWebsocketUpgrader(rr *roundrobin.RoundRobin) *WebsocketUpgrader {
 	wu := WebsocketUpgrader{
 		rr: rr,

mocks/Marathon.go

@@ -0,0 +1,829 @@
+package mocks
+
+import "github.com/gambol99/go-marathon"
+import "github.com/stretchr/testify/mock"
+
+import "net/url"
+
+import "time"
+
+// Marathon is a mock of marathon.Marathon
+type Marathon struct {
+	mock.Mock
+}
+
+// ListApplications provides a mock function with given fields: _a0
+func (_m *Marathon) ListApplications(_a0 url.Values) ([]string, error) {
+	ret := _m.Called(_a0)
+
+	var r0 []string
+	if rf, ok := ret.Get(0).(func(url.Values) []string); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(url.Values) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ApplicationVersions provides a mock function with given fields: name
+func (_m *Marathon) ApplicationVersions(name string) (*marathon.ApplicationVersions, error) {
+	ret := _m.Called(name)
+
+	var r0 *marathon.ApplicationVersions
+	if rf, ok := ret.Get(0).(func(string) *marathon.ApplicationVersions); ok {
+		r0 = rf(name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.ApplicationVersions)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(name)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// HasApplicationVersion provides a mock function with given fields: name, version
+func (_m *Marathon) HasApplicationVersion(name string, version string) (bool, error) {
+	ret := _m.Called(name, version)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(string, string) bool); ok {
+		r0 = rf(name, version)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(name, version)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SetApplicationVersion provides a mock function with given fields: name, version
+func (_m *Marathon) SetApplicationVersion(name string, version *marathon.ApplicationVersion) (*marathon.DeploymentID, error) {
+	ret := _m.Called(name, version)
+
+	var r0 *marathon.DeploymentID
+	if rf, ok := ret.Get(0).(func(string, *marathon.ApplicationVersion) *marathon.DeploymentID); ok {
+		r0 = rf(name, version)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.DeploymentID)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, *marathon.ApplicationVersion) error); ok {
+		r1 = rf(name, version)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ApplicationOK provides a mock function with given fields: name
+func (_m *Marathon) ApplicationOK(name string) (bool, error) {
+	ret := _m.Called(name)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = rf(name)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(name)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// CreateApplication provides a mock function with given fields: application
+func (_m *Marathon) CreateApplication(application *marathon.Application) (*marathon.Application, error) {
+	ret := _m.Called(application)
+
+	var r0 *marathon.Application
+	if rf, ok := ret.Get(0).(func(*marathon.Application) *marathon.Application); ok {
+		r0 = rf(application)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.Application)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(*marathon.Application) error); ok {
+		r1 = rf(application)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DeleteApplication provides a mock function with given fields: name
+func (_m *Marathon) DeleteApplication(name string) (*marathon.DeploymentID, error) {
+	ret := _m.Called(name)
+
+	var r0 *marathon.DeploymentID
+	if rf, ok := ret.Get(0).(func(string) *marathon.DeploymentID); ok {
+		r0 = rf(name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.DeploymentID)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(name)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateApplication provides a mock function with given fields: application
+func (_m *Marathon) UpdateApplication(application *marathon.Application) (*marathon.DeploymentID, error) {
+	ret := _m.Called(application)
+
+	var r0 *marathon.DeploymentID
+	if rf, ok := ret.Get(0).(func(*marathon.Application) *marathon.DeploymentID); ok {
+		r0 = rf(application)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.DeploymentID)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(*marathon.Application) error); ok {
+		r1 = rf(application)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ApplicationDeployments provides a mock function with given fields: name
+func (_m *Marathon) ApplicationDeployments(name string) ([]*marathon.DeploymentID, error) {
+	ret := _m.Called(name)
+
+	var r0 []*marathon.DeploymentID
+	if rf, ok := ret.Get(0).(func(string) []*marathon.DeploymentID); ok {
+		r0 = rf(name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*marathon.DeploymentID)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(name)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ScaleApplicationInstances provides a mock function with given fields: name, instances, force
+func (_m *Marathon) ScaleApplicationInstances(name string, instances int, force bool) (*marathon.DeploymentID, error) {
+	ret := _m.Called(name, instances, force)
+
+	var r0 *marathon.DeploymentID
+	if rf, ok := ret.Get(0).(func(string, int, bool) *marathon.DeploymentID); ok {
+		r0 = rf(name, instances, force)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.DeploymentID)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, int, bool) error); ok {
+		r1 = rf(name, instances, force)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// RestartApplication provides a mock function with given fields: name, force
+func (_m *Marathon) RestartApplication(name string, force bool) (*marathon.DeploymentID, error) {
+	ret := _m.Called(name, force)
+
+	var r0 *marathon.DeploymentID
+	if rf, ok := ret.Get(0).(func(string, bool) *marathon.DeploymentID); ok {
+		r0 = rf(name, force)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.DeploymentID)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, bool) error); ok {
+		r1 = rf(name, force)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Applications provides a mock function with given fields: _a0
+func (_m *Marathon) Applications(_a0 url.Values) (*marathon.Applications, error) {
+	ret := _m.Called(_a0)
+
+	var r0 *marathon.Applications
+	if rf, ok := ret.Get(0).(func(url.Values) *marathon.Applications); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.Applications)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(url.Values) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Application provides a mock function with given fields: name
+func (_m *Marathon) Application(name string) (*marathon.Application, error) {
+	ret := _m.Called(name)
+
+	var r0 *marathon.Application
+	if rf, ok := ret.Get(0).(func(string) *marathon.Application); ok {
+		r0 = rf(name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.Application)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(name)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// WaitOnApplication provides a mock function with given fields: name, timeout
+func (_m *Marathon) WaitOnApplication(name string, timeout time.Duration) error {
+	ret := _m.Called(name, timeout)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, time.Duration) error); ok {
+		r0 = rf(name, timeout)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Tasks provides a mock function with given fields: application
+func (_m *Marathon) Tasks(application string) (*marathon.Tasks, error) {
+	ret := _m.Called(application)
+
+	var r0 *marathon.Tasks
+	if rf, ok := ret.Get(0).(func(string) *marathon.Tasks); ok {
+		r0 = rf(application)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.Tasks)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(application)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// AllTasks provides a mock function with given fields: opts
+func (_m *Marathon) AllTasks(opts *marathon.AllTasksOpts) (*marathon.Tasks, error) {
+	ret := _m.Called(opts)
+
+	var r0 *marathon.Tasks
+	if rf, ok := ret.Get(0).(func(*marathon.AllTasksOpts) *marathon.Tasks); ok {
+		r0 = rf(opts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.Tasks)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(*marathon.AllTasksOpts) error); ok {
+		r1 = rf(opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// TaskEndpoints provides a mock function with given fields: name, port, healthCheck
+func (_m *Marathon) TaskEndpoints(name string, port int, healthCheck bool) ([]string, error) {
+	ret := _m.Called(name, port, healthCheck)
+
+	var r0 []string
+	if rf, ok := ret.Get(0).(func(string, int, bool) []string); ok {
+		r0 = rf(name, port, healthCheck)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, int, bool) error); ok {
+		r1 = rf(name, port, healthCheck)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// KillApplicationTasks provides a mock function with given fields: applicationID, opts
+func (_m *Marathon) KillApplicationTasks(applicationID string, opts *marathon.KillApplicationTasksOpts) (*marathon.Tasks, error) {
+	ret := _m.Called(applicationID, opts)
+
+	var r0 *marathon.Tasks
+	if rf, ok := ret.Get(0).(func(string, *marathon.KillApplicationTasksOpts) *marathon.Tasks); ok {
+		r0 = rf(applicationID, opts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.Tasks)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, *marathon.KillApplicationTasksOpts) error); ok {
+		r1 = rf(applicationID, opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// KillTask provides a mock function with given fields: taskID, opts
+func (_m *Marathon) KillTask(taskID string, opts *marathon.KillTaskOpts) (*marathon.Task, error) {
+	ret := _m.Called(taskID, opts)
+
+	var r0 *marathon.Task
+	if rf, ok := ret.Get(0).(func(string, *marathon.KillTaskOpts) *marathon.Task); ok {
+		r0 = rf(taskID, opts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.Task)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, *marathon.KillTaskOpts) error); ok {
+		r1 = rf(taskID, opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// KillTasks provides a mock function with given fields: taskIDs, opts
+func (_m *Marathon) KillTasks(taskIDs []string, opts *marathon.KillTaskOpts) error {
+	ret := _m.Called(taskIDs, opts)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func([]string, *marathon.KillTaskOpts) error); ok {
+		r0 = rf(taskIDs, opts)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Groups provides a mock function with given fields:
+func (_m *Marathon) Groups() (*marathon.Groups, error) {
+	ret := _m.Called()
+
+	var r0 *marathon.Groups
+	if rf, ok := ret.Get(0).(func() *marathon.Groups); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.Groups)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Group provides a mock function with given fields: name
+func (_m *Marathon) Group(name string) (*marathon.Group, error) {
+	ret := _m.Called(name)
+
+	var r0 *marathon.Group
+	if rf, ok := ret.Get(0).(func(string) *marathon.Group); ok {
+		r0 = rf(name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.Group)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(name)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// CreateGroup provides a mock function with given fields: group
+func (_m *Marathon) CreateGroup(group *marathon.Group) error {
+	ret := _m.Called(group)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*marathon.Group) error); ok {
+		r0 = rf(group)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// DeleteGroup provides a mock function with given fields: name
+func (_m *Marathon) DeleteGroup(name string) (*marathon.DeploymentID, error) {
+	ret := _m.Called(name)
+
+	var r0 *marathon.DeploymentID
+	if rf, ok := ret.Get(0).(func(string) *marathon.DeploymentID); ok {
+		r0 = rf(name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.DeploymentID)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(name)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// UpdateGroup provides a mock function with given fields: id, group
+func (_m *Marathon) UpdateGroup(id string, group *marathon.Group) (*marathon.DeploymentID, error) {
+	ret := _m.Called(id, group)
+
+	var r0 *marathon.DeploymentID
+	if rf, ok := ret.Get(0).(func(string, *marathon.Group) *marathon.DeploymentID); ok {
+		r0 = rf(id, group)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.DeploymentID)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, *marathon.Group) error); ok {
+		r1 = rf(id, group)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// HasGroup provides a mock function with given fields: name
+func (_m *Marathon) HasGroup(name string) (bool, error) {
+	ret := _m.Called(name)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = rf(name)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(name)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// WaitOnGroup provides a mock function with given fields: name, timeout
+func (_m *Marathon) WaitOnGroup(name string, timeout time.Duration) error {
+	ret := _m.Called(name, timeout)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, time.Duration) error); ok {
+		r0 = rf(name, timeout)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Deployments provides a mock function with given fields:
+func (_m *Marathon) Deployments() ([]*marathon.Deployment, error) {
+	ret := _m.Called()
+
+	var r0 []*marathon.Deployment
+	if rf, ok := ret.Get(0).(func() []*marathon.Deployment); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*marathon.Deployment)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DeleteDeployment provides a mock function with given fields: id, force
+func (_m *Marathon) DeleteDeployment(id string, force bool) (*marathon.DeploymentID, error) {
+	ret := _m.Called(id, force)
+
+	var r0 *marathon.DeploymentID
+	if rf, ok := ret.Get(0).(func(string, bool) *marathon.DeploymentID); ok {
+		r0 = rf(id, force)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.DeploymentID)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, bool) error); ok {
+		r1 = rf(id, force)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// HasDeployment provides a mock function with given fields: id
+func (_m *Marathon) HasDeployment(id string) (bool, error) {
+	ret := _m.Called(id)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = rf(id)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// WaitOnDeployment provides a mock function with given fields: id, timeout
+func (_m *Marathon) WaitOnDeployment(id string, timeout time.Duration) error {
+	ret := _m.Called(id, timeout)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, time.Duration) error); ok {
+		r0 = rf(id, timeout)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Subscriptions provides a mock function with given fields:
+func (_m *Marathon) Subscriptions() (*marathon.Subscriptions, error) {
+	ret := _m.Called()
+
+	var r0 *marathon.Subscriptions
+	if rf, ok := ret.Get(0).(func() *marathon.Subscriptions); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.Subscriptions)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// AddEventsListener provides a mock function with given fields: channel, filter
+func (_m *Marathon) AddEventsListener(channel marathon.EventsChannel, filter int) error {
+	ret := _m.Called(channel, filter)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(marathon.EventsChannel, int) error); ok {
+		r0 = rf(channel, filter)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// RemoveEventsListener provides a mock function with given fields: channel
+func (_m *Marathon) RemoveEventsListener(channel marathon.EventsChannel) {
+	_m.Called(channel)
+}
+
+// Unsubscribe provides a mock function with given fields: _a0
+func (_m *Marathon) Unsubscribe(_a0 string) error {
+	ret := _m.Called(_a0)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// GetMarathonURL provides a mock function with given fields:
+func (_m *Marathon) GetMarathonURL() string {
+	ret := _m.Called()
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// Ping provides a mock function with given fields:
+func (_m *Marathon) Ping() (bool, error) {
+	ret := _m.Called()
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func() bool); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Info provides a mock function with given fields:
+func (_m *Marathon) Info() (*marathon.Info, error) {
+	ret := _m.Called()
+
+	var r0 *marathon.Info
+	if rf, ok := ret.Get(0).(func() *marathon.Info); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*marathon.Info)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Leader provides a mock function with given fields:
+func (_m *Marathon) Leader() (string, error) {
+	ret := _m.Called()
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// AbdicateLeader provides a mock function with given fields:
+func (_m *Marathon) AbdicateLeader() (string, error) {
+	ret := _m.Called()
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}

provider.go

@@ -1,5 +0,0 @@
-package main
-
-type Provider interface {
-	Provide(configurationChan chan<- configMessage) error
-}

provider/boltdb.go

@@ -0,0 +1,20 @@
+package provider
+
+import (
+	"github.com/containous/traefik/types"
+	"github.com/docker/libkv/store"
+	"github.com/docker/libkv/store/boltdb"
+)
+
+// BoltDb holds configurations of the BoltDb provider.
+type BoltDb struct {
+	Kv `mapstructure:",squash"`
+}
+
+// Provide allows the provider to provide configurations to traefik
+// using the given configuration channel.
+func (provider *BoltDb) Provide(configurationChan chan<- types.ConfigMessage) error {
+	provider.storeType = store.BOLTDB
+	boltdb.Register()
+	return provider.provide(configurationChan)
+}

provider/consul.go

@@ -0,0 +1,20 @@
+package provider
+
+import (
+	"github.com/containous/traefik/types"
+	"github.com/docker/libkv/store"
+	"github.com/docker/libkv/store/consul"
+)
+
+// Consul holds configurations of the Consul provider.
+type Consul struct {
+	Kv `mapstructure:",squash"`
+}
+
+// Provide allows the provider to provide configurations to traefik
+// using the given configuration channel.
+func (provider *Consul) Provide(configurationChan chan<- types.ConfigMessage) error {
+	provider.storeType = store.CONSUL
+	consul.Register()
+	return provider.provide(configurationChan)
+}

provider/consul_catalog.go

@@ -0,0 +1,199 @@
+package provider
+
+import (
+	"errors"
+	"strings"
+	"text/template"
+	"time"
+
+	log "github.com/Sirupsen/logrus"
+	"github.com/cenkalti/backoff"
+	"github.com/containous/traefik/types"
+	"github.com/hashicorp/consul/api"
+)
+
+const (
+	// DefaultWatchWaitTime is the duration to wait when polling consul
+	DefaultWatchWaitTime = 15 * time.Second
+)
+
+// ConsulCatalog holds configurations of the Consul catalog provider.
+type ConsulCatalog struct {
+	BaseProvider `mapstructure:",squash"`
+	Endpoint     string
+	Domain       string
+	client       *api.Client
+}
+
+type catalogUpdate struct {
+	Service string
+	Nodes   []*api.ServiceEntry
+}
+
+func (provider *ConsulCatalog) watchServices(stopCh <-chan struct{}) <-chan map[string][]string {
+	watchCh := make(chan map[string][]string)
+
+	catalog := provider.client.Catalog()
+
+	go func() {
+		defer close(watchCh)
+
+		opts := &api.QueryOptions{WaitTime: DefaultWatchWaitTime}
+
+		for {
+			select {
+			case <-stopCh:
+				return
+			default:
+			}
+
+			data, meta, err := catalog.Services(opts)
+			if err != nil {
+				log.WithError(err).Errorf("Failed to list services")
+				return
+			}
+
+			// If LastIndex didn't change then it means `Get` returned
+			// because of the WaitTime and the key didn't changed.
+			if opts.WaitIndex == meta.LastIndex {
+				continue
+			}
+			opts.WaitIndex = meta.LastIndex
+
+			if data != nil {
+				watchCh <- data
+			}
+		}
+	}()
+
+	return watchCh
+}
+
+func (provider *ConsulCatalog) healthyNodes(service string) (catalogUpdate, error) {
+	health := provider.client.Health()
+	opts := &api.QueryOptions{}
+	data, _, err := health.Service(service, "", true, opts)
+	if err != nil {
+		log.WithError(err).Errorf("Failed to fetch details of " + service)
+		return catalogUpdate{}, err
+	}
+
+	return catalogUpdate{
+		Service: service,
+		Nodes:   data,
+	}, nil
+}
+
+func (provider *ConsulCatalog) getBackend(node *api.ServiceEntry) string {
+	return strings.ToLower(node.Service.Service)
+}
+
+func (provider *ConsulCatalog) getFrontendValue(service string) string {
+	return service + "." + provider.Domain
+}
+
+func (provider *ConsulCatalog) buildConfig(catalog []catalogUpdate) *types.Configuration {
+	var FuncMap = template.FuncMap{
+		"getBackend":       provider.getBackend,
+		"getFrontendValue": provider.getFrontendValue,
+		"replace":          replace,
+	}
+
+	allNodes := []*api.ServiceEntry{}
+	serviceNames := []string{}
+	for _, info := range catalog {
+		if len(info.Nodes) > 0 {
+			serviceNames = append(serviceNames, info.Service)
+			allNodes = append(allNodes, info.Nodes...)
+		}
+	}
+
+	templateObjects := struct {
+		Services []string
+		Nodes    []*api.ServiceEntry
+	}{
+		Services: serviceNames,
+		Nodes:    allNodes,
+	}
+
+	configuration, err := provider.getConfiguration("templates/consul_catalog.tmpl", FuncMap, templateObjects)
+	if err != nil {
+		log.WithError(err).Error("Failed to create config")
+	}
+
+	return configuration
+}
+
+func (provider *ConsulCatalog) getNodes(index map[string][]string) ([]catalogUpdate, error) {
+	visited := make(map[string]bool)
+
+	nodes := []catalogUpdate{}
+	for service := range index {
+		name := strings.ToLower(service)
+		if !strings.Contains(name, " ") && !visited[name] {
+			visited[name] = true
+			log.WithFields(log.Fields{
+				"service": name,
+			}).Debug("Fetching service")
+			healthy, err := provider.healthyNodes(name)
+			if err != nil {
+				return nil, err
+			}
+			nodes = append(nodes, healthy)
+		}
+	}
+	return nodes, nil
+}
+
+func (provider *ConsulCatalog) watch(configurationChan chan<- types.ConfigMessage) error {
+	stopCh := make(chan struct{})
+	serviceCatalog := provider.watchServices(stopCh)
+
+	defer close(stopCh)
+
+	for {
+		select {
+		case index, ok := <-serviceCatalog:
+			if !ok {
+				return errors.New("Consul service list nil")
+			}
+			log.Debug("List of services changed")
+			nodes, err := provider.getNodes(index)
+			if err != nil {
+				return err
+			}
+			configuration := provider.buildConfig(nodes)
+			configurationChan <- types.ConfigMessage{
+				ProviderName:  "consul_catalog",
+				Configuration: configuration,
+			}
+		}
+	}
+}
+
+// Provide allows the provider to provide configurations to traefik
+// using the given configuration channel.
+func (provider *ConsulCatalog) Provide(configurationChan chan<- types.ConfigMessage) error {
+	config := api.DefaultConfig()
+	config.Address = provider.Endpoint
+	client, err := api.NewClient(config)
+	if err != nil {
+		return err
+	}
+	provider.client = client
+
+	go func() {
+		notify := func(err error, time time.Duration) {
+			log.Errorf("Consul connection error %+v, retrying in %s", err, time)
+		}
+		worker := func() error {
+			return provider.watch(configurationChan)
+		}
+		err := backoff.RetryNotify(worker, backoff.NewExponentialBackOff(), notify)
+		if err != nil {
+			log.Fatalf("Cannot connect to consul server %+v", err)
+		}
+	}()
+
+	return err
+}

provider/consul_catalog_test.go

@@ -0,0 +1,110 @@
+package provider
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/containous/traefik/types"
+	"github.com/hashicorp/consul/api"
+)
+
+func TestConsulCatalogGetFrontendValue(t *testing.T) {
+	provider := &ConsulCatalog{
+		Domain: "localhost",
+	}
+
+	services := []struct {
+		service  string
+		expected string
+	}{
+		{
+			service:  "foo",
+			expected: "foo.localhost",
+		},
+	}
+
+	for _, e := range services {
+		actual := provider.getFrontendValue(e.service)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestConsulCatalogBuildConfig(t *testing.T) {
+	provider := &ConsulCatalog{
+		Domain: "localhost",
+	}
+
+	cases := []struct {
+		nodes             []catalogUpdate
+		expectedFrontends map[string]*types.Frontend
+		expectedBackends  map[string]*types.Backend
+	}{
+		{
+			nodes:             []catalogUpdate{},
+			expectedFrontends: map[string]*types.Frontend{},
+			expectedBackends:  map[string]*types.Backend{},
+		},
+		{
+			nodes: []catalogUpdate{
+				{
+					Service: "test",
+				},
+			},
+			expectedFrontends: map[string]*types.Frontend{},
+			expectedBackends:  map[string]*types.Backend{},
+		},
+		{
+			nodes: []catalogUpdate{
+				{
+					Service: "test",
+					Nodes: []*api.ServiceEntry{
+						{
+							Service: &api.AgentService{
+								Service: "test",
+								Port:    80,
+							},
+							Node: &api.Node{
+								Node:    "localhost",
+								Address: "127.0.0.1",
+							},
+						},
+					},
+				},
+			},
+			expectedFrontends: map[string]*types.Frontend{
+				"frontend-test": {
+					Backend: "backend-test",
+					Routes: map[string]types.Route{
+						"route-host-test": {
+							Rule:  "Host",
+							Value: "test.localhost",
+						},
+					},
+				},
+			},
+			expectedBackends: map[string]*types.Backend{
+				"backend-test": {
+					Servers: map[string]types.Server{
+						"server-localhost-80": {
+							URL: "http://127.0.0.1:80",
+						},
+					},
+					CircuitBreaker: nil,
+					LoadBalancer:   nil,
+				},
+			},
+		},
+	}
+
+	for _, c := range cases {
+		actualConfig := provider.buildConfig(c.nodes)
+		if !reflect.DeepEqual(actualConfig.Backends, c.expectedBackends) {
+			t.Fatalf("expected %#v, got %#v", c.expectedBackends, actualConfig.Backends)
+		}
+		if !reflect.DeepEqual(actualConfig.Frontends, c.expectedFrontends) {
+			t.Fatalf("expected %#v, got %#v", c.expectedFrontends, actualConfig.Frontends)
+		}
+	}
+}

provider/docker.go

@@ -0,0 +1,280 @@
+package provider
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"text/template"
+	"time"
+
+	"github.com/BurntSushi/ty/fun"
+	log "github.com/Sirupsen/logrus"
+	"github.com/cenkalti/backoff"
+	"github.com/containous/traefik/types"
+	"github.com/fsouza/go-dockerclient"
+)
+
+// Docker holds configurations of the Docker provider.
+type Docker struct {
+	BaseProvider `mapstructure:",squash"`
+	Endpoint     string
+	Domain       string
+	TLS          *DockerTLS
+}
+
+// DockerTLS holds TLS specific configurations
+type DockerTLS struct {
+	CA                 string
+	Cert               string
+	Key                string
+	InsecureSkipVerify bool
+}
+
+// Provide allows the provider to provide configurations to traefik
+// using the given configuration channel.
+func (provider *Docker) Provide(configurationChan chan<- types.ConfigMessage) error {
+
+	var dockerClient *docker.Client
+	var err error
+
+	if provider.TLS != nil {
+		dockerClient, err = docker.NewTLSClient(provider.Endpoint,
+			provider.TLS.Cert, provider.TLS.Key, provider.TLS.CA)
+		if err == nil {
+			dockerClient.TLSConfig.InsecureSkipVerify = provider.TLS.InsecureSkipVerify
+		}
+	} else {
+		dockerClient, err = docker.NewClient(provider.Endpoint)
+	}
+	if err != nil {
+		log.Errorf("Failed to create a client for docker, error: %s", err)
+		return err
+	}
+	err = dockerClient.Ping()
+	if err != nil {
+		log.Errorf("Docker connection error %+v", err)
+		return err
+	}
+	log.Debug("Docker connection established")
+	if provider.Watch {
+		dockerEvents := make(chan *docker.APIEvents)
+		dockerClient.AddEventListener(dockerEvents)
+		log.Debug("Docker listening")
+		go func() {
+			operation := func() error {
+				for {
+					event := <-dockerEvents
+					if event == nil {
+						return errors.New("Docker event nil")
+						//							log.Fatalf("Docker connection error")
+					}
+					if event.Status == "start" || event.Status == "die" {
+						log.Debugf("Docker event receveived %+v", event)
+						configuration := provider.loadDockerConfig(listContainers(dockerClient))
+						if configuration != nil {
+							configurationChan <- types.ConfigMessage{
+								ProviderName:  "docker",
+								Configuration: configuration,
+							}
+						}
+					}
+				}
+			}
+			notify := func(err error, time time.Duration) {
+				log.Errorf("Docker connection error %+v, retrying in %s", err, time)
+			}
+			err := backoff.RetryNotify(operation, backoff.NewExponentialBackOff(), notify)
+			if err != nil {
+				log.Fatalf("Cannot connect to docker server %+v", err)
+			}
+		}()
+	}
+
+	configuration := provider.loadDockerConfig(listContainers(dockerClient))
+	configurationChan <- types.ConfigMessage{
+		ProviderName:  "docker",
+		Configuration: configuration,
+	}
+	return nil
+}
+
+func (provider *Docker) loadDockerConfig(containersInspected []docker.Container) *types.Configuration {
+	var DockerFuncMap = template.FuncMap{
+		"getBackend":        provider.getBackend,
+		"getPort":           provider.getPort,
+		"getWeight":         provider.getWeight,
+		"getDomain":         provider.getDomain,
+		"getProtocol":       provider.getProtocol,
+		"getPassHostHeader": provider.getPassHostHeader,
+		"getEntryPoints":    provider.getEntryPoints,
+		"getFrontendValue":  provider.getFrontendValue,
+		"getFrontendRule":   provider.getFrontendRule,
+		"replace":           replace,
+	}
+
+	// filter containers
+	filteredContainers := fun.Filter(containerFilter, containersInspected).([]docker.Container)
+
+	frontends := map[string][]docker.Container{}
+	for _, container := range filteredContainers {
+		frontends[provider.getFrontendName(container)] = append(frontends[provider.getFrontendName(container)], container)
+	}
+
+	templateObjects := struct {
+		Containers []docker.Container
+		Frontends  map[string][]docker.Container
+		Domain     string
+	}{
+		filteredContainers,
+		frontends,
+		provider.Domain,
+	}
+
+	configuration, err := provider.getConfiguration("templates/docker.tmpl", DockerFuncMap, templateObjects)
+	if err != nil {
+		log.Error(err)
+	}
+	return configuration
+}
+
+func containerFilter(container docker.Container) bool {
+	if len(container.NetworkSettings.Ports) == 0 {
+		log.Debugf("Filtering container without port %s", container.Name)
+		return false
+	}
+	_, err := strconv.Atoi(container.Config.Labels["traefik.port"])
+	if len(container.NetworkSettings.Ports) > 1 && err != nil {
+		log.Debugf("Filtering container with more than 1 port and no traefik.port label %s", container.Name)
+		return false
+	}
+
+	if container.Config.Labels["traefik.enable"] == "false" {
+		log.Debugf("Filtering disabled container %s", container.Name)
+		return false
+	}
+
+	labels, err := getLabels(container, []string{"traefik.frontend.rule", "traefik.frontend.value"})
+	if len(labels) != 0 && err != nil {
+		log.Debugf("Filtering bad labeled container %s", container.Name)
+		return false
+	}
+
+	return true
+}
+
+func (provider *Docker) getFrontendName(container docker.Container) string {
+	// Replace '.' with '-' in quoted keys because of this issue https://github.com/BurntSushi/toml/issues/78
+	frontendName := fmt.Sprintf("%s-%s", provider.getFrontendRule(container), provider.getFrontendValue(container))
+	frontendName = strings.Replace(frontendName, "[", "", -1)
+	frontendName = strings.Replace(frontendName, "]", "", -1)
+
+	return strings.Replace(frontendName, ".", "-", -1)
+}
+
+// GetFrontendValue returns the frontend value for the specified container, using
+// it's label. It returns a default one if the label is not present.
+func (provider *Docker) getFrontendValue(container docker.Container) string {
+	if label, err := getLabel(container, "traefik.frontend.value"); err == nil {
+		return label
+	}
+	return getEscapedName(container.Name) + "." + provider.Domain
+}
+
+// GetFrontendRule returns the frontend rule for the specified container, using
+// it's label. It returns a default one (Host) if the label is not present.
+func (provider *Docker) getFrontendRule(container docker.Container) string {
+	if label, err := getLabel(container, "traefik.frontend.rule"); err == nil {
+		return label
+	}
+	return "Host"
+}
+
+func (provider *Docker) getBackend(container docker.Container) string {
+	if label, err := getLabel(container, "traefik.backend"); err == nil {
+		return label
+	}
+	return getEscapedName(container.Name)
+}
+
+func (provider *Docker) getPort(container docker.Container) string {
+	if label, err := getLabel(container, "traefik.port"); err == nil {
+		return label
+	}
+	for key := range container.NetworkSettings.Ports {
+		return key.Port()
+	}
+	return ""
+}
+
+func (provider *Docker) getWeight(container docker.Container) string {
+	if label, err := getLabel(container, "traefik.weight"); err == nil {
+		return label
+	}
+	return "0"
+}
+
+func (provider *Docker) getDomain(container docker.Container) string {
+	if label, err := getLabel(container, "traefik.domain"); err == nil {
+		return label
+	}
+	return provider.Domain
+}
+
+func (provider *Docker) getProtocol(container docker.Container) string {
+	if label, err := getLabel(container, "traefik.protocol"); err == nil {
+		return label
+	}
+	return "http"
+}
+
+func (provider *Docker) getPassHostHeader(container docker.Container) string {
+	if passHostHeader, err := getLabel(container, "traefik.frontend.passHostHeader"); err == nil {
+		return passHostHeader
+	}
+	return "false"
+}
+
+func (provider *Docker) getEntryPoints(container docker.Container) []string {
+	if entryPoints, err := getLabel(container, "traefik.frontend.entryPoints"); err == nil {
+		return strings.Split(entryPoints, ",")
+	}
+	return []string{}
+}
+
+func getLabel(container docker.Container, label string) (string, error) {
+	for key, value := range container.Config.Labels {
+		if key == label {
+			return value, nil
+		}
+	}
+	return "", errors.New("Label not found:" + label)
+}
+
+func getLabels(container docker.Container, labels []string) (map[string]string, error) {
+	var globalErr error
+	foundLabels := map[string]string{}
+	for _, label := range labels {
+		foundLabel, err := getLabel(container, label)
+		// Error out only if one of them is defined.
+		if err != nil {
+			globalErr = errors.New("Label not found: " + label)
+			continue
+		}
+		foundLabels[label] = foundLabel
+
+	}
+	return foundLabels, globalErr
+}
+
+func listContainers(dockerClient *docker.Client) []docker.Container {
+	containerList, _ := dockerClient.ListContainers(docker.ListContainersOptions{})
+	containersInspected := []docker.Container{}
+
+	// get inspect containers
+	for _, container := range containerList {
+		containerInspected, _ := dockerClient.InspectContainer(container.ID)
+		containersInspected = append(containersInspected, *containerInspected)
+	}
+	return containersInspected
+}

provider/docker_test.go

@@ -0,0 +1,804 @@
+package provider
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/containous/traefik/types"
+	"github.com/fsouza/go-dockerclient"
+)
+
+func TestDockerGetFrontendName(t *testing.T) {
+	provider := &Docker{
+		Domain: "docker.localhost",
+	}
+
+	containers := []struct {
+		container docker.Container
+		expected  string
+	}{
+		{
+			container: docker.Container{
+				Name:   "foo",
+				Config: &docker.Config{},
+			},
+			expected: "Host-foo-docker-localhost",
+		},
+		{
+			container: docker.Container{
+				Name: "bar",
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.frontend.rule": "Header",
+					},
+				},
+			},
+			expected: "Header-bar-docker-localhost",
+		},
+		{
+			container: docker.Container{
+				Name: "test",
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.frontend.value": "foo.bar",
+					},
+				},
+			},
+			expected: "Host-foo-bar",
+		},
+		{
+			container: docker.Container{
+				Name: "test",
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.frontend.value": "foo.bar",
+						"traefik.frontend.rule":  "Header",
+					},
+				},
+			},
+			expected: "Header-foo-bar",
+		},
+		{
+			container: docker.Container{
+				Name: "test",
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.frontend.value": "[foo.bar]",
+						"traefik.frontend.rule":  "Header",
+					},
+				},
+			},
+			expected: "Header-foo-bar",
+		},
+	}
+
+	for _, e := range containers {
+		actual := provider.getFrontendName(e.container)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestDockerGetFrontendValue(t *testing.T) {
+	provider := &Docker{
+		Domain: "docker.localhost",
+	}
+
+	containers := []struct {
+		container docker.Container
+		expected  string
+	}{
+		{
+			container: docker.Container{
+				Name:   "foo",
+				Config: &docker.Config{},
+			},
+			expected: "foo.docker.localhost",
+		},
+		{
+			container: docker.Container{
+				Name:   "bar",
+				Config: &docker.Config{},
+			},
+			expected: "bar.docker.localhost",
+		},
+		{
+			container: docker.Container{
+				Name: "test",
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.frontend.value": "foo.bar",
+					},
+				},
+			},
+			expected: "foo.bar",
+		},
+	}
+
+	for _, e := range containers {
+		actual := provider.getFrontendValue(e.container)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestDockerGetFrontendRule(t *testing.T) {
+	provider := &Docker{}
+
+	containers := []struct {
+		container docker.Container
+		expected  string
+	}{
+		{
+			container: docker.Container{
+				Name:   "foo",
+				Config: &docker.Config{},
+			},
+			expected: "Host",
+		},
+		{
+			container: docker.Container{
+				Name: "test",
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.frontend.rule": "foo",
+					},
+				},
+			},
+			expected: "foo",
+		},
+	}
+
+	for _, e := range containers {
+		actual := provider.getFrontendRule(e.container)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestDockerGetBackend(t *testing.T) {
+	provider := &Docker{}
+
+	containers := []struct {
+		container docker.Container
+		expected  string
+	}{
+		{
+			container: docker.Container{
+				Name:   "foo",
+				Config: &docker.Config{},
+			},
+			expected: "foo",
+		},
+		{
+			container: docker.Container{
+				Name:   "bar",
+				Config: &docker.Config{},
+			},
+			expected: "bar",
+		},
+		{
+			container: docker.Container{
+				Name: "test",
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.backend": "foobar",
+					},
+				},
+			},
+			expected: "foobar",
+		},
+	}
+
+	for _, e := range containers {
+		actual := provider.getBackend(e.container)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestDockerGetPort(t *testing.T) {
+	provider := &Docker{}
+
+	containers := []struct {
+		container docker.Container
+		expected  string
+	}{
+		{
+			container: docker.Container{
+				Name:            "foo",
+				Config:          &docker.Config{},
+				NetworkSettings: &docker.NetworkSettings{},
+			},
+			expected: "",
+		},
+		{
+			container: docker.Container{
+				Name:   "bar",
+				Config: &docker.Config{},
+				NetworkSettings: &docker.NetworkSettings{
+					Ports: map[docker.Port][]docker.PortBinding{
+						"80/tcp": {},
+					},
+				},
+			},
+			expected: "80",
+		},
+		// FIXME handle this better..
+		// {
+		// 	container: docker.Container{
+		// 		Name:   "bar",
+		// 		Config: &docker.Config{},
+		// 		NetworkSettings: &docker.NetworkSettings{
+		// 			Ports: map[docker.Port][]docker.PortBinding{
+		// 				"80/tcp":  []docker.PortBinding{},
+		// 				"443/tcp": []docker.PortBinding{},
+		// 			},
+		// 		},
+		// 	},
+		// 	expected: "80",
+		// },
+		{
+			container: docker.Container{
+				Name: "test",
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.port": "8080",
+					},
+				},
+				NetworkSettings: &docker.NetworkSettings{
+					Ports: map[docker.Port][]docker.PortBinding{
+						"80/tcp": {},
+					},
+				},
+			},
+			expected: "8080",
+		},
+	}
+
+	for _, e := range containers {
+		actual := provider.getPort(e.container)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestDockerGetWeight(t *testing.T) {
+	provider := &Docker{}
+
+	containers := []struct {
+		container docker.Container
+		expected  string
+	}{
+		{
+			container: docker.Container{
+				Name:   "foo",
+				Config: &docker.Config{},
+			},
+			expected: "0",
+		},
+		{
+			container: docker.Container{
+				Name: "test",
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.weight": "10",
+					},
+				},
+			},
+			expected: "10",
+		},
+	}
+
+	for _, e := range containers {
+		actual := provider.getWeight(e.container)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestDockerGetDomain(t *testing.T) {
+	provider := &Docker{
+		Domain: "docker.localhost",
+	}
+
+	containers := []struct {
+		container docker.Container
+		expected  string
+	}{
+		{
+			container: docker.Container{
+				Name:   "foo",
+				Config: &docker.Config{},
+			},
+			expected: "docker.localhost",
+		},
+		{
+			container: docker.Container{
+				Name: "test",
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.domain": "foo.bar",
+					},
+				},
+			},
+			expected: "foo.bar",
+		},
+	}
+
+	for _, e := range containers {
+		actual := provider.getDomain(e.container)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestDockerGetProtocol(t *testing.T) {
+	provider := &Docker{}
+
+	containers := []struct {
+		container docker.Container
+		expected  string
+	}{
+		{
+			container: docker.Container{
+				Name:   "foo",
+				Config: &docker.Config{},
+			},
+			expected: "http",
+		},
+		{
+			container: docker.Container{
+				Name: "test",
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.protocol": "https",
+					},
+				},
+			},
+			expected: "https",
+		},
+	}
+
+	for _, e := range containers {
+		actual := provider.getProtocol(e.container)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestDockerGetPassHostHeader(t *testing.T) {
+	provider := &Docker{}
+
+	containers := []struct {
+		container docker.Container
+		expected  string
+	}{
+		{
+			container: docker.Container{
+				Name:   "foo",
+				Config: &docker.Config{},
+			},
+			expected: "false",
+		},
+		{
+			container: docker.Container{
+				Name: "test",
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.frontend.passHostHeader": "true",
+					},
+				},
+			},
+			expected: "true",
+		},
+	}
+
+	for _, e := range containers {
+		actual := provider.getPassHostHeader(e.container)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestDockerGetLabel(t *testing.T) {
+	containers := []struct {
+		container docker.Container
+		expected  string
+	}{
+		{
+			container: docker.Container{
+				Config: &docker.Config{},
+			},
+			expected: "Label not found:",
+		},
+		{
+			container: docker.Container{
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"foo": "bar",
+					},
+				},
+			},
+			expected: "",
+		},
+	}
+
+	for _, e := range containers {
+		label, err := getLabel(e.container, "foo")
+		if e.expected != "" {
+			if err == nil || !strings.Contains(err.Error(), e.expected) {
+				t.Fatalf("expected an error with %q, got %v", e.expected, err)
+			}
+		} else {
+			if label != "bar" {
+				t.Fatalf("expected label 'bar', got %s", label)
+			}
+		}
+	}
+}
+
+func TestDockerGetLabels(t *testing.T) {
+	containers := []struct {
+		container      docker.Container
+		expectedLabels map[string]string
+		expectedError  string
+	}{
+		{
+			container: docker.Container{
+				Config: &docker.Config{},
+			},
+			expectedLabels: map[string]string{},
+			expectedError:  "Label not found:",
+		},
+		{
+			container: docker.Container{
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"foo": "fooz",
+					},
+				},
+			},
+			expectedLabels: map[string]string{
+				"foo": "fooz",
+			},
+			expectedError: "Label not found: bar",
+		},
+		{
+			container: docker.Container{
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"foo": "fooz",
+						"bar": "barz",
+					},
+				},
+			},
+			expectedLabels: map[string]string{
+				"foo": "fooz",
+				"bar": "barz",
+			},
+			expectedError: "",
+		},
+	}
+
+	for _, e := range containers {
+		labels, err := getLabels(e.container, []string{"foo", "bar"})
+		if !reflect.DeepEqual(labels, e.expectedLabels) {
+			t.Fatalf("expect %v, got %v", e.expectedLabels, labels)
+		}
+		if e.expectedError != "" {
+			if err == nil || !strings.Contains(err.Error(), e.expectedError) {
+				t.Fatalf("expected an error with %q, got %v", e.expectedError, err)
+			}
+		}
+	}
+}
+
+func TestDockerTraefikFilter(t *testing.T) {
+	containers := []struct {
+		container docker.Container
+		expected  bool
+	}{
+		{
+			container: docker.Container{
+				Config:          &docker.Config{},
+				NetworkSettings: &docker.NetworkSettings{},
+			},
+			expected: false,
+		},
+		{
+			container: docker.Container{
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.enable": "false",
+					},
+				},
+				NetworkSettings: &docker.NetworkSettings{
+					Ports: map[docker.Port][]docker.PortBinding{
+						"80/tcp": {},
+					},
+				},
+			},
+			expected: false,
+		},
+		{
+			container: docker.Container{
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.frontend.rule": "Host",
+					},
+				},
+				NetworkSettings: &docker.NetworkSettings{
+					Ports: map[docker.Port][]docker.PortBinding{
+						"80/tcp": {},
+					},
+				},
+			},
+			expected: false,
+		},
+		{
+			container: docker.Container{
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.frontend.value": "foo.bar",
+					},
+				},
+				NetworkSettings: &docker.NetworkSettings{
+					Ports: map[docker.Port][]docker.PortBinding{
+						"80/tcp": {},
+					},
+				},
+			},
+			expected: false,
+		},
+		{
+			container: docker.Container{
+				Config: &docker.Config{},
+				NetworkSettings: &docker.NetworkSettings{
+					Ports: map[docker.Port][]docker.PortBinding{
+						"80/tcp":  {},
+						"443/tcp": {},
+					},
+				},
+			},
+			expected: false,
+		},
+		{
+			container: docker.Container{
+				Config: &docker.Config{},
+				NetworkSettings: &docker.NetworkSettings{
+					Ports: map[docker.Port][]docker.PortBinding{
+						"80/tcp": {},
+					},
+				},
+			},
+			expected: true,
+		},
+		{
+			container: docker.Container{
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.port": "80",
+					},
+				},
+				NetworkSettings: &docker.NetworkSettings{
+					Ports: map[docker.Port][]docker.PortBinding{
+						"80/tcp":  {},
+						"443/tcp": {},
+					},
+				},
+			},
+			expected: true,
+		},
+		{
+			container: docker.Container{
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.enable": "true",
+					},
+				},
+				NetworkSettings: &docker.NetworkSettings{
+					Ports: map[docker.Port][]docker.PortBinding{
+						"80/tcp": {},
+					},
+				},
+			},
+			expected: true,
+		},
+		{
+			container: docker.Container{
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.enable": "anything",
+					},
+				},
+				NetworkSettings: &docker.NetworkSettings{
+					Ports: map[docker.Port][]docker.PortBinding{
+						"80/tcp": {},
+					},
+				},
+			},
+			expected: true,
+		},
+		{
+			container: docker.Container{
+				Config: &docker.Config{
+					Labels: map[string]string{
+						"traefik.frontend.rule":  "Host",
+						"traefik.frontend.value": "foo.bar",
+					},
+				},
+				NetworkSettings: &docker.NetworkSettings{
+					Ports: map[docker.Port][]docker.PortBinding{
+						"80/tcp": {},
+					},
+				},
+			},
+			expected: true,
+		},
+	}
+
+	for _, e := range containers {
+		actual := containerFilter(e.container)
+		if actual != e.expected {
+			t.Fatalf("expected %v, got %v", e.expected, actual)
+		}
+	}
+}
+
+func TestDockerLoadDockerConfig(t *testing.T) {
+	cases := []struct {
+		containers        []docker.Container
+		expectedFrontends map[string]*types.Frontend
+		expectedBackends  map[string]*types.Backend
+	}{
+		{
+			containers:        []docker.Container{},
+			expectedFrontends: map[string]*types.Frontend{},
+			expectedBackends:  map[string]*types.Backend{},
+		},
+		{
+			containers: []docker.Container{
+				{
+					Name:   "test",
+					Config: &docker.Config{},
+					NetworkSettings: &docker.NetworkSettings{
+						Ports: map[docker.Port][]docker.PortBinding{
+							"80/tcp": {},
+						},
+						Networks: map[string]docker.ContainerNetwork{
+							"bridgde": {
+								IPAddress: "127.0.0.1",
+							},
+						},
+					},
+				},
+			},
+			expectedFrontends: map[string]*types.Frontend{
+				`"frontend-Host-test-docker-localhost"`: {
+					Backend:     "backend-test",
+					EntryPoints: []string{},
+					Routes: map[string]types.Route{
+						`"route-frontend-Host-test-docker-localhost"`: {
+							Rule:  "Host",
+							Value: "test.docker.localhost",
+						},
+					},
+				},
+			},
+			expectedBackends: map[string]*types.Backend{
+				"backend-test": {
+					Servers: map[string]types.Server{
+						"server-test": {
+							URL: "http://127.0.0.1:80",
+						},
+					},
+					CircuitBreaker: nil,
+					LoadBalancer:   nil,
+				},
+			},
+		},
+		{
+			containers: []docker.Container{
+				{
+					Name: "test1",
+					Config: &docker.Config{
+						Labels: map[string]string{
+							"traefik.backend":              "foobar",
+							"traefik.frontend.entryPoints": "http,https",
+						},
+					},
+					NetworkSettings: &docker.NetworkSettings{
+						Ports: map[docker.Port][]docker.PortBinding{
+							"80/tcp": {},
+						},
+						Networks: map[string]docker.ContainerNetwork{
+							"bridgde": {
+								IPAddress: "127.0.0.1",
+							},
+						},
+					},
+				},
+				{
+					Name: "test2",
+					Config: &docker.Config{
+						Labels: map[string]string{
+							"traefik.backend": "foobar",
+						},
+					},
+					NetworkSettings: &docker.NetworkSettings{
+						Ports: map[docker.Port][]docker.PortBinding{
+							"80/tcp": {},
+						},
+						Networks: map[string]docker.ContainerNetwork{
+							"bridgde": {
+								IPAddress: "127.0.0.1",
+							},
+						},
+					},
+				},
+			},
+			expectedFrontends: map[string]*types.Frontend{
+				`"frontend-Host-test1-docker-localhost"`: {
+					Backend:     "backend-foobar",
+					EntryPoints: []string{"http", "https"},
+					Routes: map[string]types.Route{
+						`"route-frontend-Host-test1-docker-localhost"`: {
+							Rule:  "Host",
+							Value: "test1.docker.localhost",
+						},
+					},
+				},
+				`"frontend-Host-test2-docker-localhost"`: {
+					Backend:     "backend-foobar",
+					EntryPoints: []string{},
+					Routes: map[string]types.Route{
+						`"route-frontend-Host-test2-docker-localhost"`: {
+							Rule:  "Host",
+							Value: "test2.docker.localhost",
+						},
+					},
+				},
+			},
+			expectedBackends: map[string]*types.Backend{
+				"backend-foobar": {
+					Servers: map[string]types.Server{
+						"server-test1": {
+							URL: "http://127.0.0.1:80",
+						},
+						"server-test2": {
+							URL: "http://127.0.0.1:80",
+						},
+					},
+					CircuitBreaker: nil,
+					LoadBalancer:   nil,
+				},
+			},
+		},
+	}
+
+	provider := &Docker{
+		Domain: "docker.localhost",
+	}
+
+	for _, c := range cases {
+		actualConfig := provider.loadDockerConfig(c.containers)
+		// Compare backends
+		if !reflect.DeepEqual(actualConfig.Backends, c.expectedBackends) {
+			t.Fatalf("expected %#v, got %#v", c.expectedBackends, actualConfig.Backends)
+		}
+		if !reflect.DeepEqual(actualConfig.Frontends, c.expectedFrontends) {
+			t.Fatalf("expected %#v, got %#v", c.expectedFrontends, actualConfig.Frontends)
+		}
+	}
+}

provider/etcd.go

@@ -0,0 +1,20 @@
+package provider
+
+import (
+	"github.com/containous/traefik/types"
+	"github.com/docker/libkv/store"
+	"github.com/docker/libkv/store/etcd"
+)
+
+// Etcd holds configurations of the Etcd provider.
+type Etcd struct {
+	Kv `mapstructure:",squash"`
+}
+
+// Provide allows the provider to provide configurations to traefik
+// using the given configuration channel.
+func (provider *Etcd) Provide(configurationChan chan<- types.ConfigMessage) error {
+	provider.storeType = store.ETCD
+	etcd.Register()
+	return provider.provide(configurationChan)
+}

provider/file.go

@@ -1,4 +1,4 @@
-package main
+package provider
 
 import (
 	"os"
@@ -7,15 +7,18 @@ import (
 
 	"github.com/BurntSushi/toml"
 	log "github.com/Sirupsen/logrus"
+	"github.com/containous/traefik/types"
 	"gopkg.in/fsnotify.v1"
 )
 
-type FileProvider struct {
-	Watch    bool
-	Filename string
+// File holds configurations of the File provider.
+type File struct {
+	BaseProvider `mapstructure:",squash"`
 }
 
-func (provider *FileProvider) Provide(configurationChan chan<- configMessage) error {
+// Provide allows the provider to provide configurations to traefik
+// using the given configuration channel.
+func (provider *File) Provide(configurationChan chan<- types.ConfigMessage) error {
 	watcher, err := fsnotify.NewWatcher()
 	if err != nil {
 		log.Error("Error creating file watcher", err)
@@ -38,9 +41,12 @@ func (provider *FileProvider) Provide(configurationChan chan<- configMessage) er
 				case event := <-watcher.Events:
 					if strings.Contains(event.Name, file.Name()) {
 						log.Debug("File event:", event)
-						configuration := provider.LoadFileConfig(file.Name())
+						configuration := provider.loadFileConfig(file.Name())
 						if configuration != nil {
-							configurationChan <- configMessage{"file", configuration}
+							configurationChan <- types.ConfigMessage{
+								ProviderName:  "file",
+								Configuration: configuration,
+							}
 						}
 					}
 				case error := <-watcher.Errors:
@@ -55,13 +61,16 @@ func (provider *FileProvider) Provide(configurationChan chan<- configMessage) er
 		}
 	}
 
-	configuration := provider.LoadFileConfig(file.Name())
-	configurationChan <- configMessage{"file", configuration}
+	configuration := provider.loadFileConfig(file.Name())
+	configurationChan <- types.ConfigMessage{
+		ProviderName:  "file",
+		Configuration: configuration,
+	}
 	return nil
 }
 
-func (provider *FileProvider) LoadFileConfig(filename string) *Configuration {
-	configuration := new(Configuration)
+func (provider *File) loadFileConfig(filename string) *types.Configuration {
+	configuration := new(types.Configuration)
 	if _, err := toml.DecodeFile(filename, configuration); err != nil {
 		log.Error("Error reading file:", err)
 		return nil

provider/file_test.go

@@ -0,0 +1 @@
+package provider

provider/kv.go

@@ -0,0 +1,179 @@
+// Package provider holds the different provider implementation.
+package provider
+
+import (
+	"crypto/tls"
+	"crypto/x509"
+	"fmt"
+	"io/ioutil"
+	"strings"
+	"text/template"
+	"time"
+
+	"github.com/BurntSushi/ty/fun"
+	log "github.com/Sirupsen/logrus"
+	"github.com/containous/traefik/types"
+	"github.com/docker/libkv"
+	"github.com/docker/libkv/store"
+)
+
+// Kv holds common configurations of key-value providers.
+type Kv struct {
+	BaseProvider `mapstructure:",squash"`
+	Endpoint     string
+	Prefix       string
+	TLS          *KvTLS
+	storeType    store.Backend
+	kvclient     store.Store
+}
+
+// KvTLS holds TLS specific configurations
+type KvTLS struct {
+	CA                 string
+	Cert               string
+	Key                string
+	InsecureSkipVerify bool
+}
+
+func (provider *Kv) watchKv(configurationChan chan<- types.ConfigMessage, prefix string) {
+	for {
+		chanKeys, err := provider.kvclient.WatchTree(provider.Prefix, make(chan struct{}) /* stop chan */)
+		if err != nil {
+			log.Errorf("Failed to WatchTree %s", err)
+			continue
+		}
+
+		for range chanKeys {
+			configuration := provider.loadConfig()
+			if configuration != nil {
+				configurationChan <- types.ConfigMessage{
+					ProviderName:  string(provider.storeType),
+					Configuration: configuration,
+				}
+			}
+		}
+		log.Warnf("Intermittent failure to WatchTree KV. Retrying.")
+	}
+}
+
+func (provider *Kv) provide(configurationChan chan<- types.ConfigMessage) error {
+	storeConfig := &store.Config{
+		ConnectionTimeout: 30 * time.Second,
+		Bucket:            "traefik",
+	}
+
+	if provider.TLS != nil {
+		caPool := x509.NewCertPool()
+
+		if provider.TLS.CA != "" {
+			ca, err := ioutil.ReadFile(provider.TLS.CA)
+
+			if err != nil {
+				return fmt.Errorf("Failed to read CA. %s", err)
+			}
+
+			caPool.AppendCertsFromPEM(ca)
+		}
+
+		cert, err := tls.LoadX509KeyPair(provider.TLS.Cert, provider.TLS.Key)
+
+		if err != nil {
+			return fmt.Errorf("Failed to load keypair. %s", err)
+		}
+
+		storeConfig.TLS = &tls.Config{
+			Certificates:       []tls.Certificate{cert},
+			RootCAs:            caPool,
+			InsecureSkipVerify: provider.TLS.InsecureSkipVerify,
+		}
+	}
+
+	kv, err := libkv.NewStore(
+		provider.storeType,
+		strings.Split(provider.Endpoint, ","),
+		storeConfig,
+	)
+	if err != nil {
+		return err
+	}
+	if _, err := kv.List(""); err != nil {
+		return err
+	}
+	provider.kvclient = kv
+	if provider.Watch {
+		go provider.watchKv(configurationChan, provider.Prefix)
+	}
+	configuration := provider.loadConfig()
+	configurationChan <- types.ConfigMessage{
+		ProviderName:  string(provider.storeType),
+		Configuration: configuration,
+	}
+	return nil
+}
+
+func (provider *Kv) loadConfig() *types.Configuration {
+	templateObjects := struct {
+		Prefix string
+	}{
+		// Allow `/traefik/alias` to superesede `provider.Prefix`
+		strings.TrimSuffix(provider.get(provider.Prefix, provider.Prefix+"/alias"), "/"),
+	}
+	var KvFuncMap = template.FuncMap{
+		"List":     provider.list,
+		"Get":      provider.get,
+		"SplitGet": provider.splitGet,
+		"Last":     provider.last,
+	}
+
+	configuration, err := provider.getConfiguration("templates/kv.tmpl", KvFuncMap, templateObjects)
+	if err != nil {
+		log.Error(err)
+	}
+	return configuration
+}
+
+func (provider *Kv) list(keys ...string) []string {
+	joinedKeys := strings.Join(keys, "")
+	keysPairs, err := provider.kvclient.List(joinedKeys)
+	if err != nil {
+		log.Errorf("Error getting keys %s %s ", joinedKeys, err)
+		return nil
+	}
+	directoryKeys := make(map[string]string)
+	for _, key := range keysPairs {
+		directory := strings.Split(strings.TrimPrefix(key.Key, strings.TrimPrefix(joinedKeys, "/")), "/")[0]
+		directoryKeys[directory] = joinedKeys + directory
+	}
+	return fun.Values(directoryKeys).([]string)
+}
+
+func (provider *Kv) get(defaultValue string, keys ...string) string {
+	joinedKeys := strings.Join(keys, "")
+	keyPair, err := provider.kvclient.Get(joinedKeys)
+	if err != nil {
+		log.Warnf("Error getting key %s %s, setting default %s", joinedKeys, err, defaultValue)
+		return defaultValue
+	} else if keyPair == nil {
+		log.Warnf("Error getting key %s, setting default %s", joinedKeys, defaultValue)
+		return defaultValue
+	}
+	return string(keyPair.Value)
+}
+
+func (provider *Kv) splitGet(keys ...string) []string {
+	joinedKeys := strings.Join(keys, "")
+	keyPair, err := provider.kvclient.Get(joinedKeys)
+	if err != nil {
+		log.Warnf("Error getting key %s %s, setting default empty", joinedKeys, err)
+		return []string{}
+	} else if keyPair == nil {
+		log.Warnf("Error getting key %s, setting default %empty", joinedKeys)
+		return []string{}
+	}
+	return strings.Split(string(keyPair.Value), ",")
+}
+
+func (provider *Kv) last(key string) string {
+	splittedKey := strings.Split(key, "/")
+	return splittedKey[len(splittedKey)-1]
+}

provider/kv_test.go

@@ -0,0 +1,364 @@
+package provider
+
+import (
+	"errors"
+	"github.com/containous/traefik/types"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/docker/libkv/store"
+	"reflect"
+	"sort"
+)
+
+func TestKvList(t *testing.T) {
+	cases := []struct {
+		provider *Kv
+		keys     []string
+		expected []string
+	}{
+		{
+			provider: &Kv{
+				kvclient: &Mock{},
+			},
+			keys:     []string{},
+			expected: []string{},
+		},
+		{
+			provider: &Kv{
+				kvclient: &Mock{},
+			},
+			keys:     []string{"traefik"},
+			expected: []string{},
+		},
+		{
+			provider: &Kv{
+				kvclient: &Mock{
+					KVPairs: []*store.KVPair{
+						{
+							Key:   "foo",
+							Value: []byte("bar"),
+						},
+					},
+				},
+			},
+			keys:     []string{"bar"},
+			expected: []string{},
+		},
+		{
+			provider: &Kv{
+				kvclient: &Mock{
+					KVPairs: []*store.KVPair{
+						{
+							Key:   "foo",
+							Value: []byte("bar"),
+						},
+					},
+				},
+			},
+			keys:     []string{"foo"},
+			expected: []string{"foo"},
+		},
+		{
+			provider: &Kv{
+				kvclient: &Mock{
+					KVPairs: []*store.KVPair{
+						{
+							Key:   "foo/baz/1",
+							Value: []byte("bar"),
+						},
+						{
+							Key:   "foo/baz/2",
+							Value: []byte("bar"),
+						},
+						{
+							Key:   "foo/baz/biz/1",
+							Value: []byte("bar"),
+						},
+					},
+				},
+			},
+			keys:     []string{"foo", "/baz/"},
+			expected: []string{"foo/baz/biz", "foo/baz/1", "foo/baz/2"},
+		},
+	}
+
+	for _, c := range cases {
+		actual := c.provider.list(c.keys...)
+		sort.Strings(actual)
+		sort.Strings(c.expected)
+		if !reflect.DeepEqual(actual, c.expected) {
+			t.Fatalf("expected %v, got %v for %v and %v", c.expected, actual, c.keys, c.provider)
+		}
+	}
+
+	// Error case
+	provider := &Kv{
+		kvclient: &Mock{
+			Error: true,
+		},
+	}
+	actual := provider.list("anything")
+	if actual != nil {
+		t.Fatalf("Should have return nil, got %v", actual)
+	}
+}
+
+func TestKvGet(t *testing.T) {
+	cases := []struct {
+		provider *Kv
+		keys     []string
+		expected string
+	}{
+		{
+			provider: &Kv{
+				kvclient: &Mock{},
+			},
+			keys:     []string{},
+			expected: "",
+		},
+		{
+			provider: &Kv{
+				kvclient: &Mock{},
+			},
+			keys:     []string{"traefik"},
+			expected: "",
+		},
+		{
+			provider: &Kv{
+				kvclient: &Mock{
+					KVPairs: []*store.KVPair{
+						{
+							Key:   "foo",
+							Value: []byte("bar"),
+						},
+					},
+				},
+			},
+			keys:     []string{"bar"},
+			expected: "",
+		},
+		{
+			provider: &Kv{
+				kvclient: &Mock{
+					KVPairs: []*store.KVPair{
+						{
+							Key:   "foo",
+							Value: []byte("bar"),
+						},
+					},
+				},
+			},
+			keys:     []string{"foo"},
+			expected: "bar",
+		},
+		{
+			provider: &Kv{
+				kvclient: &Mock{
+					KVPairs: []*store.KVPair{
+						{
+							Key:   "foo/baz/1",
+							Value: []byte("bar1"),
+						},
+						{
+							Key:   "foo/baz/2",
+							Value: []byte("bar2"),
+						},
+						{
+							Key:   "foo/baz/biz/1",
+							Value: []byte("bar3"),
+						},
+					},
+				},
+			},
+			keys:     []string{"foo", "/baz/", "2"},
+			expected: "bar2",
+		},
+	}
+
+	for _, c := range cases {
+		actual := c.provider.get("", c.keys...)
+		if actual != c.expected {
+			t.Fatalf("expected %v, got %v for %v and %v", c.expected, actual, c.keys, c.provider)
+		}
+	}
+
+	// Error case
+	provider := &Kv{
+		kvclient: &Mock{
+			Error: true,
+		},
+	}
+	actual := provider.get("", "anything")
+	if actual != "" {
+		t.Fatalf("Should have return nil, got %v", actual)
+	}
+}
+
+func TestKvLast(t *testing.T) {
+	cases := []struct {
+		key      string
+		expected string
+	}{
+		{
+			key:      "",
+			expected: "",
+		},
+		{
+			key:      "foo",
+			expected: "foo",
+		},
+		{
+			key:      "foo/bar",
+			expected: "bar",
+		},
+		{
+			key:      "foo/bar/baz",
+			expected: "baz",
+		},
+		// FIXME is this wanted ?
+		{
+			key:      "foo/bar/",
+			expected: "",
+		},
+	}
+
+	provider := &Kv{}
+	for _, c := range cases {
+		actual := provider.last(c.key)
+		if actual != c.expected {
+			t.Fatalf("expected %s, got %s", c.expected, actual)
+		}
+	}
+}
+
+type KvMock struct {
+	Kv
+}
+
+func (provider *KvMock) loadConfig() *types.Configuration {
+	return nil
+}
+
+func TestKvWatchTree(t *testing.T) {
+	returnedChans := make(chan chan []*store.KVPair)
+	provider := &KvMock{
+		Kv{
+			kvclient: &Mock{
+				WatchTreeMethod: func() <-chan []*store.KVPair {
+					c := make(chan []*store.KVPair, 10)
+					returnedChans <- c
+					return c
+				},
+			},
+		},
+	}
+
+	configChan := make(chan types.ConfigMessage)
+	go provider.watchKv(configChan, "prefix")
+
+	select {
+	case c1 := <-returnedChans:
+		c1 <- []*store.KVPair{}
+		<-configChan
+		close(c1) // WatchTree chans can close due to error
+	case <-time.After(1 * time.Second):
+		t.Fatalf("Failed to create a new WatchTree chan")
+	}
+
+	select {
+	case c2 := <-returnedChans:
+		c2 <- []*store.KVPair{}
+		<-configChan
+	case <-time.After(1 * time.Second):
+		t.Fatalf("Failed to create a new WatchTree chan")
+	}
+
+	select {
+	case _ = <-configChan:
+		t.Fatalf("configChan should be empty")
+	default:
+	}
+}
+
+// Extremely limited mock store so we can test initialization
+type Mock struct {
+	Error           bool
+	KVPairs         []*store.KVPair
+	WatchTreeMethod func() <-chan []*store.KVPair
+}
+
+func (s *Mock) Put(key string, value []byte, opts *store.WriteOptions) error {
+	return errors.New("Put not supported")
+}
+
+func (s *Mock) Get(key string) (*store.KVPair, error) {
+	if s.Error {
+		return nil, errors.New("Error")
+	}
+	for _, kvPair := range s.KVPairs {
+		if kvPair.Key == key {
+			return kvPair, nil
+		}
+	}
+	return nil, nil
+}
+
+func (s *Mock) Delete(key string) error {
+	return errors.New("Delete not supported")
+}
+
+// Exists mock
+func (s *Mock) Exists(key string) (bool, error) {
+	return false, errors.New("Exists not supported")
+}
+
+// Watch mock
+func (s *Mock) Watch(key string, stopCh <-chan struct{}) (<-chan *store.KVPair, error) {
+	return nil, errors.New("Watch not supported")
+}
+
+// WatchTree mock
+func (s *Mock) WatchTree(prefix string, stopCh <-chan struct{}) (<-chan []*store.KVPair, error) {
+	return s.WatchTreeMethod(), nil
+}
+
+// NewLock mock
+func (s *Mock) NewLock(key string, options *store.LockOptions) (store.Locker, error) {
+	return nil, errors.New("NewLock not supported")
+}
+
+// List mock
+func (s *Mock) List(prefix string) ([]*store.KVPair, error) {
+	if s.Error {
+		return nil, errors.New("Error")
+	}
+	kv := []*store.KVPair{}
+	for _, kvPair := range s.KVPairs {
+		if strings.HasPrefix(kvPair.Key, prefix) {
+			kv = append(kv, kvPair)
+		}
+	}
+	return kv, nil
+}
+
+// DeleteTree mock
+func (s *Mock) DeleteTree(prefix string) error {
+	return errors.New("DeleteTree not supported")
+}
+
+// AtomicPut mock
+func (s *Mock) AtomicPut(key string, value []byte, previous *store.KVPair, opts *store.WriteOptions) (bool, *store.KVPair, error) {
+	return false, nil, errors.New("AtomicPut not supported")
+}
+
+// AtomicDelete mock
+func (s *Mock) AtomicDelete(key string, previous *store.KVPair) (bool, error) {
+	return false, errors.New("AtomicDelete not supported")
+}
+
+// Close mock
+func (s *Mock) Close() {
+	return
+}

provider/marathon.go

@@ -0,0 +1,338 @@
+package provider
+
+import (
+	"errors"
+	"net/url"
+	"strconv"
+	"strings"
+	"text/template"
+
+	"crypto/tls"
+	"github.com/BurntSushi/ty/fun"
+	log "github.com/Sirupsen/logrus"
+	"github.com/containous/traefik/types"
+	"github.com/gambol99/go-marathon"
+	"net/http"
+)
+
+// Marathon holds configuration of the Marathon provider.
+type Marathon struct {
+	BaseProvider   `mapstructure:",squash"`
+	Endpoint       string
+	Domain         string
+	Basic          *MarathonBasic
+	TLS            *tls.Config
+	marathonClient marathon.Marathon
+}
+
+// MarathonBasic holds basic authentication specific configurations
+type MarathonBasic struct {
+	HTTPBasicAuthUser string
+	HTTPBasicPassword string
+}
+
+type lightMarathonClient interface {
+	Applications(url.Values) (*marathon.Applications, error)
+	AllTasks(v url.Values) (*marathon.Tasks, error)
+}
+
+// Provide allows the provider to provide configurations to traefik
+// using the given configuration channel.
+func (provider *Marathon) Provide(configurationChan chan<- types.ConfigMessage) error {
+	config := marathon.NewDefaultConfig()
+	config.URL = provider.Endpoint
+	config.EventsTransport = marathon.EventsTransportSSE
+	if provider.Basic != nil {
+		config.HTTPBasicAuthUser = provider.Basic.HTTPBasicAuthUser
+		config.HTTPBasicPassword = provider.Basic.HTTPBasicPassword
+	}
+	config.HTTPClient = &http.Client{
+		Transport: &http.Transport{
+			TLSClientConfig: provider.TLS,
+		},
+	}
+	client, err := marathon.NewClient(config)
+	if err != nil {
+		log.Errorf("Failed to create a client for marathon, error: %s", err)
+		return err
+	}
+	provider.marathonClient = client
+	update := make(marathon.EventsChannel, 5)
+	if provider.Watch {
+		if err := client.AddEventsListener(update, marathon.EVENTS_APPLICATIONS); err != nil {
+			log.Errorf("Failed to register for events, %s", err)
+		} else {
+			go func() {
+				for {
+					event := <-update
+					log.Debug("Marathon event receveived", event)
+					configuration := provider.loadMarathonConfig()
+					if configuration != nil {
+						configurationChan <- types.ConfigMessage{
+							ProviderName:  "marathon",
+							Configuration: configuration,
+						}
+					}
+				}
+			}()
+		}
+	}
+
+	configuration := provider.loadMarathonConfig()
+	configurationChan <- types.ConfigMessage{
+		ProviderName:  "marathon",
+		Configuration: configuration,
+	}
+	return nil
+}
+
+func (provider *Marathon) loadMarathonConfig() *types.Configuration {
+	var MarathonFuncMap = template.FuncMap{
+		"getBackend":         provider.getBackend,
+		"getPort":            provider.getPort,
+		"getWeight":          provider.getWeight,
+		"getDomain":          provider.getDomain,
+		"getProtocol":        provider.getProtocol,
+		"getPassHostHeader":  provider.getPassHostHeader,
+		"getEntryPoints":     provider.getEntryPoints,
+		"getFrontendValue":   provider.getFrontendValue,
+		"getFrontendRule":    provider.getFrontendRule,
+		"getFrontendBackend": provider.getFrontendBackend,
+		"replace":            replace,
+	}
+
+	applications, err := provider.marathonClient.Applications(nil)
+	if err != nil {
+		log.Errorf("Failed to create a client for marathon, error: %s", err)
+		return nil
+	}
+
+	tasks, err := provider.marathonClient.AllTasks(&marathon.AllTasksOpts{Status: "running"})
+	if err != nil {
+		log.Errorf("Failed to create a client for marathon, error: %s", err)
+		return nil
+	}
+
+	//filter tasks
+	filteredTasks := fun.Filter(func(task marathon.Task) bool {
+		return taskFilter(task, applications)
+	}, tasks.Tasks).([]marathon.Task)
+
+	//filter apps
+	filteredApps := fun.Filter(func(app marathon.Application) bool {
+		return applicationFilter(app, filteredTasks)
+	}, applications.Apps).([]marathon.Application)
+
+	templateObjects := struct {
+		Applications []marathon.Application
+		Tasks        []marathon.Task
+		Domain       string
+	}{
+		filteredApps,
+		filteredTasks,
+		provider.Domain,
+	}
+
+	configuration, err := provider.getConfiguration("templates/marathon.tmpl", MarathonFuncMap, templateObjects)
+	if err != nil {
+		log.Error(err)
+	}
+	return configuration
+}
+
+func taskFilter(task marathon.Task, applications *marathon.Applications) bool {
+	if len(task.Ports) == 0 {
+		log.Debug("Filtering marathon task without port %s", task.AppID)
+		return false
+	}
+	application, err := getApplication(task, applications.Apps)
+	if err != nil {
+		log.Errorf("Unable to get marathon application from task %s", task.AppID)
+		return false
+	}
+	if application.Labels["traefik.enable"] == "false" {
+		log.Debugf("Filtering disabled marathon task %s", task.AppID)
+		return false
+	}
+
+	//filter indeterminable task port
+	portIndexLabel := application.Labels["traefik.portIndex"]
+	portValueLabel := application.Labels["traefik.port"]
+	if portIndexLabel != "" && portValueLabel != "" {
+		log.Debugf("Filtering marathon task %s specifying both traefik.portIndex and traefik.port labels", task.AppID)
+		return false
+	}
+	if portIndexLabel == "" && portValueLabel == "" && len(application.Ports) > 1 {
+		log.Debugf("Filtering marathon task %s with more than 1 port and no traefik.portIndex or traefik.port label", task.AppID)
+		return false
+	}
+	if portIndexLabel != "" {
+		index, err := strconv.Atoi(application.Labels["traefik.portIndex"])
+		if err != nil || index < 0 || index > len(application.Ports)-1 {
+			log.Debugf("Filtering marathon task %s with unexpected value for traefik.portIndex label", task.AppID)
+			return false
+		}
+	}
+	if portValueLabel != "" {
+		port, err := strconv.Atoi(application.Labels["traefik.port"])
+		if err != nil {
+			log.Debugf("Filtering marathon task %s with unexpected value for traefik.port label", task.AppID)
+			return false
+		}
+
+		var foundPort bool
+		for _, exposedPort := range task.Ports {
+			if port == exposedPort {
+				foundPort = true
+				break
+			}
+		}
+
+		if !foundPort {
+			log.Debugf("Filtering marathon task %s without a matching port for traefik.port label", task.AppID)
+			return false
+		}
+	}
+
+	//filter healthchecks
+	if application.HasHealthChecks() {
+		if task.HasHealthCheckResults() {
+			for _, healthcheck := range task.HealthCheckResults {
+				// found one bad healthcheck, return false
+				if !healthcheck.Alive {
+					log.Debugf("Filtering marathon task %s with bad healthcheck", task.AppID)
+					return false
+				}
+			}
+		} else {
+			log.Debugf("Filtering marathon task %s with bad healthcheck", task.AppID)
+			return false
+		}
+	}
+	return true
+}
+
+func applicationFilter(app marathon.Application, filteredTasks []marathon.Task) bool {
+	return fun.Exists(func(task marathon.Task) bool {
+		return task.AppID == app.ID
+	}, filteredTasks)
+}
+
+func getApplication(task marathon.Task, apps []marathon.Application) (marathon.Application, error) {
+	for _, application := range apps {
+		if application.ID == task.AppID {
+			return application, nil
+		}
+	}
+	return marathon.Application{}, errors.New("Application not found: " + task.AppID)
+}
+
+func (provider *Marathon) getLabel(application marathon.Application, label string) (string, error) {
+	for key, value := range application.Labels {
+		if key == label {
+			return value, nil
+		}
+	}
+	return "", errors.New("Label not found:" + label)
+}
+
+func (provider *Marathon) getPort(task marathon.Task, applications []marathon.Application) string {
+	application, err := getApplication(task, applications)
+	if err != nil {
+		log.Errorf("Unable to get marathon application from task %s", task.AppID)
+		return ""
+	}
+
+	if portIndexLabel, err := provider.getLabel(application, "traefik.portIndex"); err == nil {
+		if index, err := strconv.Atoi(portIndexLabel); err == nil {
+			return strconv.Itoa(task.Ports[index])
+		}
+	}
+	if portValueLabel, err := provider.getLabel(application, "traefik.port"); err == nil {
+		return portValueLabel
+	}
+
+	for _, port := range task.Ports {
+		return strconv.Itoa(port)
+	}
+	return ""
+}
+
+func (provider *Marathon) getWeight(task marathon.Task, applications []marathon.Application) string {
+	application, errApp := getApplication(task, applications)
+	if errApp != nil {
+		log.Errorf("Unable to get marathon application from task %s", task.AppID)
+		return "0"
+	}
+	if label, err := provider.getLabel(application, "traefik.weight"); err == nil {
+		return label
+	}
+	return "0"
+}
+
+func (provider *Marathon) getDomain(application marathon.Application) string {
+	if label, err := provider.getLabel(application, "traefik.domain"); err == nil {
+		return label
+	}
+	return provider.Domain
+}
+
+func (provider *Marathon) getProtocol(task marathon.Task, applications []marathon.Application) string {
+	application, errApp := getApplication(task, applications)
+	if errApp != nil {
+		log.Errorf("Unable to get marathon application from task %s", task.AppID)
+		return "http"
+	}
+	if label, err := provider.getLabel(application, "traefik.protocol"); err == nil {
+		return label
+	}
+	return "http"
+}
+
+func (provider *Marathon) getPassHostHeader(application marathon.Application) string {
+	if passHostHeader, err := provider.getLabel(application, "traefik.frontend.passHostHeader"); err == nil {
+		return passHostHeader
+	}
+	return "false"
+}
+
+func (provider *Marathon) getEntryPoints(application marathon.Application) []string {
+	if entryPoints, err := provider.getLabel(application, "traefik.frontend.entryPoints"); err == nil {
+		return strings.Split(entryPoints, ",")
+	}
+	return []string{}
+}
+
+// getFrontendValue returns the frontend value for the specified application, using
+// it's label. It returns a default one if the label is not present.
+func (provider *Marathon) getFrontendValue(application marathon.Application) string {
+	if label, err := provider.getLabel(application, "traefik.frontend.value"); err == nil {
+		return label
+	}
+	return getEscapedName(application.ID) + "." + provider.Domain
+}
+
+// getFrontendRule returns the frontend rule for the specified application, using
+// it's label. It returns a default one (Host) if the label is not present.
+func (provider *Marathon) getFrontendRule(application marathon.Application) string {
+	if label, err := provider.getLabel(application, "traefik.frontend.rule"); err == nil {
+		return label
+	}
+	return "Host"
+}
+
+func (provider *Marathon) getBackend(task marathon.Task, applications []marathon.Application) string {
+	application, errApp := getApplication(task, applications)
+	if errApp != nil {
+		log.Errorf("Unable to get marathon application from task %s", task.AppID)
+		return ""
+	}
+	return provider.getFrontendBackend(application)
+}
+
+func (provider *Marathon) getFrontendBackend(application marathon.Application) string {
+	if label, err := provider.getLabel(application, "traefik.backend"); err == nil {
+		return label
+	}
+	return replace("/", "-", application.ID)
+}

provider/marathon_test.go

@@ -0,0 +1,853 @@
+package provider
+
+import (
+	"reflect"
+	"testing"
+
+	"errors"
+	"github.com/containous/traefik/mocks"
+	"github.com/containous/traefik/types"
+	"github.com/gambol99/go-marathon"
+	"github.com/stretchr/testify/mock"
+)
+
+type fakeClient struct {
+	mocks.Marathon
+}
+
+func newFakeClient(applicationsError bool, applications *marathon.Applications, tasksError bool, tasks *marathon.Tasks) *fakeClient {
+	// create an instance of our test object
+	fakeClient := new(fakeClient)
+	if applicationsError {
+		fakeClient.On("Applications", mock.AnythingOfType("url.Values")).Return(nil, errors.New("error"))
+	}
+	fakeClient.On("Applications", mock.AnythingOfType("url.Values")).Return(applications, nil)
+	if tasksError {
+		fakeClient.On("AllTasks", mock.AnythingOfType("*marathon.AllTasksOpts")).Return(nil, errors.New("error"))
+	}
+	fakeClient.On("AllTasks", mock.AnythingOfType("*marathon.AllTasksOpts")).Return(tasks, nil)
+	return fakeClient
+}
+
+func TestMarathonLoadConfig(t *testing.T) {
+	cases := []struct {
+		applicationsError bool
+		applications      *marathon.Applications
+		tasksError        bool
+		tasks             *marathon.Tasks
+		expectedNil       bool
+		expectedFrontends map[string]*types.Frontend
+		expectedBackends  map[string]*types.Backend
+	}{
+		{
+			applications:      &marathon.Applications{},
+			tasks:             &marathon.Tasks{},
+			expectedFrontends: map[string]*types.Frontend{},
+			expectedBackends:  map[string]*types.Backend{},
+		},
+		{
+			applicationsError: true,
+			applications:      &marathon.Applications{},
+			tasks:             &marathon.Tasks{},
+			expectedNil:       true,
+			expectedFrontends: map[string]*types.Frontend{},
+			expectedBackends:  map[string]*types.Backend{},
+		},
+		{
+			applications:      &marathon.Applications{},
+			tasksError:        true,
+			tasks:             &marathon.Tasks{},
+			expectedNil:       true,
+			expectedFrontends: map[string]*types.Frontend{},
+			expectedBackends:  map[string]*types.Backend{},
+		},
+		{
+			applications: &marathon.Applications{
+				Apps: []marathon.Application{
+					{
+						ID:    "/test",
+						Ports: []int{80},
+					},
+				},
+			},
+			tasks: &marathon.Tasks{
+				Tasks: []marathon.Task{
+					{
+						ID:    "test",
+						AppID: "/test",
+						Host:  "127.0.0.1",
+						Ports: []int{80},
+					},
+				},
+			},
+			expectedFrontends: map[string]*types.Frontend{
+				`frontend-test`: {
+					Backend:     "backend-test",
+					EntryPoints: []string{},
+					Routes: map[string]types.Route{
+						`route-host-test`: {
+							Rule:  "Host",
+							Value: "test.docker.localhost",
+						},
+					},
+				},
+			},
+			expectedBackends: map[string]*types.Backend{
+				"backend-test": {
+					Servers: map[string]types.Server{
+						"server-test": {
+							URL:    "http://127.0.0.1:80",
+							Weight: 0,
+						},
+					},
+					CircuitBreaker: nil,
+					LoadBalancer:   nil,
+				},
+			},
+		},
+	}
+
+	for _, c := range cases {
+		fakeClient := newFakeClient(c.applicationsError, c.applications, c.tasksError, c.tasks)
+		provider := &Marathon{
+			Domain:         "docker.localhost",
+			marathonClient: fakeClient,
+		}
+		actualConfig := provider.loadMarathonConfig()
+		if c.expectedNil {
+			if actualConfig != nil {
+				t.Fatalf("Should have been nil, got %v", actualConfig)
+			}
+		} else {
+			// Compare backends
+			if !reflect.DeepEqual(actualConfig.Backends, c.expectedBackends) {
+				t.Fatalf("expected %#v, got %#v", c.expectedBackends, actualConfig.Backends)
+			}
+			if !reflect.DeepEqual(actualConfig.Frontends, c.expectedFrontends) {
+				t.Fatalf("expected %#v, got %#v", c.expectedFrontends, actualConfig.Frontends)
+			}
+		}
+	}
+}
+
+func TestMarathonTaskFilter(t *testing.T) {
+	cases := []struct {
+		task         marathon.Task
+		applications *marathon.Applications
+		expected     bool
+	}{
+		{
+			task:         marathon.Task{},
+			applications: &marathon.Applications{},
+			expected:     false,
+		},
+		{
+			task: marathon.Task{
+				AppID: "test",
+				Ports: []int{80},
+			},
+			applications: &marathon.Applications{},
+			expected:     false,
+		},
+		{
+			task: marathon.Task{
+				AppID: "test",
+				Ports: []int{80},
+			},
+			applications: &marathon.Applications{
+				Apps: []marathon.Application{
+					{
+						ID: "foo",
+					},
+				},
+			},
+			expected: false,
+		},
+		{
+			task: marathon.Task{
+				AppID: "foo",
+				Ports: []int{80},
+			},
+			applications: &marathon.Applications{
+				Apps: []marathon.Application{
+					{
+						ID:    "foo",
+						Ports: []int{80, 443},
+					},
+				},
+			},
+			expected: false,
+		},
+		{
+			task: marathon.Task{
+				AppID: "foo",
+				Ports: []int{80},
+			},
+			applications: &marathon.Applications{
+				Apps: []marathon.Application{
+					{
+						ID:    "foo",
+						Ports: []int{80},
+						Labels: map[string]string{
+							"traefik.enable": "false",
+						},
+					},
+				},
+			},
+			expected: false,
+		},
+		{
+			task: marathon.Task{
+				AppID: "specify-port-number",
+				Ports: []int{80, 443},
+			},
+			applications: &marathon.Applications{
+				Apps: []marathon.Application{
+					{
+						ID:    "specify-port-number",
+						Ports: []int{80, 443},
+						Labels: map[string]string{
+							"traefik.port": "80",
+						},
+					},
+				},
+			},
+			expected: true,
+		},
+		{
+			task: marathon.Task{
+				AppID: "specify-unknown-port-number",
+				Ports: []int{80, 443},
+			},
+			applications: &marathon.Applications{
+				Apps: []marathon.Application{
+					{
+						ID:    "specify-unknown-port-number",
+						Ports: []int{80, 443},
+						Labels: map[string]string{
+							"traefik.port": "8080",
+						},
+					},
+				},
+			},
+			expected: false,
+		},
+		{
+			task: marathon.Task{
+				AppID: "specify-port-index",
+				Ports: []int{80, 443},
+			},
+			applications: &marathon.Applications{
+				Apps: []marathon.Application{
+					{
+						ID:    "specify-port-index",
+						Ports: []int{80, 443},
+						Labels: map[string]string{
+							"traefik.portIndex": "0",
+						},
+					},
+				},
+			},
+			expected: true,
+		},
+		{
+			task: marathon.Task{
+				AppID: "specify-out-of-range-port-index",
+				Ports: []int{80, 443},
+			},
+			applications: &marathon.Applications{
+				Apps: []marathon.Application{
+					{
+						ID:    "specify-out-of-range-port-index",
+						Ports: []int{80, 443},
+						Labels: map[string]string{
+							"traefik.portIndex": "2",
+						},
+					},
+				},
+			},
+			expected: false,
+		},
+		{
+			task: marathon.Task{
+				AppID: "specify-both-port-index-and-number",
+				Ports: []int{80, 443},
+			},
+			applications: &marathon.Applications{
+				Apps: []marathon.Application{
+					{
+						ID:    "specify-both-port-index-and-number",
+						Ports: []int{80, 443},
+						Labels: map[string]string{
+							"traefik.port":      "443",
+							"traefik.portIndex": "1",
+						},
+					},
+				},
+			},
+			expected: false,
+		},
+		{
+			task: marathon.Task{
+				AppID: "foo",
+				Ports: []int{80},
+			},
+			applications: &marathon.Applications{
+				Apps: []marathon.Application{
+					{
+						ID:    "foo",
+						Ports: []int{80},
+						HealthChecks: []*marathon.HealthCheck{
+							marathon.NewDefaultHealthCheck(),
+						},
+					},
+				},
+			},
+			expected: false,
+		},
+		{
+			task: marathon.Task{
+				AppID: "foo",
+				Ports: []int{80},
+				HealthCheckResults: []*marathon.HealthCheckResult{
+					{
+						Alive: false,
+					},
+				},
+			},
+			applications: &marathon.Applications{
+				Apps: []marathon.Application{
+					{
+						ID:    "foo",
+						Ports: []int{80},
+						HealthChecks: []*marathon.HealthCheck{
+							marathon.NewDefaultHealthCheck(),
+						},
+					},
+				},
+			},
+			expected: false,
+		},
+		{
+			task: marathon.Task{
+				AppID: "foo",
+				Ports: []int{80},
+				HealthCheckResults: []*marathon.HealthCheckResult{
+					{
+						Alive: true,
+					},
+					{
+						Alive: false,
+					},
+				},
+			},
+			applications: &marathon.Applications{
+				Apps: []marathon.Application{
+					{
+						ID:    "foo",
+						Ports: []int{80},
+						HealthChecks: []*marathon.HealthCheck{
+							marathon.NewDefaultHealthCheck(),
+						},
+					},
+				},
+			},
+			expected: false,
+		},
+		{
+			task: marathon.Task{
+				AppID: "foo",
+				Ports: []int{80},
+			},
+			applications: &marathon.Applications{
+				Apps: []marathon.Application{
+					{
+						ID:    "foo",
+						Ports: []int{80},
+					},
+				},
+			},
+			expected: true,
+		},
+		{
+			task: marathon.Task{
+				AppID: "foo",
+				Ports: []int{80},
+				HealthCheckResults: []*marathon.HealthCheckResult{
+					{
+						Alive: true,
+					},
+				},
+			},
+			applications: &marathon.Applications{
+				Apps: []marathon.Application{
+					{
+						ID:    "foo",
+						Ports: []int{80},
+						HealthChecks: []*marathon.HealthCheck{
+							marathon.NewDefaultHealthCheck(),
+						},
+					},
+				},
+			},
+			expected: true,
+		},
+	}
+
+	for _, c := range cases {
+		actual := taskFilter(c.task, c.applications)
+		if actual != c.expected {
+			t.Fatalf("expected %v, got %v", c.expected, actual)
+		}
+	}
+}
+
+func TestMarathonApplicationFilter(t *testing.T) {
+	cases := []struct {
+		application   marathon.Application
+		filteredTasks []marathon.Task
+		expected      bool
+	}{
+		{
+			application:   marathon.Application{},
+			filteredTasks: []marathon.Task{},
+			expected:      false,
+		},
+		{
+			application: marathon.Application{
+				ID: "test",
+			},
+			filteredTasks: []marathon.Task{},
+			expected:      false,
+		},
+		{
+			application: marathon.Application{
+				ID: "foo",
+			},
+			filteredTasks: []marathon.Task{
+				{
+					AppID: "bar",
+				},
+			},
+			expected: false,
+		},
+		{
+			application: marathon.Application{
+				ID: "foo",
+			},
+			filteredTasks: []marathon.Task{
+				{
+					AppID: "foo",
+				},
+			},
+			expected: true,
+		},
+	}
+
+	for _, c := range cases {
+		actual := applicationFilter(c.application, c.filteredTasks)
+		if actual != c.expected {
+			t.Fatalf("expected %v, got %v", c.expected, actual)
+		}
+	}
+}
+
+func TestMarathonGetPort(t *testing.T) {
+	provider := &Marathon{}
+
+	cases := []struct {
+		applications []marathon.Application
+		task         marathon.Task
+		expected     string
+	}{
+		{
+			applications: []marathon.Application{},
+			task:         marathon.Task{},
+			expected:     "",
+		},
+		{
+			applications: []marathon.Application{
+				{
+					ID: "test1",
+				},
+			},
+			task: marathon.Task{
+				AppID: "test2",
+			},
+			expected: "",
+		},
+		{
+			applications: []marathon.Application{
+				{
+					ID: "test1",
+				},
+			},
+			task: marathon.Task{
+				AppID: "test1",
+				Ports: []int{80},
+			},
+			expected: "80",
+		},
+		{
+			applications: []marathon.Application{
+				{
+					ID: "test1",
+				},
+			},
+			task: marathon.Task{
+				AppID: "test1",
+				Ports: []int{80, 443},
+			},
+			expected: "80",
+		},
+		{
+			applications: []marathon.Application{
+				{
+					ID: "specify-port-number",
+					Labels: map[string]string{
+						"traefik.port": "443",
+					},
+				},
+			},
+			task: marathon.Task{
+				AppID: "specify-port-number",
+				Ports: []int{80, 443},
+			},
+			expected: "443",
+		},
+		{
+			applications: []marathon.Application{
+				{
+					ID: "specify-port-index",
+					Labels: map[string]string{
+						"traefik.portIndex": "1",
+					},
+				},
+			},
+			task: marathon.Task{
+				AppID: "specify-port-index",
+				Ports: []int{80, 443},
+			},
+			expected: "443",
+		},
+	}
+
+	for _, c := range cases {
+		actual := provider.getPort(c.task, c.applications)
+		if actual != c.expected {
+			t.Fatalf("expected %q, got %q", c.expected, actual)
+		}
+	}
+}
+
+func TestMarathonGetWeigh(t *testing.T) {
+	provider := &Marathon{}
+
+	applications := []struct {
+		applications []marathon.Application
+		task         marathon.Task
+		expected     string
+	}{
+		{
+			applications: []marathon.Application{},
+			task:         marathon.Task{},
+			expected:     "0",
+		},
+		{
+			applications: []marathon.Application{
+				{
+					ID: "test1",
+					Labels: map[string]string{
+						"traefik.weight": "10",
+					},
+				},
+			},
+			task: marathon.Task{
+				AppID: "test2",
+			},
+			expected: "0",
+		},
+		{
+			applications: []marathon.Application{
+				{
+					ID: "test",
+					Labels: map[string]string{
+						"traefik.test": "10",
+					},
+				},
+			},
+			task: marathon.Task{
+				AppID: "test",
+			},
+			expected: "0",
+		},
+		{
+			applications: []marathon.Application{
+				{
+					ID: "test",
+					Labels: map[string]string{
+						"traefik.weight": "10",
+					},
+				},
+			},
+			task: marathon.Task{
+				AppID: "test",
+			},
+			expected: "10",
+		},
+	}
+
+	for _, a := range applications {
+		actual := provider.getWeight(a.task, a.applications)
+		if actual != a.expected {
+			t.Fatalf("expected %q, got %q", a.expected, actual)
+		}
+	}
+}
+
+func TestMarathonGetDomain(t *testing.T) {
+	provider := &Marathon{
+		Domain: "docker.localhost",
+	}
+
+	applications := []struct {
+		application marathon.Application
+		expected    string
+	}{
+		{
+			application: marathon.Application{},
+			expected:    "docker.localhost",
+		},
+		{
+			application: marathon.Application{
+				Labels: map[string]string{
+					"traefik.domain": "foo.bar",
+				},
+			},
+			expected: "foo.bar",
+		},
+	}
+
+	for _, a := range applications {
+		actual := provider.getDomain(a.application)
+		if actual != a.expected {
+			t.Fatalf("expected %q, got %q", a.expected, actual)
+		}
+	}
+}
+
+func TestMarathonGetProtocol(t *testing.T) {
+	provider := &Marathon{}
+
+	applications := []struct {
+		applications []marathon.Application
+		task         marathon.Task
+		expected     string
+	}{
+		{
+			applications: []marathon.Application{},
+			task:         marathon.Task{},
+			expected:     "http",
+		},
+		{
+			applications: []marathon.Application{
+				{
+					ID: "test1",
+					Labels: map[string]string{
+						"traefik.protocol": "https",
+					},
+				},
+			},
+			task: marathon.Task{
+				AppID: "test2",
+			},
+			expected: "http",
+		},
+		{
+			applications: []marathon.Application{
+				{
+					ID: "test",
+					Labels: map[string]string{
+						"traefik.foo": "bar",
+					},
+				},
+			},
+			task: marathon.Task{
+				AppID: "test",
+			},
+			expected: "http",
+		},
+		{
+			applications: []marathon.Application{
+				{
+					ID: "test",
+					Labels: map[string]string{
+						"traefik.protocol": "https",
+					},
+				},
+			},
+			task: marathon.Task{
+				AppID: "test",
+			},
+			expected: "https",
+		},
+	}
+
+	for _, a := range applications {
+		actual := provider.getProtocol(a.task, a.applications)
+		if actual != a.expected {
+			t.Fatalf("expected %q, got %q", a.expected, actual)
+		}
+	}
+}
+
+func TestMarathonGetPassHostHeader(t *testing.T) {
+	provider := &Marathon{}
+
+	applications := []struct {
+		application marathon.Application
+		expected    string
+	}{
+		{
+			application: marathon.Application{},
+			expected:    "false",
+		},
+		{
+			application: marathon.Application{
+				Labels: map[string]string{
+					"traefik.frontend.passHostHeader": "true",
+				},
+			},
+			expected: "true",
+		},
+	}
+
+	for _, a := range applications {
+		actual := provider.getPassHostHeader(a.application)
+		if actual != a.expected {
+			t.Fatalf("expected %q, got %q", a.expected, actual)
+		}
+	}
+}
+
+func TestMarathonGetEntryPoints(t *testing.T) {
+	provider := &Marathon{}
+
+	applications := []struct {
+		application marathon.Application
+		expected    []string
+	}{
+		{
+			application: marathon.Application{},
+			expected:    []string{},
+		},
+		{
+			application: marathon.Application{
+				Labels: map[string]string{
+					"traefik.frontend.entryPoints": "http,https",
+				},
+			},
+			expected: []string{"http", "https"},
+		},
+	}
+
+	for _, a := range applications {
+		actual := provider.getEntryPoints(a.application)
+
+		if !reflect.DeepEqual(actual, a.expected) {
+			t.Fatalf("expected %#v, got %#v", a.expected, actual)
+		}
+	}
+}
+
+func TestMarathonGetFrontendValue(t *testing.T) {
+	provider := &Marathon{
+		Domain: "docker.localhost",
+	}
+
+	applications := []struct {
+		application marathon.Application
+		expected    string
+	}{
+		{
+			application: marathon.Application{},
+			expected:    ".docker.localhost",
+		},
+		{
+			application: marathon.Application{
+				ID: "test",
+			},
+			expected: "test.docker.localhost",
+		},
+		{
+			application: marathon.Application{
+				Labels: map[string]string{
+					"traefik.frontend.value": "foo.bar",
+				},
+			},
+			expected: "foo.bar",
+		},
+	}
+
+	for _, a := range applications {
+		actual := provider.getFrontendValue(a.application)
+		if actual != a.expected {
+			t.Fatalf("expected %q, got %q", a.expected, actual)
+		}
+	}
+}
+
+func TestMarathonGetFrontendRule(t *testing.T) {
+	provider := &Marathon{}
+
+	applications := []struct {
+		application marathon.Application
+		expected    string
+	}{
+		{
+			application: marathon.Application{},
+			expected:    "Host",
+		},
+		{
+			application: marathon.Application{
+				Labels: map[string]string{
+					"traefik.frontend.rule": "Header",
+				},
+			},
+			expected: "Header",
+		},
+	}
+
+	for _, a := range applications {
+		actual := provider.getFrontendRule(a.application)
+		if actual != a.expected {
+			t.Fatalf("expected %q, got %q", a.expected, actual)
+		}
+	}
+}
+
+func TestMarathonGetBackend(t *testing.T) {
+	provider := &Marathon{}
+
+	applications := []struct {
+		application marathon.Application
+		expected    string
+	}{
+		{
+			application: marathon.Application{
+				ID: "foo",
+				Labels: map[string]string{
+					"traefik.backend": "bar",
+				},
+			},
+			expected: "bar",
+		},
+	}
+
+	for _, a := range applications {
+		actual := provider.getFrontendBackend(a.application)
+		if actual != a.expected {
+			t.Fatalf("expected %q, got %q", a.expected, actual)
+		}
+	}
+}

provider/provider.go

@@ -0,0 +1,69 @@
+package provider
+
+import (
+	"bytes"
+	"io/ioutil"
+	"strings"
+	"text/template"
+
+	"github.com/BurntSushi/toml"
+	"github.com/containous/traefik/autogen"
+	"github.com/containous/traefik/types"
+)
+
+// Provider defines methods of a provider.
+type Provider interface {
+	// Provide allows the provider to provide configurations to traefik
+	// using the given configuration channel.
+	Provide(configurationChan chan<- types.ConfigMessage) error
+}
+
+// BaseProvider should be inherited by providers
+type BaseProvider struct {
+	Watch    bool
+	Filename string
+}
+
+func (p *BaseProvider) getConfiguration(defaultTemplateFile string, funcMap template.FuncMap, templateObjects interface{}) (*types.Configuration, error) {
+	var (
+		buf []byte
+		err error
+	)
+	configuration := new(types.Configuration)
+	tmpl := template.New(p.Filename).Funcs(funcMap)
+	if len(p.Filename) > 0 {
+		buf, err = ioutil.ReadFile(p.Filename)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		buf, err = autogen.Asset(defaultTemplateFile)
+		if err != nil {
+			return nil, err
+		}
+	}
+	_, err = tmpl.Parse(string(buf))
+	if err != nil {
+		return nil, err
+	}
+
+	var buffer bytes.Buffer
+	err = tmpl.Execute(&buffer, templateObjects)
+	if err != nil {
+		return nil, err
+	}
+
+	if _, err := toml.Decode(buffer.String(), configuration); err != nil {
+		return nil, err
+	}
+	return configuration, nil
+}
+
+func replace(s1 string, s2 string, s3 string) string {
+	return strings.Replace(s3, s1, s2, -1)
+}
+
+// Escape beginning slash "/", convert all others to dash "-"
+func getEscapedName(name string) string {
+	return strings.Replace(strings.TrimPrefix(name, "/"), "/", "-", -1)
+}

provider/provider_test.go

@@ -0,0 +1,170 @@
+package provider
+
+import (
+	"io/ioutil"
+	"os"
+	"strings"
+	"testing"
+	"text/template"
+)
+
+type myProvider struct {
+	BaseProvider
+}
+
+func (p *myProvider) Foo() string {
+	return "bar"
+}
+
+func TestConfigurationErrors(t *testing.T) {
+	templateErrorFile, err := ioutil.TempFile("", "provider-configuration-error")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(templateErrorFile.Name())
+	data := []byte("Not a valid template {{ Bar }}")
+	err = ioutil.WriteFile(templateErrorFile.Name(), data, 0700)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	templateInvalidTOMLFile, err := ioutil.TempFile("", "provider-configuration-error")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(templateInvalidTOMLFile.Name())
+	data = []byte(`Hello {{ .Name }}
+{{ Foo }}`)
+	err = ioutil.WriteFile(templateInvalidTOMLFile.Name(), data, 0700)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	invalids := []struct {
+		provider        *myProvider
+		defaultTemplate string
+		expectedError   string
+		funcMap         template.FuncMap
+		templateObjects interface{}
+	}{
+		{
+			provider: &myProvider{
+				BaseProvider{
+					Filename: "/non/existent/template.tmpl",
+				},
+			},
+			expectedError: "open /non/existent/template.tmpl: no such file or directory",
+		},
+		{
+			provider:        &myProvider{},
+			defaultTemplate: "non/existent/template.tmpl",
+			expectedError:   "Asset non/existent/template.tmpl not found",
+		},
+		{
+			provider: &myProvider{
+				BaseProvider{
+					Filename: templateErrorFile.Name(),
+				},
+			},
+			expectedError: `function "Bar" not defined`,
+		},
+		{
+			provider: &myProvider{
+				BaseProvider{
+					Filename: templateInvalidTOMLFile.Name(),
+				},
+			},
+			expectedError: "Near line 1, key 'Hello': Near line 1: Expected key separator '=', but got '<' instead",
+			funcMap: template.FuncMap{
+				"Foo": func() string {
+					return "bar"
+				},
+			},
+			templateObjects: struct{ Name string }{Name: "bar"},
+		},
+	}
+
+	for _, invalid := range invalids {
+		configuration, err := invalid.provider.getConfiguration(invalid.defaultTemplate, invalid.funcMap, nil)
+		if err == nil || !strings.Contains(err.Error(), invalid.expectedError) {
+			t.Fatalf("should have generate an error with %q, got %v", invalid.expectedError, err)
+		}
+		if configuration != nil {
+			t.Fatalf("shouldn't have return a configuration object : %v", configuration)
+		}
+	}
+}
+
+func TestGetConfiguration(t *testing.T) {
+	templateFile, err := ioutil.TempFile("", "provider-configuration")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(templateFile.Name())
+	data := []byte(`[backends]
+  [backends.backend1]
+    [backends.backend1.circuitbreaker]
+      expression = "NetworkErrorRatio() > 0.5"
+    [backends.backend1.servers.server1]
+    url = "http://172.17.0.2:80"
+    weight = 10
+    [backends.backend1.servers.server2]
+    url = "http://172.17.0.3:80"
+    weight = 1
+
+[frontends]
+  [frontends.frontend1]
+  backend = "backend1"
+  passHostHeader = true
+    [frontends.frontend11.routes.test_2]
+    rule = "Path"
+    value = "/test"`)
+	err = ioutil.WriteFile(templateFile.Name(), data, 0700)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	provider := &myProvider{
+		BaseProvider{
+			Filename: templateFile.Name(),
+		},
+	}
+	configuration, err := provider.getConfiguration(templateFile.Name(), nil, nil)
+	if err != nil {
+		t.Fatalf("Shouldn't have error out, got %v", err)
+	}
+	if configuration == nil {
+		t.Fatalf("Configuration should not be nil, but was")
+	}
+}
+
+func TestReplace(t *testing.T) {
+	cases := []struct {
+		str      string
+		expected string
+	}{
+		{
+			str:      "",
+			expected: "",
+		},
+		{
+			str:      "foo",
+			expected: "bar",
+		},
+		{
+			str:      "foo foo",
+			expected: "bar bar",
+		},
+		{
+			str:      "somethingfoo",
+			expected: "somethingbar",
+		},
+	}
+
+	for _, c := range cases {
+		actual := replace("foo", "bar", c.str)
+		if actual != c.expected {
+			t.Fatalf("expected %q, got %q, for %q", c.expected, actual, c.str)
+		}
+	}
+}

provider/zk.go

@@ -0,0 +1,20 @@
+package provider
+
+import (
+	"github.com/containous/traefik/types"
+	"github.com/docker/libkv/store"
+	"github.com/docker/libkv/store/zookeeper"
+)
+
+// Zookepper holds configurations of the Zookepper provider.
+type Zookepper struct {
+	Kv
+}
+
+// Provide allows the provider to provide configurations to traefik
+// using the given configuration channel.
+func (provider *Zookepper) Provide(configurationChan chan<- types.ConfigMessage) error {
+	provider.storeType = store.ZK
+	zookeeper.Register()
+	return provider.provide(configurationChan)
+}

script/.validate

@@ -3,23 +3,24 @@
 if [ -z "$VALIDATE_UPSTREAM" ]; then
 	# this is kind of an expensive check, so let's not do this twice if we
 	# are running more than one validate bundlescript
-	
-	VALIDATE_REPO='https://github.com/emilevauge/traefik.git'
+
+	VALIDATE_REPO='https://github.com/containous/traefik.git'
 	VALIDATE_BRANCH='master'
-	
-	if [ "$TRAVIS" = 'true' -a "$TRAVIS_PULL_REQUEST" != 'false' ]; then
-		VALIDATE_REPO="https://github.com/${TRAVIS_REPO_SLUG}.git"
-		VALIDATE_BRANCH="${TRAVIS_BRANCH}"
-	fi
-	
+
+        # Should not be needed for now O:)
+	# if [ "$TRAVIS" = 'true' -a "$TRAVIS_PULL_REQUEST" != 'false' ]; then
+	# 	VALIDATE_REPO="https://github.com/${TRAVIS_REPO_SLUG}.git"
+	# 	VALIDATE_BRANCH="${TRAVIS_BRANCH}"
+	# fi
+
 	VALIDATE_HEAD="$(git rev-parse --verify HEAD)"
-	
+
 	git fetch -q "$VALIDATE_REPO" "refs/heads/$VALIDATE_BRANCH"
 	VALIDATE_UPSTREAM="$(git rev-parse --verify FETCH_HEAD)"
-	
+
 	VALIDATE_COMMIT_LOG="$VALIDATE_UPSTREAM..$VALIDATE_HEAD"
 	VALIDATE_COMMIT_DIFF="$VALIDATE_UPSTREAM...$VALIDATE_HEAD"
-	
+
 	validate_diff() {
 		if [ "$VALIDATE_UPSTREAM" != "$VALIDATE_HEAD" ]; then
 			git diff "$VALIDATE_COMMIT_DIFF" "$@"

script/binary

@@ -1,7 +1,7 @@
 #!/bin/bash
 set -e
 
-if ! test -e gen.go; then
+if ! test -e autogen/gen.go; then
 	echo >&2 'error: generate must be run before binary'
 	false
 fi

script/crossbinary

@@ -1,8 +1,8 @@
 #!/bin/bash
 set -e
 
-if ! test -e gen.go; then
-	echo >&2 'error: generate must be run before binary'
+if ! test -e autogen/gen.go; then
+	echo >&2 'error: generate must be run before crossbinary'
 	false
 fi
 

script/deploy.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+set -e
+
+if ([ "$TRAVIS_BRANCH" = "master" ] || [ ! -z "$TRAVIS_TAG" ]) && [ "$TRAVIS_PULL_REQUEST" = "false" ]; then
+  echo "Deploying"
+else
+  echo "Skipping deploy"
+  exit 0
+fi
+
+curl -LO https://github.com/tcnksm/ghr/releases/download/pre-release/linux_amd64.zip
+unzip -q linux_amd64.zip
+sudo mv ghr /usr/bin/ghr
+sudo chmod +x /usr/bin/ghr
+
+# github release and tag
+ghr -t $GITHUB_TOKEN -u containous -r traefik --prerelease ${VERSION} dist/
+
+# update traefik-library-image repo (official Docker image)
+git config --global user.email "emile@vauge.com"
+git config --global user.name "Emile Vauge"
+git clone https://github.com/containous/traefik-library-image.git
+cd traefik-library-image
+git remote rm origin
+git remote add origin https://emilevauge:${GITHUB_TOKEN}@github.com/containous/traefik-library-image.git
+./update.sh $VERSION
+git add -A
+echo $VERSION | git commit --file -
+echo $VERSION | git tag -a $VERSION --file -
+git push --follow-tags -u origin master
+
+# create docker image emilevauge/traefik (compatibility)
+docker login -e $DOCKER_EMAIL -u $DOCKER_USER -p $DOCKER_PASS
+docker tag containous/traefik emilevauge/traefik:latest
+docker push emilevauge/traefik:latest
+docker tag emilevauge/traefik:latest emilevauge/traefik:${VERSION}
+docker push emilevauge/traefik:${VERSION}
+
+cd ..
+rm -Rf traefik-library-image/
+
+echo "Deployed"

script/make.sh

@@ -5,6 +5,7 @@ set -e
 DEFAULT_BUNDLES=(
 	validate-gofmt
 	validate-govet
+	generate
 	binary
 
 	test-unit

script/test-integration

@@ -1,4 +1,5 @@
 #!/bin/bash
+set -e
 
 export SCRIPTDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 export DEST=.
@@ -6,5 +7,4 @@ export DEST=.
 TESTFLAGS="$TESTFLAGS -test.timeout=30m -check.v"
 
 cd integration
-go test $TESTFLAGS
-
+CGO_ENABLED=0 go test $TESTFLAGS

script/test-unit

@@ -1,8 +1,8 @@
 #!/bin/bash
 set -e
 
-if ! test -e gen.go; then
-	echo >&2 'error: generate must be run before binary'
+if ! test -e autogen/gen.go; then
+	echo >&2 'error: generate must be run before test-unit'
 	false
 fi
 

script/validate-golint

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+source "$(dirname "$BASH_SOURCE")/.validate"
+
+IFS=$'\n'
+files=( $(validate_diff --diff-filter=ACMR --name-only -- '*.go' | grep -v '^vendor/\|autogen' || true) )
+unset IFS
+
+errors=()
+for f in "${files[@]}"; do
+	# we use "git show" here to validate that what's committed passes go vet
+	failedLint=$(golint "$f")
+	if [ "$failedLint" ]; then
+		errors+=( "$failedLint" )
+	fi
+done
+
+if [ ${#errors[@]} -eq 0 ]; then
+	echo 'Congratulations!  All Go source files have been linted.'
+else
+	{
+		echo "Errors from golint:"
+		for err in "${errors[@]}"; do
+			echo "$err"
+		done
+		echo
+		echo 'Please fix the above errors. You can test via "golint" and commit the result.'
+		echo
+	} >&2
+	false
+fi

server.go

@@ -0,0 +1,505 @@
+/*
+Copyright
+*/
+package main
+
+import (
+	"crypto/tls"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/url"
+	"os"
+	"os/signal"
+	"reflect"
+	"regexp"
+	"sort"
+	"sync"
+	"syscall"
+	"time"
+
+	log "github.com/Sirupsen/logrus"
+	"github.com/codegangsta/negroni"
+	"github.com/containous/traefik/middlewares"
+	"github.com/containous/traefik/provider"
+	"github.com/containous/traefik/types"
+	"github.com/gorilla/mux"
+	"github.com/mailgun/manners"
+	"github.com/mailgun/oxy/cbreaker"
+	"github.com/mailgun/oxy/forward"
+	"github.com/mailgun/oxy/roundrobin"
+)
+
+var oxyLogger = &OxyLogger{}
+
+// Server is the reverse-proxy/load-balancer engine
+type Server struct {
+	serverEntryPoints          map[string]serverEntryPoint
+	configurationChan          chan types.ConfigMessage
+	configurationValidatedChan chan types.ConfigMessage
+	signals                    chan os.Signal
+	stopChan                   chan bool
+	providers                  []provider.Provider
+	serverLock                 sync.Mutex
+	currentConfigurations      configs
+	globalConfiguration        GlobalConfiguration
+	loggerMiddleware           *middlewares.Logger
+}
+
+type serverEntryPoint struct {
+	httpServer *manners.GracefulServer
+	httpRouter *middlewares.HandlerSwitcher
+}
+
+// NewServer returns an initialized Server.
+func NewServer(globalConfiguration GlobalConfiguration) *Server {
+	server := new(Server)
+
+	server.serverEntryPoints = make(map[string]serverEntryPoint)
+	server.configurationChan = make(chan types.ConfigMessage, 10)
+	server.configurationValidatedChan = make(chan types.ConfigMessage, 10)
+	server.signals = make(chan os.Signal, 1)
+	server.stopChan = make(chan bool)
+	server.providers = []provider.Provider{}
+	signal.Notify(server.signals, syscall.SIGINT, syscall.SIGTERM)
+	server.currentConfigurations = make(configs)
+	server.globalConfiguration = globalConfiguration
+	server.loggerMiddleware = middlewares.NewLogger(globalConfiguration.AccessLogsFile)
+
+	return server
+}
+
+// Start starts the server and blocks until server is shutted down.
+func (server *Server) Start() {
+	go server.listenProviders()
+	go server.listenConfigurations()
+	server.configureProviders()
+	server.startProviders()
+	go server.listenSignals()
+	<-server.stopChan
+}
+
+// Stop stops the server
+func (server *Server) Stop() {
+	for _, serverEntryPoint := range server.serverEntryPoints {
+		serverEntryPoint.httpServer.BlockingClose()
+	}
+	server.stopChan <- true
+}
+
+// Close destroys the server
+func (server *Server) Close() {
+	close(server.configurationChan)
+	close(server.configurationValidatedChan)
+	close(server.signals)
+	close(server.stopChan)
+	server.loggerMiddleware.Close()
+}
+
+func (server *Server) listenProviders() {
+	lastReceivedConfiguration := time.Unix(0, 0)
+	lastConfigs := make(map[string]*types.ConfigMessage)
+	for {
+		configMsg := <-server.configurationChan
+		jsonConf, _ := json.Marshal(configMsg.Configuration)
+		log.Debugf("Configuration receveived from provider %s: %s", configMsg.ProviderName, string(jsonConf))
+		lastConfigs[configMsg.ProviderName] = &configMsg
+		if time.Now().After(lastReceivedConfiguration.Add(time.Duration(server.globalConfiguration.ProvidersThrottleDuration))) {
+			log.Debugf("Last %s config received more than %s, OK", configMsg.ProviderName, server.globalConfiguration.ProvidersThrottleDuration)
+			// last config received more than n s ago
+			server.configurationValidatedChan <- configMsg
+		} else {
+			log.Debugf("Last %s config received less than %s, waiting...", configMsg.ProviderName, server.globalConfiguration.ProvidersThrottleDuration)
+			go func() {
+				<-time.After(server.globalConfiguration.ProvidersThrottleDuration)
+				if time.Now().After(lastReceivedConfiguration.Add(time.Duration(server.globalConfiguration.ProvidersThrottleDuration))) {
+					log.Debugf("Waited for %s config, OK", configMsg.ProviderName)
+					server.configurationValidatedChan <- *lastConfigs[configMsg.ProviderName]
+				}
+			}()
+		}
+		lastReceivedConfiguration = time.Now()
+	}
+}
+
+func (server *Server) listenConfigurations() {
+	for {
+		configMsg := <-server.configurationValidatedChan
+		if configMsg.Configuration == nil {
+			log.Info("Skipping empty Configuration")
+		} else if reflect.DeepEqual(server.currentConfigurations[configMsg.ProviderName], configMsg.Configuration) {
+			log.Info("Skipping same configuration")
+		} else {
+			// Copy configurations to new map so we don't change current if LoadConfig fails
+			newConfigurations := make(configs)
+			for k, v := range server.currentConfigurations {
+				newConfigurations[k] = v
+			}
+			newConfigurations[configMsg.ProviderName] = configMsg.Configuration
+
+			newServerEntryPoints, err := server.loadConfig(newConfigurations, server.globalConfiguration)
+			if err == nil {
+				server.serverLock.Lock()
+				for newServerEntryPointName, newServerEntryPoint := range newServerEntryPoints {
+					currentServerEntryPoint := server.serverEntryPoints[newServerEntryPointName]
+					if currentServerEntryPoint.httpServer == nil {
+						newsrv, err := server.prepareServer(newServerEntryPoint.httpRouter, server.globalConfiguration.EntryPoints[newServerEntryPointName], nil, server.loggerMiddleware, metrics)
+						if err != nil {
+							log.Fatal("Error preparing server: ", err)
+						}
+						go server.startServer(newsrv, server.globalConfiguration)
+						currentServerEntryPoint.httpServer = newsrv
+						currentServerEntryPoint.httpRouter = newServerEntryPoint.httpRouter
+						server.serverEntryPoints[newServerEntryPointName] = currentServerEntryPoint
+						log.Infof("Created new Handler: %p", newServerEntryPoint.httpRouter.GetHandler())
+					} else {
+						handlerSwitcher := currentServerEntryPoint.httpRouter
+						handlerSwitcher.UpdateHandler(newServerEntryPoint.httpRouter.GetHandler())
+						log.Infof("Created new Handler: %p", newServerEntryPoint.httpRouter.GetHandler())
+					}
+				}
+				server.currentConfigurations = newConfigurations
+				server.serverLock.Unlock()
+			} else {
+				log.Error("Error loading new configuration, aborted ", err)
+			}
+		}
+	}
+}
+
+func (server *Server) configureProviders() {
+	// configure providers
+	if server.globalConfiguration.Docker != nil {
+		server.providers = append(server.providers, server.globalConfiguration.Docker)
+	}
+	if server.globalConfiguration.Marathon != nil {
+		server.providers = append(server.providers, server.globalConfiguration.Marathon)
+	}
+	if server.globalConfiguration.File != nil {
+		server.providers = append(server.providers, server.globalConfiguration.File)
+	}
+	if server.globalConfiguration.Web != nil {
+		server.globalConfiguration.Web.server = server
+		server.providers = append(server.providers, server.globalConfiguration.Web)
+	}
+	if server.globalConfiguration.Consul != nil {
+		server.providers = append(server.providers, server.globalConfiguration.Consul)
+	}
+	if server.globalConfiguration.ConsulCatalog != nil {
+		server.providers = append(server.providers, server.globalConfiguration.ConsulCatalog)
+	}
+	if server.globalConfiguration.Etcd != nil {
+		server.providers = append(server.providers, server.globalConfiguration.Etcd)
+	}
+	if server.globalConfiguration.Zookeeper != nil {
+		server.providers = append(server.providers, server.globalConfiguration.Zookeeper)
+	}
+	if server.globalConfiguration.Boltdb != nil {
+		server.providers = append(server.providers, server.globalConfiguration.Boltdb)
+	}
+}
+
+func (server *Server) startProviders() {
+	// start providers
+	for _, provider := range server.providers {
+		jsonConf, _ := json.Marshal(provider)
+		log.Infof("Starting provider %v %s", reflect.TypeOf(provider), jsonConf)
+		currentProvider := provider
+		go func() {
+			err := currentProvider.Provide(server.configurationChan)
+			if err != nil {
+				log.Errorf("Error starting provider %s", err)
+			}
+		}()
+	}
+}
+
+func (server *Server) listenSignals() {
+	sig := <-server.signals
+	log.Infof("I have to go... %+v", sig)
+	log.Info("Stopping server")
+	server.Stop()
+}
+
+// creates a TLS config that allows terminating HTTPS for multiple domains using SNI
+func (server *Server) createTLSConfig(tlsOption *TLS) (*tls.Config, error) {
+	if tlsOption == nil {
+		return nil, nil
+	}
+	if len(tlsOption.Certificates) == 0 {
+		return nil, nil
+	}
+
+	config := &tls.Config{}
+	if config.NextProtos == nil {
+		config.NextProtos = []string{"http/1.1"}
+	}
+
+	var err error
+	config.Certificates = make([]tls.Certificate, len(tlsOption.Certificates))
+	for i, v := range tlsOption.Certificates {
+		config.Certificates[i], err = tls.LoadX509KeyPair(v.CertFile, v.KeyFile)
+		if err != nil {
+			return nil, err
+		}
+	}
+	// BuildNameToCertificate parses the CommonName and SubjectAlternateName fields
+	// in each certificate and populates the config.NameToCertificate map.
+	config.BuildNameToCertificate()
+	return config, nil
+}
+
+func (server *Server) startServer(srv *manners.GracefulServer, globalConfiguration GlobalConfiguration) {
+	log.Info("Starting server on ", srv.Addr)
+	if srv.TLSConfig != nil {
+		err := srv.ListenAndServeTLSWithConfig(srv.TLSConfig)
+		if err != nil {
+			log.Fatal("Error creating server: ", err)
+		}
+	} else {
+		err := srv.ListenAndServe()
+		if err != nil {
+			log.Fatal("Error creating server: ", err)
+		}
+	}
+	log.Info("Server stopped")
+}
+
+func (server *Server) prepareServer(router http.Handler, entryPoint *EntryPoint, oldServer *manners.GracefulServer, middlewares ...negroni.Handler) (*manners.GracefulServer, error) {
+	log.Info("Preparing server")
+	// middlewares
+	var negroni = negroni.New()
+	for _, middleware := range middlewares {
+		negroni.Use(middleware)
+	}
+	negroni.UseHandler(router)
+	tlsConfig, err := server.createTLSConfig(entryPoint.TLS)
+	if err != nil {
+		log.Fatalf("Error creating TLS config %s", err)
+		return nil, err
+	}
+
+	if oldServer == nil {
+		return manners.NewWithServer(
+			&http.Server{
+				Addr:      entryPoint.Address,
+				Handler:   negroni,
+				TLSConfig: tlsConfig,
+			}), nil
+	}
+	gracefulServer, err := oldServer.HijackListener(&http.Server{
+		Addr:      entryPoint.Address,
+		Handler:   negroni,
+		TLSConfig: tlsConfig,
+	}, tlsConfig)
+	if err != nil {
+		log.Fatalf("Error hijacking server %s", err)
+		return nil, err
+	}
+	return gracefulServer, nil
+}
+
+func (server *Server) buildEntryPoints(globalConfiguration GlobalConfiguration) map[string]serverEntryPoint {
+	serverEntryPoints := make(map[string]serverEntryPoint)
+	for entryPointName := range globalConfiguration.EntryPoints {
+		router := server.buildDefaultHTTPRouter()
+		serverEntryPoints[entryPointName] = serverEntryPoint{
+			httpRouter: middlewares.NewHandlerSwitcher(router),
+		}
+	}
+	return serverEntryPoints
+}
+
+// LoadConfig returns a new gorilla.mux Route from the specified global configuration and the dynamic
+// provider configurations.
+func (server *Server) loadConfig(configurations configs, globalConfiguration GlobalConfiguration) (map[string]serverEntryPoint, error) {
+	serverEntryPoints := server.buildEntryPoints(globalConfiguration)
+	redirectHandlers := make(map[string]http.Handler)
+
+	backends := map[string]http.Handler{}
+	for _, configuration := range configurations {
+		frontendNames := sortedFrontendNamesForConfig(configuration)
+		for _, frontendName := range frontendNames {
+			frontend := configuration.Frontends[frontendName]
+
+			log.Debugf("Creating frontend %s", frontendName)
+			fwd, _ := forward.New(forward.Logger(oxyLogger), forward.PassHostHeader(frontend.PassHostHeader))
+			// default endpoints if not defined in frontends
+			if len(frontend.EntryPoints) == 0 {
+				frontend.EntryPoints = globalConfiguration.DefaultEntryPoints
+			}
+			for _, entryPointName := range frontend.EntryPoints {
+				log.Debugf("Wiring frontend %s to entryPoint %s", frontendName, entryPointName)
+				if _, ok := serverEntryPoints[entryPointName]; !ok {
+					return nil, errors.New("Undefined entrypoint: " + entryPointName)
+				}
+				newRoute := serverEntryPoints[entryPointName].httpRouter.GetHandler().NewRoute().Name(frontendName)
+				for routeName, route := range frontend.Routes {
+					log.Debugf("Creating route %s %s:%s", routeName, route.Rule, route.Value)
+					route, err := getRoute(newRoute, route.Rule, route.Value)
+					if err != nil {
+						return nil, err
+					}
+					newRoute = route
+				}
+				entryPoint := globalConfiguration.EntryPoints[entryPointName]
+				if entryPoint.Redirect != nil {
+					if redirectHandlers[entryPointName] != nil {
+						newRoute.Handler(redirectHandlers[entryPointName])
+					} else if handler, err := server.loadEntryPointConfig(entryPointName, entryPoint); err != nil {
+						return nil, err
+					} else {
+						newRoute.Handler(handler)
+						redirectHandlers[entryPointName] = handler
+					}
+				} else {
+					if backends[frontend.Backend] == nil {
+						log.Debugf("Creating backend %s", frontend.Backend)
+						var lb http.Handler
+						rr, _ := roundrobin.New(fwd)
+						if configuration.Backends[frontend.Backend] == nil {
+							return nil, errors.New("Undefined backend: " + frontend.Backend)
+						}
+						lbMethod, err := types.NewLoadBalancerMethod(configuration.Backends[frontend.Backend].LoadBalancer)
+						if err != nil {
+							configuration.Backends[frontend.Backend].LoadBalancer = &types.LoadBalancer{Method: "wrr"}
+						}
+						switch lbMethod {
+						case types.Drr:
+							log.Debugf("Creating load-balancer drr")
+							rebalancer, _ := roundrobin.NewRebalancer(rr, roundrobin.RebalancerLogger(oxyLogger))
+							lb = rebalancer
+							for serverName, server := range configuration.Backends[frontend.Backend].Servers {
+								url, err := url.Parse(server.URL)
+								if err != nil {
+									return nil, err
+								}
+								log.Debugf("Creating server %s at %s with weight %d", serverName, url.String(), server.Weight)
+								rebalancer.UpsertServer(url, roundrobin.Weight(server.Weight))
+							}
+						case types.Wrr:
+							log.Debugf("Creating load-balancer wrr")
+							lb = middlewares.NewWebsocketUpgrader(rr)
+							for serverName, server := range configuration.Backends[frontend.Backend].Servers {
+								url, err := url.Parse(server.URL)
+								if err != nil {
+									return nil, err
+								}
+								log.Debugf("Creating server %s at %s with weight %d", serverName, url.String(), server.Weight)
+								rr.UpsertServer(url, roundrobin.Weight(server.Weight))
+							}
+						}
+						var negroni = negroni.New()
+						if configuration.Backends[frontend.Backend].CircuitBreaker != nil {
+							log.Debugf("Creating circuit breaker %s", configuration.Backends[frontend.Backend].CircuitBreaker.Expression)
+							negroni.Use(middlewares.NewCircuitBreaker(lb, configuration.Backends[frontend.Backend].CircuitBreaker.Expression, cbreaker.Logger(oxyLogger)))
+						} else {
+							negroni.UseHandler(lb)
+						}
+						backends[frontend.Backend] = negroni
+					} else {
+						log.Debugf("Reusing backend %s", frontend.Backend)
+					}
+					server.wireFrontendBackend(frontend.Routes, newRoute, backends[frontend.Backend])
+				}
+				err := newRoute.GetError()
+				if err != nil {
+					log.Errorf("Error building route: %s", err)
+				}
+			}
+		}
+	}
+	return serverEntryPoints, nil
+}
+
+func (server *Server) wireFrontendBackend(routes map[string]types.Route, newRoute *mux.Route, handler http.Handler) {
+	// strip prefix
+	var strip bool
+	for _, route := range routes {
+		switch route.Rule {
+		case "PathStrip":
+			newRoute.Handler(&middlewares.StripPrefix{
+				Prefix:  route.Value,
+				Handler: handler,
+			})
+			strip = true
+			break
+		case "PathPrefixStrip":
+			newRoute.Handler(&middlewares.StripPrefix{
+				Prefix:  route.Value,
+				Handler: handler,
+			})
+			strip = true
+			break
+		}
+	}
+	if !strip {
+		newRoute.Handler(handler)
+	}
+}
+
+func (server *Server) loadEntryPointConfig(entryPointName string, entryPoint *EntryPoint) (http.Handler, error) {
+	regex := entryPoint.Redirect.Regex
+	replacement := entryPoint.Redirect.Replacement
+	if len(entryPoint.Redirect.EntryPoint) > 0 {
+		regex = "^(?:https?:\\/\\/)?([\\da-z\\.-]+)(?::\\d+)?(.*)$"
+		if server.globalConfiguration.EntryPoints[entryPoint.Redirect.EntryPoint] == nil {
+			return nil, errors.New("Unknown entrypoint " + entryPoint.Redirect.EntryPoint)
+		}
+		protocol := "http"
+		if server.globalConfiguration.EntryPoints[entryPoint.Redirect.EntryPoint].TLS != nil {
+			protocol = "https"
+		}
+		r, _ := regexp.Compile("(:\\d+)")
+		match := r.FindStringSubmatch(server.globalConfiguration.EntryPoints[entryPoint.Redirect.EntryPoint].Address)
+		if len(match) == 0 {
+			return nil, errors.New("Bad Address format: " + server.globalConfiguration.EntryPoints[entryPoint.Redirect.EntryPoint].Address)
+		}
+		replacement = protocol + "://$1" + match[0] + "$2"
+	}
+	rewrite, err := middlewares.NewRewrite(regex, replacement, true)
+	if err != nil {
+		return nil, err
+	}
+	log.Debugf("Creating entryPoint redirect %s -> %s : %s -> %s", entryPointName, entryPoint.Redirect.EntryPoint, regex, replacement)
+	negroni := negroni.New()
+	negroni.Use(rewrite)
+	return negroni, nil
+}
+
+func (server *Server) buildDefaultHTTPRouter() *mux.Router {
+	router := mux.NewRouter()
+	router.NotFoundHandler = http.HandlerFunc(notFoundHandler)
+	router.StrictSlash(true)
+	return router
+}
+
+func getRoute(any interface{}, rule string, value ...interface{}) (*mux.Route, error) {
+	switch rule {
+	case "PathStrip":
+		rule = "Path"
+	case "PathPrefixStrip":
+		rule = "PathPrefix"
+	}
+	inputs := make([]reflect.Value, len(value))
+	for i := range value {
+		inputs[i] = reflect.ValueOf(value[i])
+	}
+	method := reflect.ValueOf(any).MethodByName(rule)
+	if method.IsValid() {
+		return method.Call(inputs)[0].Interface().(*mux.Route), nil
+	}
+	return nil, errors.New("Method not found: " + rule)
+}
+
+func sortedFrontendNamesForConfig(configuration *types.Configuration) []string {
+	keys := []string{}
+
+	for key := range configuration.Frontends {
+		keys = append(keys, key)
+	}
+
+	sort.Strings(keys)
+
+	return keys
+}

static/.editorconfig

@@ -1,20 +0,0 @@
-# EditorConfig helps developers define and maintain consistent
-# coding styles between different editors and IDEs
-# editorconfig.org
-
-root = true
-
-[*]
-# Change these settings to your own preference
-indent_style = space
-indent_size = 2
-
-# We recommend you to keep these unchanged
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.md]
-trim_trailing_whitespace = false
-indent_size = 2

static/.gitignore

@@ -1,2 +0,0 @@
-node_modules
-# bower_components

static/.jshintignore

@@ -1,2 +0,0 @@
-node_modules
-bower_components

static/.jshintrc

@@ -1,120 +0,0 @@
-{
-    // JSHint Default Configuration File (as on JSHint website)
-    // See http://jshint.com/docs/ for more details
-
-    "maxerr"        : 500,       // {int} Maximum error before stopping (default:50)
-
-    // Enforcing
-    "bitwise"       : true,     // true: Prohibit bitwise operators (&, |, ^, etc.)
-    "camelcase"     : false,    // true: Identifiers must be in camelCase
-    "curly"         : true,     // true: Require {} for every new block or scope
-    "eqeqeq"        : true,     // true: Require triple equals (===) for comparison
-    "freeze"        : true,     // true: prohibits overwriting prototypes of native objects such as Array, Date etc.
-    "forin"         : true,     // true: Require filtering for..in loops with obj.hasOwnProperty()
-    "immed"         : false,    // true: Require immediate invocations to be wrapped in parens e.g. `(function () { } ());`
-    "indent"        : 4,        // {int} Number of spaces to use for indentation
-    "latedef"       : true,     // true: Require variables/functions to be defined before being used
-    "newcap"        : true,     // true: Require capitalization of all constructor functions e.g. `new F()`
-    "noarg"         : true,     // true: Prohibit use of `arguments.caller` and `arguments.callee`
-    "noempty"       : true,     // true: Prohibit use of empty blocks
-    "nonbsp"        : true,     // true: Prohibit "non-breaking whitespace" characters.
-    "nonew"         : false,    // true: Prohibit use of constructors for side-effects (without assignment)
-    "plusplus"      : false,    // true: Prohibit use of `++` & `--`
-    "quotmark"      : false,    // Quotation mark consistency:
-                                //   false    : do nothing (default)
-                                //   true     : ensure whatever is used is consistent
-                                //   "single" : require single quotes
-                                //   "double" : require double quotes
-    "regexp"        : true,     // Prohibit `.` and `[^...]` in regular expressions.
-    "undef"         : true,     // true: Require all non-global variables to be declared (prevents global leaks)
-    "unused"        : true,     // true: Require all defined variables be used
-    "strict"        : true,     // true: Requires all functions run in ES5 Strict Mode
-    "trailing"      : true,     // Prohibit trailing whitespaces.
-    "maxparams"     : false,    // {int} Max number of formal params allowed per function
-    "maxdepth"      : false,    // {int} Max depth of nested blocks (within functions)
-    "maxstatements" : false,    // {int} Max number statements per function
-    "maxcomplexity" : false,    // {int} Max cyclomatic complexity per function
-    "maxlen"        : false,    // {int} Max number of characters per line
-
-    // Relaxing
-    "asi"           : false,     // true: Tolerate Automatic Semicolon Insertion (no semicolons)
-    "boss"          : false,     // true: Tolerate assignments where comparisons would be expected
-    "debug"         : false,     // true: Allow debugger statements e.g. browser breakpoints.
-    "eqnull"        : false,     // true: Tolerate use of `== null`
-    //"es5"           : true,      // true: Allow ES5 syntax (ex: getters and setters) [default: true] if override to true -> generate error
-    "esnext"        : false,     // true: Allow ES.next (ES6) syntax (ex: `const`)
-    "moz"           : false,     // true: Allow Mozilla specific syntax (extends and overrides esnext features)
-                                 // (ex: `for each`, multiple try/catch, function expression…)
-    "evil"          : false,     // true: Tolerate use of `eval` and `new Function()`
-    "expr"          : false,     // true: Tolerate `ExpressionStatement` as Programs
-    "funcscope"     : false,     // true: Tolerate defining variables inside control statements
-    "globalstrict"  : false,     // true: Allow global "use strict" (also enables 'strict')
-    "iterator"      : false,     // true: Tolerate using the `__iterator__` property
-    "lastsemic"     : false,     // true: Tolerate omitting a semicolon for the last statement of a 1-line block
-    "laxbreak"      : true,      // true: Tolerate possibly unsafe line breakings
-    "laxcomma"      : true,      // true: Tolerate comma-first style coding
-    "loopfunc"      : false,     // true: Tolerate functions being defined in loops
-    "multistr"      : false,     // true: Tolerate multi-line strings
-    "noyield"       : false,     // true: Tolerate generator functions with no yield statement in them.
-    "notypeof"      : false,     // true: Tolerate invalid typeof operator values
-    "proto"         : false,     // true: Tolerate using the `__proto__` property
-    "scripturl"     : false,     // true: Tolerate script-targeted URLs
-    "shadow"        : false,     // true: Allows re-define variables later in code e.g. `var x=1; x=2;`
-    "smarttabs"     : false,     // Tolerate mixed tabs and spaces when the latter are used for alignment only.
-    "sub"           : false,     // true: Tolerate using `[]` notation when it can still be expressed in dot notation
-    "supernew"      : false,     // true: Tolerate `new function () { ... };` and `new Object;`
-    "validthis"     : false,     // true: Tolerate using this in a non-constructor function
-
-    // JSLint Legacy
-    "nomen"         : false,    // Prohibit use of initial or trailing underbars in names.
-    "onevar"        : false,    // Allow only one `var` statement per function.
-    "passfail"      : false,    // Stop on first error.
-    "white"         : false,    // Check against strict whitespace and indentation rules.
-
-    // Environments
-    "browser"       : true,     // Web Browser (window, document, etc)
-    //"browserify"    : false,    // Browserify (node.js code in the browser)
-    "couch"         : false,    // CouchDB
-    "devel"         : false,    // Development/debugging (alert, confirm, etc)
-    "dojo"          : false,    // Dojo Toolkit
-    "jasmine"       : true,     // Jasmine
-    "jquery"        : true,     // jQuery
-    "mocha"         : true,     // Mocha
-    "mootools"      : false,    // MooTools
-    "node"          : true,     // Node.js
-    "nonstandard"   : false,    // Widely adopted globals (escape, unescape, etc)
-    "prototypejs"   : false,    // Prototype and Scriptaculous
-    "qunit"         : false,    // QUnit
-    "rhino"         : false,    // Rhino
-    "shelljs"       : false,    // ShellJS
-    "worker"        : false,    // Web Workers
-    "wsh"           : false,    // Windows Scripting Host
-    "yui"           : false,    // Yahoo User Interface
-
-    // Custom Globals
-    // additional predefined global variables
-    "globals"       : {
-        "angular": false,
-        "require": false,
-        "process": false,
-        "module": false,
-        "__dirname": false,
-        "browser": false,
-        "repeater": false,
-        "element": false,
-        "inject": false,
-        "afterEach": false,
-        "beforeEach": false,
-        "confirm": false,
-        "describe": false,
-        "expect": false,
-        "it": false,
-        "jasmine": false,
-        "by": false,
-        "runs": false,
-        "spyOn": false,
-        "spyOnEvent": false,
-        "waitsFor": false,
-        "xdescribe": false
-    }
-}

static/app/core/health.resource.js

@@ -1,10 +0,0 @@
-(function () {
-  'use strict';
-
-  angular
-    .module('traefik.core.health', ['ngResource'])
-    .factory('Health', ['$resource', function ($resource) {
-      return $resource('/health');
-   }]);
-
-})();

static/app/sections/providers/backend-monitor/backend-monitor.controller.js

@@ -1,10 +0,0 @@
-(function () {
-  'use strict';
-
-  angular
-    .module('traefik.section.providers.backend-monitor')
-    .controller('BackendMonitorController', function () {
-
-    });
-
-})();

static/app/sections/providers/frontend-monitor/frontend-monitor.controller.js

@@ -1,10 +0,0 @@
-(function () {
-  'use strict';
-
-  angular
-    .module('traefik.section.providers.frontend-monitor')
-    .controller('FrontendMonitorController', function () {
-
-    });
-
-})();

static/app/traefik.js

@@ -1,6 +0,0 @@
-(function () {
-  'use strict';
-
-  angular.module('traefik', ['traefik.section']);
-
-})();

static/bower.json

@@ -1,26 +0,0 @@
-{
-  "name": "traefik",
-  "version": "1.0.0",
-  "homepage": "http://traefik.io",
-  "authors": [
-    "Fernandez Ludovic <ludovic.fernandez@zenika.com>"
-  ],
-  "description": "Front end for Træfɪk",
-  "main": "index.html",
-  "license": "MIT",
-  "ignore": [
-    "**/.*",
-    "node_modules",
-    "bower_components",
-    "test",
-    "tests"
-  ],
-  "dependencies": {
-    "angular": "angularjs#~1.4.7",
-    "bootstrap": "~3.3.5",
-    "angular-resource": "~1.4.7",
-    "angular-ui-router": "~0.2.15",
-    "angular-bootstrap": "~0.13.4",
-    "angular-nvd3": "~1.0.2"
-  }
-}

static/bower_components/angular-bootstrap/ui-bootstrap-csp.css

@@ -1,6 +0,0 @@
-/* Include this file in your html if you are using the CSP mode. */
-
-.ng-animate.item:not(.left):not(.right) {
-  -webkit-transition: 0s ease-in-out left;
-  transition: 0s ease-in-out left
-}