podman

1
// Copyright 2013-2022 Frank Schroeder. All rights reserved.
2
// Use of this source code is governed by a BSD-style
3
// license that can be found in the LICENSE file.
4

5
package properties
6

7
import (
8
	"fmt"
9
	"reflect"
10
	"strconv"
11
	"strings"
12
	"time"
13
)
14

15
// Decode assigns property values to exported fields of a struct.
16
//
17
// Decode traverses v recursively and returns an error if a value cannot be
18
// converted to the field type or a required value is missing for a field.
19
//
20
// The following type dependent decodings are used:
21
//
22
// String, boolean, numeric fields have the value of the property key assigned.
23
// The property key name is the name of the field. A different key and a default
24
// value can be set in the field's tag. Fields without default value are
25
// required. If the value cannot be converted to the field type an error is
26
// returned.
27
//
28
// time.Duration fields have the result of time.ParseDuration() assigned.
29
//
30
// time.Time fields have the vaule of time.Parse() assigned. The default layout
31
// is time.RFC3339 but can be set in the field's tag.
32
//
33
// Arrays and slices of string, boolean, numeric, time.Duration and time.Time
34
// fields have the value interpreted as a comma separated list of values. The
35
// individual values are trimmed of whitespace and empty values are ignored. A
36
// default value can be provided as a semicolon separated list in the field's
37
// tag.
38
//
39
// Struct fields are decoded recursively using the field name plus "." as
40
// prefix. The prefix (without dot) can be overridden in the field's tag.
41
// Default values are not supported in the field's tag. Specify them on the
42
// fields of the inner struct instead.
43
//
44
// Map fields must have a key of type string and are decoded recursively by
45
// using the field's name plus ".' as prefix and the next element of the key
46
// name as map key. The prefix (without dot) can be overridden in the field's
47
// tag. Default values are not supported.
48
//
49
// Examples:
50
//
51
//	// Field is ignored.
52
//	Field int `properties:"-"`
53
//
54
//	// Field is assigned value of 'Field'.
55
//	Field int
56
//
57
//	// Field is assigned value of 'myName'.
58
//	Field int `properties:"myName"`
59
//
60
//	// Field is assigned value of key 'myName' and has a default
61
//	// value 15 if the key does not exist.
62
//	Field int `properties:"myName,default=15"`
63
//
64
//	// Field is assigned value of key 'Field' and has a default
65
//	// value 15 if the key does not exist.
66
//	Field int `properties:",default=15"`
67
//
68
//	// Field is assigned value of key 'date' and the date
69
//	// is in format 2006-01-02
70
//	Field time.Time `properties:"date,layout=2006-01-02"`
71
//
72
//	// Field is assigned the non-empty and whitespace trimmed
73
//	// values of key 'Field' split by commas.
74
//	Field []string
75
//
76
//	// Field is assigned the non-empty and whitespace trimmed
77
//	// values of key 'Field' split by commas and has a default
78
//	// value ["a", "b", "c"] if the key does not exist.
79
//	Field []string `properties:",default=a;b;c"`
80
//
81
//	// Field is decoded recursively with "Field." as key prefix.
82
//	Field SomeStruct
83
//
84
//	// Field is decoded recursively with "myName." as key prefix.
85
//	Field SomeStruct `properties:"myName"`
86
//
87
//	// Field is decoded recursively with "Field." as key prefix
88
//	// and the next dotted element of the key as map key.
89
//	Field map[string]string
90
//
91
//	// Field is decoded recursively with "myName." as key prefix
92
//	// and the next dotted element of the key as map key.
93
//	Field map[string]string `properties:"myName"`
94
func (p *Properties) Decode(x interface{}) error {
95
	t, v := reflect.TypeOf(x), reflect.ValueOf(x)
96
	if t.Kind() != reflect.Ptr || v.Elem().Type().Kind() != reflect.Struct {
97
		return fmt.Errorf("not a pointer to struct: %s", t)
98
	}
99
	if err := dec(p, "", nil, nil, v); err != nil {
100
		return err
101
	}
102
	return nil
103
}
104

105
func dec(p *Properties, key string, def *string, opts map[string]string, v reflect.Value) error {
106
	t := v.Type()
107

108
	// value returns the property value for key or the default if provided.
109
	value := func() (string, error) {
110
		if val, ok := p.Get(key); ok {
111
			return val, nil
112
		}
113
		if def != nil {
114
			return *def, nil
115
		}
116
		return "", fmt.Errorf("missing required key %s", key)
117
	}
118

119
	// conv converts a string to a value of the given type.
120
	conv := func(s string, t reflect.Type) (val reflect.Value, err error) {
121
		var v interface{}
122

123
		switch {
124
		case isDuration(t):
125
			v, err = time.ParseDuration(s)
126

127
		case isTime(t):
128
			layout := opts["layout"]
129
			if layout == "" {
130
				layout = time.RFC3339
131
			}
132
			v, err = time.Parse(layout, s)
133

134
		case isBool(t):
135
			v, err = boolVal(s), nil
136

137
		case isString(t):
138
			v, err = s, nil
139

140
		case isFloat(t):
141
			v, err = strconv.ParseFloat(s, 64)
142

143
		case isInt(t):
144
			v, err = strconv.ParseInt(s, 10, 64)
145

146
		case isUint(t):
147
			v, err = strconv.ParseUint(s, 10, 64)
148

149
		default:
150
			return reflect.Zero(t), fmt.Errorf("unsupported type %s", t)
151
		}
152
		if err != nil {
153
			return reflect.Zero(t), err
154
		}
155
		return reflect.ValueOf(v).Convert(t), nil
156
	}
157

158
	// keydef returns the property key and the default value based on the
159
	// name of the struct field and the options in the tag.
160
	keydef := func(f reflect.StructField) (string, *string, map[string]string) {
161
		_key, _opts := parseTag(f.Tag.Get("properties"))
162

163
		var _def *string
164
		if d, ok := _opts["default"]; ok {
165
			_def = &d
166
		}
167
		if _key != "" {
168
			return _key, _def, _opts
169
		}
170
		return f.Name, _def, _opts
171
	}
172

173
	switch {
174
	case isDuration(t) || isTime(t) || isBool(t) || isString(t) || isFloat(t) || isInt(t) || isUint(t):
175
		s, err := value()
176
		if err != nil {
177
			return err
178
		}
179
		val, err := conv(s, t)
180
		if err != nil {
181
			return err
182
		}
183
		v.Set(val)
184

185
	case isPtr(t):
186
		return dec(p, key, def, opts, v.Elem())
187

188
	case isStruct(t):
189
		for i := 0; i < v.NumField(); i++ {
190
			fv := v.Field(i)
191
			fk, def, opts := keydef(t.Field(i))
192
			if !fv.CanSet() {
193
				return fmt.Errorf("cannot set %s", t.Field(i).Name)
194
			}
195
			if fk == "-" {
196
				continue
197
			}
198
			if key != "" {
199
				fk = key + "." + fk
200
			}
201
			if err := dec(p, fk, def, opts, fv); err != nil {
202
				return err
203
			}
204
		}
205
		return nil
206

207
	case isArray(t):
208
		val, err := value()
209
		if err != nil {
210
			return err
211
		}
212
		vals := split(val, ";")
213
		a := reflect.MakeSlice(t, 0, len(vals))
214
		for _, s := range vals {
215
			val, err := conv(s, t.Elem())
216
			if err != nil {
217
				return err
218
			}
219
			a = reflect.Append(a, val)
220
		}
221
		v.Set(a)
222

223
	case isMap(t):
224
		valT := t.Elem()
225
		m := reflect.MakeMap(t)
226
		for postfix := range p.FilterStripPrefix(key + ".").m {
227
			pp := strings.SplitN(postfix, ".", 2)
228
			mk, mv := pp[0], reflect.New(valT)
229
			if err := dec(p, key+"."+mk, nil, nil, mv); err != nil {
230
				return err
231
			}
232
			m.SetMapIndex(reflect.ValueOf(mk), mv.Elem())
233
		}
234
		v.Set(m)
235

236
	default:
237
		return fmt.Errorf("unsupported type %s", t)
238
	}
239
	return nil
240
}
241

242
// split splits a string on sep, trims whitespace of elements
243
// and omits empty elements
244
func split(s string, sep string) []string {
245
	var a []string
246
	for _, v := range strings.Split(s, sep) {
247
		if v = strings.TrimSpace(v); v != "" {
248
			a = append(a, v)
249
		}
250
	}
251
	return a
252
}
253

254
// parseTag parses a "key,k=v,k=v,..."
255
func parseTag(tag string) (key string, opts map[string]string) {
256
	opts = map[string]string{}
257
	for i, s := range strings.Split(tag, ",") {
258
		if i == 0 {
259
			key = s
260
			continue
261
		}
262

263
		pp := strings.SplitN(s, "=", 2)
264
		if len(pp) == 1 {
265
			opts[pp[0]] = ""
266
		} else {
267
			opts[pp[0]] = pp[1]
268
		}
269
	}
270
	return key, opts
271
}
272

273
func isArray(t reflect.Type) bool    { return t.Kind() == reflect.Array || t.Kind() == reflect.Slice }
274
func isBool(t reflect.Type) bool     { return t.Kind() == reflect.Bool }
275
func isDuration(t reflect.Type) bool { return t == reflect.TypeOf(time.Second) }
276
func isMap(t reflect.Type) bool      { return t.Kind() == reflect.Map }
277
func isPtr(t reflect.Type) bool      { return t.Kind() == reflect.Ptr }
278
func isString(t reflect.Type) bool   { return t.Kind() == reflect.String }
279
func isStruct(t reflect.Type) bool   { return t.Kind() == reflect.Struct }
280
func isTime(t reflect.Type) bool     { return t == reflect.TypeOf(time.Time{}) }
281
func isFloat(t reflect.Type) bool {
282
	return t.Kind() == reflect.Float32 || t.Kind() == reflect.Float64
283
}
284
func isInt(t reflect.Type) bool {
285
	return t.Kind() == reflect.Int || t.Kind() == reflect.Int8 || t.Kind() == reflect.Int16 || t.Kind() == reflect.Int32 || t.Kind() == reflect.Int64
286
}
287
func isUint(t reflect.Type) bool {
288
	return t.Kind() == reflect.Uint || t.Kind() == reflect.Uint8 || t.Kind() == reflect.Uint16 || t.Kind() == reflect.Uint32 || t.Kind() == reflect.Uint64
289
}
290