130 lines
3.4 KiB
Go
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)
|
|
}
|