func mapToAppSet(basePath string, data generic.Map) (appSet []models.AppParams, errs ManifestErrors) {
if data.Has("applications") {
appMaps, ok := data.Get("applications").([]interface{})
if !ok {
errs = append(errs, errors.New("Expected applications to be a list"))
return
}
// we delete applications so that we may merge top level app params into each app
data.Delete("applications")
for _, appData := range appMaps {
if !generic.IsMappable(appData) {
errs = append(errs, errors.New("Expected application to be a dictionary"))
continue
}
appMap := generic.DeepMerge(data, generic.NewMap(appData))
appParams, appErrs := mapToAppParams(basePath, appMap)
if !appErrs.Empty() {
errs = append(errs, appErrs)
continue
}
appSet = append(appSet, appParams)
}
}
return
}
func (m Manifest) getAppMaps(data generic.Map) (apps []generic.Map, errs []error) {
globalProperties := data.Except([]interface{}{"applications"})
if data.Has("applications") {
appMaps, ok := data.Get("applications").([]interface{})
if !ok {
errs = append(errs, errors.New("Expected applications to be a list"))
return
}
for _, appData := range appMaps {
if !generic.IsMappable(appData) {
errs = append(errs, errors.New(fmt.Sprintf("Expected application to be a list of key/value pairs\nError occurred in manifest near:\n'%s'", appData)))
continue
}
appMap := generic.DeepMerge(globalProperties, generic.NewMap(appData))
apps = append(apps, appMap)
}
} else {
apps = append(apps, globalProperties)
}
return
}
func setEnvVar(appMap generic.Map, env interface{}, errs *ManifestErrors) {
if !generic.IsMappable(env) {
*errs = append(*errs, errors.New("Expected env vars to be a set of key => value."))
return
}
merrs := validateEnvVars(env)
if merrs != nil {
*errs = append(*errs, merrs)
return
}
appMap.Set("env", generic.NewMap(env))
}
func parseManifest(file io.Reader) (yamlMap generic.Map, err error) {
decoder := candiedyaml.NewDecoder(file)
yamlMap = generic.NewMap()
err = decoder.Decode(yamlMap)
if err != nil {
return
}
if !generic.IsMappable(yamlMap) {
err = errors.New("Invalid manifest. Expected a map")
return
}
return
}
func parseManifest(file io.Reader) (yamlMap generic.Map, err error) {
yamlBytes, err := ioutil.ReadAll(file)
if err != nil {
return
}
document, err := gamble.Parse(string(yamlBytes))
if err != nil {
return
}
if !generic.IsMappable(document) {
err = errors.New("Invalid manifest. Expected a map")
return
}
yamlMap = generic.NewMap(document)
return
}
func setEnvVarOrEmptyMap(appMap, yamlMap generic.Map, key string, errs *ManifestErrors) {
if !yamlMap.Has(key) {
appMap.Set(key, generic.NewMap())
return
}
envVars := yamlMap.Get(key)
if !generic.IsMappable(envVars) {
*errs = append(*errs, errors.New(fmt.Sprintf("Expected %s to be a set of key => value.", key)))
return
}
merrs := validateEnvVars(envVars)
if merrs != nil {
*errs = append(*errs, merrs)
return
}
appMap.Set(key, generic.NewMap(envVars))
}