func (cmd *Push) createAppSetFromContextAndManifest(contextApp models.AppParams, manifestApps []models.AppParams) ([]models.AppParams, error) {
var err error
var apps []models.AppParams
switch len(manifestApps) {
case 0:
if contextApp.Name == nil {
return nil, errors.New(
T("Incorrect Usage. The push command requires an app name. The app name can be supplied as an argument or with a manifest.yml file.") +
"\n\n" +
commandregistry.Commands.CommandUsage("push"),
)
}
err = addApp(&apps, contextApp)
case 1:
manifestApps[0].Merge(&contextApp)
err = addApp(&apps, manifestApps[0])
default:
selectedAppName := contextApp.Name
contextApp.Name = nil
if !contextApp.IsEmpty() {
return nil, errors.New(T("Incorrect Usage. Command line flags (except -f) cannot be applied when pushing multiple apps from a manifest file."))
}
if selectedAppName != nil {
var foundApp bool
for _, appParams := range manifestApps {
if appParams.Name != nil && *appParams.Name == *selectedAppName {
foundApp = true
err = addApp(&apps, appParams)
}
}
if !foundApp {
err = errors.New(T("Could not find app named '{{.AppName}}' in manifest", map[string]interface{}{"AppName": *selectedAppName}))
}
} else {
for _, manifestApp := range manifestApps {
err = addApp(&apps, manifestApp)
}
}
}
if err != nil {
return nil, errors.New(T("Error: {{.Err}}", map[string]interface{}{"Err": err.Error()}))
}
return apps, nil
}
func mapToAppParams(basePath string, yamlMap generic.Map) (models.AppParams, error) {
err := checkForNulls(yamlMap)
if err != nil {
return models.AppParams{}, err
}
var appParams models.AppParams
var errs []error
appParams.BuildpackURL = stringValOrDefault(yamlMap, "buildpack", &errs)
appParams.DiskQuota = bytesVal(yamlMap, "disk_quota", &errs)
domainAry := sliceOrNil(yamlMap, "domains", &errs)
if domain := stringVal(yamlMap, "domain", &errs); domain != nil {
if domainAry == nil {
domainAry = []string{*domain}
} else {
domainAry = append(domainAry, *domain)
}
}
appParams.Domains = removeDuplicatedValue(domainAry)
hostsArr := sliceOrNil(yamlMap, "hosts", &errs)
if host := stringVal(yamlMap, "host", &errs); host != nil {
hostsArr = append(hostsArr, *host)
}
appParams.Hosts = removeDuplicatedValue(hostsArr)
appParams.Name = stringVal(yamlMap, "name", &errs)
appParams.Path = stringVal(yamlMap, "path", &errs)
appParams.StackName = stringVal(yamlMap, "stack", &errs)
appParams.Command = stringValOrDefault(yamlMap, "command", &errs)
appParams.Memory = bytesVal(yamlMap, "memory", &errs)
appParams.InstanceCount = intVal(yamlMap, "instances", &errs)
appParams.HealthCheckTimeout = intVal(yamlMap, "timeout", &errs)
appParams.NoRoute = boolVal(yamlMap, "no-route", &errs)
appParams.NoHostname = boolOrNil(yamlMap, "no-hostname", &errs)
appParams.UseRandomRoute = boolVal(yamlMap, "random-route", &errs)
appParams.ServicesToBind = sliceOrNil(yamlMap, "services", &errs)
appParams.EnvironmentVars = envVarOrEmptyMap(yamlMap, &errs)
appParams.HealthCheckType = stringVal(yamlMap, "health-check-type", &errs)
appParams.AppPorts = intSliceVal(yamlMap, "app-ports", &errs)
appParams.Routes = parseRoutes(yamlMap, &errs)
if appParams.Path != nil {
path := *appParams.Path
if filepath.IsAbs(path) {
path = filepath.Clean(path)
} else {
path = filepath.Join(basePath, path)
}
appParams.Path = &path
}
if len(errs) > 0 {
message := ""
for _, err := range errs {
message = message + fmt.Sprintf("%s\n", err.Error())
}
return models.AppParams{}, errors.New(message)
}
return appParams, nil
}
func (cmd *Push) getAppParamsFromContext(c flags.FlagContext) (models.AppParams, error) {
noHostBool := c.Bool("no-hostname")
appParams := models.AppParams{
NoRoute: c.Bool("no-route"),
UseRandomRoute: c.Bool("random-route"),
NoHostname: &noHostBool,
}
if len(c.Args()) > 0 {
appParams.Name = &c.Args()[0]
}
if c.String("n") != "" {
appParams.Hosts = []string{c.String("n")}
}
if c.String("route-path") != "" {
routePath := c.String("route-path")
appParams.RoutePath = &routePath
}
if c.String("app-ports") != "" {
appPortStrings := strings.Split(c.String("app-ports"), ",")
appPorts := make([]int, len(appPortStrings))
for i, s := range appPortStrings {
p, err := strconv.Atoi(s)
if err != nil {
return models.AppParams{}, errors.New(T("Invalid app port: {{.AppPort}}\nApp port must be a number", map[string]interface{}{
"AppPort": s,
}))
}
appPorts[i] = p
}
appParams.AppPorts = &appPorts
}
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") != "" {
appParams.Domains = []string{c.String("d")}
}
if c.IsSet("i") {
instances := c.Int("i")
if instances < 1 {
return models.AppParams{}, errors.New(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 {
return models.AppParams{}, errors.New(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 {
return models.AppParams{}, errors.New(T("Invalid memory limit: {{.MemLimit}}\n{{.Err}}",
map[string]interface{}{"MemLimit": c.String("m"), "Err": err.Error()}))
}
appParams.Memory = &memory
}
if c.String("docker-image") != "" {
dockerImage := c.String("docker-image")
appParams.DockerImage = &dockerImage
}
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 {
return models.AppParams{}, fmt.Errorf("Error: %s", fmt.Errorf(T("Invalid timeout param: {{.Timeout}}\n{{.Err}}",
map[string]interface{}{"Timeout": c.String("t"), "Err": err.Error()})))
}
appParams.HealthCheckTimeout = &timeout
}
if healthCheckType := c.String("u"); healthCheckType != "" {
if healthCheckType != "port" && healthCheckType != "none" {
return models.AppParams{}, fmt.Errorf("Error: %s", fmt.Errorf(T("Invalid health-check-type param: {{.healthCheckType}}",
map[string]interface{}{"healthCheckType": healthCheckType})))
}
appParams.HealthCheckType = &healthCheckType
}
return appParams, nil
}