Merge pull request #109 from polds/docker/clean-frontend

Replace [ and ] in frontend names

.gitignore

@@ -5,5 +5,5 @@ log
 *.iml
 traefik
 traefik.toml
-
+*.test
 vendor/

Makefile

@@ -3,7 +3,8 @@
 TRAEFIK_ENVS := \
 	-e OS_ARCH_ARG \
 	-e OS_PLATFORM_ARG \
-	-e TESTFLAGS
+	-e TESTFLAGS \
+	-e CIRCLECI
 
 BIND_DIR := "dist"
 TRAEFIK_MOUNT := -v "$(CURDIR)/$(BIND_DIR):/go/src/github.com/emilevauge/traefik/$(BIND_DIR)"
@@ -39,7 +40,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
@@ -47,6 +48,9 @@ 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 .
 

adapters.go

@@ -4,40 +4,37 @@ Copyright
 package main
 
 import (
+	"net/http"
+
 	log "github.com/Sirupsen/logrus"
 	"github.com/gorilla/mux"
-	"github.com/mailgun/oxy/utils"
-	"net/http"
 )
 
+// 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)
 }
 
+// LoadDefaultConfig returns a default gorrilla.mux router from the specified configuration.
 func LoadDefaultConfig(globalConfiguration *GlobalConfiguration) *mux.Router {
 	router := mux.NewRouter()
 	router.NotFoundHandler = http.HandlerFunc(notFoundHandler)

build.Dockerfile

@@ -4,6 +4,7 @@ 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

configuration.go

@@ -1,12 +1,16 @@
 package main
 
 import (
+	fmtlog "log"
 	"time"
 
+	"github.com/BurntSushi/toml"
 	"github.com/emilevauge/traefik/provider"
 	"github.com/emilevauge/traefik/types"
 )
 
+// 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
@@ -25,6 +29,7 @@ type GlobalConfiguration struct {
 	Boltdb                    *provider.BoltDb
 }
 
+// NewGlobalConfiguration returns a GlobalConfiguration with default values.
 func NewGlobalConfiguration() *GlobalConfiguration {
 	globalConfiguration := new(GlobalConfiguration)
 	// default values
@@ -36,4 +41,13 @@ func NewGlobalConfiguration() *GlobalConfiguration {
 	return globalConfiguration
 }
 
+// LoadFileConfig returns a GlobalConfiguration from reading the specified file (a toml file).
+func LoadFileConfig(file string) *GlobalConfiguration {
+	configuration := NewGlobalConfiguration()
+	if _, err := toml.DecodeFile(file, configuration); err != nil {
+		fmtlog.Fatalf("Error reading file: %s", err)
+	}
+	return configuration
+}
+
 type configs map[string]*types.Configuration

integration/basic_test.go

@@ -10,6 +10,9 @@ import (
 	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()
@@ -37,6 +40,7 @@ func (s *SimpleSuite) TestSimpleDefaultConfig(c *check.C) {
 	cmd := exec.Command(traefikBinary, "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
@@ -45,7 +49,18 @@ func (s *SimpleSuite) TestSimpleDefaultConfig(c *check.C) {
 	// 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)
+}
+
+func (s *SimpleSuite) TestWithWebConfig(c *check.C) {
+	cmd := exec.Command(traefikBinary, "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_test.go

@@ -13,6 +13,7 @@ func (s *ConsulSuite) TestSimpleConfiguration(c *check.C) {
 	cmd := exec.Command(traefikBinary, "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
@@ -21,7 +22,4 @@ func (s *ConsulSuite) TestSimpleConfiguration(c *check.C) {
 	// 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)
 }

integration/docker_test.go

@@ -1,15 +1,140 @@
 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)
@@ -17,15 +142,110 @@ func (s *DockerSuite) TestSimpleConfiguration(c *check.C) {
 	cmd := exec.Command(traefikBinary, 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/")
 
+	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, 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/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, 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/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, 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/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/file_test.go

@@ -13,6 +13,7 @@ func (s *FileSuite) TestSimpleConfiguration(c *check.C) {
 	cmd := exec.Command(traefikBinary, "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/")
@@ -20,9 +21,6 @@ func (s *FileSuite) TestSimpleConfiguration(c *check.C) {
 	// 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
@@ -30,6 +28,7 @@ func (s *FileSuite) TestSimpleConfigurationNoPanic(c *check.C) {
 	cmd := exec.Command(traefikBinary, "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/")
@@ -37,7 +36,4 @@ func (s *FileSuite) TestSimpleConfigurationNoPanic(c *check.C) {
 	// 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/simple_web.toml

@@ -0,0 +1,5 @@
+logLevel = "DEBUG"
+
+[web]
+
+address = ":8080"

integration/integration_test.go

@@ -32,9 +32,6 @@ func init() {
 
 var traefikBinary = "../dist/traefik"
 
-// SimpleSuite
-type SimpleSuite struct{ BaseSuite }
-
 // File test suites
 type FileSuite struct{ BaseSuite }
 
@@ -44,17 +41,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 }
 

integration/marathon_test.go

@@ -13,6 +13,7 @@ func (s *MarathonSuite) TestSimpleConfiguration(c *check.C) {
 	cmd := exec.Command(traefikBinary, "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
@@ -21,7 +22,4 @@ func (s *MarathonSuite) TestSimpleConfiguration(c *check.C) {
 	// 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)
 }

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/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/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,

provider/boltdb.go

@@ -2,6 +2,7 @@ package provider
 
 import "github.com/emilevauge/traefik/types"
 
+// BoltDb holds configurations of the BoltDb provider.
 type BoltDb struct {
 	Watch      bool
 	Endpoint   string
@@ -10,6 +11,8 @@ type BoltDb struct {
 	KvProvider *Kv
 }
 
+// Provide allows the provider to provide configurations to traefik
+// using the given configuration channel.
 func (provider *BoltDb) Provide(configurationChan chan<- types.ConfigMessage) error {
 	provider.KvProvider = NewBoltDbProvider(provider)
 	return provider.KvProvider.provide(configurationChan)

provider/consul.go

@@ -2,6 +2,7 @@ package provider
 
 import "github.com/emilevauge/traefik/types"
 
+// Consul holds configurations of the Consul provider.
 type Consul struct {
 	Watch      bool
 	Endpoint   string
@@ -10,6 +11,8 @@ type Consul struct {
 	KvProvider *Kv
 }
 
+// Provide allows the provider to provide configurations to traefik
+// using the given configuration channel.
 func (provider *Consul) Provide(configurationChan chan<- types.ConfigMessage) error {
 	provider.KvProvider = NewConsulProvider(provider)
 	return provider.KvProvider.provide(configurationChan)

provider/docker.go

@@ -18,6 +18,7 @@ import (
 	"github.com/fsouza/go-dockerclient"
 )
 
+// Docker holds configurations of the Docker provider.
 type Docker struct {
 	Watch    bool
 	Endpoint string
@@ -25,51 +26,54 @@ type Docker struct {
 	Domain   string
 }
 
+// Provide allows the provider to provide configurations to traefik
+// using the given configuration channel.
 func (provider *Docker) Provide(configurationChan chan<- types.ConfigMessage) error {
-	if dockerClient, err := docker.NewClient(provider.Endpoint); err != nil {
+
+	dockerClient, err := docker.NewClient(provider.Endpoint)
+	if 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 <- types.ConfigMessage{"docker", configuration}
-							}
+	}
+	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 <- types.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 <- types.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 <- types.ConfigMessage{"docker", configuration}
 	return nil
 }
 
@@ -147,7 +151,8 @@ func (provider *Docker) loadDockerConfig(dockerClient *docker.Client) *types.Con
 			return false
 		}
 
-		if _, err := provider.getLabels(container, []string{"traefik.frontend.rule", "traefik.frontend.value"}); err != nil {
+		labels, err := provider.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
 		}
@@ -204,6 +209,9 @@ func (provider *Docker) loadDockerConfig(dockerClient *docker.Client) *types.Con
 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)
 }
 
@@ -221,17 +229,23 @@ func (provider *Docker) getLabel(container docker.Container, label string) (stri
 }
 
 func (provider *Docker) getLabels(container docker.Container, labels []string) (map[string]string, error) {
+	var globalErr 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
+		foundLabel, err := provider.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, nil
+	return foundLabels, globalErr
 }
 
+// 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 := provider.getLabel(container, "traefik.frontend.value"); err == nil {
 		return label
@@ -239,6 +253,8 @@ func (provider *Docker) GetFrontendValue(container docker.Container) string {
 	return provider.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 := provider.getLabel(container, "traefik.frontend.rule"); err == nil {
 		return label

provider/etcd.go

@@ -2,6 +2,7 @@ package provider
 
 import "github.com/emilevauge/traefik/types"
 
+// Etcd holds configurations of the Etcd provider.
 type Etcd struct {
 	Watch      bool
 	Endpoint   string
@@ -10,6 +11,8 @@ type Etcd struct {
 	KvProvider *Kv
 }
 
+// Provide allows the provider to provide configurations to traefik
+// using the given configuration channel.
 func (provider *Etcd) Provide(configurationChan chan<- types.ConfigMessage) error {
 	provider.KvProvider = NewEtcdProvider(provider)
 	return provider.KvProvider.provide(configurationChan)

provider/file.go

@@ -11,11 +11,14 @@ import (
 	"gopkg.in/fsnotify.v1"
 )
 
+// File holds configurations of the File provider.
 type File struct {
 	Watch    bool
 	Filename string
 }
 
+// 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 {
@@ -39,7 +42,7 @@ func (provider *File) Provide(configurationChan chan<- types.ConfigMessage) erro
 				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 <- types.ConfigMessage{"file", configuration}
 						}
@@ -56,12 +59,12 @@ func (provider *File) Provide(configurationChan chan<- types.ConfigMessage) erro
 		}
 	}
 
-	configuration := provider.LoadFileConfig(file.Name())
+	configuration := provider.loadFileConfig(file.Name())
 	configurationChan <- types.ConfigMessage{"file", configuration}
 	return nil
 }
 
-func (provider *File) LoadFileConfig(filename string) *types.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)

provider/kv.go

@@ -1,6 +1,4 @@
-/*
-Copyright
-*/
+// Package provider holds the different provider implementation.
 package provider
 
 import (
@@ -23,6 +21,7 @@ import (
 	"github.com/emilevauge/traefik/types"
 )
 
+// Kv holds common configurations of key-value providers.
 type Kv struct {
 	Watch     bool
 	Endpoint  string
@@ -32,6 +31,7 @@ type Kv struct {
 	kvclient  store.Store
 }
 
+// NewConsulProvider returns a Consul provider.
 func NewConsulProvider(provider *Consul) *Kv {
 	kvProvider := new(Kv)
 	kvProvider.Watch = provider.Watch
@@ -42,6 +42,7 @@ func NewConsulProvider(provider *Consul) *Kv {
 	return kvProvider
 }
 
+// NewEtcdProvider returns a Etcd provider.
 func NewEtcdProvider(provider *Etcd) *Kv {
 	kvProvider := new(Kv)
 	kvProvider.Watch = provider.Watch
@@ -52,6 +53,7 @@ func NewEtcdProvider(provider *Etcd) *Kv {
 	return kvProvider
 }
 
+// NewZkProvider returns a Zookepper provider.
 func NewZkProvider(provider *Zookepper) *Kv {
 	kvProvider := new(Kv)
 	kvProvider.Watch = provider.Watch
@@ -62,6 +64,7 @@ func NewZkProvider(provider *Zookepper) *Kv {
 	return kvProvider
 }
 
+// NewBoltDbProvider returns a BoldDb provider.
 func NewBoltDbProvider(provider *BoltDb) *Kv {
 	kvProvider := new(Kv)
 	kvProvider.Watch = provider.Watch

provider/marathon.go

@@ -15,15 +15,18 @@ import (
 	"github.com/gambol99/go-marathon"
 )
 
+// Marathon holds configuration of the Marathon provider.
 type Marathon struct {
 	Watch            bool
 	Endpoint         string
-	marathonClient   marathon.Marathon
 	Domain           string
 	Filename         string
 	NetworkInterface string
+	marathonClient   marathon.Marathon
 }
 
+// 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
@@ -238,6 +241,8 @@ func (provider *Marathon) getEscapedName(name string) string {
 	return strings.Replace(name, "/", "", -1)
 }
 
+// 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
@@ -245,6 +250,8 @@ func (provider *Marathon) GetFrontendValue(application marathon.Application) str
 	return provider.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

provider/provider.go

@@ -2,6 +2,9 @@ package provider
 
 import "github.com/emilevauge/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
 }

provider/zk.go

@@ -2,6 +2,7 @@ package provider
 
 import "github.com/emilevauge/traefik/types"
 
+// Zookepper holds configurations of the Zookepper provider.
 type Zookepper struct {
 	Watch      bool
 	Endpoint   string
@@ -10,6 +11,8 @@ type Zookepper struct {
 	KvProvider *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.KvProvider = NewZkProvider(provider)
 	return provider.KvProvider.provide(configurationChan)

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

traefik.go

@@ -14,7 +14,6 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/BurntSushi/toml"
 	log "github.com/Sirupsen/logrus"
 	"github.com/codegangsta/negroni"
 	"github.com/emilevauge/traefik/middlewares"
@@ -266,20 +265,20 @@ func prepareServer(router *mux.Router, globalConfiguration *GlobalConfiguration,
 				Handler:   negroni,
 				TLSConfig: tlsConfig,
 			}), nil
-	} else {
-		server, err := oldServer.HijackListener(&http.Server{
-			Addr:    globalConfiguration.Port,
-			Handler: negroni,
-		}, tlsConfig)
-		if err != nil {
-			log.Fatalf("Error hijacking server %s", err)
-			return nil, err
-		} else {
-			return server, nil
-		}
 	}
+	server, err := oldServer.HijackListener(&http.Server{
+		Addr:    globalConfiguration.Port,
+		Handler: negroni,
+	}, tlsConfig)
+	if err != nil {
+		log.Fatalf("Error hijacking server %s", err)
+		return nil, err
+	}
+	return server, nil
 }
 
+// LoadConfig returns a new gorrilla.mux Route from the specified global configuration and the dynamic
+// provider configurations.
 func LoadConfig(configurations configs, globalConfiguration *GlobalConfiguration) (*mux.Router, error) {
 	router := mux.NewRouter()
 	router.NotFoundHandler = http.HandlerFunc(notFoundHandler)
@@ -346,13 +345,15 @@ func LoadConfig(configurations configs, globalConfiguration *GlobalConfiguration
 			newRoute.Handler(backends[frontend.Backend])
 			err := newRoute.GetError()
 			if err != nil {
-				log.Error("Error building route: %s", err)
+				log.Errorf("Error building route: %s", err)
 			}
 		}
 	}
 	return router, nil
 }
 
+// Invoke calls the specified method with the specified arguments on the specified interface.
+// It uses the go(lang) reflect package.
 func Invoke(any interface{}, name string, args ...interface{}) []reflect.Value {
 	inputs := make([]reflect.Value, len(args))
 	for i := range args {
@@ -360,11 +361,3 @@ func Invoke(any interface{}, name string, args ...interface{}) []reflect.Value {
 	}
 	return reflect.ValueOf(any).MethodByName(name).Call(inputs)
 }
-
-func LoadFileConfig(file string) *GlobalConfiguration {
-	configuration := NewGlobalConfiguration()
-	if _, err := toml.DecodeFile(file, configuration); err != nil {
-		fmtlog.Fatalf("Error reading file: %s", err)
-	}
-	return configuration
-}

types/types.go

@@ -5,43 +5,43 @@ import (
 	"strings"
 )
 
-// Backend configuration
+// Backend holds backend configuration.
 type Backend struct {
 	Servers        map[string]Server `json:"servers,omitempty"`
 	CircuitBreaker *CircuitBreaker   `json:"circuitBreaker,omitempty"`
 	LoadBalancer   *LoadBalancer     `json:"loadBalancer,omitempty"`
 }
 
-// LoadBalancer configuration
+// LoadBalancer holds load balancing configuration.
 type LoadBalancer struct {
 	Method string `json:"method,omitempty"`
 }
 
-// CircuitBreaker configuration
+// CircuitBreaker holds circuit breaker configuration.
 type CircuitBreaker struct {
 	Expression string `json:"expression,omitempty"`
 }
 
-// Server configuration
+// Server holds server configuration.
 type Server struct {
 	URL    string `json:"url,omitempty"`
 	Weight int    `json:"weight,omitempty"`
 }
 
-// Route configuration
+// Route holds route configuration.
 type Route struct {
 	Rule  string `json:"rule,omitempty"`
 	Value string `json:"value,omitempty"`
 }
 
-// Frontend configuration
+// Frontend holds frontend configuration.
 type Frontend struct {
 	Backend        string           `json:"backend,omitempty"`
 	Routes         map[string]Route `json:"routes,omitempty"`
 	PassHostHeader bool             `json:"passHostHeader,omitempty"`
 }
 
-// Load Balancer Method
+// LoadBalancerMethod holds the method of load balancing to use.
 type LoadBalancerMethod uint8
 
 const (
@@ -56,6 +56,7 @@ var loadBalancerMethodNames = []string{
 	"Drr",
 }
 
+// NewLoadBalancerMethod create a new LoadBalancerMethod from a given LoadBalancer.
 func NewLoadBalancerMethod(loadBalancer *LoadBalancer) (LoadBalancerMethod, error) {
 	if loadBalancer != nil {
 		for i, name := range loadBalancerMethodNames {
@@ -67,14 +68,16 @@ func NewLoadBalancerMethod(loadBalancer *LoadBalancer) (LoadBalancerMethod, erro
 	return Wrr, ErrInvalidLoadBalancerMethod
 }
 
+// ErrInvalidLoadBalancerMethod is thrown when the specified load balancing method is invalid.
 var ErrInvalidLoadBalancerMethod = errors.New("Invalid method, using default")
 
-// Configuration of a provider
+// Configuration of a provider.
 type Configuration struct {
 	Backends  map[string]*Backend  `json:"backends,omitempty"`
 	Frontends map[string]*Frontend `json:"frontends,omitempty"`
 }
 
+// ConfigMessage hold configuration information exchanged between parts of traefik.
 type ConfigMessage struct {
 	ProviderName  string
 	Configuration *Configuration

version.go

@@ -1,6 +1,8 @@
 package main
 
 var (
-	Version   = ""
+	// Version holds the current version of traefik.
+	Version = ""
+	// BuildDate holds the build date of traefik.
 	BuildDate = ""
 )

web.go

@@ -14,6 +14,8 @@ import (
 	"github.com/unrolled/render"
 )
 
+// WebProvider is a provider.Provider implementation that provides the UI.
+// FIXME to be handled another way.
 type WebProvider struct {
 	Address           string
 	CertFile, KeyFile string
@@ -25,6 +27,8 @@ var (
 	})
 )
 
+// Provide allows the provider to provide configurations to traefik
+// using the given configuration channel.
 func (provider *WebProvider) Provide(configurationChan chan<- types.ConfigMessage) error {
 	systemRouter := mux.NewRouter()