traefik/pkg/server/aggregator.go

220 lines
7 KiB
Go
Raw Normal View History

package server
import (
2024-02-19 14:44:03 +00:00
"slices"
"github.com/go-acme/lego/v4/challenge/tlsalpn01"
2022-11-21 17:36:05 +00:00
"github.com/rs/zerolog/log"
2023-02-03 14:24:05 +00:00
"github.com/traefik/traefik/v3/pkg/config/dynamic"
"github.com/traefik/traefik/v3/pkg/logs"
"github.com/traefik/traefik/v3/pkg/server/provider"
"github.com/traefik/traefik/v3/pkg/tls"
)
2020-03-09 10:12:05 +00:00
func mergeConfiguration(configurations dynamic.Configurations, defaultEntryPoints []string) dynamic.Configuration {
// TODO: see if we can use DeepCopies inside, so that the given argument is left
// untouched, and the modified copy is returned.
conf := dynamic.Configuration{
HTTP: &dynamic.HTTPConfiguration{
2020-09-11 13:40:03 +00:00
Routers: make(map[string]*dynamic.Router),
Middlewares: make(map[string]*dynamic.Middleware),
Services: make(map[string]*dynamic.Service),
Models: make(map[string]*dynamic.Model),
ServersTransports: make(map[string]*dynamic.ServersTransport),
},
TCP: &dynamic.TCPConfiguration{
Routers: make(map[string]*dynamic.TCPRouter),
Services: make(map[string]*dynamic.TCPService),
Middlewares: make(map[string]*dynamic.TCPMiddleware),
2024-01-23 10:34:05 +00:00
Models: make(map[string]*dynamic.TCPModel),
ServersTransports: make(map[string]*dynamic.TCPServersTransport),
},
UDP: &dynamic.UDPConfiguration{
Routers: make(map[string]*dynamic.UDPRouter),
Services: make(map[string]*dynamic.UDPService),
},
TLS: &dynamic.TLSConfiguration{
Stores: make(map[string]tls.Store),
Options: make(map[string]tls.Options),
},
}
var defaultTLSOptionProviders []string
2020-02-24 16:14:06 +00:00
var defaultTLSStoreProviders []string
for pvd, configuration := range configurations {
if configuration.HTTP != nil {
for routerName, router := range configuration.HTTP.Routers {
if len(router.EntryPoints) == 0 {
2022-11-21 17:36:05 +00:00
log.Debug().
Str(logs.RouterName, routerName).
Strs(logs.EntryPointName, defaultEntryPoints).
Msg("No entryPoint defined for this router, using the default one(s) instead")
2020-03-09 10:12:05 +00:00
router.EntryPoints = defaultEntryPoints
}
conf.HTTP.Routers[provider.MakeQualifiedName(pvd, routerName)] = router
}
for middlewareName, middleware := range configuration.HTTP.Middlewares {
conf.HTTP.Middlewares[provider.MakeQualifiedName(pvd, middlewareName)] = middleware
}
for serviceName, service := range configuration.HTTP.Services {
conf.HTTP.Services[provider.MakeQualifiedName(pvd, serviceName)] = service
}
for modelName, model := range configuration.HTTP.Models {
conf.HTTP.Models[provider.MakeQualifiedName(pvd, modelName)] = model
}
2020-09-11 13:40:03 +00:00
for serversTransportName, serversTransport := range configuration.HTTP.ServersTransports {
conf.HTTP.ServersTransports[provider.MakeQualifiedName(pvd, serversTransportName)] = serversTransport
}
}
if configuration.TCP != nil {
for routerName, router := range configuration.TCP.Routers {
if len(router.EntryPoints) == 0 {
2022-11-21 17:36:05 +00:00
log.Debug().
Str(logs.RouterName, routerName).
Msgf("No entryPoint defined for this TCP router, using the default one(s) instead: %+v", defaultEntryPoints)
router.EntryPoints = defaultEntryPoints
}
conf.TCP.Routers[provider.MakeQualifiedName(pvd, routerName)] = router
}
2021-06-11 13:30:05 +00:00
for middlewareName, middleware := range configuration.TCP.Middlewares {
conf.TCP.Middlewares[provider.MakeQualifiedName(pvd, middlewareName)] = middleware
}
for serviceName, service := range configuration.TCP.Services {
conf.TCP.Services[provider.MakeQualifiedName(pvd, serviceName)] = service
}
2024-05-14 07:42:04 +00:00
for modelName, model := range configuration.TCP.Models {
conf.TCP.Models[provider.MakeQualifiedName(pvd, modelName)] = model
}
for serversTransportName, serversTransport := range configuration.TCP.ServersTransports {
conf.TCP.ServersTransports[provider.MakeQualifiedName(pvd, serversTransportName)] = serversTransport
}
}
if configuration.UDP != nil {
for routerName, router := range configuration.UDP.Routers {
conf.UDP.Routers[provider.MakeQualifiedName(pvd, routerName)] = router
}
for serviceName, service := range configuration.UDP.Services {
conf.UDP.Services[provider.MakeQualifiedName(pvd, serviceName)] = service
}
}
if configuration.TLS != nil {
for _, cert := range configuration.TLS.Certificates {
2024-02-19 14:44:03 +00:00
if slices.Contains(cert.Stores, tlsalpn01.ACMETLS1Protocol) && pvd != "tlsalpn.acme" {
continue
}
conf.TLS.Certificates = append(conf.TLS.Certificates, cert)
}
for key, store := range configuration.TLS.Stores {
if key != tls.DefaultTLSStoreName {
2020-02-24 16:14:06 +00:00
key = provider.MakeQualifiedName(pvd, key)
} else {
defaultTLSStoreProviders = append(defaultTLSStoreProviders, pvd)
}
conf.TLS.Stores[key] = store
}
for tlsOptionsName, options := range configuration.TLS.Options {
if tlsOptionsName != "default" {
tlsOptionsName = provider.MakeQualifiedName(pvd, tlsOptionsName)
} else {
defaultTLSOptionProviders = append(defaultTLSOptionProviders, pvd)
}
conf.TLS.Options[tlsOptionsName] = options
}
}
}
2020-02-24 16:14:06 +00:00
if len(defaultTLSStoreProviders) > 1 {
2024-03-12 09:38:29 +00:00
log.Error().Msgf("Default TLS Store defined in multiple providers: %v", defaultTLSStoreProviders)
delete(conf.TLS.Stores, tls.DefaultTLSStoreName)
2020-02-24 16:14:06 +00:00
}
if len(defaultTLSOptionProviders) == 0 {
conf.TLS.Options[tls.DefaultTLSConfigName] = tls.DefaultTLSOptions
} else if len(defaultTLSOptionProviders) > 1 {
2024-03-12 09:38:29 +00:00
log.Error().Msgf("Default TLS Options defined in multiple providers %v", defaultTLSOptionProviders)
// We do not set an empty tls.TLS{} as above so that we actually get a "cascading failure" later on,
// i.e. routers depending on this missing TLS option will fail to initialize as well.
delete(conf.TLS.Options, tls.DefaultTLSConfigName)
}
return conf
}
func applyModel(cfg dynamic.Configuration) dynamic.Configuration {
2024-05-14 07:42:04 +00:00
if cfg.HTTP != nil && len(cfg.HTTP.Models) > 0 {
rts := make(map[string]*dynamic.Router)
2024-05-14 07:42:04 +00:00
for name, rt := range cfg.HTTP.Routers {
router := rt.DeepCopy()
2020-03-09 10:12:05 +00:00
2024-05-14 07:42:04 +00:00
if !router.DefaultRule && router.RuleSyntax == "" {
for _, model := range cfg.HTTP.Models {
router.RuleSyntax = model.DefaultRuleSyntax
break
}
2024-01-23 10:34:05 +00:00
}
2024-05-14 07:42:04 +00:00
eps := router.EntryPoints
router.EntryPoints = nil
2024-05-14 07:42:04 +00:00
for _, epName := range eps {
m, ok := cfg.HTTP.Models[epName+"@internal"]
if ok {
cp := router.DeepCopy()
2024-05-14 07:42:04 +00:00
cp.EntryPoints = []string{epName}
2024-05-14 07:42:04 +00:00
if cp.TLS == nil {
cp.TLS = m.TLS
}
2024-05-14 07:42:04 +00:00
cp.Middlewares = append(m.Middlewares, cp.Middlewares...)
2024-05-14 07:42:04 +00:00
rtName := name
if len(eps) > 1 {
rtName = epName + "-" + name
}
rts[rtName] = cp
} else {
router.EntryPoints = append(router.EntryPoints, epName)
2024-05-14 07:42:04 +00:00
rts[name] = router
}
}
}
2024-05-14 07:42:04 +00:00
cfg.HTTP.Routers = rts
}
2024-01-23 10:34:05 +00:00
if cfg.TCP == nil || len(cfg.TCP.Models) == 0 {
return cfg
}
tcpRouters := make(map[string]*dynamic.TCPRouter)
2024-05-14 07:42:04 +00:00
for name, rt := range cfg.TCP.Routers {
2024-01-23 10:34:05 +00:00
router := rt.DeepCopy()
if router.RuleSyntax == "" {
for _, model := range cfg.TCP.Models {
router.RuleSyntax = model.DefaultRuleSyntax
break
}
}
2024-05-14 07:42:04 +00:00
tcpRouters[name] = router
2024-01-23 10:34:05 +00:00
}
cfg.TCP.Routers = tcpRouters
return cfg
}