-
Notifications
You must be signed in to change notification settings - Fork 38
/
validators.go
112 lines (101 loc) · 4.77 KB
/
validators.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
package builtin_argument
import (
"github.com/kurtosis-tech/kurtosis/core/server/api_container/server/startosis_engine/startosis_errors"
"go.starlark.net/starlark"
"reflect"
"regexp"
"strings"
"time"
)
func NonEmptyString(value starlark.Value, argNameForLogging string) *startosis_errors.InterpretationError {
valueStr, ok := value.(starlark.String)
if !ok {
return startosis_errors.NewInterpretationError("Value for '%s' was expected to be a starlark.String but was '%s'", argNameForLogging, reflect.TypeOf(value))
}
if len(valueStr.GoString()) == 0 {
return startosis_errors.NewInterpretationError("Value for '%s' was an empty string. This is disallowed", argNameForLogging)
}
return nil
}
func Uint64InRange(value starlark.Value, argNameForLogging string, min uint64, max uint64) *startosis_errors.InterpretationError {
valueInt, ok := value.(starlark.Int)
if !ok {
return startosis_errors.NewInterpretationError("Value for '%s' was expected to be an integer between %d and %d, but it was '%s'", argNameForLogging, min, max, reflect.TypeOf(value))
}
valueUint64, ok := valueInt.Uint64()
if !ok {
return startosis_errors.NewInterpretationError("Value for '%s' was expected to be an integer between %d and %d, but it was %v", argNameForLogging, min, max, valueInt)
}
if valueUint64 < min || valueUint64 > max {
return startosis_errors.NewInterpretationError("Value for '%s' was expected to be an integer between %d and %d, but it was %v", argNameForLogging, min, max, valueUint64)
}
return nil
}
func FloatInRange(value starlark.Value, argNameForLogging string, min float64, max float64) *startosis_errors.InterpretationError {
valueStarlarkFloat, ok := value.(starlark.Float)
if !ok {
return startosis_errors.NewInterpretationError("Value for '%s' was expected to be a float between %f and %f, but it was '%s'", argNameForLogging, min, max, reflect.TypeOf(value))
}
valueFloat := float64(valueStarlarkFloat)
if !ok {
return startosis_errors.NewInterpretationError("Value for '%s' was expected to be a float between %f and %f, but it was %v", argNameForLogging, min, max, valueFloat)
}
if valueFloat < min || valueFloat > max {
return startosis_errors.NewInterpretationError("Value for '%s' was expected to be a float between %f and %f, but it was %v", argNameForLogging, min, max, valueFloat)
}
return nil
}
func StringValues(value starlark.Value, argNameForLogging string, acceptableValues []string) *startosis_errors.InterpretationError {
valueStr, ok := value.(starlark.String)
if !ok {
return startosis_errors.NewInterpretationError("Value for '%s' was expected to be a starlark.String but was '%s'", argNameForLogging, reflect.TypeOf(value))
}
for _, acceptableValue := range acceptableValues {
if acceptableValue == valueStr.GoString() {
return nil
}
}
return startosis_errors.NewInterpretationError("Invalid argument value for '%s': '%s'. Valid values are %s", argNameForLogging, valueStr.GoString(), strings.Join(acceptableValues, ", "))
}
func StringRegexp(value starlark.Value, argNameForLogging string, mustMatchRegexpStr string) *startosis_errors.InterpretationError {
mustMatchRegexp := regexp.MustCompile(mustMatchRegexpStr)
valueStr, ok := value.(starlark.String)
if !ok {
return startosis_errors.NewInterpretationError("Value for '%s' was expected to be a starlark.String but was '%s'", argNameForLogging, reflect.TypeOf(value))
}
doesMatch := mustMatchRegexp.MatchString(valueStr.GoString())
if doesMatch {
return nil
}
return startosis_errors.NewInterpretationError(
"Argument '%s' must match regexp: '%v'. Its value was '%s'",
argNameForLogging,
mustMatchRegexpStr,
valueStr.GoString(),
)
}
func Duration(value starlark.Value, attributeName string) *startosis_errors.InterpretationError {
valueStarlarkStr, ok := value.(starlark.String)
if !ok {
return startosis_errors.NewInterpretationError("The '%s' attribute is not a valid string type (was '%s').", attributeName, reflect.TypeOf(value))
}
if valueStarlarkStr.GoString() == "" {
return nil
}
_, parseErr := time.ParseDuration(valueStarlarkStr.GoString())
if parseErr != nil {
return startosis_errors.WrapWithInterpretationError(parseErr, "The value '%v' of '%s' attribute is not a valid duration string format", valueStarlarkStr.GoString(), attributeName)
}
return nil
}
func DurationOrNone(value starlark.Value, attributeName string) *startosis_errors.InterpretationError {
// the value can be a string duration, or it can be a Starlark none value (which usually is used to disable the argument and his behaviour)
if _, ok := value.(starlark.NoneType); !ok {
// we do not accept empty string as a none wait config
if interpretationErr := NonEmptyString(value, attributeName); interpretationErr != nil {
return interpretationErr
}
return Duration(value, attributeName)
}
return nil
}