Make Traefik health checks label-configurable with Marathon.

For the two existing health check parameters (path and interval), we add
support for Marathon labels.

Changes in detail:

- Extend the Marathon provider and template.
- Refactor Server.loadConfig to reduce duplication.
- Refactor the healthcheck package slightly to accommodate the changes
  and allow extending by future parameters.
- Update documentation.

server/server_test.go

@@ -0,0 +1,157 @@
+package server
+
+import (
+	"fmt"
+	"net/url"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/containous/traefik/healthcheck"
+	"github.com/containous/traefik/types"
+	"github.com/vulcand/oxy/roundrobin"
+)
+
+type testLoadBalancer struct{}
+
+func (lb *testLoadBalancer) RemoveServer(u *url.URL) error {
+	return nil
+}
+
+func (lb *testLoadBalancer) UpsertServer(u *url.URL, options ...roundrobin.ServerOption) error {
+	return nil
+}
+
+func (lb *testLoadBalancer) Servers() []*url.URL {
+	return []*url.URL{}
+}
+
+func TestServerLoadConfigHealthCheckOptions(t *testing.T) {
+	healthChecks := []*types.HealthCheck{
+		nil,
+		{
+			Path: "/path",
+		},
+	}
+
+	for _, lbMethod := range []string{"Wrr", "Drr"} {
+		for _, healthCheck := range healthChecks {
+			t.Run(fmt.Sprintf("%s/hc=%t", lbMethod, healthCheck != nil), func(t *testing.T) {
+				globalConfig := GlobalConfiguration{
+					EntryPoints: EntryPoints{
+						"http": &EntryPoint{},
+					},
+				}
+
+				dynamicConfigs := configs{
+					"config": &types.Configuration{
+						Frontends: map[string]*types.Frontend{
+							"frontend": {
+								EntryPoints: []string{"http"},
+								Backend:     "backend",
+							},
+						},
+						Backends: map[string]*types.Backend{
+							"backend": {
+								Servers: map[string]types.Server{
+									"server": {
+										URL: "http://localhost",
+									},
+								},
+								LoadBalancer: &types.LoadBalancer{
+									Method: lbMethod,
+								},
+								HealthCheck: healthCheck,
+							},
+						},
+					},
+				}
+
+				srv := NewServer(globalConfig)
+				if _, err := srv.loadConfig(dynamicConfigs, globalConfig); err != nil {
+					t.Fatalf("got error: %s", err)
+				}
+
+				wantNumHealthCheckBackends := 0
+				if healthCheck != nil {
+					wantNumHealthCheckBackends = 1
+				}
+				gotNumHealthCheckBackends := len(healthcheck.GetHealthCheck().Backends)
+				if gotNumHealthCheckBackends != wantNumHealthCheckBackends {
+					t.Errorf("got %d health check backends, want %d", gotNumHealthCheckBackends, wantNumHealthCheckBackends)
+				}
+			})
+		}
+	}
+}
+
+func TestServerParseHealthCheckOptions(t *testing.T) {
+	lb := &testLoadBalancer{}
+
+	tests := []struct {
+		desc     string
+		hc       *types.HealthCheck
+		wantOpts *healthcheck.Options
+	}{
+		{
+			desc:     "nil health check",
+			hc:       nil,
+			wantOpts: nil,
+		},
+		{
+			desc: "empty path",
+			hc: &types.HealthCheck{
+				Path: "",
+			},
+			wantOpts: nil,
+		},
+		{
+			desc: "unparseable interval",
+			hc: &types.HealthCheck{
+				Path:     "/path",
+				Interval: "unparseable",
+			},
+			wantOpts: &healthcheck.Options{
+				Path:     "/path",
+				Interval: healthcheck.DefaultInterval,
+				LB:       lb,
+			},
+		},
+		{
+			desc: "sub-zero interval",
+			hc: &types.HealthCheck{
+				Path:     "/path",
+				Interval: "-15s",
+			},
+			wantOpts: &healthcheck.Options{
+				Path:     "/path",
+				Interval: healthcheck.DefaultInterval,
+				LB:       lb,
+			},
+		},
+		{
+			desc: "parseable interval",
+			hc: &types.HealthCheck{
+				Path:     "/path",
+				Interval: "5m",
+			},
+			wantOpts: &healthcheck.Options{
+				Path:     "/path",
+				Interval: 5 * time.Minute,
+				LB:       lb,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			gotOpts := parseHealthCheckOptions(lb, "backend", test.hc)
+			if !reflect.DeepEqual(gotOpts, test.wantOpts) {
+				t.Errorf("got health check options %+v, want %+v", gotOpts, test.wantOpts)
+			}
+		})
+	}
+}