func (req APIEndpointRequirement) Execute() error {
if req.config.APIEndpoint() == "" {
loginTip := terminal.CommandColor(fmt.Sprintf(T("{{.CFName}} login", map[string]interface{}{"CFName": cf.Name})))
apiTip := terminal.CommandColor(fmt.Sprintf(T("{{.CFName}} api", map[string]interface{}{"CFName": cf.Name})))
return errors.New(T("No API endpoint set. Use '{{.LoginTip}}' or '{{.APITip}}' to target an endpoint.",
map[string]interface{}{
"LoginTip": loginTip,
"APITip": apiTip,
}))
}
return nil
}
func (cmd *Start) waitForInstancesToStage(app models.Application) (bool, error) {
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 {
return false, err
}
if app.PackageState == "FAILED" {
cmd.ui.Say("")
if app.StagingFailedReason == "NoAppDetectedError" {
return false, errors.New(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))}))
}
return false, errors.New(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, nil
}
return true, nil
}
func (cmd *UnsetEnv) Execute(c flags.FlagContext) error {
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 nil
}
delete(envParams, varName)
_, err := cmd.appRepo.Update(app.GUID, models.AppParams{EnvironmentVars: &envParams})
if err != nil {
return err
}
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")}))
return nil
}
func (cmd API) setAPIEndpoint(endpoint string, skipSSL bool, cmdName string) error {
if strings.HasSuffix(endpoint, "/") {
endpoint = strings.TrimSuffix(endpoint, "/")
}
cmd.config.SetSSLDisabled(skipSSL)
refresher := coreconfig.APIConfigRefresher{
Endpoint: endpoint,
EndpointRepo: cmd.endpointRepo,
Config: cmd.config,
}
warning, err := refresher.Refresh()
if err != nil {
cmd.config.SetAPIEndpoint("")
cmd.config.SetSSLDisabled(false)
switch typedErr := err.(type) {
case *errors.InvalidSSLCert:
cfAPICommand := terminal.CommandColor(fmt.Sprintf("%s %s --skip-ssl-validation", cf.Name, cmdName))
tipMessage := fmt.Sprintf(T("TIP: Use '{{.APICommand}}' to continue with an insecure API endpoint",
map[string]interface{}{"APICommand": cfAPICommand}))
return errors.New(T("Invalid SSL Cert for {{.URL}}\n{{.TipMessage}}",
map[string]interface{}{"URL": typedErr.URL, "TipMessage": tipMessage}))
default:
return typedErr
}
}
if warning != nil {
cmd.ui.Say(terminal.WarningColor(warning.Warn()))
}
return nil
}
func (cmd API) Execute(c flags.FlagContext) error {
if c.Bool("unset") {
cmd.ui.Say(T("Unsetting api endpoint..."))
cmd.config.SetAPIEndpoint("")
cmd.ui.Ok()
cmd.ui.Say(T("\nNo api endpoint set."))
} else if len(c.Args()) == 0 {
if cmd.config.APIEndpoint() == "" {
cmd.ui.Say(fmt.Sprintf(T("No api endpoint set. Use '{{.Name}}' to set an endpoint",
map[string]interface{}{"Name": terminal.CommandColor(cf.Name + " api")})))
} else {
cmd.ui.Say(T("API endpoint: {{.APIEndpoint}} (API version: {{.APIVersion}})",
map[string]interface{}{"APIEndpoint": terminal.EntityNameColor(cmd.config.APIEndpoint()),
"APIVersion": terminal.EntityNameColor(cmd.config.APIVersion())}))
}
} else {
endpoint := c.Args()[0]
cmd.ui.Say(T("Setting api endpoint to {{.Endpoint}}...",
map[string]interface{}{"Endpoint": terminal.EntityNameColor(endpoint)}))
err := cmd.setAPIEndpoint(endpoint, c.Bool("skip-ssl-validation"), cmd.MetaData().Name)
if err != nil {
return err
}
cmd.ui.Ok()
cmd.ui.Say("")
cmd.ui.ShowConfiguration(cmd.config)
}
return nil
}
func (cmd *SetEnv) Execute(c flags.FlagContext) error {
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]interface{}{}
}
envParams := app.EnvironmentVars
envParams[varName] = varValue
_, err := cmd.appRepo.Update(app.GUID, models.AppParams{EnvironmentVars: &envParams})
if err != nil {
return err
}
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 " + app.Name)}))
return nil
}
func (cmd *Start) waitForOneRunningInstance(app models.Application) error {
timer := time.NewTimer(cmd.StartupTimeout)
for {
select {
case <-timer.C:
tipMsg := T("Start app timeout\n\nTIP: Application must be listening on the right port. Instead of hard coding the port, use the $PORT environment variable.") + "\n\n"
tipMsg += T("Use '{{.Command}}' for more information", map[string]interface{}{"Command": terminal.CommandColor(fmt.Sprintf("%s logs %s --recent", cf.Name, app.Name))})
return errors.New(tipMsg)
default:
count, err := cmd.fetchInstanceCount(app.GUID)
if err != nil {
cmd.ui.Warn("Could not fetch instance count: %s", err.Error())
time.Sleep(cmd.PingerThrottle)
continue
}
cmd.ui.Say(instancesDetails(count))
if count.running > 0 {
return nil
}
if count.flapping > 0 || count.crashed > 0 {
return fmt.Errorf(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))}))
}
time.Sleep(cmd.PingerThrottle)
}
}
}
func (cmd *UpdateUserProvidedService) Execute(c flags.FlagContext) error {
serviceInstance := cmd.serviceInstanceReq.GetServiceInstance()
if !serviceInstance.IsUserProvided() {
return errors.New(T("Service Instance is not user provided"))
}
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 {
return err
}
err = json.Unmarshal(jsonBytes, &credentialsMap)
if err != nil {
for _, param := range strings.Split(credentials, ",") {
param = strings.Trim(param, " ")
credentialsMap[param] = cmd.ui.Ask(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
err := cmd.userProvidedServiceInstanceRepo.Update(serviceInstance.ServiceInstanceFields)
if err != nil {
return err
}
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."))
}
return nil
}
func printSuccessMessageForServiceInstance(serviceInstanceName string, serviceRepo api.ServiceRepository, ui terminal.UI) error {
instance, apiErr := serviceRepo.FindInstanceByName(serviceInstanceName)
if apiErr != nil {
return apiErr
}
if instance.ServiceInstanceFields.LastOperation.State == "in progress" {
ui.Ok()
ui.Say("")
ui.Say(T("{{.State}} in progress. Use '{{.ServicesCommand}}' or '{{.ServiceCommand}}' to check operation status.",
map[string]interface{}{
"State": strings.Title(instance.ServiceInstanceFields.LastOperation.Type),
"ServicesCommand": terminal.CommandColor("cf services"),
"ServiceCommand": terminal.CommandColor(fmt.Sprintf("cf service %s", serviceInstanceName)),
}))
} else {
ui.Ok()
}
return nil
}
func (cmd *Authenticate) Execute(c flags.FlagContext) error {
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..."))
err := cmd.authenticator.Authenticate(map[string]string{"username": c.Args()[0], "password": c.Args()[1]})
if err != nil {
return err
}
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")}))
cmd.ui.NotifyUpdateIfNeeded(cmd.config)
return nil
}
func (cmd *BindService) Execute(c flags.FlagContext) error {
app := cmd.appReq.GetApplication()
serviceInstance := cmd.serviceInstanceReq.GetServiceInstance()
params := c.String("c")
paramsMap, err := json.ParseJSONFromFileOrString(params)
if err != nil {
return errors.New(T("Invalid configuration provided for -c flag. Please provide a valid JSON object or path to a file containing a valid JSON object."))
}
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, paramsMap)
if err != nil {
if httperr, ok := err.(errors.HTTPError); ok && httperr.ErrorCode() == errors.ServiceBindingAppServiceTaken {
cmd.ui.Ok()
cmd.ui.Warn(T("App {{.AppName}} is already bound to {{.ServiceName}}.",
map[string]interface{}{
"AppName": app.Name,
"ServiceName": serviceInstance.Name,
}))
return nil
}
return err
}
cmd.ui.Ok()
cmd.ui.Say(T("TIP: Use '{{.CFCommand}} {{.AppName}}' to ensure your env variable changes take effect",
map[string]interface{}{"CFCommand": terminal.CommandColor(cf.Name + " restage"), "AppName": app.Name}))
return nil
}
func (cmd *CreateOrg) Execute(c flags.FlagContext) error {
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 {
return err
}
org.QuotaDefinition.GUID = quota.GUID
}
err := cmd.orgRepo.Create(org)
if err != nil {
if apiErr, ok := err.(errors.HTTPError); ok && apiErr.ErrorCode() == errors.OrganizationNameTaken {
cmd.ui.Ok()
cmd.ui.Warn(T("Org {{.OrgName}} already exists",
map[string]interface{}{"OrgName": name}))
return nil
}
return err
}
cmd.ui.Ok()
if cmd.config.IsMinAPIVersion(cf.SetRolesByUsernameMinimumAPIVersion) {
setRolesByUsernameFlag, err := cmd.flagRepo.FindByName("set_roles_by_username")
if err != nil {
cmd.ui.Warn(T("Warning: accessing feature flag 'set_roles_by_username'") + " - " + err.Error() + "\n" + T("Skip assigning org role to user"))
}
if setRolesByUsernameFlag.Enabled {
org, err := cmd.orgRepo.FindByName(name)
if err != nil {
return errors.New(T("Error accessing org {{.OrgName}} for GUID': ", map[string]interface{}{"Orgname": name}) + err.Error() + "\n" + T("Skip assigning org role to user"))
}
cmd.ui.Say("")
cmd.ui.Say(T("Assigning role {{.Role}} to user {{.CurrentUser}} in org {{.TargetOrg}} ...",
map[string]interface{}{
"Role": terminal.EntityNameColor("OrgManager"),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
"TargetOrg": terminal.EntityNameColor(name),
}))
err = cmd.orgRoleSetter.SetOrgRole(org.GUID, models.RoleOrgManager, "", cmd.config.Username())
if err != nil {
return errors.New(T("Failed assigning org role to user: "******"\nTIP: Use '{{.Command}}' to target new org",
map[string]interface{}{"Command": terminal.CommandColor(cf.Name + " target -o " + name)}))
return nil
}
func (req targetedOrgAPIRequirement) Execute() error {
if !req.config.HasOrganization() {
message := fmt.Sprintf(T("No org targeted, use '{{.Command}}' to target an org.", map[string]interface{}{"Command": terminal.CommandColor(cf.Name + " target -o ORG")}))
return errors.New(message)
}
return nil
}
func (cmd *CreateBuildpack) Execute(c flags.FlagContext) error {
buildpackName := c.Args()[0]
buildpackFile, buildpackFileName, err := cmd.buildpackBitsRepo.CreateBuildpackZipFile(c.Args()[1])
if err != nil {
cmd.ui.Warn(T("Failed to create a local temporary zip file for the buildpack"))
return err
}
cmd.ui.Say(T("Creating buildpack {{.BuildpackName}}...", map[string]interface{}{"BuildpackName": terminal.EntityNameColor(buildpackName)}))
buildpack, err := cmd.createBuildpack(buildpackName, c)
if err != nil {
if httpErr, ok := err.(errors.HTTPError); ok && httpErr.ErrorCode() == errors.BuildpackNameTaken {
cmd.ui.Ok()
cmd.ui.Warn(T("Buildpack {{.BuildpackName}} already exists", map[string]interface{}{"BuildpackName": buildpackName}))
cmd.ui.Say(T("TIP: use '{{.CfUpdateBuildpackCommand}}' to update this buildpack", map[string]interface{}{"CfUpdateBuildpackCommand": terminal.CommandColor(cf.Name + " " + "update-buildpack")}))
} else {
return err
}
return nil
}
cmd.ui.Ok()
cmd.ui.Say("")
cmd.ui.Say(T("Uploading buildpack {{.BuildpackName}}...", map[string]interface{}{"BuildpackName": terminal.EntityNameColor(buildpackName)}))
err = cmd.buildpackBitsRepo.UploadBuildpack(buildpack, buildpackFile, buildpackFileName)
if err != nil {
return err
}
cmd.ui.Ok()
return nil
}
func (req TargetedSpaceRequirement) Execute() error {
if !req.config.HasOrganization() {
message := fmt.Sprintf(T("No org and space targeted, use '{{.Command}}' to target an org and space", map[string]interface{}{"Command": terminal.CommandColor(cf.Name + " target -o ORG -s SPACE")}))
return errors.New(message)
}
if !req.config.HasSpace() {
message := fmt.Sprintf(T("No space targeted, use '{{.Command}}' to target a space", map[string]interface{}{"Command": terminal.CommandColor("cf target -s")}))
return errors.New(message)
}
return nil
}
func (cmd *CreateSpace) Execute(c flags.FlagContext) error {
spaceName := c.Args()[0]
orgName := c.String("o")
spaceQuotaName := c.String("q")
orgGUID := ""
if orgName == "" {
orgName = cmd.config.OrganizationFields().Name
orgGUID = cmd.config.OrganizationFields().GUID
}
cmd.ui.Say(T("Creating space {{.SpaceName}} in org {{.OrgName}} as {{.CurrentUser}}...",
map[string]interface{}{
"SpaceName": terminal.EntityNameColor(spaceName),
"OrgName": terminal.EntityNameColor(orgName),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
}))
if orgGUID == "" {
org, err := cmd.orgRepo.FindByName(orgName)
switch err.(type) {
case nil:
case *errors.ModelNotFoundError:
return errors.New(T("Org {{.OrgName}} does not exist or is not accessible", map[string]interface{}{"OrgName": orgName}))
default:
return errors.New(T("Error finding org {{.OrgName}}\n{{.ErrorDescription}}",
map[string]interface{}{
"OrgName": orgName,
"ErrorDescription": err.Error(),
}))
}
orgGUID = org.GUID
}
var spaceQuotaGUID string
if spaceQuotaName != "" {
spaceQuota, err := cmd.spaceQuotaRepo.FindByNameAndOrgGUID(spaceQuotaName, orgGUID)
if err != nil {
return err
}
spaceQuotaGUID = spaceQuota.GUID
}
space, err := cmd.spaceRepo.Create(spaceName, orgGUID, spaceQuotaGUID)
if err != nil {
if httpErr, ok := err.(errors.HTTPError); ok && httpErr.ErrorCode() == errors.SpaceNameTaken {
cmd.ui.Ok()
cmd.ui.Warn(T("Space {{.SpaceName}} already exists", map[string]interface{}{"SpaceName": spaceName}))
return nil
}
return err
}
cmd.ui.Ok()
err = cmd.spaceRoleSetter.SetSpaceRole(space, orgGUID, orgName, models.RoleSpaceManager, cmd.config.UserGUID(), cmd.config.Username())
if err != nil {
return err
}
err = cmd.spaceRoleSetter.SetSpaceRole(space, orgGUID, orgName, models.RoleSpaceDeveloper, cmd.config.UserGUID(), cmd.config.Username())
if err != nil {
return err
}
cmd.ui.Say(T("\nTIP: Use '{{.CFTargetCommand}}' to target new space",
map[string]interface{}{
"CFTargetCommand": terminal.CommandColor(cf.Name + " target -o \"" + orgName + "\" -s \"" + space.Name + "\""),
}))
return nil
}