func (c *V3Apps) addRow(
table table,
application models.V3Application,
processes []models.V3Process,
routes []models.V3Route,
) {
var webProcess models.V3Process
for i := range processes {
if processes[i].Type == "web" {
webProcess = processes[i]
}
}
var appRoutes []string
for _, route := range routes {
appRoutes = append(appRoutes, route.Host+route.Path)
}
table.Add(
application.Name,
strings.ToLower(application.DesiredState),
fmt.Sprintf("%d", application.TotalDesiredInstances),
formatters.ByteSize(webProcess.MemoryInMB*formatters.MEGABYTE),
formatters.ByteSize(webProcess.DiskInMB*formatters.MEGABYTE),
strings.Join(appRoutes, ", "),
)
}
func (cmd *ListSpaceQuotas) Execute(c flags.FlagContext) error {
cmd.ui.Say(T("Getting space quotas as {{.Username}}...", map[string]interface{}{"Username": terminal.EntityNameColor(cmd.config.Username())}))
quotas, err := cmd.spaceQuotaRepo.FindByOrg(cmd.config.OrganizationFields().GUID)
if err != nil {
return err
}
cmd.ui.Ok()
cmd.ui.Say("")
table := cmd.ui.Table([]string{
T("name"),
T("total memory"),
T("instance memory"),
T("routes"),
T("service instances"),
T("paid plans"),
T("app instances"),
T("route ports"),
})
var megabytes string
for _, quota := range quotas {
if quota.InstanceMemoryLimit == -1 {
megabytes = T("unlimited")
} else {
megabytes = formatters.ByteSize(quota.InstanceMemoryLimit * formatters.MEGABYTE)
}
servicesLimit := strconv.Itoa(quota.ServicesLimit)
if servicesLimit == "-1" {
servicesLimit = T("unlimited")
}
table.Add(
quota.Name,
formatters.ByteSize(quota.MemoryLimit*formatters.MEGABYTE),
megabytes,
fmt.Sprintf("%d", quota.RoutesLimit),
T(quota.FormattedServicesLimit()),
formatters.Allowed(quota.NonBasicServicesAllowed),
T(quota.FormattedAppInstanceLimit()),
T(quota.FormattedRoutePortsLimit()),
)
}
err = table.Print()
if err != nil {
return err
}
return nil
}
func (cmd *showQuota) Execute(c flags.FlagContext) error {
quotaName := c.Args()[0]
cmd.ui.Say(T("Getting quota {{.QuotaName}} info as {{.Username}}...", map[string]interface{}{"QuotaName": quotaName, "Username": cmd.config.Username()}))
quota, err := cmd.quotaRepo.FindByName(quotaName)
if err != nil {
return err
}
cmd.ui.Ok()
var megabytes string
if quota.InstanceMemoryLimit == -1 {
megabytes = T("unlimited")
} else {
megabytes = formatters.ByteSize(quota.InstanceMemoryLimit * formatters.MEGABYTE)
}
servicesLimit := strconv.Itoa(quota.ServicesLimit)
if servicesLimit == "-1" {
servicesLimit = T("unlimited")
}
appInstanceLimit := strconv.Itoa(quota.AppInstanceLimit)
if quota.AppInstanceLimit == resources.UnlimitedAppInstances {
appInstanceLimit = T("unlimited")
}
reservedRoutePorts := string(quota.ReservedRoutePorts)
if reservedRoutePorts == resources.UnlimitedReservedRoutePorts {
reservedRoutePorts = T("unlimited")
}
table := cmd.ui.Table([]string{"", ""})
table.Add(T("Total Memory"), formatters.ByteSize(quota.MemoryLimit*formatters.MEGABYTE))
table.Add(T("Instance Memory"), megabytes)
table.Add(T("Routes"), fmt.Sprint(quota.RoutesLimit))
table.Add(T("Services"), servicesLimit)
table.Add(T("Paid service plans"), formatters.Allowed(quota.NonBasicServicesAllowed))
table.Add(T("App instance limit"), appInstanceLimit)
if reservedRoutePorts != "" {
table.Add(T("Reserved Route Ports"), reservedRoutePorts)
}
err = table.Print()
if err != nil {
return err
}
return nil
}
func (cmd *SpaceQuota) Execute(c flags.FlagContext) error {
name := c.Args()[0]
cmd.ui.Say(T("Getting space quota {{.Quota}} info as {{.Username}}...",
map[string]interface{}{
"Quota": terminal.EntityNameColor(name),
"Username": terminal.EntityNameColor(cmd.config.Username()),
}))
spaceQuota, err := cmd.spaceQuotaRepo.FindByName(name)
if err != nil {
return err
}
cmd.ui.Ok()
cmd.ui.Say("")
var megabytes string
table := cmd.ui.Table([]string{"", ""})
table.Add(T("total memory limit"), formatters.ByteSize(spaceQuota.MemoryLimit*formatters.MEGABYTE))
if spaceQuota.InstanceMemoryLimit == -1 {
megabytes = T("unlimited")
} else {
megabytes = formatters.ByteSize(spaceQuota.InstanceMemoryLimit * formatters.MEGABYTE)
}
table.Add(T("instance memory limit"), megabytes)
table.Add(T("routes"), fmt.Sprintf("%d", spaceQuota.RoutesLimit))
table.Add(T("services"), T(spaceQuota.FormattedServicesLimit()))
table.Add(T("non basic services"), formatters.Allowed(spaceQuota.NonBasicServicesAllowed))
table.Add(T("app instance limit"), T(spaceQuota.FormattedAppInstanceLimit()))
table.Add(T("reserved route ports"), T(spaceQuota.FormattedRoutePortsLimit()))
err = table.Print()
if err != nil {
return err
}
return nil
}
func (cmd *Push) uploadApp(appGUID, appDir, appDirOrZipFile string, localFiles []models.AppFileFields) error {
uploadDir, err := ioutil.TempDir("", "apps")
if err != nil {
return err
}
remoteFiles, hasFileToUpload, err := cmd.actor.GatherFiles(localFiles, appDir, uploadDir)
if err != nil {
return err
}
zipFile, err := ioutil.TempFile("", "uploads")
if err != nil {
return err
}
defer func() {
zipFile.Close()
os.Remove(zipFile.Name())
}()
if hasFileToUpload {
err = cmd.zipper.Zip(uploadDir, zipFile)
if err != nil {
if emptyDirErr, ok := err.(*errors.EmptyDirError); ok {
return emptyDirErr
}
return fmt.Errorf("%s: %s", T("Error zipping application"), err.Error())
}
var zipFileSize int64
zipFileSize, err = cmd.zipper.GetZipSize(zipFile)
if err != nil {
return err
}
zipFileCount := cmd.appfiles.CountFiles(uploadDir)
if zipFileCount > 0 {
cmd.ui.Say(T("Uploading app files from: {{.Path}}", map[string]interface{}{"Path": appDir}))
cmd.ui.Say(T("Uploading {{.ZipFileBytes}}, {{.FileCount}} files",
map[string]interface{}{
"ZipFileBytes": formatters.ByteSize(zipFileSize),
"FileCount": zipFileCount}))
}
}
err = os.RemoveAll(uploadDir)
if err != nil {
return err
}
return cmd.actor.UploadApp(appGUID, zipFile, remoteFiles)
}
func (progressReader *ProgressReader) printProgress(quit chan bool) {
timer := time.NewTicker(progressReader.outputInterval)
for {
select {
case <-quit:
//The spaces are there to ensure we overwrite the entire line
//before using the terminal printer to output Done Uploading
progressReader.ui.PrintCapturingNoOutput("\r ")
progressReader.ui.Say("\rDone uploading")
return
case <-timer.C:
progressReader.mutex.RLock()
progressReader.ui.PrintCapturingNoOutput("\r%s uploaded...", formatters.ByteSize(progressReader.bytesRead))
progressReader.mutex.RUnlock()
}
}
}
func (cmd *ListQuotas) Execute(c flags.FlagContext) error {
cmd.ui.Say(T("Getting quotas as {{.Username}}...", map[string]interface{}{"Username": terminal.EntityNameColor(cmd.config.Username())}))
quotas, err := cmd.quotaRepo.FindAll()
if err != nil {
return err
}
cmd.ui.Ok()
cmd.ui.Say("")
table := cmd.ui.Table([]string{
T("name"),
T("total memory"),
T("instance memory"),
T("routes"),
T("service instances"),
T("paid plans"),
T("app instances"),
T("route ports"),
})
var megabytes string
for _, quota := range quotas {
if quota.InstanceMemoryLimit == -1 {
megabytes = T("unlimited")
} else {
megabytes = formatters.ByteSize(quota.InstanceMemoryLimit * formatters.MEGABYTE)
}
servicesLimit := strconv.Itoa(quota.ServicesLimit)
if quota.ServicesLimit == -1 {
servicesLimit = T("unlimited")
}
appInstanceLimit := strconv.Itoa(quota.AppInstanceLimit)
if quota.AppInstanceLimit == resources.UnlimitedAppInstances {
appInstanceLimit = T("unlimited")
}
reservedRoutePorts := string(quota.ReservedRoutePorts)
if reservedRoutePorts == resources.UnlimitedReservedRoutePorts {
reservedRoutePorts = T("unlimited")
}
routesLimit := fmt.Sprintf("%d", quota.RoutesLimit)
if routesLimit == resources.UnlimitedRoutes {
routesLimit = T("unlimited")
}
table.Add(
quota.Name,
formatters.ByteSize(quota.MemoryLimit*formatters.MEGABYTE),
megabytes,
routesLimit,
fmt.Sprint(servicesLimit),
formatters.Allowed(quota.NonBasicServicesAllowed),
fmt.Sprint(appInstanceLimit),
fmt.Sprint(reservedRoutePorts),
)
}
err = table.Print()
if err != nil {
return err
}
return nil
}
func (q SpaceQuota) FormattedInstanceMemoryLimit() string {
if q.InstanceMemoryLimit == -1 {
return T(UnlimitedDisplay)
}
return formatters.ByteSize(q.InstanceMemoryLimit * formatters.MEGABYTE)
}
func (q SpaceQuota) FormattedMemoryLimit() string {
return formatters.ByteSize(q.MemoryLimit * formatters.MEGABYTE)
}
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 *ShowApp) ShowApp(app models.Application, orgName, spaceName string) error {
cmd.ui.Say(T("Showing health and status for app {{.AppName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.Username}}...",
map[string]interface{}{
"AppName": terminal.EntityNameColor(app.Name),
"OrgName": terminal.EntityNameColor(orgName),
"SpaceName": terminal.EntityNameColor(spaceName),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
application, err := cmd.appSummaryRepo.GetSummary(app.GUID)
appIsStopped := (application.State == "stopped")
if assertionErr, ok := err.(errors.HTTPError); ok {
if assertionErr.ErrorCode() == errors.InstancesError || assertionErr.ErrorCode() == errors.NotStaged {
appIsStopped = true
}
}
if err != nil && !appIsStopped {
return err
}
var instances []models.AppInstanceFields
instances, err = cmd.appInstancesRepo.GetInstances(app.GUID)
if err != nil && !appIsStopped {
return err
}
if cmd.pluginCall {
cmd.populatePluginModel(application, app.Stack, instances)
}
cmd.ui.Ok()
cmd.ui.Say("\n%s %s", terminal.HeaderColor(T("requested state:")), uihelpers.ColoredAppState(application.ApplicationFields))
cmd.ui.Say("%s %s", terminal.HeaderColor(T("instances:")), uihelpers.ColoredAppInstances(application.ApplicationFields))
// Commented to hide app-ports for release #117189491
// if len(application.AppPorts) > 0 {
// appPorts := make([]string, len(application.AppPorts))
// for i, p := range application.AppPorts {
// appPorts[i] = strconv.Itoa(p)
// }
// cmd.ui.Say("%s %s", terminal.HeaderColor(T("app ports:")), strings.Join(appPorts, ", "))
// }
cmd.ui.Say(T("{{.Usage}} {{.FormattedMemory}} x {{.InstanceCount}} instances",
map[string]interface{}{
"Usage": terminal.HeaderColor(T("usage:")),
"FormattedMemory": formatters.ByteSize(application.Memory * formatters.MEGABYTE),
"InstanceCount": application.InstanceCount}))
var urls []string
for _, route := range application.Routes {
urls = append(urls, route.URL())
}
cmd.ui.Say("%s %s", terminal.HeaderColor(T("urls:")), strings.Join(urls, ", "))
var lastUpdated string
if application.PackageUpdatedAt != nil {
lastUpdated = application.PackageUpdatedAt.Format("Mon Jan 2 15:04:05 MST 2006")
} else {
lastUpdated = "unknown"
}
cmd.ui.Say("%s %s", terminal.HeaderColor(T("last uploaded:")), lastUpdated)
appStack, err := cmd.stackRepo.FindByGUID(application.ApplicationFields.StackGUID)
if appStack.Name != "" && err == nil {
cmd.ui.Say("%s %s", terminal.HeaderColor(T("stack:")), appStack.Name)
} else {
cmd.ui.Say("%s %s", terminal.HeaderColor(T("stack:")), "unknown")
}
if app.Buildpack != "" {
cmd.ui.Say("%s %s\n", terminal.HeaderColor(T("buildpack:")), app.Buildpack)
} else if app.DetectedBuildpack != "" {
cmd.ui.Say("%s %s\n", terminal.HeaderColor(T("buildpack:")), app.DetectedBuildpack)
} else {
cmd.ui.Say("%s %s\n", terminal.HeaderColor(T("buildpack:")), "unknown")
}
if appIsStopped {
cmd.ui.Say(T("There are no running instances of this app."))
return nil
}
table := cmd.ui.Table([]string{"", T("state"), T("since"), T("cpu"), T("memory"), T("disk"), T("details")})
for index, instance := range instances {
table.Add(
fmt.Sprintf("#%d", index),
uihelpers.ColoredInstanceState(instance),
instance.Since.Format("2006-01-02 03:04:05 PM"),
fmt.Sprintf("%.1f%%", instance.CPUUsage*100),
fmt.Sprintf(T("{{.MemUsage}} of {{.MemQuota}}",
map[string]interface{}{
"MemUsage": formatters.ByteSize(instance.MemUsage),
"MemQuota": formatters.ByteSize(instance.MemQuota)})),
fmt.Sprintf(T("{{.DiskUsage}} of {{.DiskQuota}}",
map[string]interface{}{
"DiskUsage": formatters.ByteSize(instance.DiskUsage),
"DiskQuota": formatters.ByteSize(instance.DiskQuota)})),
fmt.Sprintf("%s", instance.Details),
)
}
err = table.Print()
if err != nil {
return err
}
if err != nil {
return err
}
return nil
}
func (cmd *ListApps) Execute(c flags.FlagContext) error {
cmd.ui.Say(T("Getting apps in org {{.OrgName}} / space {{.SpaceName}} as {{.Username}}...",
map[string]interface{}{
"OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
apps, err := cmd.appSummaryRepo.GetSummariesInCurrentSpace()
if err != nil {
return err
}
cmd.ui.Ok()
cmd.ui.Say("")
if len(apps) == 0 {
cmd.ui.Say(T("No apps found"))
return nil
}
table := cmd.ui.Table([]string{
T("name"),
T("requested state"),
T("instances"),
T("memory"),
T("disk"),
// Hide this column #117189491
// T("app ports"),
T("urls"),
})
for _, application := range apps {
var urls []string
for _, route := range application.Routes {
urls = append(urls, route.URL())
}
appPorts := make([]string, len(application.AppPorts))
for i, p := range application.AppPorts {
appPorts[i] = strconv.Itoa(p)
}
table.Add(
application.Name,
uihelpers.ColoredAppState(application.ApplicationFields),
uihelpers.ColoredAppInstances(application.ApplicationFields),
formatters.ByteSize(application.Memory*formatters.MEGABYTE),
formatters.ByteSize(application.DiskQuota*formatters.MEGABYTE),
// Hide this column #117189491
// strings.Join(appPorts, ", "),
strings.Join(urls, ", "),
)
}
err = table.Print()
if err != nil {
return err
}
if cmd.pluginCall {
cmd.populatePluginModel(apps)
}
return nil
}
