traefik/pkg/plugins/middlewares.go
Ludovic Fernandez 577709fff3
fix: middleware plugins memory leak
Co-authored-by: Julien Salleyron <julien.salleyron@gmail.com>
2022-01-14 12:22:06 +01:00

130 lines
3.4 KiB
Go

package plugins
import (
"context"
"fmt"
"net/http"
"path"
"reflect"
"strings"
"github.com/mitchellh/mapstructure"
"github.com/traefik/yaegi/interp"
)
// Build builds a middleware plugin.
func (b Builder) Build(pName string, config map[string]interface{}, middlewareName string) (Constructor, error) {
if b.middlewareBuilders == nil {
return nil, fmt.Errorf("no plugin definition in the static configuration: %s", pName)
}
descriptor, ok := b.middlewareBuilders[pName]
if !ok {
return nil, fmt.Errorf("unknown plugin type: %s", pName)
}
m, err := newMiddleware(descriptor, config, middlewareName)
if err != nil {
return nil, err
}
return m.NewHandler, err
}
type middlewareBuilder struct {
fnNew reflect.Value
fnCreateConfig reflect.Value
}
func newMiddlewareBuilder(i *interp.Interpreter, basePkg, imp string) (*middlewareBuilder, error) {
if basePkg == "" {
basePkg = strings.ReplaceAll(path.Base(imp), "-", "_")
}
fnNew, err := i.Eval(basePkg + `.New`)
if err != nil {
return nil, fmt.Errorf("failed to eval New: %w", err)
}
fnCreateConfig, err := i.Eval(basePkg + `.CreateConfig`)
if err != nil {
return nil, fmt.Errorf("failed to eval CreateConfig: %w", err)
}
return &middlewareBuilder{
fnNew: fnNew,
fnCreateConfig: fnCreateConfig,
}, nil
}
func (p middlewareBuilder) newHandler(ctx context.Context, next http.Handler, cfg reflect.Value, middlewareName string) (http.Handler, error) {
args := []reflect.Value{reflect.ValueOf(ctx), reflect.ValueOf(next), cfg, reflect.ValueOf(middlewareName)}
results := p.fnNew.Call(args)
if len(results) > 1 && results[1].Interface() != nil {
err, ok := results[1].Interface().(error)
if !ok {
return nil, fmt.Errorf("invalid error type: %T", results[0].Interface())
}
return nil, err
}
handler, ok := results[0].Interface().(http.Handler)
if !ok {
return nil, fmt.Errorf("invalid handler type: %T", results[0].Interface())
}
return handler, nil
}
func (p middlewareBuilder) createConfig(config map[string]interface{}) (reflect.Value, error) {
results := p.fnCreateConfig.Call(nil)
if len(results) != 1 {
return reflect.Value{}, fmt.Errorf("invalid number of return for the CreateConfig function: %d", len(results))
}
vConfig := results[0]
cfg := &mapstructure.DecoderConfig{
DecodeHook: mapstructure.StringToSliceHookFunc(","),
WeaklyTypedInput: true,
Result: vConfig.Interface(),
}
decoder, err := mapstructure.NewDecoder(cfg)
if err != nil {
return reflect.Value{}, fmt.Errorf("failed to create configuration decoder: %w", err)
}
err = decoder.Decode(config)
if err != nil {
return reflect.Value{}, fmt.Errorf("failed to decode configuration: %w", err)
}
return vConfig, nil
}
// Middleware is an HTTP handler plugin wrapper.
type Middleware struct {
middlewareName string
config reflect.Value
builder *middlewareBuilder
}
func newMiddleware(builder *middlewareBuilder, config map[string]interface{}, middlewareName string) (*Middleware, error) {
vConfig, err := builder.createConfig(config)
if err != nil {
return nil, err
}
return &Middleware{
middlewareName: middlewareName,
config: vConfig,
builder: builder,
}, nil
}
// NewHandler creates a new HTTP handler.
func (m *Middleware) NewHandler(ctx context.Context, next http.Handler) (http.Handler, error) {
return m.builder.newHandler(ctx, next, m.config, m.middlewareName)
}