mirror of https://github.com/pulumi/pulumi.git
150 lines
3.3 KiB
Go
150 lines
3.3 KiB
Go
//go:build exclude
|
|
|
|
package utilities
|
|
|
|
import (
|
|
"github.com/pulumi/pulumi/sdk/v3/go/pulumi/internals"
|
|
)
|
|
|
|
type envParser func(v string) interface{}
|
|
|
|
func ParseEnvBool(v string) interface{} {
|
|
b, err := strconv.ParseBool(v)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return b
|
|
}
|
|
|
|
func ParseEnvInt(v string) interface{} {
|
|
i, err := strconv.ParseInt(v, 0, 0)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return int(i)
|
|
}
|
|
|
|
func ParseEnvFloat(v string) interface{} {
|
|
f, err := strconv.ParseFloat(v, 64)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return f
|
|
}
|
|
|
|
func ParseEnvStringArray(v string) interface{} {
|
|
var result pulumi.StringArray
|
|
for _, item := range strings.Split(v, ";") {
|
|
result = append(result, pulumi.String(item))
|
|
}
|
|
return result
|
|
}
|
|
|
|
func GetEnvOrDefault(def interface{}, parser envParser, vars ...string) interface{} {
|
|
for _, v := range vars {
|
|
if value, ok := os.LookupEnv(v); ok {
|
|
if parser != nil {
|
|
return parser(value)
|
|
}
|
|
return value
|
|
}
|
|
}
|
|
return def
|
|
}
|
|
|
|
// PkgVersion uses reflection to determine the version of the current package.
|
|
// If a version cannot be determined, v1 will be assumed. The second return
|
|
// value is always nil.
|
|
func PkgVersion() (semver.Version, error) {
|
|
// emptyVersion defaults to v0.0.0
|
|
if !SdkVersion.Equals(semver.Version{}) {
|
|
return SdkVersion, nil
|
|
}
|
|
type sentinal struct{}
|
|
pkgPath := reflect.TypeOf(sentinal{}).PkgPath()
|
|
re := regexp.MustCompile("${packageRegex}")
|
|
if match := re.FindStringSubmatch(pkgPath); match != nil {
|
|
vStr := match[1]
|
|
if len(vStr) == 0 { // If the version capture group was empty, default to v1.
|
|
return semver.Version{Major: 1}, nil
|
|
}
|
|
return semver.MustParse(fmt.Sprintf("%s.0.0", vStr[2:])), nil
|
|
}
|
|
return semver.Version{Major: 1}, nil
|
|
}
|
|
|
|
// isZero is a null safe check for if a value is it's types zero value.
|
|
func IsZero(v interface{}) bool {
|
|
if v == nil {
|
|
return true
|
|
}
|
|
return reflect.ValueOf(v).IsZero()
|
|
}
|
|
|
|
func CallPlain(
|
|
ctx *pulumi.Context,
|
|
tok string,
|
|
args pulumi.Input,
|
|
output pulumi.Output,
|
|
self pulumi.Resource,
|
|
property string,
|
|
resultPtr reflect.Value,
|
|
errorPtr *error,
|
|
opts ...pulumi.InvokeOption,
|
|
) {
|
|
res, err := callPlainInner(ctx, tok, args, output, self, opts...)
|
|
if err != nil {
|
|
*errorPtr = err
|
|
return
|
|
}
|
|
|
|
v := reflect.ValueOf(res)
|
|
|
|
// extract res.property field if asked to do so
|
|
if property != "" {
|
|
v = v.FieldByName("Res")
|
|
}
|
|
|
|
// return by setting the result pointer; this style of returns shortens the generated code without generics
|
|
resultPtr.Elem().Set(v)
|
|
}
|
|
|
|
func callPlainInner(
|
|
ctx *pulumi.Context,
|
|
tok string,
|
|
args pulumi.Input,
|
|
output pulumi.Output,
|
|
self pulumi.Resource,
|
|
opts ...pulumi.InvokeOption,
|
|
) (any, error) {
|
|
o, err := ctx.Call(tok, args, output, self, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
outputData, err := internals.UnsafeAwaitOutput(ctx.Context(), o)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Ingoring deps silently. They are typically non-empty, r.f() calls include r as a dependency.
|
|
known := outputData.Known
|
|
value := outputData.Value
|
|
secret := outputData.Secret
|
|
|
|
problem := ""
|
|
if !known {
|
|
problem = "an unknown value"
|
|
} else if secret {
|
|
problem = "a secret value"
|
|
}
|
|
|
|
if problem != "" {
|
|
return nil, fmt.Errorf("Plain resource method %q incorrectly returned %s. "+
|
|
"This is an error in the provider, please report this to the provider developer.",
|
|
tok, problem)
|
|
}
|
|
|
|
return value, nil
|
|
}
|