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(T("Expected applications to be a list")))
return
}
for _, appData := range appMaps {
if !generic.IsMappable(appData) {
errs = append(errs, errors.NewWithFmt(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)
}
return
}
func (cmd CreateBuildpack) createBuildpack(buildpackName string, c *cli.Context) (buildpack models.Buildpack, apiErr error) {
position, err := strconv.Atoi(c.Args()[2])
if err != nil {
apiErr = errors.NewWithFmt(T("Invalid position. {{.ErrorDescription}}", map[string]interface{}{"ErrorDescription": err.Error()}))
return
}
enabled := c.Bool("enable")
disabled := c.Bool("disable")
if enabled && disabled {
apiErr = errors.New(T("Cannot specify both {{.Enabled}} and {{.Disabled}}.", map[string]interface{}{
"Enabled": "enabled",
"Disabled": "disabled",
}))
return
}
var enableOption *bool = nil
if enabled {
enableOption = &enabled
}
if disabled {
disabled = false
enableOption = &disabled
}
buildpack, apiErr = cmd.buildpackRepo.Create(buildpackName, &position, enableOption, nil)
return
}
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 = errors.NewWithFmt(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 sliceOrEmptyVal(yamlMap generic.Map, key string, errs *[]error) *[]string {
if !yamlMap.Has(key) {
return new([]string)
}
var (
stringSlice []string
err error
)
sliceErr := errors.NewWithFmt(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 nil
}
return &stringSlice
}
func ParseVersion(input string) (Version, error) {
parts := strings.Split(input, ".")
if len(parts) != 3 {
return Version{}, errors.NewWithFmt(T("Could not parse version number: {{.Input}}",
map[string]interface{}{"Input": input}))
}
major, err1 := strconv.ParseInt(parts[0], 10, 64)
minor, err2 := strconv.ParseInt(parts[1], 10, 64)
patch, err3 := strconv.ParseInt(parts[2], 10, 64)
if err1 != nil || err2 != nil || err3 != nil {
return Version{}, errors.NewWithFmt(T("Could not parse version number: {{.Input}}",
map[string]interface{}{"Input": input}))
}
return Version{major, minor, patch}, nil
}
func (matcher haveSucceededMatcher) Match(actual interface{}) (bool, error) {
switch actual.(type) {
case testcmd.RunCommandResult:
result := actual.(testcmd.RunCommandResult)
return result == testcmd.RunCommandResultSuccess, nil
default:
return false, errors.NewWithFmt("Expected actual value to be an enum, but it was a %T", actual)
}
}
func envVarOrEmptyMap(yamlMap generic.Map, errs *[]error) *map[string]string {
key := "env"
switch envVars := yamlMap.Get(key).(type) {
case nil:
aMap := make(map[string]string, 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]string, envVars.Count())
generic.Each(envVars, func(key, value interface{}) {
switch value.(type) {
case string:
result[key.(string)] = value.(string)
case int64, int, int32:
result[key.(string)] = fmt.Sprintf("%d", value)
case float32, float64:
result[key.(string)] = fmt.Sprintf("%f", value)
default:
*errs = append(*errs, errors.NewWithFmt(T("Expected environment variable {{.PropertyName}} to have a string value, but it was a {{.PropertyType}}.",
map[string]interface{}{"PropertyName": key, "PropertyType": value})))
}
})
return &result
default:
*errs = append(*errs, errors.NewWithFmt(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 (repo CloudControllerUserRepository) checkSpaceRole(userGuid, spaceGuid, role string) (fullPath string, apiErr error) {
rolePath, found := spaceRoleToPathMap[role]
if !found {
apiErr = errors.NewWithFmt(T("Invalid Role {{.Role}}",
map[string]interface{}{"Role": role}))
}
fullPath = fmt.Sprintf("%s/v2/spaces/%s/%s/%s", repo.config.ApiEndpoint(), spaceGuid, rolePath, userGuid)
return
}
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, errors.NewWithFmt(T("{{.PropertyName}} must be a string value", map[string]interface{}{"PropertyName": key})))
return nil
}
return &result
}
func checkForNulls(yamlMap generic.Map) (errs []error) {
generic.Each(yamlMap, func(key interface{}, value interface{}) {
if key == "command" || key == "buildpack" {
return
}
if value == nil {
errs = append(errs, errors.NewWithFmt(T("{{.PropertyName}} should not be null", map[string]interface{}{"PropertyName": key})))
}
})
return
}
func (matcher havePassedRequirementsMatcher) Match(actual interface{}) (bool, error) {
switch actual.(type) {
case bool:
asBool := actual.(bool)
return asBool == true, nil
case testcmd.RunCommandResult:
result := actual.(testcmd.RunCommandResult)
return result == testcmd.RunCommandResultSuccess, nil
default:
return false, errors.NewWithFmt("Expected actual value to be a bool or enum, but it was a %T", actual)
}
}
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, errors.NewWithFmt(T("Expected {{.PropertyName}} to be a boolean.", map[string]interface{}{"PropertyName": key})))
return false
}
}
func bytesVal(yamlMap generic.Map, key string, errs *[]error) *int64 {
yamlVal := yamlMap.Get(key)
if yamlVal == nil {
return nil
}
value, err := formatters.ToMegabytes(yamlVal.(string))
if err != nil {
*errs = append(*errs, errors.NewWithFmt(T("Unexpected value for {{.PropertyName}} :\n{{.Error}}",
map[string]interface{}{"PropertyName": key, "Error": err.Error()})))
return nil
}
return &value
}
func (cmd Target) setOrganization(orgName string) error {
// setting an org necessarily invalidates any space you had previously targeted
cmd.config.SetOrganizationFields(models.OrganizationFields{})
cmd.config.SetSpaceFields(models.SpaceFields{})
org, apiErr := cmd.orgRepo.FindByName(orgName)
if apiErr != nil {
return errors.NewWithFmt(T("Could not target org.\n{{.ApiErr}}",
map[string]interface{}{"ApiErr": apiErr.Error()}))
}
cmd.config.SetOrganizationFields(org.OrganizationFields)
return nil
}
func (cmd Target) setSpace(spaceName string) error {
cmd.config.SetSpaceFields(models.SpaceFields{})
if !cmd.config.HasOrganization() {
return errors.New(T("An org must be targeted before targeting a space"))
}
space, apiErr := cmd.spaceRepo.FindByName(spaceName)
if apiErr != nil {
return errors.NewWithFmt(T("Unable to access space {{.SpaceName}}.\n{{.ApiErr}}",
map[string]interface{}{"SpaceName": spaceName, "ApiErr": apiErr.Error()}))
}
cmd.config.SetSpaceFields(space.SpaceFields)
return nil
}
func expandProperties(input interface{}, babbler generator.WordGenerator) (output interface{}, errs []error) {
switch input := input.(type) {
case string:
match := propertyRegex.FindStringSubmatch(input)
if match != nil {
if match[0] == "${random-word}" {
output = strings.Replace(input, "${random-word}", strings.ToLower(babbler.Babble()), -1)
} else {
err := errors.NewWithFmt(T("Property '{{.PropertyName}}' found in manifest. This feature is no longer supported. Please remove it and try again.",
map[string]interface{}{"PropertyName": match[0]}))
errs = append(errs, err)
}
} else {
output = input
}
case []interface{}:
outputSlice := make([]interface{}, len(input))
for index, item := range input {
itemOutput, itemErrs := expandProperties(item, babbler)
outputSlice[index] = itemOutput
errs = append(errs, itemErrs...)
}
output = outputSlice
case map[interface{}]interface{}:
outputMap := make(map[interface{}]interface{})
for key, value := range input {
itemOutput, itemErrs := expandProperties(value, babbler)
outputMap[key] = itemOutput
errs = append(errs, itemErrs...)
}
output = outputMap
case generic.Map:
outputMap := generic.NewMap()
generic.Each(input, func(key, value interface{}) {
itemOutput, itemErrs := expandProperties(value, babbler)
outputMap.Set(key, itemOutput)
errs = append(errs, itemErrs...)
})
output = outputMap
default:
output = input
}
return
}
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
} else {
return &val
}
case nil:
return &empty
default:
*errs = append(*errs, errors.NewWithFmt(T("{{.PropertyName}} must be a string or null value", map[string]interface{}{"PropertyName": key})))
return nil
}
}
func (repo CloudControllerUserRepository) setOrUnsetOrgRole(verb, userGuid, orgGuid, role string) (apiErr error) {
rolePath, found := orgRoleToPathMap[role]
if !found {
apiErr = errors.NewWithFmt(T("Invalid Role {{.Role}}",
map[string]interface{}{"Role": role}))
return
}
path := fmt.Sprintf("%s/v2/organizations/%s/%s/%s", repo.config.ApiEndpoint(), orgGuid, rolePath, userGuid)
request, apiErr := repo.ccGateway.NewRequest(verb, path, repo.config.AccessToken(), nil)
if apiErr != nil {
return
}
_, apiErr = repo.ccGateway.PerformRequest(request)
if apiErr != nil {
return
}
return
}
func ParseJSON(path string) ([]map[string]interface{}, error) {
if path == "" {
return nil, nil
}
file, err := os.Open(path)
if err != nil {
return nil, err
}
bytes, err := ioutil.ReadAll(file)
if err != nil {
return nil, err
}
stringMaps := []map[string]interface{}{}
err = json.Unmarshal(bytes, &stringMaps)
if err != nil {
return nil, errors.NewWithFmt("Incorrect json format: %s", err.Error())
}
return stringMaps, nil
}
func (cmd *Push) getAppParamsFromContext(c *cli.Context) (appParams models.AppParams) {
if len(c.Args()) > 0 {
appParams.Name = &c.Args()[0]
}
appParams.NoRoute = c.Bool("no-route")
appParams.UseRandomHostname = c.Bool("random-route")
if c.String("n") != "" {
hostname := c.String("n")
appParams.Host = &hostname
}
if c.String("b") != "" {
buildpack := c.String("b")
if buildpack == "null" || buildpack == "default" {
buildpack = ""
}
appParams.BuildpackUrl = &buildpack
}
if c.String("c") != "" {
command := c.String("c")
if command == "null" || command == "default" {
command = ""
}
appParams.Command = &command
}
if c.String("d") != "" {
domain := c.String("d")
appParams.Domain = &domain
}
if c.IsSet("i") {
instances := c.Int("i")
if instances < 1 {
cmd.ui.Failed(T("Invalid instance count: {{.InstancesCount}}\nInstance count must be a positive integer",
map[string]interface{}{"InstancesCount": instances}))
}
appParams.InstanceCount = &instances
}
if c.String("k") != "" {
diskQuota, err := formatters.ToMegabytes(c.String("k"))
if err != nil {
cmd.ui.Failed(T("Invalid disk quota: {{.DiskQuota}}\n{{.Err}}",
map[string]interface{}{"DiskQuota": c.String("k"), "Err": err.Error()}))
}
appParams.DiskQuota = &diskQuota
}
if c.String("m") != "" {
memory, err := formatters.ToMegabytes(c.String("m"))
if err != nil {
cmd.ui.Failed(T("Invalid memory limit: {{.MemLimit}}\n{{.Err}}",
map[string]interface{}{"MemLimit": c.String("m"), "Err": err.Error()}))
}
appParams.Memory = &memory
}
if c.String("p") != "" {
path := c.String("p")
appParams.Path = &path
}
if c.String("s") != "" {
stackName := c.String("s")
appParams.StackName = &stackName
}
if c.String("t") != "" {
timeout, err := strconv.Atoi(c.String("t"))
if err != nil {
cmd.ui.Failed("Error: %s", errors.NewWithFmt(T("Invalid timeout param: {{.Timeout}}\n{{.Err}}",
map[string]interface{}{"Timeout": c.String("t"), "Err": err.Error()})))
}
appParams.HealthCheckTimeout = &timeout
}
if c.IsSet("z") == true {
zoneName := c.String("z")
if zoneName == "null" || zoneName == "default" || zoneName == "" {
zoneGuid := ""
appParams.ZoneGuid = &zoneGuid
} else {
zone, apiErr := cmd.zoneRepo.FindByName(zoneName, cmd.config.OrganizationFields().Guid)
switch apiErr.(type) {
case nil:
case *errors.ModelNotFoundError:
cmd.ui.Failed(T("Zone {{.ZoneName}} does not exist or is not accessible", map[string]interface{}{"ZoneName": zoneName}))
return
default:
cmd.ui.Failed(T("Error finding zone {{.ZoneName}}\n{{.ErrorDescription}}",
map[string]interface{}{
"ZoneName": zoneName,
"ErrorDescription": apiErr.Error(),
}))
return
}
appParams.ZoneGuid = &zone.ZoneFields.Guid
}
}
return
}
