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 *Scale) Execute(c flags.FlagContext) error { currentApp := cmd.appReq.GetApplication() if !anyFlagsSet(c) { cmd.ui.Say(T("Showing current scale of app {{.AppName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.CurrentUser}}...", map[string]interface{}{ "AppName": terminal.EntityNameColor(currentApp.Name), "OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name), "SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name), "CurrentUser": terminal.EntityNameColor(cmd.config.Username()), })) cmd.ui.Ok() cmd.ui.Say("") cmd.ui.Say("%s %s", terminal.HeaderColor(T("memory:")), formatters.ByteSize(currentApp.Memory*bytesInAMegabyte)) cmd.ui.Say("%s %s", terminal.HeaderColor(T("disk:")), formatters.ByteSize(currentApp.DiskQuota*bytesInAMegabyte)) cmd.ui.Say("%s %d", terminal.HeaderColor(T("instances:")), currentApp.InstanceCount) return nil } params := models.AppParams{} shouldRestart := false if c.String("m") != "" { memory, err := formatters.ToMegabytes(c.String("m")) if err != nil { return errors.New(T("Invalid memory limit: {{.Memory}}\n{{.ErrorDescription}}", map[string]interface{}{ "Memory": c.String("m"), "ErrorDescription": err, })) } params.Memory = &memory shouldRestart = true } if c.String("k") != "" { diskQuota, err := formatters.ToMegabytes(c.String("k")) if err != nil { return errors.New(T("Invalid disk quota: {{.DiskQuota}}\n{{.ErrorDescription}}", map[string]interface{}{ "DiskQuota": c.String("k"), "ErrorDescription": err, })) } params.DiskQuota = &diskQuota shouldRestart = true } if c.IsSet("i") { instances := c.Int("i") params.InstanceCount = &instances } if shouldRestart && !cmd.confirmRestart(c, currentApp.Name) { return nil } cmd.ui.Say(T("Scaling app {{.AppName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.CurrentUser}}...", map[string]interface{}{ "AppName": terminal.EntityNameColor(currentApp.Name), "OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name), "SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name), "CurrentUser": terminal.EntityNameColor(cmd.config.Username()), })) updatedApp, err := cmd.appRepo.Update(currentApp.GUID, params) if err != nil { return err } cmd.ui.Ok() if shouldRestart { err = cmd.restarter.ApplicationRestart(updatedApp, cmd.config.OrganizationFields().Name, cmd.config.SpaceFields().Name) if err != nil { return err } } return 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 }