func parseRoutes(input generic.Map, errs *[]error) []models.ManifestRoute {
if !input.Has("routes") {
return nil
}
genericRoutes, ok := input.Get("routes").([]interface{})
if !ok {
*errs = append(*errs, fmt.Errorf(T("'routes' should be a list")))
return nil
}
manifestRoutes := []models.ManifestRoute{}
for _, genericRoute := range genericRoutes {
route, ok := genericRoute.(map[interface{}]interface{})
if !ok {
*errs = append(*errs, fmt.Errorf(T("each route in 'routes' must have a 'route' property")))
continue
}
if routeVal, exist := route["route"]; exist {
manifestRoutes = append(manifestRoutes, models.ManifestRoute{
Route: routeVal.(string),
})
} else {
*errs = append(*errs, fmt.Errorf(T("each route in 'routes' must have a 'route' property")))
}
}
return manifestRoutes
}
func intSliceVal(yamlMap generic.Map, key string, errs *[]error) *[]int {
if !yamlMap.Has(key) {
return nil
}
err := fmt.Errorf(T("Expected {{.PropertyName}} to be a list of integers.", map[string]interface{}{"PropertyName": key}))
s, ok := yamlMap.Get(key).([]interface{})
if !ok {
*errs = append(*errs, err)
return nil
}
var intSlice []int
for _, el := range s {
intValue, ok := el.(int)
if !ok {
*errs = append(*errs, err)
return nil
}
intSlice = append(intSlice, intValue)
}
return &intSlice
}
func sliceOrNil(yamlMap generic.Map, key string, errs *[]error) []string {
if !yamlMap.Has(key) {
return nil
}
var err error
stringSlice := []string{}
sliceErr := fmt.Errorf(T("Expected {{.PropertyName}} to be a list of strings.", map[string]interface{}{"PropertyName": key}))
switch input := yamlMap.Get(key).(type) {
case []interface{}:
for _, value := range input {
stringValue, ok := value.(string)
if !ok {
err = sliceErr
break
}
stringSlice = append(stringSlice, stringValue)
}
default:
err = sliceErr
}
if err != nil {
*errs = append(*errs, err)
return []string{}
}
return stringSlice
}
func formatDescription(metadata generic.Map, keys []string) string {
parts := []string{}
for _, key := range keys {
value := metadata.Get(key)
if value != nil {
parts = append(parts, fmt.Sprintf("%s: %s", key, formatDescriptionPart(value)))
}
}
return strings.Join(parts, ", ")
}
func envVarOrEmptyMap(yamlMap generic.Map, errs *[]error) *map[string]interface{} {
key := "env"
switch envVars := yamlMap.Get(key).(type) {
case nil:
aMap := make(map[string]interface{}, 0)
return &aMap
case map[string]interface{}:
yamlMap.Set(key, generic.NewMap(yamlMap.Get(key)))
return envVarOrEmptyMap(yamlMap, errs)
case map[interface{}]interface{}:
yamlMap.Set(key, generic.NewMap(yamlMap.Get(key)))
return envVarOrEmptyMap(yamlMap, errs)
case generic.Map:
merrs := validateEnvVars(envVars)
if merrs != nil {
*errs = append(*errs, merrs...)
return nil
}
result := make(map[string]interface{}, envVars.Count())
generic.Each(envVars, func(key, value interface{}) {
result[key.(string)] = value
})
return &result
default:
*errs = append(*errs, fmt.Errorf(T("Expected {{.Name}} to be a set of key => value, but it was a {{.Type}}.",
map[string]interface{}{"Name": key, "Type": envVars})))
return nil
}
}
func stringVal(yamlMap generic.Map, key string, errs *[]error) *string {
val := yamlMap.Get(key)
if val == nil {
return nil
}
result, ok := val.(string)
if !ok {
*errs = append(*errs, fmt.Errorf(T("{{.PropertyName}} must be a string value", map[string]interface{}{"PropertyName": key})))
return nil
}
return &result
}
func intVal(yamlMap generic.Map, key string, errs *[]error) *int {
var (
intVal int
err error
)
switch val := yamlMap.Get(key).(type) {
case string:
intVal, err = strconv.Atoi(val)
case int:
intVal = val
case int64:
intVal = int(val)
case nil:
return nil
default:
err = fmt.Errorf(T("Expected {{.PropertyName}} to be a number, but it was a {{.PropertyType}}.",
map[string]interface{}{"PropertyName": key, "PropertyType": val}))
}
if err != nil {
*errs = append(*errs, err)
return nil
}
return &intVal
}
func stringValOrDefault(yamlMap generic.Map, key string, errs *[]error) *string {
if !yamlMap.Has(key) {
return nil
}
empty := ""
switch val := yamlMap.Get(key).(type) {
case string:
if val == "default" {
return &empty
}
return &val
case nil:
return &empty
default:
*errs = append(*errs, fmt.Errorf(T("{{.PropertyName}} must be a string or null value", map[string]interface{}{"PropertyName": key})))
return nil
}
}
func bytesVal(yamlMap generic.Map, key string, errs *[]error) *int64 {
yamlVal := yamlMap.Get(key)
if yamlVal == nil {
return nil
}
stringVal := coerceToString(yamlVal)
value, err := formatters.ToMegabytes(stringVal)
if err != nil {
*errs = append(*errs, fmt.Errorf(T("Invalid value for '{{.PropertyName}}': {{.StringVal}}\n{{.Error}}",
map[string]interface{}{
"PropertyName": key,
"Error": err.Error(),
"StringVal": stringVal,
})))
return nil
}
return &value
}
func (m Manifest) getAppMaps(data generic.Map) ([]generic.Map, error) {
globalProperties := data.Except([]interface{}{"applications"})
var apps []generic.Map
var errs []error
if data.Has("applications") {
appMaps, ok := data.Get("applications").([]interface{})
if !ok {
return []generic.Map{}, errors.New(T("Expected applications to be a list"))
}
for _, appData := range appMaps {
if !generic.IsMappable(appData) {
errs = append(errs, fmt.Errorf(T("Expected application to be a list of key/value pairs\nError occurred in manifest near:\n'{{.YmlSnippet}}'",
map[string]interface{}{"YmlSnippet": appData})))
continue
}
appMap := generic.DeepMerge(globalProperties, generic.NewMap(appData))
apps = append(apps, appMap)
}
} else {
apps = append(apps, globalProperties)
}
if len(errs) > 0 {
message := ""
for i := range errs {
message = message + fmt.Sprintf("%s\n", errs[i].Error())
}
return []generic.Map{}, errors.New(message)
}
return apps, nil
}
func boolVal(yamlMap generic.Map, key string, errs *[]error) bool {
switch val := yamlMap.Get(key).(type) {
case nil:
return false
case bool:
return val
case string:
return val == "true"
default:
*errs = append(*errs, fmt.Errorf(T("Expected {{.PropertyName}} to be a boolean.", map[string]interface{}{"PropertyName": key})))
return false
}
}