func (ui terminalUI) ShowConfiguration(config configuration.Reader) {
if config.HasAPIEndpoint() {
ui.Say("API endpoint: %s (API version: %s)",
EntityNameColor(config.ApiEndpoint()),
EntityNameColor(config.ApiVersion()))
}
if !config.IsLoggedIn() {
ui.Say(NotLoggedInText())
return
} else {
ui.Say("User: %s", EntityNameColor(config.UserEmail()))
}
if !config.HasOrganization() && !config.HasSpace() {
command := fmt.Sprintf("%s target -o ORG -s SPACE", cf.Name())
ui.Say("No org or space targeted, use '%s'", CommandColor(command))
return
}
if config.HasOrganization() {
ui.Say("Org: %s", EntityNameColor(config.OrganizationFields().Name))
} else {
command := fmt.Sprintf("%s target -o Org", cf.Name())
ui.Say("Org: No org targeted, use '%s'", CommandColor(command))
}
if config.HasSpace() {
ui.Say("Space: %s", EntityNameColor(config.SpaceFields().Name))
} else {
command := fmt.Sprintf("%s target -s SPACE", cf.Name())
ui.Say("Space: No space targeted, use '%s'", CommandColor(command))
}
}
func (ui terminalUI) ShowConfiguration(config configuration.Reader) {
if config.HasAPIEndpoint() {
ui.Say(T("API endpoint: {{.ApiEndpoint}} (API version: {{.ApiVersionString}})", map[string]interface{}{"ApiEndpoint": EntityNameColor(config.ApiEndpoint()), "ApiVersionString": EntityNameColor(config.ApiVersion())}))
}
if !config.IsLoggedIn() {
ui.Say(NotLoggedInText())
return
} else {
ui.Say(T("User: {{.UserEmail}}", map[string]interface{}{"UserEmail": EntityNameColor(config.UserEmail())}))
}
if !config.HasOrganization() && !config.HasSpace() {
command := fmt.Sprintf("%s target -o ORG -s SPACE", cf.Name())
ui.Say(T("No org or space targeted, use '{{.CFTargetCommand}}'", map[string]interface{}{"CFTargetCommand": CommandColor(command)}))
return
}
if config.HasOrganization() {
ui.Say(T("Org: {{.OrganizationName}}", map[string]interface{}{"OrganizationName": EntityNameColor(config.OrganizationFields().Name)}))
} else {
command := fmt.Sprintf("%s target -o Org", cf.Name())
ui.Say(T("Org: No org targeted, use '{{.CFTargetCommand}}'", map[string]interface{}{"CFTargetCommand": CommandColor(command)}))
}
if config.HasSpace() {
ui.Say(T("Space: {{.SpaceName}}", map[string]interface{}{"SpaceName": EntityNameColor(config.SpaceFields().Name)}))
} else {
command := fmt.Sprintf("%s target -s SPACE", cf.Name())
ui.Say(T("Space: No space targeted, use '{{.CFTargetCommand}}'", map[string]interface{}{"CFTargetCommand": CommandColor(command)}))
}
}
func (req ApiEndpointRequirement) Execute() (success bool) {
if req.config.ApiEndpoint() == "" {
loginTip := terminal.CommandColor(fmt.Sprintf("%s login", cf.Name()))
apiTip := terminal.CommandColor(fmt.Sprintf("%s api", cf.Name()))
req.ui.Say("No API endpoint targeted. Use '%s' or '%s' to target an endpoint.", loginTip, apiTip)
return false
}
return true
}
func (cmd *Start) waitForInstancesToStage(app models.Application) bool {
stagingStartTime := time.Now()
var err error
if cmd.StagingTimeout == 0 {
app, err = cmd.appRepo.GetApp(app.Guid)
} else {
for app.PackageState != "STAGED" && app.PackageState != "FAILED" && time.Since(stagingStartTime) < cmd.StagingTimeout {
app, err = cmd.appRepo.GetApp(app.Guid)
if err != nil {
break
}
time.Sleep(cmd.PingerThrottle)
}
}
if err != nil {
cmd.ui.Failed(err.Error())
}
if app.PackageState == "FAILED" {
cmd.ui.Say("")
if app.StagingFailedReason == "NoAppDetectedError" {
cmd.ui.Failed(T(`{{.Err}}
TIP: Buildpacks are detected when the "{{.PushCommand}}" is executed from within the directory that contains the app source code.
Use '{{.BuildpackCommand}}' to see a list of supported buildpacks.
Use '{{.Command}}' for more in depth log information.`,
map[string]interface{}{
"Err": app.StagingFailedReason,
"PushCommand": terminal.CommandColor(fmt.Sprintf("%s push", cf.Name())),
"BuildpackCommand": terminal.CommandColor(fmt.Sprintf("%s buildpacks", cf.Name())),
"Command": terminal.CommandColor(fmt.Sprintf("%s logs %s --recent", cf.Name(), app.Name))}))
} else {
cmd.ui.Failed(T("{{.Err}}\n\nTIP: use '{{.Command}}' for more information",
map[string]interface{}{
"Err": app.StagingFailedReason,
"Command": terminal.CommandColor(fmt.Sprintf("%s logs %s --recent", cf.Name(), app.Name))}))
}
}
if time.Since(stagingStartTime) >= cmd.StagingTimeout {
return false
}
return true
}
func (cmd *UpdateUserProvidedService) Run(c *cli.Context) {
serviceInstance := cmd.serviceInstanceReq.GetServiceInstance()
if !serviceInstance.IsUserProvided() {
cmd.ui.Failed(T("Service Instance is not user provided"))
return
}
drainUrl := c.String("l")
params := c.String("p")
paramsMap := make(map[string]string)
if params != "" {
err := json.Unmarshal([]byte(params), ¶msMap)
if err != nil {
cmd.ui.Failed(T("JSON is invalid: {{.ErrorDescription}}", map[string]interface{}{"ErrorDescription": err.Error()}))
return
}
}
cmd.ui.Say(T("Updating user provided service {{.ServiceName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.CurrentUser}}...",
map[string]interface{}{
"ServiceName": terminal.EntityNameColor(serviceInstance.Name),
"OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
}))
serviceInstance.Params = paramsMap
serviceInstance.SysLogDrainUrl = drainUrl
apiErr := cmd.userProvidedServiceInstanceRepo.Update(serviceInstance.ServiceInstanceFields)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say(T("TIP: To make these changes take effect, use '{{.CFUnbindCommand}}' to unbind the service, '{{.CFBindComand}}' to rebind, and then '{{.CFPushCommand}}' to update the app with the new env variables",
map[string]interface{}{
"CFUnbindCommand": cf.Name() + " " + "unbind-service",
"CFBindComand": cf.Name() + " " + "bind-service",
"CFPushCommand": cf.Name() + " " + "push",
}))
if params == "" && drainUrl == "" {
cmd.ui.Warn(T("No flags specified. No changes were made."))
}
}
func displayCrashDialog(errorMessage string) {
formattedString := `
Aww shucks.
Something completely unexpected happened. This is a bug in %s.
Please file this bug : https://github.com/cloudfoundry/cli/issues
Tell us that you ran this command:
%s
this error occurred:
%s
and this stack trace:
%s
`
stackByteCount := 0
STACK_SIZE_LIMIT := 1024 * 1024
var bytes []byte
for stackSize := 1024; (stackByteCount == 0 || stackByteCount == stackSize) && stackSize < STACK_SIZE_LIMIT; stackSize = 2 * stackSize {
bytes = make([]byte, stackSize)
stackByteCount = runtime.Stack(bytes, true)
}
stackTrace := "\t" + strings.Replace(string(bytes), "\n", "\n\t", -1)
println(fmt.Sprintf(formattedString, cf.Name(), strings.Join(os.Args, " "), errorMessage, stackTrace))
}
func (cmd *RenameService) Run(c *cli.Context) {
newName := c.Args()[1]
serviceInstance := cmd.serviceInstanceReq.GetServiceInstance()
cmd.ui.Say(T("Renaming service {{.ServiceName}} to {{.NewServiceName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.CurrentUser}}...",
map[string]interface{}{
"ServiceName": terminal.EntityNameColor(serviceInstance.Name),
"NewServiceName": terminal.EntityNameColor(newName),
"OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
}))
err := cmd.serviceRepo.RenameService(serviceInstance, newName)
if err != nil {
if httpError, ok := err.(errors.HttpError); ok && httpError.ErrorCode() == errors.SERVICE_INSTANCE_NAME_TAKEN {
cmd.ui.Failed(T("{{.ErrorDescription}}\nTIP: Use '{{.CFServicesCommand}}' to view all services in this org and space.",
map[string]interface{}{
"ErrorDescription": httpError.Error(),
"CFServicesCommand": cf.Name() + " " + "services",
}))
} else {
cmd.ui.Failed(err.Error())
}
}
cmd.ui.Ok()
}
func (cmd *DeleteSpace) Run(c *cli.Context) {
spaceName := c.Args()[0]
if !c.Bool("f") {
if !cmd.ui.ConfirmDelete("space", spaceName) {
return
}
}
cmd.ui.Say("Deleting space %s in org %s as %s...",
terminal.EntityNameColor(spaceName),
terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
terminal.EntityNameColor(cmd.config.Username()),
)
space := cmd.spaceReq.GetSpace()
apiErr := cmd.spaceRepo.Delete(space.Guid)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
if cmd.config.SpaceFields().Name == spaceName {
cmd.config.SetSpaceFields(models.SpaceFields{})
cmd.ui.Say("TIP: No space targeted, use '%s target -s' to target a space", cf.Name())
}
return
}
func CrashDialog(errorMessage string, commandArgs string, stackTrace string) string {
formattedString := `
Something unexpected happened. This is a bug in %s.
Please re-run the command that caused this exception with the environment
variable CF_TRACE set to true.
Also, please update to the latest cli and try the command again:
https://github.com/cloudfoundry/cli/releases
Please create an issue at: https://github.com/cloudfoundry/cli/issues
Include the below information when creating the issue:
Command
%s
CLI Version
%s
Error
%s
Stack Trace
%s
Your Platform Details
e.g. Mac OS X 10.11, Windows 8.1 64-bit, Ubuntu 14.04.3 64-bit
Shell
e.g. Terminal, iTerm, Powershell, Cygwin, gnome-terminal, terminator
`
return fmt.Sprintf(formattedString, cf.Name(), commandArgs, cf.Version, errorMessage, stackTrace)
}
func CrashDialog(errorMessage string, commandArgs string, stackTrace string) string {
formattedString := `
Aww shucks.
Something completely unexpected happened. This is a bug in %s.
Please file this bug : https://github.com/cloudfoundry/cli/issues
Tell us that you ran this command:
%s
using this version of the CLI:
%s
and that this error occurred:
%s
and this stack trace:
%s
`
return fmt.Sprintf(formattedString, cf.Name(), commandArgs, cf.Version, errorMessage, stackTrace)
}
func (cmd *SetEnv) Run(c *cli.Context) {
varName := c.Args()[1]
varValue := c.Args()[2]
app := cmd.appReq.GetApplication()
cmd.ui.Say(T("Setting env variable '{{.VarName}}' to '{{.VarValue}}' for app {{.AppName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.CurrentUser}}...",
map[string]interface{}{
"VarName": terminal.EntityNameColor(varName),
"VarValue": terminal.EntityNameColor(varValue),
"AppName": terminal.EntityNameColor(app.Name),
"OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username())}))
if len(app.EnvironmentVars) == 0 {
app.EnvironmentVars = map[string]string{}
}
envParams := app.EnvironmentVars
envParams[varName] = varValue
_, apiErr := cmd.appRepo.Update(app.Guid, models.AppParams{EnvironmentVars: &envParams})
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say(T("TIP: Use '{{.Command}}' to ensure your env variable changes take effect",
map[string]interface{}{"Command": terminal.CommandColor(cf.Name() + " restage")}))
}
func (cmd *UpdateUserProvidedService) Execute(c flags.FlagContext) {
serviceInstance := cmd.serviceInstanceReq.GetServiceInstance()
if !serviceInstance.IsUserProvided() {
cmd.ui.Failed(T("Service Instance is not user provided"))
return
}
drainUrl := c.String("l")
credentials := strings.Trim(c.String("p"), `'"`)
routeServiceUrl := c.String("r")
credentialsMap := make(map[string]interface{})
if c.IsSet("p") {
jsonBytes, err := util.GetContentsFromFlagValue(credentials)
if err != nil && strings.HasPrefix(credentials, "@") {
cmd.ui.Failed(err.Error())
}
if bytes.IndexAny(jsonBytes, "[{") != -1 {
err = json.Unmarshal(jsonBytes, &credentialsMap)
if err != nil {
cmd.ui.Failed(T("JSON is invalid: {{.ErrorDescription}}", map[string]interface{}{"ErrorDescription": err.Error()}))
}
} else {
for _, param := range strings.Split(credentials, ",") {
param = strings.Trim(param, " ")
credentialsMap[param] = cmd.ui.Ask("%s", param)
}
}
}
cmd.ui.Say(T("Updating user provided service {{.ServiceName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.CurrentUser}}...",
map[string]interface{}{
"ServiceName": terminal.EntityNameColor(serviceInstance.Name),
"OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
}))
serviceInstance.Params = credentialsMap
serviceInstance.SysLogDrainUrl = drainUrl
serviceInstance.RouteServiceUrl = routeServiceUrl
apiErr := cmd.userProvidedServiceInstanceRepo.Update(serviceInstance.ServiceInstanceFields)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say(T("TIP: Use '{{.CFRestageCommand}}' for any bound apps to ensure your env variable changes take effect",
map[string]interface{}{
"CFRestageCommand": terminal.CommandColor(cf.Name() + " restage"),
}))
if routeServiceUrl == "" && credentials == "" && drainUrl == "" {
cmd.ui.Warn(T("No flags specified. No changes were made."))
}
}
func (cmd *Start) waitForInstancesToStage(app models.Application) bool {
stagingStartTime := time.Now()
var err error
if cmd.StagingTimeout == 0 {
app, err = cmd.appRepo.GetApp(app.Guid)
} else {
for app.PackageState != "STAGED" && app.PackageState != "FAILED" && time.Since(stagingStartTime) < cmd.StagingTimeout {
app, err = cmd.appRepo.GetApp(app.Guid)
if err != nil {
break
}
cmd.ui.Wait(cmd.PingerThrottle)
}
}
if err != nil {
cmd.ui.Failed(err.Error())
}
if app.PackageState == "FAILED" {
cmd.ui.Say("")
cmd.ui.Failed(T("{{.Err}}\n\nTIP: use '{{.Command}}' for more information",
map[string]interface{}{
"Err": app.StagingFailedReason,
"Command": terminal.CommandColor(fmt.Sprintf("%s logs %s --recent", cf.Name(), app.Name))}))
}
if time.Since(stagingStartTime) >= cmd.StagingTimeout {
return false
}
return true
}
func (cmd Start) waitForOneRunningInstance(app models.Application) {
startupStartTime := time.Now()
for {
if time.Since(startupStartTime) > cmd.StartupTimeout {
cmd.ui.Failed(fmt.Sprintf(T("Start app timeout\n\nTIP: use '{{.Command}}' for more information",
map[string]interface{}{
"Command": terminal.CommandColor(fmt.Sprintf("%s logs %s --recent", cf.Name(), app.Name))})))
return
}
count, err := cmd.fetchInstanceCount(app.Guid)
if err != nil {
cmd.ui.Wait(cmd.PingerThrottle)
continue
}
cmd.ui.Say(instancesDetails(count))
if count.running > 0 {
return
}
if count.flapping > 0 {
cmd.ui.Failed(fmt.Sprintf(T("Start unsuccessful\n\nTIP: use '{{.Command}}' for more information",
map[string]interface{}{"Command": terminal.CommandColor(fmt.Sprintf("%s logs %s --recent", cf.Name(), app.Name))})))
return
}
cmd.ui.Wait(cmd.PingerThrottle)
}
}
func (cmd *BindService) Run(c *cli.Context) {
app := cmd.appReq.GetApplication()
serviceInstance := cmd.serviceInstanceReq.GetServiceInstance()
cmd.ui.Say(T("Binding service {{.ServiceInstanceName}} to app {{.AppName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.CurrentUser}}...",
map[string]interface{}{
"ServiceInstanceName": terminal.EntityNameColor(serviceInstance.Name),
"AppName": terminal.EntityNameColor(app.Name),
"OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
}))
err := cmd.BindApplication(app, serviceInstance)
if err != nil {
if httperr, ok := err.(errors.HttpError); ok && httperr.ErrorCode() == errors.APP_ALREADY_BOUND {
cmd.ui.Ok()
cmd.ui.Warn(T("App {{.AppName}} is already bound to {{.ServiceName}}.",
map[string]interface{}{
"AppName": app.Name,
"ServiceName": serviceInstance.Name,
}))
return
} else {
cmd.ui.Failed(err.Error())
}
}
cmd.ui.Ok()
cmd.ui.Say(T("TIP: Use '{{.CFCommand}}' to ensure your env variable changes take effect",
map[string]interface{}{"CFCommand": terminal.CommandColor(cf.Name() + " restage")}))
}
func (cmd *UnsetEnv) Execute(c flags.FlagContext) {
varName := c.Args()[1]
app := cmd.appReq.GetApplication()
cmd.ui.Say(T("Removing env variable {{.VarName}} from app {{.AppName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.CurrentUser}}...",
map[string]interface{}{
"VarName": terminal.EntityNameColor(varName),
"AppName": terminal.EntityNameColor(app.Name),
"OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username())}))
envParams := app.EnvironmentVars
if _, ok := envParams[varName]; !ok {
cmd.ui.Ok()
cmd.ui.Warn(T("Env variable {{.VarName}} was not set.", map[string]interface{}{"VarName": varName}))
return
}
delete(envParams, varName)
_, apiErr := cmd.appRepo.Update(app.Guid, models.AppParams{EnvironmentVars: &envParams})
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say(T("TIP: Use '{{.Command}}' to ensure your env variable changes take effect",
map[string]interface{}{"Command": terminal.CommandColor(cf.Name() + " restage")}))
}
func (cmd CreateOrg) Run(c *cli.Context) {
name := c.Args()[0]
cmd.ui.Say(T("Creating org {{.OrgName}} as {{.Username}}...",
map[string]interface{}{
"OrgName": terminal.EntityNameColor(name),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
org := models.Organization{OrganizationFields: models.OrganizationFields{Name: name}}
quotaName := c.String("q")
if quotaName != "" {
quota, err := cmd.quotaRepo.FindByName(quotaName)
if err != nil {
cmd.ui.Failed(err.Error())
}
org.QuotaDefinition.Guid = quota.Guid
}
err := cmd.orgRepo.Create(org)
if err != nil {
if apiErr, ok := err.(errors.HttpError); ok && apiErr.ErrorCode() == errors.ORG_EXISTS {
cmd.ui.Ok()
cmd.ui.Warn(T("Org {{.OrgName}} already exists",
map[string]interface{}{"OrgName": name}))
return
} else {
cmd.ui.Failed(err.Error())
}
}
cmd.ui.Ok()
cmd.ui.Say(T("\nTIP: Use '{{.Command}}' to target new org",
map[string]interface{}{"Command": terminal.CommandColor(cf.Name() + " target -o " + name)}))
}
func (cmd *DeleteSpace) Run(c *cli.Context) {
spaceName := c.Args()[0]
if !c.Bool("f") {
if !cmd.ui.ConfirmDelete(T("space"), spaceName) {
return
}
}
cmd.ui.Say(T("Deleting space {{.TargetSpace}} in org {{.TargetOrg}} as {{.CurrentUser}}...",
map[string]interface{}{
"TargetSpace": terminal.EntityNameColor(spaceName),
"TargetOrg": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
}))
space := cmd.spaceReq.GetSpace()
apiErr := cmd.spaceRepo.Delete(space.Guid)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
if cmd.config.SpaceFields().Name == spaceName {
cmd.config.SetSpaceFields(models.SpaceFields{})
cmd.ui.Say(T("TIP: No space targeted, use '{{.CfTargetCommand}}' to target a space",
map[string]interface{}{"CfTargetCommand": cf.Name() + " target -s"}))
}
return
}
func (cmd CreateSpace) Run(c *cli.Context) {
spaceName := c.Args()[0]
orgName := c.String("o")
orgGuid := ""
if orgName == "" {
orgName = cmd.config.OrganizationFields().Name
orgGuid = cmd.config.OrganizationFields().Guid
}
cmd.ui.Say("Creating space %s in org %s as %s...",
terminal.EntityNameColor(spaceName),
terminal.EntityNameColor(orgName),
terminal.EntityNameColor(cmd.config.Username()),
)
if orgGuid == "" {
org, apiErr := cmd.orgRepo.FindByName(orgName)
switch apiErr.(type) {
case nil:
case *errors.ModelNotFoundError:
cmd.ui.Failed("Org %s does not exist or is not accessible", orgName)
return
default:
cmd.ui.Failed("Error finding org %s\n%s", orgName, apiErr.Error())
return
}
orgGuid = org.Guid
}
space, err := cmd.spaceRepo.Create(spaceName, orgGuid)
if err != nil {
if httpErr, ok := err.(errors.HttpError); ok && httpErr.ErrorCode() == errors.SPACE_EXISTS {
cmd.ui.Ok()
cmd.ui.Warn("Space %s already exists", spaceName)
return
}
cmd.ui.Failed(err.Error())
return
}
cmd.ui.Ok()
err = cmd.spaceRoleSetter.SetSpaceRole(space, models.SPACE_MANAGER, cmd.config.UserGuid(), cmd.config.Username())
if err != nil {
cmd.ui.Failed(err.Error())
return
}
err = cmd.spaceRoleSetter.SetSpaceRole(space, models.SPACE_DEVELOPER, cmd.config.UserGuid(), cmd.config.Username())
if err != nil {
cmd.ui.Failed(err.Error())
return
}
cmd.ui.Say("\nTIP: Use '%s' to target new space", terminal.CommandColor(cf.Name()+" target -o "+orgName+" -s "+space.Name))
}
func (req targetedOrgApiRequirement) Execute() (success bool) {
if !req.config.HasOrganization() {
message := fmt.Sprintf("No org targeted, use '%s' to target an org.",
terminal.CommandColor(cf.Name()+" target -o ORG"))
req.ui.Failed(message)
return false
}
return true
}
func getCommand(metadata command_metadata.CommandMetadata, runner command_runner.Runner) cli.Command {
return cli.Command{
Name: metadata.Name,
ShortName: metadata.ShortName,
Description: metadata.Description,
Usage: strings.Replace(metadata.Usage, "CF_NAME", cf.Name(), -1),
Action: func(context *cli.Context) {
runner.RunCmdByName(metadata.Name, context)
},
Flags: metadata.Flags,
SkipFlagParsing: metadata.SkipFlagParsing,
}
}
func (cmd *UpdateUserProvidedService) Execute(c flags.FlagContext) {
serviceInstance := cmd.serviceInstanceReq.GetServiceInstance()
if !serviceInstance.IsUserProvided() {
cmd.ui.Failed(T("Service Instance is not user provided"))
return
}
drainUrl := c.String("l")
params := c.String("p")
routeServiceUrl := c.String("r")
paramsMap := make(map[string]interface{})
if params != "" {
err := json.Unmarshal([]byte(params), ¶msMap)
if err != nil {
cmd.ui.Failed(T("JSON is invalid: {{.ErrorDescription}}", map[string]interface{}{"ErrorDescription": err.Error()}))
return
}
}
cmd.ui.Say(T("Updating user provided service {{.ServiceName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.CurrentUser}}...",
map[string]interface{}{
"ServiceName": terminal.EntityNameColor(serviceInstance.Name),
"OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
}))
serviceInstance.Params = paramsMap
serviceInstance.SysLogDrainUrl = drainUrl
serviceInstance.RouteServiceUrl = routeServiceUrl
apiErr := cmd.userProvidedServiceInstanceRepo.Update(serviceInstance.ServiceInstanceFields)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say(T("TIP: Use '{{.CFRestageCommand}}' for any bound apps to ensure your env variable changes take effect",
map[string]interface{}{
"CFRestageCommand": terminal.CommandColor(cf.Name() + " restage"),
}))
if routeServiceUrl == "" && params == "" && drainUrl == "" {
cmd.ui.Warn(T("No flags specified. No changes were made."))
}
}
func (r *registry) CommandUsage(cmdName string) string {
output := ""
cmd := r.FindCommand(cmdName)
output = T("NAME") + ":" + "\n"
output += " " + cmd.MetaData().Name + " - " + cmd.MetaData().Description + "\n\n"
output += T("USAGE") + ":" + "\n"
output += " " + strings.Replace(cmd.MetaData().Usage, "CF_NAME", cf.Name(), -1) + "\n"
if cmd.MetaData().ShortName != "" {
output += "\n" + T("ALIAS") + ":" + "\n"
output += " " + cmd.MetaData().ShortName + "\n"
}
if cmd.MetaData().Flags != nil {
output += "\n" + T("OPTIONS") + ":" + "\n"
//find longest name length
l := 0
for n, _ := range cmd.MetaData().Flags {
if len(n) > l {
l = len(n)
}
}
//print non-bool flags first
for n, f := range cmd.MetaData().Flags {
switch f.GetValue().(type) {
case bool:
default:
output += " -" + n + strings.Repeat(" ", 7+(l-len(n))) + f.String() + "\n"
}
}
//then bool flags
for n, f := range cmd.MetaData().Flags {
switch f.GetValue().(type) {
case bool:
if len(f.GetName()) == 1 {
output += " -" + n + strings.Repeat(" ", 7+(l-len(n))) + f.String() + "\n"
} else {
output += " --" + n + strings.Repeat(" ", 6+(l-len(n))) + f.String() + "\n"
}
}
}
}
return output
}
func (req TargetedSpaceRequirement) Execute() (success bool) {
if !req.config.HasOrganization() {
message := fmt.Sprintf("No org and space targeted, use '%s' to target an org and space",
terminal.CommandColor(cf.Name()+" target -o ORG -s SPACE"))
req.ui.Failed(message)
return false
}
if !req.config.HasSpace() {
message := fmt.Sprintf("No space targeted, use '%s' to target a space", terminal.CommandColor("cf target -s"))
req.ui.Failed(message)
return false
}
return true
}
func (cmd Start) waitForInstancesToStage(app models.Application) {
stagingStartTime := time.Now()
_, err := cmd.appInstancesRepo.GetInstances(app.Guid)
for err != nil && time.Since(stagingStartTime) < cmd.StagingTimeout {
if httpError, ok := err.(errors.HttpError); ok && httpError.ErrorCode() != errors.APP_NOT_STAGED {
cmd.ui.Say("")
cmd.ui.Failed(fmt.Sprintf("%s\n\nTIP: use '%s' for more information",
httpError.Error(),
terminal.CommandColor(fmt.Sprintf("%s logs %s --recent", cf.Name(), app.Name))))
return
}
cmd.ui.Wait(cmd.PingerThrottle)
_, err = cmd.appInstancesRepo.GetInstances(app.Guid)
}
return
}
func (cmd Start) waitForOneRunningInstance(app models.Application) {
var runningCount, startingCount, flappingCount, downCount int
startupStartTime := time.Now()
for runningCount == 0 {
if time.Since(startupStartTime) > cmd.StartupTimeout {
cmd.ui.Failed(fmt.Sprintf(T("Start app timeout\n\nTIP: use '{{.Command}}' for more information",
map[string]interface{}{
"Command": terminal.CommandColor(fmt.Sprintf("%s logs %s --recent", cf.Name(), app.Name))})))
return
}
instances, apiErr := cmd.appInstancesRepo.GetInstances(app.Guid)
if apiErr != nil {
cmd.ui.Wait(cmd.PingerThrottle)
continue
}
totalCount := len(instances)
runningCount, startingCount, flappingCount, downCount = 0, 0, 0, 0
for _, inst := range instances {
switch inst.State {
case models.InstanceRunning:
runningCount++
case models.InstanceStarting:
startingCount++
case models.InstanceFlapping:
flappingCount++
case models.InstanceDown:
downCount++
}
}
cmd.ui.Say(instancesDetails(startingCount, downCount, runningCount, flappingCount, totalCount))
if flappingCount > 0 {
cmd.ui.Failed(fmt.Sprintf(T("Start unsuccessful\n\nTIP: use '{{.Command}}' for more information",
map[string]interface{}{"Command": terminal.CommandColor(fmt.Sprintf("%s logs %s --recent", cf.Name(), app.Name))})))
return
}
}
}
func (cmd Start) waitForInstancesToStage(app models.Application) {
stagingStartTime := time.Now()
_, err := cmd.appInstancesRepo.GetInstances(app.Guid)
for isStagingError(err) && time.Since(stagingStartTime) < cmd.StagingTimeout {
cmd.ui.Wait(cmd.PingerThrottle)
_, err = cmd.appInstancesRepo.GetInstances(app.Guid)
}
if err != nil && !isStagingError(err) {
cmd.ui.Say("")
cmd.ui.Failed(T("{{.Err}}\n\nTIP: use '{{.Command}}' for more information",
map[string]interface{}{
"Err": err.Error(),
"Command": terminal.CommandColor(fmt.Sprintf("%s logs %s --recent", cf.Name(), app.Name))}))
}
return
}
func (cmd Authenticate) Run(c *cli.Context) {
cmd.config.ClearSession()
cmd.authenticator.GetLoginPromptsAndSaveUAAServerURL()
cmd.ui.Say(T("API endpoint: {{.ApiEndpoint}}",
map[string]interface{}{"ApiEndpoint": terminal.EntityNameColor(cmd.config.ApiEndpoint())}))
cmd.ui.Say(T("Authenticating..."))
apiErr := cmd.authenticator.Authenticate(map[string]string{"username": c.Args()[0], "password": c.Args()[1]})
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say(T("Use '{{.Name}}' to view or set your target org and space",
map[string]interface{}{"Name": terminal.CommandColor(cf.Name() + " target")}))
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 CreateUser) Run(c *cli.Context) {
username := c.Args()[0]
password := c.Args()[1]
cmd.ui.Say("Creating user %s as %s...",
terminal.EntityNameColor(username),
terminal.EntityNameColor(cmd.config.Username()),
)
err := cmd.userRepo.Create(username, password)
switch err.(type) {
case nil:
case *errors.ModelAlreadyExistsError:
cmd.ui.Warn("%s", err.Error())
default:
cmd.ui.Failed("Error creating user %s.\n%s", terminal.EntityNameColor(username), err.Error())
}
cmd.ui.Ok()
cmd.ui.Say("\nTIP: Assign roles with '%s set-org-role' and '%s set-space-role'", cf.Name(), cf.Name())
}
