166 lines
4.1 KiB
Go
166 lines
4.1 KiB
Go
package parser
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/containous/traefik/pkg/types"
|
|
)
|
|
|
|
const defaultPtrValue = "false"
|
|
|
|
// FlatOpts holds options used when encoding to Flat.
|
|
type FlatOpts struct {
|
|
Case string // "lower" or "upper", defaults to "lower".
|
|
Separator string
|
|
SkipRoot bool
|
|
}
|
|
|
|
// Flat is a configuration item representation.
|
|
type Flat struct {
|
|
Name string
|
|
Description string
|
|
Default string
|
|
}
|
|
|
|
// EncodeToFlat encodes a node to a Flat representation.
|
|
// Even though the given node argument should have already been augmented with metadata such as kind,
|
|
// the element (and its type information) is still needed to treat remaining edge cases.
|
|
func EncodeToFlat(element interface{}, node *Node, opts FlatOpts) ([]Flat, error) {
|
|
if element == nil || node == nil {
|
|
return nil, nil
|
|
}
|
|
|
|
if node.Kind == 0 {
|
|
return nil, fmt.Errorf("missing node type: %s", node.Name)
|
|
}
|
|
|
|
elem := reflect.ValueOf(element)
|
|
if elem.Kind() == reflect.Struct {
|
|
return nil, fmt.Errorf("structs are not supported, use pointer instead")
|
|
}
|
|
|
|
encoder := encoderToFlat{FlatOpts: opts}
|
|
|
|
var entries []Flat
|
|
if encoder.SkipRoot {
|
|
for _, child := range node.Children {
|
|
field := encoder.getField(elem.Elem(), child)
|
|
entries = append(entries, encoder.createFlat(field, child.Name, child)...)
|
|
}
|
|
} else {
|
|
entries = encoder.createFlat(elem, strings.ToLower(node.Name), node)
|
|
}
|
|
|
|
sort.Slice(entries, func(i, j int) bool { return entries[i].Name < entries[j].Name })
|
|
|
|
return entries, nil
|
|
}
|
|
|
|
type encoderToFlat struct {
|
|
FlatOpts
|
|
}
|
|
|
|
func (e encoderToFlat) createFlat(field reflect.Value, name string, node *Node) []Flat {
|
|
var entries []Flat
|
|
if node.Kind != reflect.Map && node.Description != "-" {
|
|
if !(node.Kind == reflect.Ptr && len(node.Children) > 0) ||
|
|
(node.Kind == reflect.Ptr && node.Tag.Get("label") == TagLabelAllowEmpty) {
|
|
if node.Name[0] != '[' {
|
|
entries = append(entries, Flat{
|
|
Name: e.getName(name),
|
|
Description: node.Description,
|
|
Default: e.getNodeValue(e.getField(field, node), node),
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
for _, child := range node.Children {
|
|
if node.Kind == reflect.Map {
|
|
fChild := e.getField(field, child)
|
|
|
|
var v string
|
|
if child.Kind == reflect.Struct {
|
|
v = defaultPtrValue
|
|
} else {
|
|
v = e.getNodeValue(fChild, child)
|
|
}
|
|
|
|
if node.Description != "-" {
|
|
entries = append(entries, Flat{
|
|
Name: e.getName(name, child.Name),
|
|
Description: node.Description,
|
|
Default: v,
|
|
})
|
|
}
|
|
|
|
if child.Kind == reflect.Struct || child.Kind == reflect.Ptr {
|
|
for _, ch := range child.Children {
|
|
f := e.getField(fChild, ch)
|
|
n := e.getName(name, child.Name, ch.Name)
|
|
entries = append(entries, e.createFlat(f, n, ch)...)
|
|
}
|
|
}
|
|
} else {
|
|
f := e.getField(field, child)
|
|
n := e.getName(name, child.Name)
|
|
entries = append(entries, e.createFlat(f, n, child)...)
|
|
}
|
|
}
|
|
|
|
return entries
|
|
}
|
|
|
|
func (e encoderToFlat) getField(field reflect.Value, node *Node) reflect.Value {
|
|
switch field.Kind() {
|
|
case reflect.Struct:
|
|
return field.FieldByName(node.FieldName)
|
|
case reflect.Ptr:
|
|
if field.Elem().Kind() == reflect.Struct {
|
|
return field.Elem().FieldByName(node.FieldName)
|
|
}
|
|
return field.Elem()
|
|
case reflect.Map:
|
|
return field.MapIndex(reflect.ValueOf(node.FieldName))
|
|
default:
|
|
return field
|
|
}
|
|
}
|
|
|
|
func (e encoderToFlat) getNodeValue(field reflect.Value, node *Node) string {
|
|
if node.Kind == reflect.Ptr && len(node.Children) > 0 {
|
|
return defaultPtrValue
|
|
}
|
|
|
|
if field.Kind() == reflect.Int64 {
|
|
i, _ := strconv.ParseInt(node.Value, 10, 64)
|
|
|
|
switch field.Type() {
|
|
case reflect.TypeOf(types.Duration(time.Second)):
|
|
return strconv.Itoa(int(i) / int(time.Second))
|
|
case reflect.TypeOf(time.Second):
|
|
return time.Duration(i).String()
|
|
}
|
|
}
|
|
|
|
return node.Value
|
|
}
|
|
|
|
func (e encoderToFlat) getName(names ...string) string {
|
|
var name string
|
|
if names[len(names)-1][0] == '[' {
|
|
name = strings.Join(names, "")
|
|
} else {
|
|
name = strings.Join(names, e.Separator)
|
|
}
|
|
|
|
if strings.EqualFold(e.Case, "upper") {
|
|
return strings.ToUpper(name)
|
|
}
|
|
return strings.ToLower(name)
|
|
}
|