Vendor main dependencies.

vendor/github.com/containous/staert/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Containous SAS, Emile Vauge, emile@vauge.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/github.com/containous/staert/kv.go

@@ -0,0 +1,328 @@
+package staert
+
+import (
+	"encoding"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"github.com/containous/flaeg"
+	"github.com/docker/libkv"
+	"github.com/docker/libkv/store"
+	"github.com/mitchellh/mapstructure"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// KvSource implements Source
+// It handles all mapstructure features(Squashed Embeded Sub-Structures, Maps, Pointers)
+// It supports Slices (and maybe Arraies). They must be sorted in the KvStore like this :
+// Key : ".../[sliceIndex]" -> Value
+type KvSource struct {
+	store.Store
+	Prefix string // like this "prefix" (without the /)
+}
+
+// NewKvSource creates a new KvSource
+func NewKvSource(backend store.Backend, addrs []string, options *store.Config, prefix string) (*KvSource, error) {
+	store, err := libkv.NewStore(backend, addrs, options)
+	return &KvSource{Store: store, Prefix: prefix}, err
+}
+
+// Parse uses libkv and mapstructure to fill the structure
+func (kv *KvSource) Parse(cmd *flaeg.Command) (*flaeg.Command, error) {
+	err := kv.LoadConfig(cmd.Config)
+	if err != nil {
+		return nil, err
+	}
+	return cmd, nil
+}
+
+// LoadConfig loads data from the KV Store into the config structure (given by reference)
+func (kv *KvSource) LoadConfig(config interface{}) error {
+	pairs := map[string][]byte{}
+	if err := kv.ListRecursive(kv.Prefix, pairs); err != nil {
+		return err
+	}
+	// fmt.Printf("pairs : %#v\n", pairs)
+	mapstruct, err := generateMapstructure(convertPairs(pairs), kv.Prefix)
+	if err != nil {
+		return err
+	}
+	// fmt.Printf("mapstruct : %#v\n", mapstruct)
+	configDecoder := &mapstructure.DecoderConfig{
+		Metadata:         nil,
+		Result:           config,
+		WeaklyTypedInput: true,
+		DecodeHook:       decodeHook,
+	}
+	decoder, err := mapstructure.NewDecoder(configDecoder)
+	if err != nil {
+		return err
+	}
+	if err := decoder.Decode(mapstruct); err != nil {
+		return err
+	}
+	return nil
+}
+
+func generateMapstructure(pairs []*store.KVPair, prefix string) (map[string]interface{}, error) {
+	raw := make(map[string]interface{})
+	for _, p := range pairs {
+		// Trim the prefix off our key first
+		key := strings.TrimPrefix(strings.Trim(p.Key, "/"), strings.Trim(prefix, "/")+"/")
+		raw, err := processKV(key, p.Value, raw)
+		if err != nil {
+			return raw, err
+		}
+
+	}
+	return raw, nil
+}
+
+func processKV(key string, v []byte, raw map[string]interface{}) (map[string]interface{}, error) {
+	// Determine which map we're writing the value to. We split by '/'
+	// to determine any sub-maps that need to be created.
+	m := raw
+	children := strings.Split(key, "/")
+	if len(children) > 0 {
+		key = children[len(children)-1]
+		children = children[:len(children)-1]
+		for _, child := range children {
+			if m[child] == nil {
+				m[child] = make(map[string]interface{})
+			}
+			subm, ok := m[child].(map[string]interface{})
+			if !ok {
+				return nil, fmt.Errorf("child is both a data item and dir: %s", child)
+			}
+			m = subm
+		}
+	}
+	m[key] = string(v)
+	return raw, nil
+}
+
+func decodeHook(fromType reflect.Type, toType reflect.Type, data interface{}) (interface{}, error) {
+	// TODO : Array support
+
+	// custom unmarshaler
+	textUnmarshalerType := reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
+	if toType.Implements(textUnmarshalerType) {
+		object := reflect.New(toType.Elem()).Interface()
+		err := object.(encoding.TextUnmarshaler).UnmarshalText([]byte(data.(string)))
+		if err != nil {
+			return nil, fmt.Errorf("Error unmarshaling %v: %v", data, err)
+		}
+		return object, nil
+	}
+	switch toType.Kind() {
+	case reflect.Ptr:
+		if fromType.Kind() == reflect.String {
+			if data == "" {
+				// default value Pointer
+				return make(map[string]interface{}), nil
+			}
+		}
+	case reflect.Slice:
+		if fromType.Kind() == reflect.Map {
+			// Type assertion
+			dataMap, ok := data.(map[string]interface{})
+			if !ok {
+				return data, fmt.Errorf("input data is not a map : %#v", data)
+			}
+			// Sorting map
+			indexes := make([]int, len(dataMap))
+			i := 0
+			for k := range dataMap {
+				ind, err := strconv.Atoi(k)
+				if err != nil {
+					return dataMap, err
+				}
+				indexes[i] = ind
+				i++
+			}
+			sort.Ints(indexes)
+			// Building slice
+			dataOutput := make([]interface{}, i)
+			i = 0
+			for _, k := range indexes {
+				dataOutput[i] = dataMap[strconv.Itoa(k)]
+				i++
+			}
+
+			return dataOutput, nil
+		} else if fromType.Kind() == reflect.String {
+			b, err := base64.StdEncoding.DecodeString(data.(string))
+			if err != nil {
+				return nil, err
+			}
+			return b, nil
+		}
+	}
+	return data, nil
+}
+
+// StoreConfig stores the config into the KV Store
+func (kv *KvSource) StoreConfig(config interface{}) error {
+	kvMap := map[string]string{}
+	if err := collateKvRecursive(reflect.ValueOf(config), kvMap, kv.Prefix); err != nil {
+		return err
+	}
+	keys := []string{}
+	for key := range kvMap {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	for _, k := range keys {
+		var writeOptions *store.WriteOptions
+		// is it a directory ?
+		if strings.HasSuffix(k, "/") {
+			writeOptions = &store.WriteOptions{
+				IsDir: true,
+			}
+		}
+		if err := kv.Put(k, []byte(kvMap[k]), writeOptions); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func collateKvRecursive(objValue reflect.Value, kv map[string]string, key string) error {
+	name := key
+	kind := objValue.Kind()
+
+	// custom marshaler
+	if marshaler, ok := objValue.Interface().(encoding.TextMarshaler); ok {
+		test, err := marshaler.MarshalText()
+		if err != nil {
+			return fmt.Errorf("Error marshaling key %s: %v", name, err)
+		}
+		kv[name] = string(test)
+		return nil
+	}
+	switch kind {
+	case reflect.Struct:
+		for i := 0; i < objValue.NumField(); i++ {
+			objType := objValue.Type()
+			if objType.Field(i).Name[:1] != strings.ToUpper(objType.Field(i).Name[:1]) {
+				//if unexported field
+				continue
+			}
+			squashed := false
+			if objType.Field(i).Anonymous {
+				if objValue.Field(i).Kind() == reflect.Struct {
+					tags := objType.Field(i).Tag
+					if strings.Contains(string(tags), "squash") {
+						squashed = true
+					}
+				}
+			}
+			if squashed {
+				if err := collateKvRecursive(objValue.Field(i), kv, name); err != nil {
+					return err
+				}
+			} else {
+				fieldName := objType.Field(i).Name
+				//useless if not empty Prefix is required ?
+				if len(key) == 0 {
+					name = strings.ToLower(fieldName)
+				} else {
+					name = key + "/" + strings.ToLower(fieldName)
+				}
+
+				if err := collateKvRecursive(objValue.Field(i), kv, name); err != nil {
+					return err
+				}
+			}
+		}
+
+	case reflect.Ptr:
+		if !objValue.IsNil() {
+			// hack to avoid calling this at the beginning
+			if len(kv) > 0 {
+				kv[name+"/"] = ""
+			}
+			if err := collateKvRecursive(objValue.Elem(), kv, name); err != nil {
+				return err
+			}
+		}
+	case reflect.Map:
+		for _, k := range objValue.MapKeys() {
+			if k.Kind() == reflect.Struct {
+				return errors.New("Struct as key not supported")
+			}
+			name = key + "/" + fmt.Sprint(k)
+			if err := collateKvRecursive(objValue.MapIndex(k), kv, name); err != nil {
+				return err
+			}
+		}
+	case reflect.Array, reflect.Slice:
+		// Byte slices get special treatment
+		if objValue.Type().Elem().Kind() == reflect.Uint8 {
+			kv[name] = base64.StdEncoding.EncodeToString(objValue.Bytes())
+		} else {
+			for i := 0; i < objValue.Len(); i++ {
+				name = key + "/" + strconv.Itoa(i)
+				if err := collateKvRecursive(objValue.Index(i), kv, name); err != nil {
+					return err
+				}
+			}
+		}
+	case reflect.Interface, reflect.String, reflect.Bool, reflect.Int, reflect.Int8, reflect.Int16,
+		reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16,
+		reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.Float32, reflect.Float64:
+		if _, ok := kv[name]; ok {
+			return errors.New("key already exists: " + name)
+		}
+		kv[name] = fmt.Sprint(objValue)
+
+	default:
+		return fmt.Errorf("Kind %s not supported", kind.String())
+	}
+	return nil
+}
+
+// ListRecursive lists all key value childrens under key
+func (kv *KvSource) ListRecursive(key string, pairs map[string][]byte) error {
+	pairsN1, err := kv.List(key)
+	if err == store.ErrKeyNotFound {
+		return nil
+	}
+	if err != nil {
+		return err
+	}
+	if len(pairsN1) == 0 {
+		pairLeaf, err := kv.Get(key)
+		if err != nil {
+			return err
+		}
+		if pairLeaf == nil {
+			return nil
+		}
+		pairs[pairLeaf.Key] = pairLeaf.Value
+		return nil
+	}
+	for _, p := range pairsN1 {
+		err := kv.ListRecursive(p.Key, pairs)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func convertPairs(pairs map[string][]byte) []*store.KVPair {
+	slicePairs := make([]*store.KVPair, len(pairs))
+	i := 0
+	for k, v := range pairs {
+		slicePairs[i] = &store.KVPair{
+			Key:   k,
+			Value: v,
+		}
+		i++
+	}
+	return slicePairs
+}

vendor/github.com/containous/staert/staert.go

@@ -0,0 +1,198 @@
+package staert
+
+import (
+	"fmt"
+	"github.com/BurntSushi/toml"
+	"github.com/containous/flaeg"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+)
+
+// Source interface must be satisfy to Add any kink of Source to Staert as like as TomlFile or Flaeg
+type Source interface {
+	Parse(cmd *flaeg.Command) (*flaeg.Command, error)
+}
+
+// Staert contains the struct to configure, thee default values inside structs and the sources
+type Staert struct {
+	command *flaeg.Command
+	sources []Source
+}
+
+// NewStaert creats and return a pointer on Staert. Need defaultConfig and defaultPointersConfig given by references
+func NewStaert(rootCommand *flaeg.Command) *Staert {
+	s := Staert{
+		command: rootCommand,
+	}
+	return &s
+}
+
+// AddSource adds new Source to Staert, give it by reference
+func (s *Staert) AddSource(src Source) {
+	s.sources = append(s.sources, src)
+}
+
+// getConfig for a flaeg.Command run sources Parse func in the raw
+func (s *Staert) parseConfigAllSources(cmd *flaeg.Command) error {
+	for _, src := range s.sources {
+		var err error
+		_, err = src.Parse(cmd)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// LoadConfig check which command is called and parses config
+// It returns the the parsed config or an error if it fails
+func (s *Staert) LoadConfig() (interface{}, error) {
+	for _, src := range s.sources {
+		//Type assertion
+		f, ok := src.(*flaeg.Flaeg)
+		if ok {
+			if fCmd, err := f.GetCommand(); err != nil {
+				return nil, err
+			} else if s.command != fCmd {
+				//IF fleag sub-command
+				if fCmd.Metadata["parseAllSources"] == "true" {
+					//IF parseAllSources
+					fCmdConfigType := reflect.TypeOf(fCmd.Config)
+					sCmdConfigType := reflect.TypeOf(s.command.Config)
+					if fCmdConfigType != sCmdConfigType {
+						return nil, fmt.Errorf("Command %s : Config type doesn't match with root command config type. Expected %s got %s", fCmd.Name, sCmdConfigType.Name(), fCmdConfigType.Name())
+					}
+					s.command = fCmd
+				} else {
+					// ELSE (not parseAllSources)
+					s.command, err = f.Parse(fCmd)
+					return s.command.Config, err
+				}
+			}
+		}
+	}
+	err := s.parseConfigAllSources(s.command)
+	return s.command.Config, err
+}
+
+// Run calls the Run func of the command
+// Warning, Run doesn't parse the config
+func (s *Staert) Run() error {
+	return s.command.Run()
+}
+
+//TomlSource impement Source
+type TomlSource struct {
+	filename     string
+	dirNfullpath []string
+	fullpath     string
+}
+
+// NewTomlSource creats and return a pointer on TomlSource.
+// Parameter filename is the file name (without extension type, ".toml" will be added)
+// dirNfullpath may contain directories or fullpath to the file.
+func NewTomlSource(filename string, dirNfullpath []string) *TomlSource {
+	return &TomlSource{filename, dirNfullpath, ""}
+}
+
+// ConfigFileUsed return config file used
+func (ts *TomlSource) ConfigFileUsed() string {
+	return ts.fullpath
+}
+
+func preprocessDir(dirIn string) (string, error) {
+	dirOut := dirIn
+	if strings.HasPrefix(dirIn, "$") {
+		end := strings.Index(dirIn, string(os.PathSeparator))
+		if end == -1 {
+			end = len(dirIn)
+		}
+		dirOut = os.Getenv(dirIn[1:end]) + dirIn[end:]
+	}
+	dirOut, err := filepath.Abs(dirOut)
+	return dirOut, err
+}
+
+func findFile(filename string, dirNfile []string) string {
+	for _, df := range dirNfile {
+		if df != "" {
+			fullpath, _ := preprocessDir(df)
+			if fileinfo, err := os.Stat(fullpath); err == nil && !fileinfo.IsDir() {
+				return fullpath
+			}
+			fullpath = fullpath + "/" + filename + ".toml"
+			if fileinfo, err := os.Stat(fullpath); err == nil && !fileinfo.IsDir() {
+				return fullpath
+			}
+		}
+	}
+	return ""
+}
+
+// Parse calls toml.DecodeFile() func
+func (ts *TomlSource) Parse(cmd *flaeg.Command) (*flaeg.Command, error) {
+	ts.fullpath = findFile(ts.filename, ts.dirNfullpath)
+	if len(ts.fullpath) < 2 {
+		return cmd, nil
+	}
+	metadata, err := toml.DecodeFile(ts.fullpath, cmd.Config)
+	if err != nil {
+		return nil, err
+	}
+	boolFlags, err := flaeg.GetBoolFlags(cmd.Config)
+	if err != nil {
+		return nil, err
+	}
+	flaegArgs, hasUnderField, err := generateArgs(metadata, boolFlags)
+	if err != nil {
+		return nil, err
+	}
+
+	// fmt.Println(flaegArgs)
+	err = flaeg.Load(cmd.Config, cmd.DefaultPointersConfig, flaegArgs)
+	//if err!= missing parser err
+	if err != nil && err != flaeg.ErrParserNotFound {
+		return nil, err
+	}
+	if hasUnderField {
+		_, err := toml.DecodeFile(ts.fullpath, cmd.Config)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return cmd, nil
+}
+
+func generateArgs(metadata toml.MetaData, flags []string) ([]string, bool, error) {
+	flaegArgs := []string{}
+	keys := metadata.Keys()
+	hasUnderField := false
+	for i, key := range keys {
+		// fmt.Println(key)
+		if metadata.Type(key.String()) == "Hash" {
+			// TOML hashes correspond to Go structs or maps.
+			// fmt.Printf("%s could be a ptr on a struct, or a map\n", key)
+			for j := i; j < len(keys); j++ {
+				// fmt.Printf("%s =? %s\n", keys[j].String(), "."+key.String())
+				if strings.Contains(keys[j].String(), key.String()+".") {
+					hasUnderField = true
+					break
+				}
+			}
+			match := false
+			for _, flag := range flags {
+				if flag == strings.ToLower(key.String()) {
+					match = true
+					break
+				}
+			}
+			if match {
+				flaegArgs = append(flaegArgs, "--"+strings.ToLower(key.String()))
+			}
+		}
+	}
+	return flaegArgs, hasUnderField, nil
+}