homelab/traefik
1
0
Fork 0
Code Activity

Refactor new muxer to have only one parser instance

Browse source
This commit is contained in:
Julien Salleyron 2025-05-26 17:12:08 +02:00 • committed by GitHub
parent 55e6d327bc
commit fa18c35a9a
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
13 changed files with 240 additions and 105 deletions
Download patch file Download diff file Expand all files Collapse all files

5
cmd/traefik/traefik.go
View file

@ -301,7 +301,10 @@ func setupServer(staticConfiguration *static.Configuration) (*server.Server, err
// Router factory
routerFactory := server.NewRouterFactory(*staticConfiguration, managerFactory, tlsManager, observabilityMgr, pluginBuilder, dialerManager)
routerFactory, err := server.NewRouterFactory(*staticConfiguration, managerFactory, tlsManager, observabilityMgr, pluginBuilder, dialerManager)
if err != nil {
return nil, fmt.Errorf("creating router factory: %w", err)
}
// Watcher

8
integration/simple_test.go
View file

@ -711,11 +711,11 @@ func (s *SimpleSuite) TestWithDefaultRuleSyntax() {
require.NoError(s.T(), err)
// router2 has an error because it uses the wrong rule syntax (v3 instead of v2)
err = try.GetRequest("http://127.0.0.1:8080/api/http/routers/router2@file", 1*time.Second, try.BodyContains("error while parsing rule QueryRegexp(`foo`, `bar`): unsupported function: QueryRegexp"))
err = try.GetRequest("http://127.0.0.1:8080/api/http/routers/router2@file", 1*time.Second, try.BodyContains("parsing rule QueryRegexp(`foo`, `bar`): unsupported function: QueryRegexp"))
require.NoError(s.T(), err)
// router3 has an error because it uses the wrong rule syntax (v2 instead of v3)
err = try.GetRequest("http://127.0.0.1:8080/api/http/routers/router3@file", 1*time.Second, try.BodyContains("error while adding rule PathPrefix: unexpected number of parameters; got 2, expected one of [1]"))
err = try.GetRequest("http://127.0.0.1:8080/api/http/routers/router3@file", 1*time.Second, try.BodyContains("adding rule PathPrefix: unexpected number of parameters; got 2, expected one of [1]"))
require.NoError(s.T(), err)
}
@ -741,11 +741,11 @@ func (s *SimpleSuite) TestWithoutDefaultRuleSyntax() {
require.NoError(s.T(), err)
// router2 has an error because it uses the wrong rule syntax (v3 instead of v2)
err = try.GetRequest("http://127.0.0.1:8080/api/http/routers/router2@file", 1*time.Second, try.BodyContains("error while adding rule PathPrefix: unexpected number of parameters; got 2, expected one of [1]"))
err = try.GetRequest("http://127.0.0.1:8080/api/http/routers/router2@file", 1*time.Second, try.BodyContains("adding rule PathPrefix: unexpected number of parameters; got 2, expected one of [1]"))
require.NoError(s.T(), err)
// router2 has an error because it uses the wrong rule syntax (v2 instead of v3)
err = try.GetRequest("http://127.0.0.1:8080/api/http/routers/router3@file", 1*time.Second, try.BodyContains("error while parsing rule QueryRegexp(`foo`, `bar`): unsupported function: QueryRegexp"))
err = try.GetRequest("http://127.0.0.1:8080/api/http/routers/router3@file", 1*time.Second, try.BodyContains("parsing rule QueryRegexp(`foo`, `bar`): unsupported function: QueryRegexp"))
require.NoError(s.T(), err)
}

2
pkg/muxer/http/matcher.go
View file

@ -13,7 +13,7 @@ import (
"github.com/traefik/traefik/v3/pkg/middlewares/requestdecorator"
)
var httpFuncs = map[string]func(*matchersTree, ...string) error{
var httpFuncs = matcherBuilderFuncs{
"ClientIP": expectNParameters(clientIP, 1),
"Method": expectNParameters(method, 1),
"Host": expectNParameters(host, 1),

44
pkg/muxer/http/matcher_test.go
View file

@ -69,9 +69,11 @@ func TestClientIPMatcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -142,9 +144,11 @@ func TestMethodMatcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -259,9 +263,11 @@ func TestHostMatcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -358,9 +364,11 @@ func TestHostRegexpMatcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -431,9 +439,11 @@ func TestPathMatcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -523,9 +533,11 @@ func TestPathRegexpMatcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -594,9 +606,11 @@ func TestPathPrefixMatcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -680,9 +694,11 @@ func TestHeaderMatcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -787,9 +803,11 @@ func TestHeaderRegexpMatcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -875,9 +893,11 @@ func TestQueryMatcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -988,9 +1008,11 @@ func TestQueryRegexpMatcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "", 0, handler)
if test.expectedError {
require.Error(t, err)

2
pkg/muxer/http/matcher_v2.go
View file

@ -11,7 +11,7 @@ import (
"github.com/traefik/traefik/v3/pkg/middlewares/requestdecorator"
)
var httpFuncsV2 = map[string]func(*matchersTree, ...string) error{
var httpFuncsV2 = matcherBuilderFuncs{
"Host": hostV2,
"HostHeader": hostV2,
"HostRegexp": hostRegexpV2,

40
pkg/muxer/http/matcher_v2_test.go
View file

@ -73,9 +73,11 @@ func TestClientIPV2Matcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "v2", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -149,9 +151,11 @@ func TestMethodV2Matcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "v2", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -273,9 +277,11 @@ func TestHostV2Matcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "v2", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -375,9 +381,11 @@ func TestHostRegexpV2Matcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "v2", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -469,9 +477,11 @@ func TestPathV2Matcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "v2", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -561,9 +571,11 @@ func TestPathPrefixV2Matcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "v2", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -647,9 +659,11 @@ func TestHeadersMatcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "v2", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -754,9 +768,11 @@ func TestHeaderRegexpV2Matcher(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "v2", 0, handler)
if test.expectedError {
require.Error(t, err)
@ -846,9 +862,11 @@ func TestHostRegexp(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.hostExp, "v2", 0, handler)
require.NoError(t, err)
@ -1513,9 +1531,11 @@ func Test_addRoute(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "v2", 0, handler)
if test.expectedError {
require.Error(t, err)

72
pkg/muxer/http/mux.go
View file

@ -7,44 +7,27 @@ import (
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v3/pkg/rules"
"github.com/vulcand/predicate"
)
type matcherBuilderFuncs map[string]matcherBuilderFunc
type matcherBuilderFunc func(*matchersTree, ...string) error
type MatcherFunc func(*http.Request) bool
// Muxer handles routing with rules.
type Muxer struct {
routes routes
parser predicate.Parser
parserV2 predicate.Parser
parser SyntaxParser
defaultHandler http.Handler
}
// NewMuxer returns a new muxer instance.
func NewMuxer() (*Muxer, error) {
var matchers []string
for matcher := range httpFuncs {
matchers = append(matchers, matcher)
}
parser, err := rules.NewParser(matchers)
if err != nil {
return nil, fmt.Errorf("error while creating parser: %w", err)
}
var matchersV2 []string
for matcher := range httpFuncsV2 {
matchersV2 = append(matchersV2, matcher)
}
parserV2, err := rules.NewParser(matchersV2)
if err != nil {
return nil, fmt.Errorf("error while creating v2 parser: %w", err)
}
func NewMuxer(parser SyntaxParser) *Muxer {
return &Muxer{
parser: parser,
parserV2: parserV2,
defaultHandler: http.NotFoundHandler(),
}, nil
}
}
// ServeHTTP forwards the connection to the matching HTTP handler.
@ -73,36 +56,9 @@ func GetRulePriority(rule string) int {
// AddRoute add a new route to the router.
func (m *Muxer) AddRoute(rule string, syntax string, priority int, handler http.Handler) error {
var parse interface{}
var err error
var matcherFuncs map[string]func(*matchersTree, ...string) error
switch syntax {
case "v2":
parse, err = m.parserV2.Parse(rule)
if err != nil {
return fmt.Errorf("error while parsing rule %s: %w", rule, err)
}
matcherFuncs = httpFuncsV2
default:
parse, err = m.parser.Parse(rule)
if err != nil {
return fmt.Errorf("error while parsing rule %s: %w", rule, err)
}
matcherFuncs = httpFuncs
}
buildTree, ok := parse.(rules.TreeBuilder)
if !ok {
return fmt.Errorf("error while parsing rule %s", rule)
}
var matchers matchersTree
err = matchers.addRule(buildTree(), matcherFuncs)
matchers, err := m.parser.parse(syntax, rule)
if err != nil {
return fmt.Errorf("error while adding rule %s: %w", rule, err)
return fmt.Errorf("error while parsing rule %s: %w", rule, err)
}
m.routes = append(m.routes, &route{
@ -173,7 +129,7 @@ type matchersTree struct {
// matcher is a matcher func used to match HTTP request properties.
// If matcher is not nil, it means that this matcherTree is a leaf of the tree.
// It is therefore mutually exclusive with left and right.
matcher func(*http.Request) bool
matcher MatcherFunc
// operator to combine the evaluation of left and right leaves.
operator string
// Mutually exclusive with matcher.
@ -204,9 +160,7 @@ func (m *matchersTree) match(req *http.Request) bool {
}
}
type matcherFuncs map[string]func(*matchersTree, ...string) error
func (m *matchersTree) addRule(rule *rules.Tree, funcs matcherFuncs) error {
func (m *matchersTree) addRule(rule *rules.Tree, funcs matcherBuilderFuncs) error {
switch rule.Matcher {
case "and", "or":
m.operator = rule.Matcher

12
pkg/muxer/http/mux_test.go
View file

@ -225,9 +225,11 @@ func TestMuxer(t *testing.T) {
t.Run(test.desc, func(t *testing.T) {
t.Parallel()
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
err = muxer.AddRoute(test.rule, "", 0, handler)
if test.expectedError {
@ -378,9 +380,11 @@ func Test_addRoutePriority(t *testing.T) {
for _, test := range testCases {
t.Run(test.desc, func(t *testing.T) {
t.Parallel()
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
for _, route := range test.cases {
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("X-From", route.xFrom)
@ -510,9 +514,11 @@ func TestEmptyHost(t *testing.T) {
t.Parallel()
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
muxer, err := NewMuxer()
parser, err := NewSyntaxParser()
require.NoError(t, err)
muxer := NewMuxer(parser)
err = muxer.AddRoute(test.rule, "", 0, handler)
require.NoError(t, err)

103
pkg/muxer/http/parser.go Normal file
View file

@ -0,0 +1,103 @@
package http
import (
"errors"
"fmt"
"maps"
"slices"
"strings"
"github.com/traefik/traefik/v3/pkg/rules"
"github.com/vulcand/predicate"
)
type SyntaxParser struct {
parsers map[string]*parser
}
type Options func(map[string]matcherBuilderFuncs)
func WithMatcher(syntax, matcherName string, builderFunc func(params ...string) (MatcherFunc, error)) Options {
return func(syntaxFuncs map[string]matcherBuilderFuncs) {
syntax = strings.ToLower(syntax)
syntaxFuncs[syntax][matcherName] = func(tree *matchersTree, s ...string) error {
matcher, err := builderFunc(s...)
if err != nil {
return fmt.Errorf("building matcher: %w", err)
}
tree.matcher = matcher
return nil
}
}
}
func NewSyntaxParser(opts ...Options) (SyntaxParser, error) {
syntaxFuncs := map[string]matcherBuilderFuncs{
"v2": httpFuncsV2,
"v3": httpFuncs,
}
for _, opt := range opts {
opt(syntaxFuncs)
}
parsers := map[string]*parser{}
for syntax, funcs := range syntaxFuncs {
var err error
parsers[syntax], err = newParser(funcs)
if err != nil {
return SyntaxParser{}, err
}
}
return SyntaxParser{
parsers: parsers,
}, nil
}
func (s SyntaxParser) parse(syntax string, rule string) (matchersTree, error) {
parser, ok := s.parsers[syntax]
if !ok {
parser = s.parsers["v3"]
}
return parser.parse(rule)
}
func newParser(funcs matcherBuilderFuncs) (*parser, error) {
p, err := rules.NewParser(slices.Collect(maps.Keys(funcs)))
if err != nil {
return nil, err
}
return &parser{
parser: p,
matcherFuncs: funcs,
}, nil
}
type parser struct {
parser predicate.Parser
matcherFuncs matcherBuilderFuncs
}
func (p *parser) parse(rule string) (matchersTree, error) {
parse, err := p.parser.Parse(rule)
if err != nil {
return matchersTree{}, fmt.Errorf("parsing rule %s: %w", rule, err)
}
buildTree, ok := parse.(rules.TreeBuilder)
if !ok {
return matchersTree{}, errors.New("obtaining build tree")
}
var matchers matchersTree
err = matchers.addRule(buildTree(), p.matcherFuncs)
if err != nil {
return matchersTree{}, fmt.Errorf("adding rule %s: %w", rule, err)
}
return matchers, nil
}

9
pkg/server/router/router.go
View file

@ -42,10 +42,11 @@ type Manager struct {
middlewaresBuilder middlewareBuilder
conf *runtime.Configuration
tlsManager *tls.Manager
parser httpmuxer.SyntaxParser
}
// NewManager creates a new Manager.
func NewManager(conf *runtime.Configuration, serviceManager serviceManager, middlewaresBuilder middlewareBuilder, observabilityMgr *middleware.ObservabilityMgr, tlsManager *tls.Manager) *Manager {
func NewManager(conf *runtime.Configuration, serviceManager serviceManager, middlewaresBuilder middlewareBuilder, observabilityMgr *middleware.ObservabilityMgr, tlsManager *tls.Manager, parser httpmuxer.SyntaxParser) *Manager {
return &Manager{
routerHandlers: make(map[string]http.Handler),
serviceManager: serviceManager,
@ -53,6 +54,7 @@ func NewManager(conf *runtime.Configuration, serviceManager serviceManager, midd
middlewaresBuilder: middlewaresBuilder,
conf: conf,
tlsManager: tlsManager,
parser: parser,
}
}
@ -103,10 +105,7 @@ func (m *Manager) BuildHandlers(rootCtx context.Context, entryPoints []string, t
}
func (m *Manager) buildEntryPointHandler(ctx context.Context, entryPointName string, configs map[string]*runtime.RouterInfo) (http.Handler, error) {
muxer, err := httpmuxer.NewMuxer()
if err != nil {
return nil, err
}
muxer := httpmuxer.NewMuxer(m.parser)
defaultHandler, err := m.observabilityMgr.BuildEPChain(ctx, entryPointName, "", nil).Then(http.NotFoundHandler())
if err != nil {

22
pkg/server/router/router_test.go
View file

@ -13,10 +13,12 @@ import (
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
ptypes "github.com/traefik/paerser/types"
"github.com/traefik/traefik/v3/pkg/config/dynamic"
"github.com/traefik/traefik/v3/pkg/config/runtime"
"github.com/traefik/traefik/v3/pkg/middlewares/requestdecorator"
httpmuxer "github.com/traefik/traefik/v3/pkg/muxer/http"
"github.com/traefik/traefik/v3/pkg/server/middleware"
"github.com/traefik/traefik/v3/pkg/server/service"
"github.com/traefik/traefik/v3/pkg/testhelpers"
@ -326,7 +328,10 @@ func TestRouterManager_Get(t *testing.T) {
middlewaresBuilder := middleware.NewBuilder(rtConf.Middlewares, serviceManager, nil)
tlsManager := traefiktls.NewManager()
routerManager := NewManager(rtConf, serviceManager, middlewaresBuilder, nil, tlsManager)
parser, err := httpmuxer.NewSyntaxParser()
require.NoError(t, err)
routerManager := NewManager(rtConf, serviceManager, middlewaresBuilder, nil, tlsManager, parser)
handlers := routerManager.BuildHandlers(context.Background(), test.entryPoints, false)
@ -711,7 +716,10 @@ func TestRuntimeConfiguration(t *testing.T) {
tlsManager := traefiktls.NewManager()
tlsManager.UpdateConfigs(context.Background(), nil, test.tlsOptions, nil)
routerManager := NewManager(rtConf, serviceManager, middlewaresBuilder, nil, tlsManager)
parser, err := httpmuxer.NewSyntaxParser()
require.NoError(t, err)
routerManager := NewManager(rtConf, serviceManager, middlewaresBuilder, nil, tlsManager, parser)
_ = routerManager.BuildHandlers(context.Background(), entryPoints, false)
_ = routerManager.BuildHandlers(context.Background(), entryPoints, true)
@ -789,7 +797,10 @@ func TestProviderOnMiddlewares(t *testing.T) {
middlewaresBuilder := middleware.NewBuilder(rtConf.Middlewares, serviceManager, nil)
tlsManager := traefiktls.NewManager()
routerManager := NewManager(rtConf, serviceManager, middlewaresBuilder, nil, tlsManager)
parser, err := httpmuxer.NewSyntaxParser()
require.NoError(t, err)
routerManager := NewManager(rtConf, serviceManager, middlewaresBuilder, nil, tlsManager, parser)
_ = routerManager.BuildHandlers(context.Background(), entryPoints, false)
@ -865,7 +876,10 @@ func BenchmarkRouterServe(b *testing.B) {
middlewaresBuilder := middleware.NewBuilder(rtConf.Middlewares, serviceManager, nil)
tlsManager := traefiktls.NewManager()
routerManager := NewManager(rtConf, serviceManager, middlewaresBuilder, nil, tlsManager)
parser, err := httpmuxer.NewSyntaxParser()
require.NoError(b, err)
routerManager := NewManager(rtConf, serviceManager, middlewaresBuilder, nil, tlsManager, parser)
handlers := routerManager.BuildHandlers(context.Background(), entryPoints, false)

16
pkg/server/routerfactory.go
View file

@ -2,10 +2,12 @@ package server
import (
"context"
"fmt"
"github.com/rs/zerolog/log"
"github.com/traefik/traefik/v3/pkg/config/runtime"
"github.com/traefik/traefik/v3/pkg/config/static"
httpmuxer "github.com/traefik/traefik/v3/pkg/muxer/http"
"github.com/traefik/traefik/v3/pkg/server/middleware"
tcpmiddleware "github.com/traefik/traefik/v3/pkg/server/middleware/tcp"
"github.com/traefik/traefik/v3/pkg/server/router"
@ -35,12 +37,14 @@ type RouterFactory struct {
dialerManager *tcp.DialerManager
cancelPrevState func()
parser httpmuxer.SyntaxParser
}
// NewRouterFactory creates a new RouterFactory.
func NewRouterFactory(staticConfiguration static.Configuration, managerFactory *service.ManagerFactory, tlsManager *tls.Manager,
observabilityMgr *middleware.ObservabilityMgr, pluginBuilder middleware.PluginsBuilder, dialerManager *tcp.DialerManager,
) *RouterFactory {
) (*RouterFactory, error) {
handlesTLSChallenge := false
for _, resolver := range staticConfiguration.CertificatesResolvers {
if resolver.ACME != nil && resolver.ACME.TLSChallenge != nil {
@ -67,6 +71,11 @@ func NewRouterFactory(staticConfiguration static.Configuration, managerFactory *
}
}
parser, err := httpmuxer.NewSyntaxParser()
if err != nil {
return nil, fmt.Errorf("creating parser: %w", err)
}
return &RouterFactory{
entryPointsTCP: entryPointsTCP,
entryPointsUDP: entryPointsUDP,
@ -76,7 +85,8 @@ func NewRouterFactory(staticConfiguration static.Configuration, managerFactory *
pluginBuilder: pluginBuilder,
dialerManager: dialerManager,
allowACMEByPass: allowACMEByPass,
}
parser: parser,
}, nil
}
// CreateRouters creates new TCPRouters and UDPRouters.
@ -93,7 +103,7 @@ func (f *RouterFactory) CreateRouters(rtConf *runtime.Configuration) (map[string
middlewaresBuilder := middleware.NewBuilder(rtConf.Middlewares, serviceManager, f.pluginBuilder)
routerManager := router.NewManager(rtConf, serviceManager, middlewaresBuilder, f.observabilityMgr, f.tlsManager)
routerManager := router.NewManager(rtConf, serviceManager, middlewaresBuilder, f.observabilityMgr, f.tlsManager, f.parser)
handlersNonTLS := routerManager.BuildHandlers(ctx, f.entryPointsTCP, false)
handlersTLS := routerManager.BuildHandlers(ctx, f.entryPointsTCP, true)

10
pkg/server/routerfactory_test.go
View file

@ -8,6 +8,7 @@ import (
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/traefik/traefik/v3/pkg/config/dynamic"
"github.com/traefik/traefik/v3/pkg/config/runtime"
"github.com/traefik/traefik/v3/pkg/config/static"
@ -58,7 +59,8 @@ func TestReuseService(t *testing.T) {
dialerManager := tcp.NewDialerManager(nil)
dialerManager.Update(map[string]*dynamic.TCPServersTransport{"default@internal": {}})
factory := NewRouterFactory(staticConfig, managerFactory, tlsManager, nil, nil, dialerManager)
factory, err := NewRouterFactory(staticConfig, managerFactory, tlsManager, nil, nil, dialerManager)
require.NoError(t, err)
entryPointsHandlers, _ := factory.CreateRouters(runtime.NewConfig(dynamic.Configuration{HTTP: dynamicConfigs}))
@ -196,7 +198,8 @@ func TestServerResponseEmptyBackend(t *testing.T) {
dialerManager := tcp.NewDialerManager(nil)
dialerManager.Update(map[string]*dynamic.TCPServersTransport{"default@internal": {}})
observabiltyMgr := middleware.NewObservabilityMgr(staticConfig, nil, nil, nil, nil, nil)
factory := NewRouterFactory(staticConfig, managerFactory, tlsManager, observabiltyMgr, nil, dialerManager)
factory, err := NewRouterFactory(staticConfig, managerFactory, tlsManager, observabiltyMgr, nil, dialerManager)
require.NoError(t, err)
entryPointsHandlers, _ := factory.CreateRouters(runtime.NewConfig(dynamic.Configuration{HTTP: test.config(testServer.URL)}))
@ -240,7 +243,8 @@ func TestInternalServices(t *testing.T) {
dialerManager := tcp.NewDialerManager(nil)
dialerManager.Update(map[string]*dynamic.TCPServersTransport{"default@internal": {}})
factory := NewRouterFactory(staticConfig, managerFactory, tlsManager, nil, nil, dialerManager)
factory, err := NewRouterFactory(staticConfig, managerFactory, tlsManager, nil, nil, dialerManager)
require.NoError(t, err)
entryPointsHandlers, _ := factory.CreateRouters(runtime.NewConfig(dynamic.Configuration{HTTP: dynamicConfigs}))