mirror of
https://github.com/ceph/ceph-csi.git
synced 2024-12-04 20:20:19 +00:00
3c0e1b4970
Bumps [github.com/hashicorp/vault/api](https://github.com/hashicorp/vault) from 1.5.0 to 1.6.0. - [Release notes](https://github.com/hashicorp/vault/releases) - [Changelog](https://github.com/hashicorp/vault/blob/main/CHANGELOG.md) - [Commits](https://github.com/hashicorp/vault/compare/v1.5.0...v1.6.0) --- updated-dependencies: - dependency-name: github.com/hashicorp/vault/api dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com>
280 lines
6.7 KiB
Go
280 lines
6.7 KiB
Go
package mapstructure
|
|
|
|
import (
|
|
"encoding"
|
|
"errors"
|
|
"fmt"
|
|
"net"
|
|
"reflect"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// typedDecodeHook takes a raw DecodeHookFunc (an interface{}) and turns
|
|
// it into the proper DecodeHookFunc type, such as DecodeHookFuncType.
|
|
func typedDecodeHook(h DecodeHookFunc) DecodeHookFunc {
|
|
// Create variables here so we can reference them with the reflect pkg
|
|
var f1 DecodeHookFuncType
|
|
var f2 DecodeHookFuncKind
|
|
var f3 DecodeHookFuncValue
|
|
|
|
// Fill in the variables into this interface and the rest is done
|
|
// automatically using the reflect package.
|
|
potential := []interface{}{f1, f2, f3}
|
|
|
|
v := reflect.ValueOf(h)
|
|
vt := v.Type()
|
|
for _, raw := range potential {
|
|
pt := reflect.ValueOf(raw).Type()
|
|
if vt.ConvertibleTo(pt) {
|
|
return v.Convert(pt).Interface()
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// DecodeHookExec executes the given decode hook. This should be used
|
|
// since it'll naturally degrade to the older backwards compatible DecodeHookFunc
|
|
// that took reflect.Kind instead of reflect.Type.
|
|
func DecodeHookExec(
|
|
raw DecodeHookFunc,
|
|
from reflect.Value, to reflect.Value) (interface{}, error) {
|
|
|
|
switch f := typedDecodeHook(raw).(type) {
|
|
case DecodeHookFuncType:
|
|
return f(from.Type(), to.Type(), from.Interface())
|
|
case DecodeHookFuncKind:
|
|
return f(from.Kind(), to.Kind(), from.Interface())
|
|
case DecodeHookFuncValue:
|
|
return f(from, to)
|
|
default:
|
|
return nil, errors.New("invalid decode hook signature")
|
|
}
|
|
}
|
|
|
|
// ComposeDecodeHookFunc creates a single DecodeHookFunc that
|
|
// automatically composes multiple DecodeHookFuncs.
|
|
//
|
|
// The composed funcs are called in order, with the result of the
|
|
// previous transformation.
|
|
func ComposeDecodeHookFunc(fs ...DecodeHookFunc) DecodeHookFunc {
|
|
return func(f reflect.Value, t reflect.Value) (interface{}, error) {
|
|
var err error
|
|
data := f.Interface()
|
|
|
|
newFrom := f
|
|
for _, f1 := range fs {
|
|
data, err = DecodeHookExec(f1, newFrom, t)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
newFrom = reflect.ValueOf(data)
|
|
}
|
|
|
|
return data, nil
|
|
}
|
|
}
|
|
|
|
// OrComposeDecodeHookFunc executes all input hook functions until one of them returns no error. In that case its value is returned.
|
|
// If all hooks return an error, OrComposeDecodeHookFunc returns an error concatenating all error messages.
|
|
func OrComposeDecodeHookFunc(ff ...DecodeHookFunc) DecodeHookFunc {
|
|
return func(a, b reflect.Value) (interface{}, error) {
|
|
var allErrs string
|
|
var out interface{}
|
|
var err error
|
|
|
|
for _, f := range ff {
|
|
out, err = DecodeHookExec(f, a, b)
|
|
if err != nil {
|
|
allErrs += err.Error() + "\n"
|
|
continue
|
|
}
|
|
|
|
return out, nil
|
|
}
|
|
|
|
return nil, errors.New(allErrs)
|
|
}
|
|
}
|
|
|
|
// StringToSliceHookFunc returns a DecodeHookFunc that converts
|
|
// string to []string by splitting on the given sep.
|
|
func StringToSliceHookFunc(sep string) DecodeHookFunc {
|
|
return func(
|
|
f reflect.Kind,
|
|
t reflect.Kind,
|
|
data interface{}) (interface{}, error) {
|
|
if f != reflect.String || t != reflect.Slice {
|
|
return data, nil
|
|
}
|
|
|
|
raw := data.(string)
|
|
if raw == "" {
|
|
return []string{}, nil
|
|
}
|
|
|
|
return strings.Split(raw, sep), nil
|
|
}
|
|
}
|
|
|
|
// StringToTimeDurationHookFunc returns a DecodeHookFunc that converts
|
|
// strings to time.Duration.
|
|
func StringToTimeDurationHookFunc() DecodeHookFunc {
|
|
return func(
|
|
f reflect.Type,
|
|
t reflect.Type,
|
|
data interface{}) (interface{}, error) {
|
|
if f.Kind() != reflect.String {
|
|
return data, nil
|
|
}
|
|
if t != reflect.TypeOf(time.Duration(5)) {
|
|
return data, nil
|
|
}
|
|
|
|
// Convert it by parsing
|
|
return time.ParseDuration(data.(string))
|
|
}
|
|
}
|
|
|
|
// StringToIPHookFunc returns a DecodeHookFunc that converts
|
|
// strings to net.IP
|
|
func StringToIPHookFunc() DecodeHookFunc {
|
|
return func(
|
|
f reflect.Type,
|
|
t reflect.Type,
|
|
data interface{}) (interface{}, error) {
|
|
if f.Kind() != reflect.String {
|
|
return data, nil
|
|
}
|
|
if t != reflect.TypeOf(net.IP{}) {
|
|
return data, nil
|
|
}
|
|
|
|
// Convert it by parsing
|
|
ip := net.ParseIP(data.(string))
|
|
if ip == nil {
|
|
return net.IP{}, fmt.Errorf("failed parsing ip %v", data)
|
|
}
|
|
|
|
return ip, nil
|
|
}
|
|
}
|
|
|
|
// StringToIPNetHookFunc returns a DecodeHookFunc that converts
|
|
// strings to net.IPNet
|
|
func StringToIPNetHookFunc() DecodeHookFunc {
|
|
return func(
|
|
f reflect.Type,
|
|
t reflect.Type,
|
|
data interface{}) (interface{}, error) {
|
|
if f.Kind() != reflect.String {
|
|
return data, nil
|
|
}
|
|
if t != reflect.TypeOf(net.IPNet{}) {
|
|
return data, nil
|
|
}
|
|
|
|
// Convert it by parsing
|
|
_, net, err := net.ParseCIDR(data.(string))
|
|
return net, err
|
|
}
|
|
}
|
|
|
|
// StringToTimeHookFunc returns a DecodeHookFunc that converts
|
|
// strings to time.Time.
|
|
func StringToTimeHookFunc(layout string) DecodeHookFunc {
|
|
return func(
|
|
f reflect.Type,
|
|
t reflect.Type,
|
|
data interface{}) (interface{}, error) {
|
|
if f.Kind() != reflect.String {
|
|
return data, nil
|
|
}
|
|
if t != reflect.TypeOf(time.Time{}) {
|
|
return data, nil
|
|
}
|
|
|
|
// Convert it by parsing
|
|
return time.Parse(layout, data.(string))
|
|
}
|
|
}
|
|
|
|
// WeaklyTypedHook is a DecodeHookFunc which adds support for weak typing to
|
|
// the decoder.
|
|
//
|
|
// Note that this is significantly different from the WeaklyTypedInput option
|
|
// of the DecoderConfig.
|
|
func WeaklyTypedHook(
|
|
f reflect.Kind,
|
|
t reflect.Kind,
|
|
data interface{}) (interface{}, error) {
|
|
dataVal := reflect.ValueOf(data)
|
|
switch t {
|
|
case reflect.String:
|
|
switch f {
|
|
case reflect.Bool:
|
|
if dataVal.Bool() {
|
|
return "1", nil
|
|
}
|
|
return "0", nil
|
|
case reflect.Float32:
|
|
return strconv.FormatFloat(dataVal.Float(), 'f', -1, 64), nil
|
|
case reflect.Int:
|
|
return strconv.FormatInt(dataVal.Int(), 10), nil
|
|
case reflect.Slice:
|
|
dataType := dataVal.Type()
|
|
elemKind := dataType.Elem().Kind()
|
|
if elemKind == reflect.Uint8 {
|
|
return string(dataVal.Interface().([]uint8)), nil
|
|
}
|
|
case reflect.Uint:
|
|
return strconv.FormatUint(dataVal.Uint(), 10), nil
|
|
}
|
|
}
|
|
|
|
return data, nil
|
|
}
|
|
|
|
func RecursiveStructToMapHookFunc() DecodeHookFunc {
|
|
return func(f reflect.Value, t reflect.Value) (interface{}, error) {
|
|
if f.Kind() != reflect.Struct {
|
|
return f.Interface(), nil
|
|
}
|
|
|
|
var i interface{} = struct{}{}
|
|
if t.Type() != reflect.TypeOf(&i).Elem() {
|
|
return f.Interface(), nil
|
|
}
|
|
|
|
m := make(map[string]interface{})
|
|
t.Set(reflect.ValueOf(m))
|
|
|
|
return f.Interface(), nil
|
|
}
|
|
}
|
|
|
|
// TextUnmarshallerHookFunc returns a DecodeHookFunc that applies
|
|
// strings to the UnmarshalText function, when the target type
|
|
// implements the encoding.TextUnmarshaler interface
|
|
func TextUnmarshallerHookFunc() DecodeHookFuncType {
|
|
return func(
|
|
f reflect.Type,
|
|
t reflect.Type,
|
|
data interface{}) (interface{}, error) {
|
|
if f.Kind() != reflect.String {
|
|
return data, nil
|
|
}
|
|
result := reflect.New(t).Interface()
|
|
unmarshaller, ok := result.(encoding.TextUnmarshaler)
|
|
if !ok {
|
|
return data, nil
|
|
}
|
|
if err := unmarshaller.UnmarshalText([]byte(data.(string))); err != nil {
|
|
return nil, err
|
|
}
|
|
return result, nil
|
|
}
|
|
}
|