- {{range $keyFrontends, $valueFrontends := .Configuration.Frontends}}
+ {{range $keyProviders, $valueProviders := .Configurations}}
+ {{range $keyFrontends, $valueFrontends := $valueProviders.Frontends}}
- {{range $keyBackends, $valueBackends := .Configuration.Backends}}
+ {{range $keyProviders, $valueProviders := .Configurations}}
+ {{range $keyBackends, $valueBackends := $valueProviders.Backends}}
-
{{$keyBackends}}
+
{{$keyBackends}}({{$keyProviders}})
{{with $valueBackends.LoadBalancer}}
@@ -87,6 +90,7 @@
{{end}}
+ {{end}}
diff --git a/traefik.go b/traefik.go
index 1a0b8ede7..00a2ae8a4 100644
--- a/traefik.go
+++ b/traefik.go
@@ -28,24 +28,31 @@ import (
)
var (
- globalConfigFile = kingpin.Arg("conf", "Main configration file.").Default("traefik.toml").String()
- currentConfiguration = new(Configuration)
- metrics = stats.New()
- oxyLogger = &OxyLogger{}
- templatesRenderer = render.New(render.Options{
+ globalConfigFile = kingpin.Arg("conf", "Main configration file.").Default("traefik.toml").String()
+ currentConfigurations = make(configs)
+ metrics = stats.New()
+ oxyLogger = &OxyLogger{}
+ templatesRenderer = render.New(render.Options{
Directory: "templates",
Asset: Asset,
AssetNames: AssetNames,
})
)
+type configMessage struct {
+ providerName string
+ configuration *Configuration
+}
+
+type configs map[string]*Configuration
+
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
kingpin.Parse()
fmtlog.SetFlags(fmtlog.Lshortfile | fmtlog.LstdFlags)
var srv *manners.GracefulServer
var configurationRouter *mux.Router
- var configurationChan = make(chan *Configuration, 10)
+ var configurationChan = make(chan configMessage, 10)
defer close(configurationChan)
var sigs = make(chan os.Signal, 1)
defer close(sigs)
@@ -84,17 +91,25 @@ func main() {
// listen new configurations from providers
go func() {
+
for {
- configuration := <-configurationChan
- log.Infof("Configuration receveived %+v", configuration)
- if configuration == nil {
+ configMsg := <-configurationChan
+ log.Infof("Configuration receveived from provider %v: %+v", configMsg.providerName, configMsg.configuration)
+ if configMsg.configuration == nil {
log.Info("Skipping empty configuration")
- } else if reflect.DeepEqual(currentConfiguration, configuration) {
+ } else if reflect.DeepEqual(currentConfigurations[configMsg.providerName], configMsg.configuration) {
log.Info("Skipping same configuration")
} else {
- newConfigurationRouter, err := LoadConfig(configuration, globalConfiguration)
+ // Copy configurations to new map so we don't change current if LoadConfig fails
+ newConfigurations := make(configs)
+ for k, v := range currentConfigurations {
+ newConfigurations[k] = v
+ }
+ newConfigurations[configMsg.providerName] = configMsg.configuration
+
+ newConfigurationRouter, err := LoadConfig(newConfigurations, globalConfiguration)
if err == nil {
- currentConfiguration = configuration
+ currentConfigurations = newConfigurations
configurationRouter = newConfigurationRouter
oldServer := srv
newsrv := prepareServer(configurationRouter, globalConfiguration, oldServer, loggerMiddleware, metrics)
@@ -210,69 +225,71 @@ func prepareServer(router *mux.Router, globalConfiguration *GlobalConfiguration,
}
}
-func LoadConfig(configuration *Configuration, globalConfiguration *GlobalConfiguration) (*mux.Router, error) {
+func LoadConfig(configurations configs, globalConfiguration *GlobalConfiguration) (*mux.Router, error) {
router := mux.NewRouter()
router.NotFoundHandler = http.HandlerFunc(notFoundHandler)
backends := map[string]http.Handler{}
- for frontendName, frontend := range configuration.Frontends {
- log.Debugf("Creating frontend %s", frontendName)
- fwd, _ := forward.New(forward.Logger(oxyLogger))
- newRoute := router.NewRoute().Name(frontendName)
- for routeName, route := range frontend.Routes {
- log.Debugf("Creating route %s %s:%s", routeName, route.Rule, route.Value)
- newRouteReflect := Invoke(newRoute, route.Rule, route.Value)
- newRoute = newRouteReflect[0].Interface().(*mux.Route)
- }
- if backends[frontend.Backend] == nil {
- log.Debugf("Creating backend %s", frontend.Backend)
- var lb http.Handler
- rr, _ := roundrobin.New(fwd)
- lbMethod, err := NewLoadBalancerMethod(configuration.Backends[frontend.Backend].LoadBalancer)
- if err != nil {
- configuration.Backends[frontend.Backend].LoadBalancer = &LoadBalancer{Method: "wrr"}
+ for _, configuration := range configurations {
+ for frontendName, frontend := range configuration.Frontends {
+ log.Debugf("Creating frontend %s", frontendName)
+ fwd, _ := forward.New(forward.Logger(oxyLogger))
+ newRoute := router.NewRoute().Name(frontendName)
+ for routeName, route := range frontend.Routes {
+ log.Debugf("Creating route %s %s:%s", routeName, route.Rule, route.Value)
+ newRouteReflect := Invoke(newRoute, route.Rule, route.Value)
+ newRoute = newRouteReflect[0].Interface().(*mux.Route)
}
- switch lbMethod {
- case 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 %s", serverName, url.String())
- rebalancer.UpsertServer(url, roundrobin.Weight(server.Weight))
+ if backends[frontend.Backend] == nil {
+ log.Debugf("Creating backend %s", frontend.Backend)
+ var lb http.Handler
+ rr, _ := roundrobin.New(fwd)
+ lbMethod, err := NewLoadBalancerMethod(configuration.Backends[frontend.Backend].LoadBalancer)
+ if err != nil {
+ configuration.Backends[frontend.Backend].LoadBalancer = &LoadBalancer{Method: "wrr"}
}
- case wrr:
- log.Debugf("Creating load-balancer wrr")
- lb = rr
- for serverName, server := range configuration.Backends[frontend.Backend].Servers {
- url, err := url.Parse(server.URL)
- if err != nil {
- return nil, err
+ switch lbMethod {
+ case 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 %s", serverName, url.String())
+ rebalancer.UpsertServer(url, roundrobin.Weight(server.Weight))
+ }
+ case wrr:
+ log.Debugf("Creating load-balancer wrr")
+ lb = 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 %s", serverName, url.String())
+ rr.UpsertServer(url, roundrobin.Weight(server.Weight))
}
- log.Debugf("Creating server %s %s", serverName, url.String())
- 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)))
+ 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 {
- negroni.UseHandler(lb)
+ log.Debugf("Reusing backend %s", frontend.Backend)
}
- backends[frontend.Backend] = negroni
- } else {
- log.Debugf("Reusing backend %s", frontend.Backend)
- }
- // stream.New(backends[frontend.Backend], stream.Retry("IsNetworkError() && Attempts() <= " + strconv.Itoa(globalConfiguration.Replay)), stream.Logger(oxyLogger))
+ // stream.New(backends[frontend.Backend], stream.Retry("IsNetworkError() && Attempts() <= " + strconv.Itoa(globalConfiguration.Replay)), stream.Logger(oxyLogger))
- newRoute.Handler(backends[frontend.Backend])
- err := newRoute.GetError()
- if err != nil {
- log.Error("Error building route: %s", err)
+ newRoute.Handler(backends[frontend.Backend])
+ err := newRoute.GetError()
+ if err != nil {
+ log.Error("Error building route: %s", err)
+ }
}
}
return router, nil
diff --git a/web.go b/web.go
index 1151ceeb3..9e80dfafa 100644
--- a/web.go
+++ b/web.go
@@ -17,33 +17,41 @@ type WebProvider struct {
}
type Page struct {
- Configuration Configuration
+ Configurations configs
}
-func (provider *WebProvider) Provide(configurationChan chan<- *Configuration) {
+func (provider *WebProvider) Provide(configurationChan chan<- configMessage) {
systemRouter := mux.NewRouter()
systemRouter.Methods("GET").Path("/").Handler(http.HandlerFunc(GetHTMLConfigHandler))
systemRouter.Methods("GET").Path("/health").Handler(http.HandlerFunc(GetHealthHandler))
systemRouter.Methods("GET").Path("/api").Handler(http.HandlerFunc(GetConfigHandler))
- systemRouter.Methods("PUT").Path("/api").Handler(http.HandlerFunc(
+ systemRouter.Methods("GET").Path("/api/{provider}").Handler(http.HandlerFunc(GetConfigHandler))
+ systemRouter.Methods("PUT").Path("/api/{provider}").Handler(http.HandlerFunc(
func(rw http.ResponseWriter, r *http.Request) {
+ vars := mux.Vars(r)
+ if vars["provider"] != "web" {
+ rw.WriteHeader(http.StatusBadRequest)
+ fmt.Fprintf(rw, "Only 'web' provider can be updated through the REST API")
+ return
+ }
+
configuration := new(Configuration)
b, _ := ioutil.ReadAll(r.Body)
err := json.Unmarshal(b, configuration)
if err == nil {
- configurationChan <- configuration
+ configurationChan <- configMessage{"web", configuration}
GetConfigHandler(rw, r)
} else {
log.Errorf("Error parsing configuration %+v", err)
http.Error(rw, fmt.Sprintf("%+v", err), http.StatusBadRequest)
}
}))
- systemRouter.Methods("GET").Path("/api/backends").Handler(http.HandlerFunc(GetBackendsHandler))
- systemRouter.Methods("GET").Path("/api/backends/{backend}").Handler(http.HandlerFunc(GetBackendHandler))
- systemRouter.Methods("GET").Path("/api/backends/{backend}/servers").Handler(http.HandlerFunc(GetServersHandler))
- systemRouter.Methods("GET").Path("/api/backends/{backend}/servers/{server}").Handler(http.HandlerFunc(GetServerHandler))
- systemRouter.Methods("GET").Path("/api/frontends").Handler(http.HandlerFunc(GetFrontendsHandler))
- systemRouter.Methods("GET").Path("/api/frontends/{frontend}").Handler(http.HandlerFunc(GetFrontendHandler))
+ systemRouter.Methods("GET").Path("/api/{provider}/backends").Handler(http.HandlerFunc(GetBackendsHandler))
+ systemRouter.Methods("GET").Path("/api/{provider}/backends/{backend}").Handler(http.HandlerFunc(GetBackendHandler))
+ systemRouter.Methods("GET").Path("/api/{provider}/backends/{backend}/servers").Handler(http.HandlerFunc(GetServersHandler))
+ systemRouter.Methods("GET").Path("/api/{provider}/backends/{backend}/servers/{server}").Handler(http.HandlerFunc(GetServerHandler))
+ systemRouter.Methods("GET").Path("/api/{provider}/frontends").Handler(http.HandlerFunc(GetFrontendsHandler))
+ systemRouter.Methods("GET").Path("/api/{provider}/frontends/{frontend}").Handler(http.HandlerFunc(GetFrontendHandler))
systemRouter.Methods("GET").PathPrefix("/static/").Handler(http.StripPrefix("/static/", http.FileServer(&assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir, Prefix: "static"})))
go func() {
@@ -62,11 +70,11 @@ func (provider *WebProvider) Provide(configurationChan chan<- *Configuration) {
}
func GetConfigHandler(rw http.ResponseWriter, r *http.Request) {
- templatesRenderer.JSON(rw, http.StatusOK, currentConfiguration)
+ templatesRenderer.JSON(rw, http.StatusOK, currentConfigurations)
}
func GetHTMLConfigHandler(response http.ResponseWriter, request *http.Request) {
- templatesRenderer.HTML(response, http.StatusOK, "configuration", Page{Configuration: *currentConfiguration})
+ templatesRenderer.HTML(response, http.StatusOK, "configuration", Page{Configurations: currentConfigurations})
}
func GetHealthHandler(rw http.ResponseWriter, r *http.Request) {
@@ -74,54 +82,76 @@ func GetHealthHandler(rw http.ResponseWriter, r *http.Request) {
}
func GetBackendsHandler(rw http.ResponseWriter, r *http.Request) {
- templatesRenderer.JSON(rw, http.StatusOK, currentConfiguration.Backends)
+ vars := mux.Vars(r)
+ providerId := vars["provider"]
+ if provider, ok := currentConfigurations[providerId]; ok {
+ templatesRenderer.JSON(rw, http.StatusOK, provider.Backends)
+ } else {
+ http.NotFound(rw, r)
+ }
}
func GetBackendHandler(rw http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
- id := vars["backend"]
- if backend, ok := currentConfiguration.Backends[id]; ok {
- templatesRenderer.JSON(rw, http.StatusOK, backend)
- } else {
- http.NotFound(rw, r)
+ providerId := vars["provider"]
+ backendId := vars["backend"]
+ if provider, ok := currentConfigurations[providerId]; ok {
+ if backend, ok := provider.Backends[backendId]; ok {
+ templatesRenderer.JSON(rw, http.StatusOK, backend)
+ return
+ }
}
+ http.NotFound(rw, r)
}
func GetFrontendsHandler(rw http.ResponseWriter, r *http.Request) {
- templatesRenderer.JSON(rw, http.StatusOK, currentConfiguration.Frontends)
+ vars := mux.Vars(r)
+ providerId := vars["provider"]
+ if provider, ok := currentConfigurations[providerId]; ok {
+ templatesRenderer.JSON(rw, http.StatusOK, provider.Frontends)
+ } else {
+ http.NotFound(rw, r)
+ }
}
func GetFrontendHandler(rw http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
- id := vars["frontend"]
- if frontend, ok := currentConfiguration.Frontends[id]; ok {
- templatesRenderer.JSON(rw, http.StatusOK, frontend)
- } else {
- http.NotFound(rw, r)
+ providerId := vars["provider"]
+ frontendId := vars["frontend"]
+ if provider, ok := currentConfigurations[providerId]; ok {
+ if frontend, ok := provider.Frontends[frontendId]; ok {
+ templatesRenderer.JSON(rw, http.StatusOK, frontend)
+ return
+ }
}
+ http.NotFound(rw, r)
}
func GetServersHandler(rw http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
- backend := vars["backend"]
- if backend, ok := currentConfiguration.Backends[backend]; ok {
- templatesRenderer.JSON(rw, http.StatusOK, backend.Servers)
- } else {
- http.NotFound(rw, r)
+ providerId := vars["provider"]
+ backendId := vars["backend"]
+ if provider, ok := currentConfigurations[providerId]; ok {
+ if backend, ok := provider.Backends[backendId]; ok {
+ templatesRenderer.JSON(rw, http.StatusOK, backend.Servers)
+ return
+ }
}
+ http.NotFound(rw, r)
}
func GetServerHandler(rw http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
- backend := vars["backend"]
- server := vars["server"]
- if backend, ok := currentConfiguration.Backends[backend]; ok {
- if server, ok := backend.Servers[server]; ok {
- templatesRenderer.JSON(rw, http.StatusOK, server)
- } else {
- http.NotFound(rw, r)
+ providerId := vars["provider"]
+ backendId := vars["backend"]
+ serverId := vars["server"]
+ if provider, ok := currentConfigurations[providerId]; ok {
+ if backend, ok := provider.Backends[backendId]; ok {
+ if server, ok := backend.Servers[serverId]; ok {
+ templatesRenderer.JSON(rw, http.StatusOK, server)
+ return
+ }
}
- } else {
- http.NotFound(rw, r)
}
+ http.NotFound(rw, r)
}