Add MaxConn field for the frontends config TOML

- This commit enables adding a MaxConn field on the frontends defined
for Sidecar via the TOML specified in the Filename field.

- Design discussed here: #7 (comment)
and here: #8 (comment)

Author: mihaitodor

configuration.go

@@ -336,7 +336,6 @@ func NewTraefikDefaultPointersConfiguration() *TraefikConfiguration {
 	defaultSidecar.Endpoint = "http://127.0.0.1:7777"
 	defaultSidecar.Filename = "sidecar.toml"
 	defaultSidecar.RefreshConn = flaeg.Duration(60 * time.Second)
-	defaultSidecar.MaxConns = 2000
 
 	//default Docker
 	var defaultDocker provider.Docker

provider/sidecar.go

@@ -23,10 +23,11 @@ import (
 )
 
 const (
-	method               = "wrr"
-	weight               = 0
-	sticky               = false
-	maxConnExtractorFunc = "request.host"
+	method                      = "wrr"
+	weight                      = 0
+	sticky                      = false
+	defaultMaxConnAmount        = 2000
+	defaultMaxConnExtractorFunc = "request.host"
 )
 
 var (
@@ -51,7 +52,15 @@ type Sidecar struct {
 	configurationChan chan<- types.ConfigMessage
 	RefreshConn       flaeg.Duration `description:"How often to refresh the connection to Sidecar backend"`
 	connTimer         *time.Timer
-	MaxConns          int64 `description:"Maximum number of connections allowed for each backend"`
+}
+
+type sidecarFrontend struct {
+	*types.Frontend
+	MaxConn *types.MaxConn `json:"maxConn,omitempty"`
+}
+
+type sidecarConfig struct {
+	Frontends map[string]*sidecarFrontend `json:"frontends,omitempty"`
 }
 
 type callback func(map[string][]*service.Service, error)
@@ -119,12 +128,32 @@ func (provider *Sidecar) Provide(configurationChan chan<- types.ConfigMessage, p
 
 func (provider *Sidecar) constructConfig(sidecarStates *catalog.ServicesState) (*types.Configuration, error) {
 	log.Infoln("loading sidecar config")
-	sidecarConfig := types.Configuration{Backends: provider.makeBackends(sidecarStates)}
-	var err error
-	sidecarConfig.Frontends, err = provider.makeFrontends()
+	sidecarConfig := types.Configuration{
+		Backends:  provider.makeBackends(sidecarStates),
+		Frontends: map[string]*types.Frontend{},
+	}
+
+	frontends, err := provider.makeFrontends()
 	if err != nil {
 		return nil, err
 	}
+
+	for name, frontend := range frontends {
+		sidecarConfig.Frontends[name] = frontend.Frontend
+
+		if backend, ok := sidecarConfig.Backends[name]; ok {
+			backend.MaxConn = frontend.MaxConn
+
+			if backend.MaxConn == nil {
+				backend.MaxConn = &types.MaxConn{
+					Amount:        defaultMaxConnAmount,
+					ExtractorFunc: defaultMaxConnExtractorFunc,
+				}
+			}
+
+		}
+	}
+
 	return &sidecarConfig, nil
 }
 
@@ -203,12 +232,13 @@ func (provider *Sidecar) callbackLoader(sidecarStates *catalog.ServicesState, er
 	provider.connTimer.Reset(time.Duration(provider.RefreshConn))
 }
 
-func (provider *Sidecar) makeFrontends() (map[string]*types.Frontend, error) {
-	configuration := new(types.Configuration)
+func (provider *Sidecar) makeFrontends() (map[string]*sidecarFrontend, error) {
+	configuration := new(sidecarConfig)
 	if _, err := toml.DecodeFile(provider.Filename, configuration); err != nil {
 		log.Errorf("Error reading file: %s", err)
 		return nil, err
 	}
+
 	return configuration.Frontends, nil
 }
 
@@ -223,10 +253,6 @@ func (provider *Sidecar) makeBackends(sidecarStates *catalog.ServicesState) map[
 				backend = &types.Backend{
 					LoadBalancer: &types.LoadBalancer{Method: method, Sticky: sticky},
 					Servers:      make(map[string]types.Server),
-					MaxConn: &types.MaxConn{
-						Amount:        provider.MaxConns,
-						ExtractorFunc: maxConnExtractorFunc,
-					},
 				}
 
 				sidecarBacks[svc.Name] = backend

provider/sidecar_test.go

@@ -85,7 +85,6 @@ func TestSidecar(t *testing.T) {
 		Convey("create backends", func() {
 			prov := Sidecar{
 				Endpoint: "http://some.dummy.service",
-				MaxConns: 10,
 			}
 
 			dummyState.AddServiceEntry(
@@ -106,13 +105,58 @@ func TestSidecar(t *testing.T) {
 			So(backs["web"].Servers["some-aws-host"].URL, ShouldEqual, "http://some-aws-host:8000")
 			So(backs["api"].Servers["another-aws-host"], ShouldBeZeroValue)
 
-			So(backs["web"].MaxConn.Amount, ShouldEqual, 10)
-			So(backs["web"].MaxConn.ExtractorFunc, ShouldEqual, "request.host")
-			So(backs["api"].MaxConn.Amount, ShouldEqual, 10)
-			So(backs["api"].MaxConn.ExtractorFunc, ShouldEqual, "request.host")
+			So(backs["web"].MaxConn, ShouldBeNil)
+			So(backs["api"].MaxConn, ShouldBeNil)
 
 		})
 
+		Convey("construct config", func() {
+			prov := Sidecar{
+				BaseProvider: BaseProvider{
+					Filename: "testdata/sidecar_testdata.toml",
+				},
+				Endpoint: "http://some.dummy.service",
+			}
+
+			dummyState.AddServiceEntry(
+				service.Service{
+					ID:       "008",
+					Name:     "api",
+					Hostname: "another-aws-host",
+					Status:   1,
+				},
+			)
+
+			dummyState.AddServiceEntry(
+				service.Service{
+					ID:       "009",
+					Name:     "sso",
+					Hostname: "yet-another-aws-host",
+					Status:   1,
+				},
+			)
+
+			states, err := prov.fetchState()
+			So(err, ShouldBeNil)
+
+			config, err := prov.constructConfig(states)
+			So(err, ShouldBeNil)
+
+			So(config.Frontends, ShouldContainKey, "web")
+			So(config.Frontends, ShouldContainKey, "api")
+			So(config.Frontends, ShouldNotContainKey, "sso")
+
+			So(config.Backends, ShouldContainKey, "web")
+			So(config.Backends, ShouldContainKey, "api")
+			So(config.Backends, ShouldContainKey, "sso")
+
+			So(config.Backends["web"].MaxConn.Amount, ShouldEqual, 10)
+			So(config.Backends["web"].MaxConn.ExtractorFunc, ShouldEqual, "client.ip")
+			So(config.Backends["api"].MaxConn.Amount, ShouldEqual, defaultMaxConnAmount)
+			So(config.Backends["api"].MaxConn.ExtractorFunc, ShouldEqual, defaultMaxConnExtractorFunc)
+			So(config.Backends["sso"].MaxConn, ShouldBeNil)
+		})
+
 		Convey("run Provide", func() {
 			prov := Sidecar{
 				BaseProvider: BaseProvider{
@@ -196,8 +240,8 @@ func TestSidecar(t *testing.T) {
 				},
 			)
 
-			// Unblock the second call to recycleConn() to receive the updated config
-			releaseWatch <- true
+			// Unblock the rest of the calls to recycleConn() to receive the updated config
+			close(releaseWatch)
 			configMsg = <-configMsgChan
 
 			So(configMsg.Configuration.Backends, ShouldContainKey, "api")
@@ -224,11 +268,13 @@ func TestSidecarMakeFrontend(t *testing.T) {
 			Endpoint: "http://some.dummy.service",
 		}
 
-		conf, err := prov.makeFrontends()
+		frontends, err := prov.makeFrontends()
 		So(err, ShouldEqual, nil)
-		So(conf["web"].PassHostHeader, ShouldEqual, true)
-		So(conf["web"].EntryPoints, ShouldResemble, []string{"http", "https"})
-		So(conf["web"].Routes["test_1"].Rule, ShouldEqual, "Host: some-aws-host")
+		So(frontends, ShouldContainKey, "web")
+		So(frontends, ShouldContainKey, "api")
+		So(frontends["web"].PassHostHeader, ShouldEqual, true)
+		So(frontends["web"].EntryPoints, ShouldResemble, []string{"http", "https"})
+		So(frontends["web"].Routes["test_1"].Rule, ShouldEqual, "Host: some-aws-host")
 
 		prov.Filename = "testdata/dummyfile.toml"
 		_, err = prov.makeFrontends()

provider/testdata/sidecar_testdata.toml

@@ -1,7 +1,13 @@
 [frontends]
     [frontends.web]
-    backend = "web"
-    passHostHeader = true
-    entrypoints = ["http","https"]
+        backend = "web"
+        passHostHeader = true
+        entrypoints = ["http","https"]
         [frontends.web.routes.test_1]
-        rule = "Host: some-aws-host"
+            rule = "Host: some-aws-host"
+        [frontends.web.maxconn]
+            amount = 10
+            extractorfunc = "client.ip"
+    [frontends.api]
+        backend = "api"
+        passHostHeader = true