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 }