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 *Wildcard) WildcardCommandApps(cliConnection plugin.CliConnection, args string) {
introduction(cliConnection, args)
output := getMatchedApps(cliConnection, args)
mytable := table.NewTable([]string{("name"), ("requested state"), ("instances"), ("memory"), ("disk"), ("urls")})
for _, app := range output {
var urls []string
for _, route := range app.Routes {
if route.Host == "" {
urls = append(urls, route.Domain.Name)
}
urls = append(urls, fmt.Sprintf("%s.%s", route.Host, route.Domain.Name))
}
runningInstances := strconv.Itoa(app.RunningInstances)
if app.RunningInstances < 0 {
runningInstances = "?"
}
mytable.Add(
app.Name,
app.State,
runningInstances+"/"+strconv.Itoa(app.TotalInstances),
formatters.ByteSize(app.Memory*formatters.MEGABYTE),
formatters.ByteSize(app.DiskQuota*formatters.MEGABYTE),
strings.Join(urls, ", "),
)
}
mytable.Print()
if len(output) == 0 {
fmt.Println(table.WarningColor("No apps found matching"), table.WarningColor(args))
}
}
func (cmd *Wildcard) WildcardCommandApps(cliConnection plugin.CliConnection, args []string) {
InitializeCliDependencies()
defer panic.HandlePanics()
cmd.getMatchedApps(cliConnection, args)
cmd.ui = terminal.NewUI(os.Stdin, terminal.NewTeePrinter())
table := terminal.NewTable(cmd.ui, []string{T("name"), T("requested state"), T("instances"), T("memory"), T("disk"), T("urls")})
for _, app := range cmd.matchedApps {
var urls []string
for _, route := range app.Routes {
if route.Host == "" {
urls = append(urls, route.Domain.Name)
}
urls = append(urls, fmt.Sprintf("%s.%s", route.Host, route.Domain.Name))
}
table.Add(
app.Name,
app.State,
strconv.Itoa(app.RunningInstances),
formatters.ByteSize(app.Memory*formatters.MEGABYTE),
formatters.ByteSize(app.DiskQuota*formatters.MEGABYTE),
strings.Join(urls, ", "),
)
}
table.Print()
}
func (cmd *ListQuotas) Run(c *cli.Context) {
cmd.ui.Say(T("Getting quotas as {{.Username}}...", map[string]interface{}{"Username": terminal.EntityNameColor(cmd.config.Username())}))
quotas, apiErr := cmd.quotaRepo.FindAll()
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say("")
table := terminal.NewTable(cmd.ui, []string{T("name"), T("total memory limit"), T("instance memory limit"), T("routes"), T("service instances"), T("paid service plans")})
var megabytes string
for _, quota := range quotas {
if quota.InstanceMemoryLimit == -1 {
megabytes = "-1"
} else {
megabytes = formatters.ByteSize(quota.InstanceMemoryLimit * formatters.MEGABYTE)
}
table.Add(
quota.Name,
formatters.ByteSize(quota.MemoryLimit*formatters.MEGABYTE),
megabytes,
fmt.Sprintf("%d", quota.RoutesLimit),
fmt.Sprintf("%d", quota.ServicesLimit),
formatters.Allowed(quota.NonBasicServicesAllowed),
)
}
table.Print()
}
func (cmd *SpaceQuota) Run(c *cli.Context) {
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, apiErr := cmd.spaceQuotaRepo.FindByName(name)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say("")
var megabytes string
table := terminal.NewTable(cmd.ui, []string{"", ""})
table.Add(T("total memory limit"), formatters.ByteSize(spaceQuota.MemoryLimit*formatters.MEGABYTE))
if spaceQuota.InstanceMemoryLimit == -1 {
megabytes = "-1"
} 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"), fmt.Sprintf("%d", spaceQuota.ServicesLimit))
table.Add(T("non basic services"), formatters.Allowed(spaceQuota.NonBasicServicesAllowed))
table.Print()
}
func (cmd *ShowSpace) quotaString(space models.Space) string {
var instance_memory string
if space.SpaceQuotaGuid == "" {
return ""
}
quota, err := cmd.quotaRepo.FindByGuid(space.SpaceQuotaGuid)
if err != nil {
cmd.ui.Failed(err.Error())
return ""
}
if quota.InstanceMemoryLimit == -1 {
instance_memory = "-1"
} else {
instance_memory = formatters.ByteSize(quota.InstanceMemoryLimit * formatters.MEGABYTE)
}
memory := formatters.ByteSize(quota.MemoryLimit * formatters.MEGABYTE)
spaceQuota := fmt.Sprintf("%s (%s memory limit, %s instance memory limit, %d routes, %d services, paid services %s)", quota.Name, memory, instance_memory, quota.RoutesLimit, quota.ServicesLimit, formatters.Allowed(quota.NonBasicServicesAllowed))
// spaceQuota := fmt.Sprintf(T("{{.QuotaName}} ({{.MemoryLimit}} memory limit, {{.InstanceMemoryLimit}} instance memory limit, {{.RoutesLimit}} routes, {{.ServicesLimit}} services, paid services {{.NonBasicServicesAllowed}})",
// map[string]interface{}{
// "QuotaName": quota.Name,
// "MemoryLimit": memory,
// "InstanceMemoryLimit": instance_memory,
// "RoutesLimit": quota.RoutesLimit,
// "ServicesLimit": quota.ServicesLimit,
// "NonBasicServicesAllowed": formatters.Allowed(quota.NonBasicServicesAllowed)}))
return spaceQuota
}
func (cmd *showQuota) Execute(c flags.FlagContext) {
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 {
cmd.ui.Failed(err.Error())
}
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")
}
table := terminal.NewTable(cmd.ui, []string{"", ""})
table.Add(T("Total Memory"), formatters.ByteSize(quota.MemoryLimit*formatters.MEGABYTE))
table.Add(T("Instance Memory"), megabytes)
table.Add(T("Routes"), fmt.Sprintf("%d", quota.RoutesLimit))
table.Add(T("Services"), servicesLimit)
table.Add(T("Paid service plans"), formatters.Allowed(quota.NonBasicServicesAllowed))
table.Print()
}
func (cmd *ListApps) Execute(c flags.FlagContext) {
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, apiErr := cmd.appSummaryRepo.GetSummariesInCurrentSpace()
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say("")
if len(apps) == 0 {
cmd.ui.Say(T("No apps found"))
return
}
table := terminal.NewTable(cmd.ui, []string{
T("name"),
T("requested state"),
T("instances"),
T("memory"),
T("disk"),
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,
ui_helpers.ColoredAppState(application.ApplicationFields),
ui_helpers.ColoredAppInstances(application.ApplicationFields),
formatters.ByteSize(application.Memory*formatters.MEGABYTE),
formatters.ByteSize(application.DiskQuota*formatters.MEGABYTE),
strings.Join(appPorts, ", "),
strings.Join(urls, ", "),
)
}
table.Print()
if cmd.pluginCall {
cmd.populatePluginModel(apps)
}
}
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 *ListQuotas) Execute(c flags.FlagContext) {
cmd.ui.Say(T("Getting quotas as {{.Username}}...", map[string]interface{}{"Username": terminal.EntityNameColor(cmd.config.Username())}))
quotas, apiErr := cmd.quotaRepo.FindAll()
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say("")
table := cmd.ui.Table([]string{T("name"), T("total memory limit"), T("instance memory limit"), T("routes"), T("service instances"), T("paid service plans"), T("app instance limit"), 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 := strconv.Itoa(quota.ReservedRoutePorts)
if quota.ReservedRoutePorts == resources.UnlimitedReservedRoutePorts {
reservedRoutePorts = T("unlimited")
}
table.Add(
quota.Name,
formatters.ByteSize(quota.MemoryLimit*formatters.MEGABYTE),
megabytes,
fmt.Sprintf("%d", quota.RoutesLimit),
fmt.Sprint(servicesLimit),
formatters.Allowed(quota.NonBasicServicesAllowed),
fmt.Sprint(appInstanceLimit),
fmt.Sprint(reservedRoutePorts),
)
}
table.Print()
}
func (cmd ListApps) Run(c *cli.Context) {
cmd.ui.Say("Getting apps in org %s / space %s as %s...",
terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
terminal.EntityNameColor(cmd.config.SpaceFields().Name),
terminal.EntityNameColor(cmd.config.Username()),
)
apps, apiErr := cmd.appSummaryRepo.GetSummariesInCurrentSpace()
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say("")
if len(apps) == 0 {
cmd.ui.Say("No apps found")
return
}
table := terminal.NewTable(cmd.ui, []string{
"name",
"requested state",
"instances",
"memory",
"disk",
"urls",
})
for _, application := range apps {
var urls []string
for _, route := range application.Routes {
urls = append(urls, route.URL())
}
table.Add([]string{
application.Name,
ui_helpers.ColoredAppState(application.ApplicationFields),
ui_helpers.ColoredAppInstances(application.ApplicationFields),
formatters.ByteSize(application.Memory * formatters.MEGABYTE),
formatters.ByteSize(application.DiskQuota * formatters.MEGABYTE),
strings.Join(urls, ", "),
})
}
table.Print()
}
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 *Push) zipAppFiles(zipFile *os.File, appDir string, uploadDir string) error {
err := cmd.zipper.Zip(uploadDir, zipFile)
if err != nil {
if emptyDirErr, ok := err.(*errors.EmptyDirError); ok {
zipFile = nil
return emptyDirErr
}
return fmt.Errorf("%s: %s", T("Error zipping application"), err.Error())
}
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}))
}
return nil
}
func (cmd *Push) describeUploadOperation(path string, zipFileBytes, fileCount uint64) {
if fileCount > 0 {
cmd.ui.Say("Uploading app files from: %s", path)
cmd.ui.Say("Uploading %s, %d files", formatters.ByteSize(zipFileBytes), fileCount)
} else {
cmd.ui.Warn("None of your application files have changed. Nothing will be uploaded.")
}
}
func (cmd *Push) describeUploadOperation(path string, zipFileBytes, fileCount int64) {
if fileCount > 0 {
cmd.ui.Say(T("Uploading app files from: {{.Path}}", map[string]interface{}{"Path": path}))
cmd.ui.Say(T("Uploading {{.ZipFileBytes}}, {{.FileCount}} files",
map[string]interface{}{
"ZipFileBytes": formatters.ByteSize(zipFileBytes),
"FileCount": fileCount}))
}
}
func (cmd *showQuota) Run(context *cli.Context) {
quotaName := context.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 {
cmd.ui.Failed(err.Error())
}
cmd.ui.Ok()
table := terminal.NewTable(cmd.ui, []string{"", ""})
table.Add(T("Total Memory"), formatters.ByteSize(quota.MemoryLimit*formatters.MEGABYTE))
table.Add(T("Instance Memory"), formatters.ByteSize(quota.InstanceMemoryLimit*formatters.MEGABYTE))
table.Add(T("Routes"), fmt.Sprintf("%d", quota.RoutesLimit))
table.Add(T("Services"), fmt.Sprintf("%d", quota.ServicesLimit))
table.Add(T("Paid service plans"), formatters.Allowed(quota.NonBasicServicesAllowed))
table.Print()
}
func (cmd *Push) describeUploadOperation(path string, zipFileBytes, fileCount int64) {
if fileCount > 0 {
cmd.ui.Say(T("Uploading app files from: {{.Path}}", map[string]interface{}{"Path": path}))
cmd.ui.Say(T("Uploading {{.ZipFileBytes}}, {{.FileCount}} files",
map[string]interface{}{
"ZipFileBytes": formatters.ByteSize(zipFileBytes),
"FileCount": fileCount}))
} else {
cmd.ui.Warn(T("None of your application files have changed. Nothing will be uploaded."))
}
}
func (cmd *ListSpaceQuotas) Execute(c flags.FlagContext) {
cmd.ui.Say(T("Getting space quotas as {{.Username}}...", map[string]interface{}{"Username": terminal.EntityNameColor(cmd.config.Username())}))
quotas, apiErr := cmd.spaceQuotaRepo.FindByOrg(cmd.config.OrganizationFields().Guid)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say("")
table := terminal.NewTable(cmd.ui, []string{T("name"), T("total memory limit"), T("instance memory limit"), T("routes"), T("service instances"), T("paid service plans")})
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),
fmt.Sprintf(servicesLimit),
formatters.Allowed(quota.NonBasicServicesAllowed),
)
}
table.Print()
}
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 (cmd *ShowSpace) quotaString(space models.Space) string {
var instance_memory string
if space.SpaceQuotaGuid == "" {
return ""
}
quota, err := cmd.quotaRepo.FindByGuid(space.SpaceQuotaGuid)
if err != nil {
cmd.ui.Failed(err.Error())
return ""
}
if quota.InstanceMemoryLimit == -1 {
instance_memory = "-1"
} else {
instance_memory = formatters.ByteSize(quota.InstanceMemoryLimit * formatters.MEGABYTE)
}
memory := formatters.ByteSize(quota.MemoryLimit * formatters.MEGABYTE)
spaceQuota := fmt.Sprintf("%s (%s memory limit, %s instance memory limit, %d routes, %d services, paid services %s)", quota.Name, memory, instance_memory, quota.RoutesLimit, quota.ServicesLimit, formatters.Allowed(quota.NonBasicServicesAllowed))
return spaceQuota
}
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.ui.PrintCapturingNoOutput("\r%s uploaded...", formatters.ByteSize(progressReader.bytesRead))
}
}
}
func (q SpaceQuota) FormattedMemoryLimit() string {
return formatters.ByteSize(q.MemoryLimit * formatters.MEGABYTE)
}
func (cmd *ShowApp) ShowApp(app models.Application) {
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(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
application, apiErr := cmd.appSummaryRepo.GetSummary(app.Guid)
appIsStopped := (application.State == "stopped")
if err, ok := apiErr.(errors.HttpError); ok {
if err.ErrorCode() == errors.APP_STOPPED || err.ErrorCode() == errors.APP_NOT_STAGED {
appIsStopped = true
}
}
if apiErr != nil && !appIsStopped {
cmd.ui.Failed(apiErr.Error())
return
}
var instances []models.AppInstanceFields
instances, apiErr = cmd.appInstancesRepo.GetInstances(app.Guid)
if apiErr != nil && !appIsStopped {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say("\n%s %s", terminal.HeaderColor(T("requested state:")), ui_helpers.ColoredAppState(application.ApplicationFields))
cmd.ui.Say("%s %s", terminal.HeaderColor(T("instances:")), ui_helpers.ColoredAppInstances(application.ApplicationFields))
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\n", terminal.HeaderColor(T("urls:")), strings.Join(urls, ", "))
if appIsStopped {
cmd.ui.Say(T("There are no running instances of this app."))
return
}
table := terminal.NewTable(cmd.ui, []string{"", T("state"), T("since"), T("cpu"), T("memory"), T("disk")})
for index, instance := range instances {
table.Add([]string{
fmt.Sprintf("#%d", index),
ui_helpers.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)})),
})
}
table.Print()
}
func (cmd *Scale) Execute(c flags.FlagContext) {
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
}
params := models.AppParams{}
shouldRestart := false
if c.String("m") != "" {
memory, err := formatters.ToMegabytes(c.String("m"))
if err != nil {
cmd.ui.Failed(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 {
cmd.ui.Failed(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")
if instances > 0 {
params.InstanceCount = &instances
} else {
cmd.ui.Failed(T("Invalid instance count: {{.InstanceCount}}\nInstance count must be a positive integer",
map[string]interface{}{
"InstanceCount": instances,
}))
}
}
if shouldRestart && !cmd.confirmRestart(c, currentApp.Name) {
return
}
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, 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, cmd.config.OrganizationFields().Name, cmd.config.SpaceFields().Name)
}
}
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 (cmd *ShowApp) ShowApp(app models.Application, orgName, spaceName string) {
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, apiErr := cmd.appSummaryRepo.GetSummary(app.Guid)
appIsStopped := (application.State == "stopped")
if err, ok := apiErr.(errors.HttpError); ok {
if err.ErrorCode() == errors.APP_STOPPED || err.ErrorCode() == errors.APP_NOT_STAGED {
appIsStopped = true
}
}
if apiErr != nil && !appIsStopped {
cmd.ui.Failed(apiErr.Error())
return
}
var instances []models.AppInstanceFields
instances, apiErr = cmd.appInstancesRepo.GetInstances(app.Guid)
if apiErr != nil && !appIsStopped {
cmd.ui.Failed(apiErr.Error())
return
}
if apiErr != nil && !appIsStopped {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say("\n%s %s", terminal.HeaderColor(T("requested state:")), ui_helpers.ColoredAppState(application.ApplicationFields))
cmd.ui.Say("%s %s", terminal.HeaderColor(T("instances:")), ui_helpers.ColoredAppInstances(application.ApplicationFields))
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)
if app.Stack != nil {
cmd.ui.Say("%s %s", terminal.HeaderColor(T("stack:")), app.Stack.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
}
table := terminal.NewTable(cmd.ui, []string{"", T("state"), T("since"), T("cpu"), T("memory"), T("disk"), T("details")})
for index, instance := range instances {
table.Add(
fmt.Sprintf("#%d", index),
ui_helpers.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),
)
if cmd.pluginCall {
i := plugin_models.GetApp_AppInstanceFields{}
i.State = fmt.Sprintf("%s", instance.State)
i.Details = instance.Details
i.Since = instance.Since
i.CpuUsage = instance.CpuUsage
i.DiskQuota = instance.DiskQuota
i.DiskUsage = instance.DiskUsage
i.MemQuota = instance.MemQuota
i.MemUsage = instance.MemUsage
cmd.pluginAppModel.Instances = append(cmd.pluginAppModel.Instances, i)
}
}
table.Print()
}
func (q SpaceQuota) FormattedInstanceMemoryLimit() string {
if q.InstanceMemoryLimit == -1 {
return "unlimited"
}
return formatters.ByteSize(q.InstanceMemoryLimit * formatters.MEGABYTE)
}
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 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)
if app.Stack != nil {
cmd.ui.Say("%s %s", terminal.HeaderColor(T("stack:")), app.Stack.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),
)
}
table.Print()
return nil
}