func (cmd *Start) ApplicationWatchStaging(app models.Application, orgName, spaceName string, start func(app models.Application) (models.Application, error)) (updatedApp models.Application, err error) {
stopChan := make(chan bool, 1)
loggingStartedWait := &sync.WaitGroup{}
loggingStartedWait.Add(1)
loggingDoneWait := &sync.WaitGroup{}
loggingDoneWait.Add(1)
go cmd.tailStagingLogs(app, stopChan, loggingStartedWait, loggingDoneWait)
loggingStartedWait.Wait()
updatedApp, apiErr := start(app)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
isStaged := cmd.waitForInstancesToStage(updatedApp)
stopChan <- true
loggingDoneWait.Wait()
cmd.ui.Say("")
if !isStaged {
cmd.ui.Failed(fmt.Sprintf("%s failed to stage within %f minutes", app.Name, cmd.StagingTimeout.Minutes()))
}
cmd.waitForOneRunningInstance(updatedApp)
cmd.ui.Say(terminal.HeaderColor(T("\nApp started\n")))
cmd.ui.Say("")
cmd.ui.Ok()
//detectedstartcommand on first push is not present until starting completes
startedApp, apiErr := cmd.appRepo.GetApp(updatedApp.GUID)
if err != nil {
cmd.ui.Failed(apiErr.Error())
return
}
var appStartCommand string
if app.Command == "" {
appStartCommand = startedApp.DetectedStartCommand
} else {
appStartCommand = startedApp.Command
}
cmd.ui.Say(T("\nApp {{.AppName}} was started using this command `{{.Command}}`\n",
map[string]interface{}{
"AppName": terminal.EntityNameColor(startedApp.Name),
"Command": appStartCommand,
}))
cmd.appDisplayer.ShowApp(startedApp, orgName, spaceName)
return
}
func (cmd *OrgUsers) Run(c *cli.Context) {
org := cmd.orgReq.GetOrganization()
all := c.Bool("a")
cmd.ui.Say("Getting users in org %s as %s...",
terminal.EntityNameColor(org.Name),
terminal.EntityNameColor(cmd.config.Username()),
)
roles := orgRoles
if all {
roles = []string{models.ORG_USER}
}
for _, role := range roles {
displayName := orgRoleToDisplayName[role]
users, apiErr := cmd.userRepo.ListUsersInOrgForRole(org.Guid, role)
cmd.ui.Say("")
cmd.ui.Say("%s", terminal.HeaderColor(displayName))
for _, user := range users {
cmd.ui.Say(" %s", user.Username)
}
if apiErr != nil {
cmd.ui.Failed("Failed fetching org-users for role %s.\n%s", apiErr.Error(), displayName)
return
}
}
}
func (cmd *Start) ApplicationWatchStaging(app models.Application, start func(app models.Application) (models.Application, error)) (updatedApp models.Application, err error) {
stopLoggingChan := make(chan bool, 1)
loggingStartedChan := make(chan bool)
go cmd.tailStagingLogs(app, loggingStartedChan, stopLoggingChan)
<-loggingStartedChan // block until we have established connection to Loggregator
updatedApp, apiErr := start(app)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.waitForInstancesToStage(updatedApp)
stopLoggingChan <- true
cmd.ui.Say("")
cmd.waitForOneRunningInstance(updatedApp)
cmd.ui.Say(terminal.HeaderColor(T("\nApp started\n")))
cmd.appDisplayer.ShowApp(updatedApp)
return
}
func (cmd *SpaceUsers) Run(c *cli.Context) {
spaceName := c.Args()[1]
org := cmd.orgReq.GetOrganization()
space, apiErr := cmd.spaceRepo.FindByNameInOrg(spaceName, org.Guid)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
}
cmd.ui.Say("Getting users in org %s / space %s as %s",
terminal.EntityNameColor(org.Name),
terminal.EntityNameColor(space.Name),
terminal.EntityNameColor(cmd.config.Username()),
)
for _, role := range spaceRoles {
displayName := spaceRoleToDisplayName[role]
users, apiErr := cmd.userRepo.ListUsersInSpaceForRole(space.Guid, role)
cmd.ui.Say("")
cmd.ui.Say("%s", terminal.HeaderColor(displayName))
for _, user := range users {
cmd.ui.Say(" %s", user.Username)
}
if apiErr != nil {
cmd.ui.Failed("Failed fetching space-users for role %s.\n%s", apiErr.Error(), displayName)
return
}
}
}
func dumpResponse(res *http.Response) {
dumpedResponse, err := httputil.DumpResponse(res, true)
if err != nil {
trace.Logger.Printf(T("Error dumping response\n{{.Err}}\n", map[string]interface{}{"Err": err}))
} else {
trace.Logger.Printf("\n%s [%s]\n%s\n", terminal.HeaderColor(T("RESPONSE:")), time.Now().Format(time.RFC3339), Sanitize(string(dumpedResponse)))
}
}
func dumpRequest(req *http.Request) {
shouldDisplayBody := !strings.Contains(req.Header.Get("Content-Type"), "multipart/form-data")
dumpedRequest, err := httputil.DumpRequest(req, shouldDisplayBody)
if err != nil {
trace.Logger.Printf(T("Error dumping request\n{{.Err}}\n", map[string]interface{}{"Err": err}))
} else {
trace.Logger.Printf("\n%s [%s]\n%s\n", terminal.HeaderColor(T("REQUEST:")), time.Now().Format(time.RFC3339), Sanitize(string(dumpedRequest)))
if !shouldDisplayBody {
trace.Logger.Println(T("[MULTIPART/FORM-DATA CONTENT HIDDEN]"))
}
}
}
func (cmd *OrgUsers) Run(c *cli.Context) {
org := cmd.orgReq.GetOrganization()
all := c.Bool("a")
cmd.ui.Say(T("Getting users in org {{.TargetOrg}} as {{.CurrentUser}}...",
map[string]interface{}{
"TargetOrg": terminal.EntityNameColor(org.Name),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
}))
roles := orgRoles
if all {
roles = []string{models.ORG_USER}
}
var orgRoleToDisplayName = map[string]string{
models.ORG_USER: T("USERS"),
models.ORG_MANAGER: T("ORG MANAGER"),
models.BILLING_MANAGER: T("BILLING MANAGER"),
models.ORG_AUDITOR: T("ORG AUDITOR"),
}
var users []models.UserFields
var apiErr error
for _, role := range roles {
displayName := orgRoleToDisplayName[role]
if cmd.config.IsMinApiVersion("2.21.0") {
users, apiErr = cmd.userRepo.ListUsersInOrgForRoleWithNoUAA(org.Guid, role)
} else {
users, apiErr = cmd.userRepo.ListUsersInOrgForRole(org.Guid, role)
}
cmd.ui.Say("")
cmd.ui.Say("%s", terminal.HeaderColor(displayName))
for _, user := range users {
cmd.ui.Say(" %s", user.Username)
}
if apiErr != nil {
cmd.ui.Failed(T("Failed fetching org-users for role {{.OrgRoleToDisplayName}}.\n{{.Error}}",
map[string]interface{}{
"Error": apiErr.Error(),
"OrgRoleToDisplayName": displayName,
}))
return
}
}
}
func (cmd *SpaceUsers) Run(c *cli.Context) {
spaceName := c.Args()[1]
org := cmd.orgReq.GetOrganization()
space, apiErr := cmd.spaceRepo.FindByNameInOrg(spaceName, org.Guid)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
}
cmd.ui.Say(T("Getting users in org {{.TargetOrg}} / space {{.TargetSpace}} as {{.CurrentUser}}",
map[string]interface{}{
"TargetOrg": terminal.EntityNameColor(org.Name),
"TargetSpace": terminal.EntityNameColor(space.Name),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
}))
var spaceRoleToDisplayName = map[string]string{
models.SPACE_MANAGER: T("SPACE MANAGER"),
models.SPACE_DEVELOPER: T("SPACE DEVELOPER"),
models.SPACE_AUDITOR: T("SPACE AUDITOR"),
}
var users []models.UserFields
for _, role := range spaceRoles {
displayName := spaceRoleToDisplayName[role]
if cmd.config.IsMinApiVersion("2.21.0") {
users, apiErr = cmd.userRepo.ListUsersInSpaceForRoleWithNoUAA(space.Guid, role)
} else {
users, apiErr = cmd.userRepo.ListUsersInSpaceForRole(space.Guid, role)
}
cmd.ui.Say("")
cmd.ui.Say("%s", terminal.HeaderColor(displayName))
for _, user := range users {
cmd.ui.Say(" %s", user.Username)
}
if apiErr != nil {
cmd.ui.Failed(T("Failed fetching space-users for role {{.SpaceRoleToDisplayName}}.\n{{.Error}}",
map[string]interface{}{
"Error": apiErr.Error(),
"SpaceRoleToDisplayName": displayName,
}))
return
}
}
}
func NewApp(cmdRunner command_runner.Runner, metadatas ...command_metadata.CommandMetadata) (app *cli.App) {
helpCommand := cli.Command{
Name: "help",
ShortName: "h",
Description: T("Show help"),
Usage: fmt.Sprintf(T("{{.Command}} help [COMMAND]", map[string]interface{}{"Command": cf.Name()})),
Action: func(c *cli.Context) {
args := c.Args()
if len(args) > 0 {
cli.ShowCommandHelp(c, args[0])
} else {
showAppHelp(appHelpTemplate(), c.App)
}
},
}
cli.AppHelpTemplate = appHelpTemplate()
cli.HelpPrinter = ShowHelp
trace.Logger.Printf("\n%s\n%s\n\n", terminal.HeaderColor(T("VERSION:")), cf.Version)
app = cli.NewApp()
app.Usage = Usage()
app.Version = cf.Version + "-" + cf.BuiltOnDate
app.Action = helpCommand.Action
app.CommandNotFound = func(c *cli.Context, command string) {
panic(errors.Exception{
Message: fmt.Sprintf(UnknownCommand, command),
DisplayCrashDialog: false,
})
}
compiledAtTime, err := time.Parse("2006-01-02T03:04:05+00:00", cf.BuiltOnDate)
if err == nil {
app.Compiled = compiledAtTime
} else {
err = nil
app.Compiled = time.Now()
}
app.Commands = []cli.Command{helpCommand}
for _, metadata := range metadatas {
app.Commands = append(app.Commands, getCommand(metadata, cmdRunner))
}
return
}
func NewApp(cmdRunner command_runner.Runner, metadatas ...command_metadata.CommandMetadata) (app *cli.App) {
helpCommand := cli.Command{
Name: "help",
ShortName: "h",
Description: "Show help",
Usage: fmt.Sprintf("%s help [COMMAND]", cf.Name()),
Action: func(c *cli.Context) {
args := c.Args()
if len(args) > 0 {
cli.ShowCommandHelp(c, args[0])
} else {
showAppHelp(appHelpTemplate, c.App)
}
},
}
cli.HelpPrinter = showAppHelp
cli.AppHelpTemplate = appHelpTemplate
trace.Logger.Printf("\n%s\n%s\n\n", terminal.HeaderColor("VERSION:"), cf.Version)
app = cli.NewApp()
app.Usage = cf.Usage
app.Version = cf.Version + "-" + cf.BuiltOnDate
app.Action = helpCommand.Action
compiledAtTime, err := time.Parse("2006-01-02T03:04:05+00:00", cf.BuiltOnDate)
if err == nil {
app.Compiled = compiledAtTime
} else {
err = nil
app.Compiled = time.Now()
}
app.Commands = []cli.Command{helpCommand}
for _, metadata := range metadatas {
app.Commands = append(app.Commands, getCommand(metadata, cmdRunner))
}
return
}
func (cmd *Start) ApplicationStart(app models.Application) (updatedApp models.Application, err error) {
if app.State == "started" {
cmd.ui.Say(terminal.WarningColor("App " + app.Name + " is already started"))
return
}
stopLoggingChan := make(chan bool, 1)
loggingStartedChan := make(chan bool)
go cmd.tailStagingLogs(app, loggingStartedChan, stopLoggingChan)
<-loggingStartedChan // block until we have established connection to Loggregator
cmd.ui.Say("Starting app %s in org %s / space %s as %s...",
terminal.EntityNameColor(app.Name),
terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
terminal.EntityNameColor(cmd.config.SpaceFields().Name),
terminal.EntityNameColor(cmd.config.Username()),
)
state := "STARTED"
updatedApp, apiErr := cmd.appRepo.Update(app.Guid, models.AppParams{State: &state})
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.waitForInstancesToStage(updatedApp)
stopLoggingChan <- true
cmd.ui.Say("")
cmd.waitForOneRunningInstance(updatedApp)
cmd.ui.Say(terminal.HeaderColor("\nApp started\n"))
cmd.appDisplayer.ShowApp(updatedApp)
return
}
func (p *SpaceUsersUIPrinter) PrintUsers(guid string, username string) {
for _, role := range p.Roles {
displayName := p.RoleDisplayNames[role]
users, err := p.UserLister(guid, role)
if err != nil {
p.UI.Failed(T("Failed fetching space-users for role {{.SpaceRoleToDisplayName}}.\n{{.Error}}",
map[string]interface{}{
"Error": err.Error(),
"SpaceRoleToDisplayName": displayName,
}))
return
}
p.UI.Say("")
p.UI.Say("%s", terminal.HeaderColor(displayName))
if len(users) == 0 {
p.UI.Say(fmt.Sprintf(" "+T("No %s found"), displayName))
} else {
for _, user := range users {
p.UI.Say(" %s", user.Username)
}
}
}
}
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 *SpaceUsers) Execute(c flags.FlagContext) {
spaceName := c.Args()[1]
org := cmd.orgReq.GetOrganization()
space, apiErr := cmd.spaceRepo.FindByNameInOrg(spaceName, org.Guid)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
}
cmd.ui.Say(T("Getting users in org {{.TargetOrg}} / space {{.TargetSpace}} as {{.CurrentUser}}",
map[string]interface{}{
"TargetOrg": terminal.EntityNameColor(org.Name),
"TargetSpace": terminal.EntityNameColor(space.Name),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
}))
var spaceRoleToDisplayName = map[string]string{
models.SPACE_MANAGER: T("SPACE MANAGER"),
models.SPACE_DEVELOPER: T("SPACE DEVELOPER"),
models.SPACE_AUDITOR: T("SPACE AUDITOR"),
}
var usersMap = make(map[string]plugin_models.GetSpaceUsers_Model)
var users []models.UserFields
for _, role := range spaceRoles {
displayName := spaceRoleToDisplayName[role]
if cmd.config.IsMinApiVersion("2.21.0") {
users, apiErr = cmd.userRepo.ListUsersInSpaceForRoleWithNoUAA(space.Guid, role)
} else {
users, apiErr = cmd.userRepo.ListUsersInSpaceForRole(space.Guid, role)
}
cmd.ui.Say("")
cmd.ui.Say("%s", terminal.HeaderColor(displayName))
for _, user := range users {
cmd.ui.Say(" %s", user.Username)
if cmd.pluginCall {
u, found := usersMap[user.Username]
if !found {
u = plugin_models.GetSpaceUsers_Model{}
u.Username = user.Username
u.Guid = user.Guid
u.IsAdmin = user.IsAdmin
u.Roles = make([]string, 1)
u.Roles[0] = role
usersMap[user.Username] = u
} else {
u.Roles = append(u.Roles, role)
usersMap[user.Username] = u
}
}
}
if apiErr != nil {
cmd.ui.Failed(T("Failed fetching space-users for role {{.SpaceRoleToDisplayName}}.\n{{.Error}}",
map[string]interface{}{
"Error": apiErr.Error(),
"SpaceRoleToDisplayName": displayName,
}))
return
}
}
if cmd.pluginCall {
for _, v := range usersMap {
*(cmd.pluginModel) = append(*(cmd.pluginModel), v)
}
}
}
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 (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 (c groupedCommands) SubTitle(name string) string {
return terminal.HeaderColor(name + ":")
}
func (p appPresenter) Title(name string) string {
return terminal.HeaderColor(name)
}
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 *OrgUsers) Execute(c flags.FlagContext) {
org := cmd.orgReq.GetOrganization()
all := c.Bool("a")
cmd.ui.Say(T("Getting users in org {{.TargetOrg}} as {{.CurrentUser}}...",
map[string]interface{}{
"TargetOrg": terminal.EntityNameColor(org.Name),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
}))
roles := orgRoles
if all {
roles = []string{models.ORG_USER}
}
var orgRoleToDisplayName = map[string]string{
models.ORG_USER: T("USERS"),
models.ORG_MANAGER: T("ORG MANAGER"),
models.BILLING_MANAGER: T("BILLING MANAGER"),
models.ORG_AUDITOR: T("ORG AUDITOR"),
}
var usersMap = make(map[string]plugin_models.GetOrgUsers_Model)
var users []models.UserFields
var apiErr error
for _, role := range roles {
displayName := orgRoleToDisplayName[role]
if cmd.config.IsMinApiVersion("2.21.0") {
users, apiErr = cmd.userRepo.ListUsersInOrgForRoleWithNoUAA(org.Guid, role)
} else {
users, apiErr = cmd.userRepo.ListUsersInOrgForRole(org.Guid, role)
}
cmd.ui.Say("")
cmd.ui.Say("%s", terminal.HeaderColor(displayName))
for _, user := range users {
cmd.ui.Say(" %s", user.Username)
if cmd.pluginCall {
u, found := usersMap[user.Username]
if !found {
u = plugin_models.GetOrgUsers_Model{}
u.Username = user.Username
u.Guid = user.Guid
u.IsAdmin = user.IsAdmin
u.Roles = make([]string, 1)
u.Roles[0] = role
usersMap[user.Username] = u
} else {
u.Roles = append(u.Roles, role)
usersMap[user.Username] = u
}
}
}
if apiErr != nil {
cmd.ui.Failed(T("Failed fetching org-users for role {{.OrgRoleToDisplayName}}.\n{{.Error}}",
map[string]interface{}{
"Error": apiErr.Error(),
"OrgRoleToDisplayName": displayName,
}))
return
}
}
if cmd.pluginCall {
for _, v := range usersMap {
*(cmd.pluginModel) = append(*(cmd.pluginModel), v)
}
}
}
func (cmd *Start) ApplicationWatchStaging(app models.Application, orgName, spaceName string, start func(app models.Application) (models.Application, error)) (updatedApp models.Application, err error) {
var isConnected bool
loggingStartedChan := make(chan bool)
doneLoggingChan := make(chan bool)
go cmd.tailStagingLogs(app, loggingStartedChan, doneLoggingChan)
timeout := make(chan struct{})
go func() {
time.Sleep(cmd.LogServerConnectionTimeout)
close(timeout)
}()
select {
case <-timeout:
cmd.ui.Warn("timeout connecting to log server, no log will be shown")
break
case <-loggingStartedChan: // block until we have established connection to Loggregator
isConnected = true
break
}
updatedApp, apiErr := start(app)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
isStaged := cmd.waitForInstancesToStage(updatedApp)
if isConnected { //only close when actually connected, else CLI hangs at closing consumer connection
cmd.logRepo.Close()
}
<-doneLoggingChan
cmd.ui.Say("")
if !isStaged {
cmd.ui.Failed(fmt.Sprintf("%s failed to stage within %f minutes", app.Name, cmd.StagingTimeout.Minutes()))
}
cmd.waitForOneRunningInstance(updatedApp)
cmd.ui.Say(terminal.HeaderColor(T("\nApp started\n")))
cmd.ui.Say("")
cmd.ui.Ok()
//detectedstartcommand on first push is not present until starting completes
startedApp, apiErr := cmd.appRepo.Read(updatedApp.Name)
if err != nil {
cmd.ui.Failed(apiErr.Error())
return
}
var appStartCommand string
if app.Command == "" {
appStartCommand = startedApp.DetectedStartCommand
} else {
appStartCommand = startedApp.Command
}
cmd.ui.Say(T("\nApp {{.AppName}} was started using this command `{{.Command}}`\n",
map[string]interface{}{
"AppName": terminal.EntityNameColor(startedApp.Name),
"Command": appStartCommand,
}))
cmd.appDisplayer.ShowApp(startedApp, orgName, spaceName)
return
}
func (cmd *GetHealthCheck) Execute(fc flags.FlagContext) {
app := cmd.appReq.GetApplication()
cmd.ui.Say(T("health_check_type is ") + terminal.HeaderColor(app.HealthCheckType))
}
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
}