func (cmd *Scale) Run(c *cli.Context) {
currentApp := cmd.appReq.GetApplication()
cmd.ui.Say("Scaling app %s in org %s / space %s as %s...",
terminal.EntityNameColor(currentApp.Name),
terminal.EntityNameColor(cmd.config.OrganizationFields.Name),
terminal.EntityNameColor(cmd.config.SpaceFields.Name),
terminal.EntityNameColor(cmd.config.Username()),
)
params := cf.NewEmptyAppParams()
if c.String("m") != "" {
memory, err := formatters.ToMegabytes(c.String("m"))
if err != nil {
cmd.ui.Say("Invalid value for memory")
cmd.ui.FailWithUsage(c, "scale")
return
}
params.Set("memory", memory)
}
if c.Int("i") != -1 {
params.Set("instances", c.Int("i"))
}
_, apiResponse := cmd.appRepo.Update(currentApp.Guid, params)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
cmd.ui.Say("")
}
func setBytesVal(appMap, yamlMap generic.Map, key string, errs *ManifestErrors) {
value, err := formatters.ToMegabytes(yamlMap.Get(key).(string))
if err != nil {
*errs = append(*errs, errors.New(fmt.Sprintf("Unexpected value for %s :\n%s", key, err.Error())))
return
}
appMap.Set(key, value)
}
func NewAppParamsFromContext(c *cli.Context) (appParams AppParams, err error) {
appParams = NewEmptyAppParams()
if len(c.Args()) > 0 {
appParams.Set("name", c.Args()[0])
}
if c.String("b") != "" {
appParams.Set("buildpack", c.String("b"))
}
if c.String("m") != "" {
var memory uint64
memory, err = formatters.ToMegabytes(c.String("m"))
if err != nil {
err = errors.New(fmt.Sprintf("Invalid memory param: %s\n%s", c.String("m"), err))
return
}
appParams.Set("memory", memory)
}
if c.String("c") != "" {
appParams.Set("command", c.String("c"))
}
if c.String("c") == "null" {
appParams.Set("command", "")
}
if c.String("i") != "" {
var instances int
instances, err = strconv.Atoi(c.String("i"))
if err != nil {
err = errors.New(fmt.Sprintf("Invalid instances param: %s\n%s", c.String("i"), err))
return
}
appParams.Set("instances", instances)
}
if c.String("s") != "" {
appParams.Set("stack", c.String("s"))
}
if c.String("t") != "" {
var timeout int
timeout, err = strconv.Atoi(c.String("t"))
if err != nil {
err = errors.New(fmt.Sprintf("Invalid timeout param: %s\n%s", c.String("t"), err))
return
}
appParams.Set("health_check_timeout", timeout)
}
return
}
func (cmd *updateQuota) Run(c *cli.Context) {
oldQuotaName := c.Args()[0]
quota, err := cmd.quotaRepo.FindByName(oldQuotaName)
if err != nil {
cmd.ui.Failed(err.Error())
}
allowPaidServices := c.Bool("allow-paid-service-plans")
disallowPaidServices := c.Bool("disallow-paid-service-plans")
if allowPaidServices && disallowPaidServices {
cmd.ui.Failed("Please choose either allow or disallow. Both flags are not permitted to be passed in the same command. ")
}
if allowPaidServices {
quota.NonBasicServicesAllowed = true
}
if disallowPaidServices {
quota.NonBasicServicesAllowed = false
}
if c.String("m") != "" {
memory, err := formatters.ToMegabytes(c.String("m"))
if err != nil {
cmd.ui.FailWithUsage(c, "update-quota")
}
quota.MemoryLimit = memory
}
if c.String("n") != "" {
quota.Name = c.String("n")
}
if c.IsSet("s") {
quota.ServicesLimit = c.Int("s")
}
if c.IsSet("r") {
quota.RoutesLimit = c.Int("r")
}
cmd.ui.Say("Updating quota %s as %s...",
terminal.EntityNameColor(oldQuotaName),
terminal.EntityNameColor(cmd.config.Username()))
err = cmd.quotaRepo.Update(quota)
if err != nil {
cmd.ui.Failed(err.Error())
}
cmd.ui.Ok()
}
func bytesVal(yamlMap generic.Map, key string, errs *ManifestErrors) *uint64 {
yamlVal := yamlMap.Get(key)
if yamlVal == nil {
return nil
}
value, err := formatters.ToMegabytes(yamlVal.(string))
if err != nil {
*errs = append(*errs, errors.New(fmt.Sprintf("Unexpected value for %s :\n%s", key, err.Error())))
return nil
}
return &value
}
func (cmd CreateQuota) Run(context *cli.Context) {
name := context.Args()[0]
cmd.ui.Say("Creating quota %s as %s...",
terminal.EntityNameColor(name),
terminal.EntityNameColor(cmd.config.Username()))
quota := models.QuotaFields{
Name: name,
}
memoryLimit := context.String("m")
if memoryLimit != "" {
parsedMemory, err := formatters.ToMegabytes(memoryLimit)
if err != nil {
cmd.ui.Failed("Invalid memory limit: %s\n%s", memoryLimit, err)
}
quota.MemoryLimit = parsedMemory
}
if context.IsSet("r") {
quota.RoutesLimit = context.Int("r")
}
if context.IsSet("s") {
quota.ServicesLimit = context.Int("s")
}
if context.IsSet("allow-paid-service-plans") {
quota.NonBasicServicesAllowed = true
}
err := cmd.quotaRepo.Create(quota)
httpErr, ok := err.(errors.HttpError)
if ok && httpErr.ErrorCode() == errors.QUOTA_EXISTS {
cmd.ui.Ok()
cmd.ui.Warn("Quota Definition %s already exists", quota.Name)
return
}
if err != nil {
cmd.ui.Failed(err.Error())
}
cmd.ui.Ok()
}
func mapToAppParams(yamlMap generic.Map) (appParams cf.AppParams, errs ManifestErrors) {
appParams = cf.NewEmptyAppParams()
errs = checkForNulls(yamlMap)
if !errs.Empty() {
return
}
for _, key := range []string{"buildpack", "command", "disk_quota", "domain", "host", "name", "path", "stack", "no-route"} {
if yamlMap.Has(key) {
setStringVal(appParams, key, yamlMap.Get(key), &errs)
}
}
if yamlMap.Has("memory") {
memory, err := formatters.ToMegabytes(yamlMap.Get("memory").(string))
if err != nil {
errs = append(errs, errors.New(fmt.Sprintf("Unexpected value for app memory:\n%s", err.Error())))
return
}
appParams.Set("memory", memory)
}
if yamlMap.Has("timeout") {
setIntVal(appParams, "health_check_timeout", yamlMap.Get("timeout"), &errs)
}
if yamlMap.Has("instances") {
setIntVal(appParams, "instances", yamlMap.Get("instances"), &errs)
}
if yamlMap.Has("services") {
setStringSlice(appParams, "services", yamlMap.Get("services"), &errs)
} else {
appParams.Set("services", []string{})
}
if yamlMap.Has("env") {
setEnvVar(appParams, yamlMap.Get("env"), &errs)
} else {
appParams.Set("env", generic.NewMap())
}
return
}
func (cmd *Scale) Run(c *cli.Context) {
currentApp := cmd.appReq.GetApplication()
cmd.ui.Say("Scaling app %s in org %s / space %s as %s...",
terminal.EntityNameColor(currentApp.Name),
terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
terminal.EntityNameColor(cmd.config.SpaceFields().Name),
terminal.EntityNameColor(cmd.config.Username()),
)
params := models.AppParams{}
shouldRestart := false
if c.String("m") != "" {
memory, err := formatters.ToMegabytes(c.String("m"))
if err != nil {
cmd.ui.Say("Invalid value for memory")
cmd.ui.FailWithUsage(c, "scale")
return
}
params.Memory = &memory
shouldRestart = true
}
instances := c.Int("i")
if instances != -1 {
params.InstanceCount = &instances
}
updatedApp, apiResponse := cmd.appRepo.Update(currentApp.Guid, params)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
cmd.ui.Say("")
if shouldRestart {
cmd.restarter.ApplicationRestart(updatedApp)
}
}
func (cmd *Push) getAppParamsFromContext(c *cli.Context) (appParams models.AppParams) {
if len(c.Args()) > 0 {
appParams.Name = &c.Args()[0]
}
if c.String("b") != "" {
buildpack := c.String("b")
appParams.BuildpackUrl = &buildpack
}
if c.String("m") != "" {
memory, err := formatters.ToMegabytes(c.String("m"))
if err != nil {
cmd.ui.Failed("Error: %s", errors.NewWithFmt("Invalid memory param: %s\n%s", c.String("m"), err))
return
}
appParams.Memory = &memory
}
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("d") != "" {
domain := c.String("d")
appParams.Domain = &domain
}
if c.String("c") != "" {
command := c.String("c")
appParams.Command = &command
}
if c.String("c") == "null" {
emptyStr := ""
appParams.Command = &emptyStr
}
if c.String("i") != "" {
instances, err := strconv.Atoi(c.String("i"))
if err != nil {
cmd.ui.Failed("Error: %s", errors.NewWithFmt("Invalid instances param: %s\n%s", c.String("i"), err))
}
appParams.InstanceCount = &instances
}
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("Invalid timeout param: %s\n%s", c.String("t"), err))
}
appParams.HealthCheckTimeout = &timeout
}
if c.String("p") != "" {
path := c.String("p")
appParams.Path = &path
}
return
}
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("Invalid instance count: %d\nInstance count must be a positive integer", instances)
}
appParams.InstanceCount = &instances
}
if c.String("k") != "" {
diskQuota, err := formatters.ToMegabytes(c.String("k"))
if err != nil {
cmd.ui.Failed("Invalid disk quota: %s\n%s", c.String("k"), err)
}
appParams.DiskQuota = &diskQuota
}
if c.String("m") != "" {
memory, err := formatters.ToMegabytes(c.String("m"))
if err != nil {
cmd.ui.Failed("Invalid memory limit: %s\n%s", c.String("m"), err)
}
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("Invalid timeout param: %s\n%s", c.String("t"), err))
}
appParams.HealthCheckTimeout = &timeout
}
return
}
func (cmd *Scale) Run(c *cli.Context) {
currentApp := cmd.appReq.GetApplication()
if !anyFlagsSet(c) {
cmd.ui.Say("Showing current scale of app %s in org %s / space %s as %s...",
terminal.EntityNameColor(currentApp.Name),
terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
terminal.EntityNameColor(cmd.config.SpaceFields().Name),
terminal.EntityNameColor(cmd.config.Username()),
)
cmd.ui.Ok()
cmd.ui.Say("")
cmd.ui.Say("%s %s", terminal.HeaderColor("memory:"), formatters.ByteSize(currentApp.Memory*bytesInAMegabyte))
cmd.ui.Say("%s %s", terminal.HeaderColor("disk:"), formatters.ByteSize(currentApp.DiskQuota*bytesInAMegabyte))
cmd.ui.Say("%s %d", terminal.HeaderColor("instances:"), currentApp.InstanceCount)
return
}
params := models.AppParams{}
shouldRestart := false
if c.String("m") != "" {
memory, err := formatters.ToMegabytes(c.String("m"))
if err != nil {
cmd.ui.Failed("Invalid memory limit: %s\n%s", c.String("m"), err)
}
params.Memory = &memory
shouldRestart = true
}
if c.String("k") != "" {
diskQuota, err := formatters.ToMegabytes(c.String("k"))
if err != nil {
cmd.ui.Failed("Invalid disk quota: %s\n%s", c.String("k"), err)
}
params.DiskQuota = &diskQuota
shouldRestart = true
}
if c.IsSet("i") {
instances := c.Int("i")
if instances > 0 {
params.InstanceCount = &instances
} else {
cmd.ui.Failed("Invalid instance count: %d\nInstance count must be a positive integer", instances)
}
}
if shouldRestart && !cmd.confirmRestart(c, currentApp.Name) {
return
}
cmd.ui.Say("Scaling app %s in org %s / space %s as %s...",
terminal.EntityNameColor(currentApp.Name),
terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
terminal.EntityNameColor(cmd.config.SpaceFields().Name),
terminal.EntityNameColor(cmd.config.Username()),
)
updatedApp, apiErr := cmd.appRepo.Update(currentApp.Guid, params)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
if shouldRestart {
cmd.restarter.ApplicationRestart(updatedApp)
}
}
func newAppParamsFromContext(c *cli.Context) (appParams models.AppParams, err error) {
if len(c.Args()) > 0 {
appParams.Name = &c.Args()[0]
}
if c.String("b") != "" {
buildpack := c.String("b")
appParams.BuildpackUrl = &buildpack
}
if c.String("m") != "" {
var memory uint64
memory, err = formatters.ToMegabytes(c.String("m"))
if err != nil {
err = errors.New(fmt.Sprintf("Invalid memory param: %s\n%s", c.String("m"), err))
return
}
appParams.Memory = &memory
}
if c.String("c") != "" {
command := c.String("c")
appParams.Command = &command
}
if c.String("c") == "null" {
emptyStr := ""
appParams.Command = &emptyStr
}
if c.String("i") != "" {
var instances int
instances, err = strconv.Atoi(c.String("i"))
if err != nil {
err = errors.New(fmt.Sprintf("Invalid instances param: %s\n%s", c.String("i"), err))
return
}
appParams.InstanceCount = &instances
}
if c.String("s") != "" {
stackName := c.String("s")
appParams.StackName = &stackName
}
if c.String("t") != "" {
var timeout int
timeout, err = strconv.Atoi(c.String("t"))
if err != nil {
err = errors.New(fmt.Sprintf("Invalid timeout param: %s\n%s", c.String("t"), err))
return
}
appParams.HealthCheckTimeout = &timeout
}
if c.String("p") != "" {
var path string
path, err = filepath.Abs(c.String("p"))
if err != nil {
err = errors.New(fmt.Sprintf("Error finding app path: %s", err))
return
}
appParams.Path = &path
}
return
}
