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 loadConfig(termUI terminal.UI, configRepo configuration.ConfigurationRepository) (config *configuration.Configuration) {
config, err := configRepo.Get()
if err != nil {
termUI.Failed(fmt.Sprintf(
"Error loading config. Please reset target (%s) and log in (%s).",
terminal.CommandColor(fmt.Sprintf("%s target", cf.Name())),
terminal.CommandColor(fmt.Sprintf("%s login", cf.Name())),
))
configRepo.Delete()
os.Exit(1)
return
}
return
}
func (cmd *SetEnv) Run(c *cli.Context) {
varName := c.Args()[1]
varValue := c.Args()[2]
app := cmd.appReq.GetApplication()
cmd.ui.Say("Setting env variable '%s' to '%s' for app %s in org %s / space %s as %s...",
terminal.EntityNameColor(varName),
terminal.EntityNameColor(varValue),
terminal.EntityNameColor(app.Name),
terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
terminal.EntityNameColor(cmd.config.SpaceFields().Name),
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("TIP: Use '%s' to ensure your env variable changes take effect", terminal.CommandColor(cf.Name()+" push"))
}
func (cmd *BindService) Run(c *cli.Context) {
app := cmd.appReq.GetApplication()
serviceInstance := cmd.serviceInstanceReq.GetServiceInstance()
cmd.ui.Say("Binding service %s to app %s in org %s / space %s as %s...",
terminal.EntityNameColor(serviceInstance.Name),
terminal.EntityNameColor(app.Name),
terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
terminal.EntityNameColor(cmd.config.SpaceFields().Name),
terminal.EntityNameColor(cmd.config.Username()),
)
err := cmd.BindApplication(app, serviceInstance)
if err != nil {
if err, ok := err.(errors.HttpError); ok && err.ErrorCode() == errors.APP_ALREADY_BOUND {
cmd.ui.Ok()
cmd.ui.Warn("App %s is already bound to %s.", app.Name, serviceInstance.Name)
return
} else {
cmd.ui.Failed(err.Error())
}
}
cmd.ui.Ok()
cmd.ui.Say("TIP: Use '%s' to ensure your env variable changes take effect", terminal.CommandColor(cf.Name()+" push"))
}
func (cmd *SetEnv) Run(c *cli.Context) {
varName := c.Args()[1]
varValue := c.Args()[2]
app := cmd.appReq.GetApplication()
cmd.ui.Say("Setting env variable '%s' to '%s' for app %s in org %s / space %s as %s...",
terminal.EntityNameColor(varName),
terminal.EntityNameColor(varValue),
terminal.EntityNameColor(app.Name),
terminal.EntityNameColor(cmd.config.OrganizationFields.Name),
terminal.EntityNameColor(cmd.config.SpaceFields.Name),
terminal.EntityNameColor(cmd.config.Username()),
)
appParams := app.ToParams()
envParams := appParams.Get("env").(generic.Map)
envParams.Set(varName, varValue)
updateParams := cf.NewEmptyAppParams()
updateParams.Set("env", envParams)
_, apiResponse := cmd.appRepo.Update(app.Guid, updateParams)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
cmd.ui.Say("TIP: Use '%s' to ensure your env variable changes take effect", terminal.CommandColor(cf.Name()+" push"))
}
func (req TargetedSpaceRequirement) Execute() (success bool) {
if !req.config.HasOrganization() {
message := fmt.Sprintf("No org and space targeted. See '%s' to target an org and space.",
terminal.CommandColor("cf target --o ORGNAME --s SPACENAME"))
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 *UnsetEnv) Run(c *cli.Context) {
varName := c.Args()[1]
app := cmd.appReq.GetApplication()
cmd.ui.Say("Removing env variable %s from app %s in org %s / space %s as %s...",
terminal.EntityNameColor(varName),
terminal.EntityNameColor(app.Name),
terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
terminal.EntityNameColor(cmd.config.SpaceFields().Name),
terminal.EntityNameColor(cmd.config.Username()),
)
envParams := app.EnvironmentVars
if _, ok := envParams[varName]; !ok {
cmd.ui.Ok()
cmd.ui.Warn("Env variable %s was not set.", varName)
return
}
delete(envParams, varName)
_, apiResponse := cmd.appRepo.Update(app.Guid, models.AppParams{EnvironmentVars: &envParams})
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
cmd.ui.Say("TIP: Use '%s' to ensure your env variable changes take effect", terminal.CommandColor(cf.Name()+" push"))
}
func (cmd Api) setApiEndpoint(endpoint string, skipSSL bool) {
if strings.HasSuffix(endpoint, "/") {
endpoint = strings.TrimSuffix(endpoint, "/")
}
cmd.config.SetSSLDisabled(skipSSL)
endpoint, err := cmd.endpointRepo.UpdateEndpoint(endpoint)
if err != nil {
cmd.config.SetApiEndpoint("")
cmd.config.SetSSLDisabled(false)
switch typedErr := err.(type) {
case *errors.InvalidSSLCert:
cfApiCommand := terminal.CommandColor(fmt.Sprintf("%s api --skip-ssl-validation", cf.Name()))
tipMessage := fmt.Sprintf("TIP: Use '%s' to continue with an insecure API endpoint", cfApiCommand)
cmd.ui.Failed("Invalid SSL Cert for %s\n%s", typedErr.URL, tipMessage)
default:
cmd.ui.Failed(typedErr.Error())
}
}
if !strings.HasPrefix(endpoint, "https://") {
cmd.ui.Say(terminal.WarningColor("Warning: Insecure http API endpoint detected: secure https API endpoints are recommended\n"))
}
}
func (l Login) doLogin(username, password string) (apiErr *net.ApiError) {
apiErr = l.authenticator.Authenticate(username, password)
if apiErr == nil {
l.ui.Ok()
l.ui.Say("Use '%s' to view or set your target organization and space", term.CommandColor("cf target"))
}
return
}
func (cmd Authenticate) doLogin(username, password string) (apiResponse net.ApiResponse) {
apiResponse = cmd.authenticator.Authenticate(username, password)
if apiResponse.IsSuccessful() {
cmd.ui.Ok()
cmd.ui.Say("Use '%s' to view or set your target org and space", terminal.CommandColor(cf.Name()+" target"))
}
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, apiErr := cmd.spaceRepo.Create(spaceName, orgGuid)
if apiErr != nil {
if apiErr.ErrorCode() == cf.SPACE_EXISTS {
cmd.ui.Ok()
cmd.ui.Warn("Space %s already exists", spaceName)
return
}
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
var err error
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 (cmd Target) Run(c *cli.Context) {
orgName := c.String("o")
spaceName := c.String("s")
shouldShowTarget := (orgName == "" && spaceName == "")
if shouldShowTarget {
cmd.ui.ShowConfiguration(cmd.config)
if !cmd.config.HasOrganization() {
cmd.ui.Say("No org targeted, use '%s' to target an org", terminal.CommandColor(cf.Name()+" target -o"))
}
if !cmd.config.HasSpace() {
cmd.ui.Say("No space targeted, use '%s' to target a space", terminal.CommandColor(cf.Name()+" target -s"))
}
return
}
if orgName != "" {
err := cmd.setOrganization(orgName)
if spaceName == "" && cmd.config.IsLoggedIn() {
cmd.showConfig()
cmd.ui.Say("No space targeted, use '%s' to target a space", terminal.CommandColor(cf.Name()+" target -s"))
return
}
if err != nil {
return
}
}
if spaceName != "" {
err := cmd.setSpace(spaceName)
if err != nil {
return
}
}
cmd.showConfig()
return
}
func (cmd CreateOrganization) Run(c *cli.Context) {
name := c.Args()[0]
cmd.ui.Say("Creating organization %s...", term.EntityNameColor(name))
apiErr := cmd.orgRepo.Create(name)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say("\nTIP: Use '%s' to target new org.", term.CommandColor("cf target -o "+name))
}
func (cmd CreateSpace) Run(c *cli.Context) {
spaceName := c.Args()[0]
cmd.ui.Say("Creating space %s...", term.EntityNameColor(spaceName))
err := cmd.spaceRepo.Create(spaceName)
if err != nil {
cmd.ui.Failed(err.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say("\nTIP: Use '%s' to target new space.", term.CommandColor("cf target -s "+spaceName))
}
func (cmd Target) setOrganization(orgName string) (err error) {
if !cmd.config.IsLoggedIn() {
cmd.ui.Failed("You must be logged in to target an org. Use '%s'.", terminal.CommandColor(cf.Name()+" login"))
return
}
org, apiErr := cmd.orgRepo.FindByName(orgName)
if apiErr != nil {
cmd.ui.Failed("Could not target org.\n%s", apiErr.Error())
return
}
cmd.config.SetOrganizationFields(org.OrganizationFields)
return
}
func (cmd Api) Run(c *cli.Context) {
if len(c.Args()) == 0 {
if cmd.config.ApiEndpoint() == "" {
cmd.ui.Say(fmt.Sprintf("No api endpoint set. Use '%s' to set an endpoint", terminal.CommandColor(cf.Name()+" api")))
} else {
cmd.ui.Say(
"API endpoint: %s (API version: %s)",
terminal.EntityNameColor(cmd.config.ApiEndpoint()),
terminal.EntityNameColor(cmd.config.ApiVersion()),
)
}
return
}
cmd.SetApiEndpoint(c.Args()[0])
}
func (cmd Start) waitForInstancesToStage(app models.Application) {
stagingStartTime := time.Now()
_, apiResponse := cmd.appInstancesRepo.GetInstances(app.Guid)
for apiResponse.IsNotSuccessful() && time.Since(stagingStartTime) < cmd.StagingTimeout {
if apiResponse.ErrorCode != cf.APP_NOT_STAGED {
cmd.ui.Say("")
cmd.ui.Failed(fmt.Sprintf("%s\n\nTIP: use '%s' for more information",
apiResponse.Message,
terminal.CommandColor(fmt.Sprintf("%s logs %s --recent", cf.Name(), app.Name))))
return
}
cmd.ui.Wait(cmd.PingerThrottle)
_, apiResponse = cmd.appInstancesRepo.GetInstances(app.Guid)
}
return
}
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 err, ok := err.(errors.HttpError); ok && err.ErrorCode() != errors.APP_NOT_STAGED {
cmd.ui.Say("")
cmd.ui.Failed(fmt.Sprintf("%s\n\nTIP: use '%s' for more information",
err.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 Authenticate) Run(c *cli.Context) {
cmd.ui.Say("API endpoint: %s", terminal.EntityNameColor(cmd.config.ApiEndpoint()))
cmd.ui.Say("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("Use '%s' to view or set your target org and space", terminal.CommandColor(cf.Name()+" target"))
return
}
func (cmd Authenticate) Run(c *cli.Context) {
cmd.ui.Say("API endpoint: %s", terminal.EntityNameColor(cmd.config.ApiEndpoint()))
username := c.Args()[0]
password := c.Args()[1]
cmd.ui.Say("Authenticating...")
apiResponse := cmd.authenticator.Authenticate(username, password)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
cmd.ui.Say("Use '%s' to view or set your target org and space", terminal.CommandColor(cf.Name()+" target"))
return
}
func (cmd Target) setOrganization(orgName string) (err error) {
if !cmd.config.IsLoggedIn() {
cmd.ui.Failed("You must be logged in to target an org. Use '%s'.", terminal.CommandColor(cf.Name()+" login"))
return
}
org, apiResponse := cmd.orgRepo.FindByName(orgName)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed("Could not target org.\n%s", apiResponse.Message)
return
}
err = cmd.configRepo.SetOrganization(org.OrganizationFields)
if err != nil {
cmd.ui.Failed("Error setting org in config file.\n%s", err)
return
}
return
}
func (cmd *CreateDomain) Run(c *cli.Context) {
domainName := c.Args()[1]
owningOrg := cmd.orgReq.GetOrganization()
cmd.ui.Say("Creating domain %s for org %s as %s...",
terminal.EntityNameColor(domainName),
terminal.EntityNameColor(owningOrg.Name),
terminal.EntityNameColor(cmd.config.Username()),
)
_, apiResponse := cmd.domainRepo.Create(domainName, owningOrg.Guid)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
cmd.ui.Say("TIP: Use '%s' to assign it to a space", terminal.CommandColor(cf.Name()+" map-domain"))
}
func (cmd CreateOrg) Run(c *cli.Context) {
name := c.Args()[0]
cmd.ui.Say("Creating org %s as %s...",
terminal.EntityNameColor(name),
terminal.EntityNameColor(cmd.config.Username()),
)
err := cmd.orgRepo.Create(name)
if err != nil {
if apiErr, ok := err.(errors.HttpError); ok && apiErr.ErrorCode() == errors.ORG_EXISTS {
cmd.ui.Ok()
cmd.ui.Warn("Org %s already exists", name)
return
} else {
cmd.ui.Failed(err.Error())
}
}
cmd.ui.Ok()
cmd.ui.Say("\nTIP: Use '%s' to target new org", terminal.CommandColor(cf.Name()+" target -o "+name))
}
func (cmd Target) setSpace(spaceName string) (err error) {
if !cmd.config.IsLoggedIn() {
cmd.ui.Failed("You must be logged in to set a space. Use '%s'.", terminal.CommandColor(fmt.Sprintf("%s login", cf.Name())))
return
}
if !cmd.config.HasOrganization() {
cmd.ui.Failed("An org must be targeted before targeting a space")
return
}
space, apiErr := cmd.spaceRepo.FindByName(spaceName)
if apiErr != nil {
cmd.ui.Failed("Unable to access space %s.\n%s", spaceName, apiErr.Error())
return
}
cmd.config.SetSpaceFields(space.SpaceFields)
return
}
func (cmd CreateSpace) Run(c *cli.Context) {
spaceName := c.Args()[0]
cmd.ui.Say("Creating space %s in org %s as %s...",
terminal.EntityNameColor(spaceName),
terminal.EntityNameColor(cmd.config.Organization.Name),
terminal.EntityNameColor(cmd.config.Username()),
)
apiResponse := cmd.spaceRepo.Create(spaceName)
if apiResponse.IsNotSuccessful() {
if apiResponse.ErrorCode == cf.SPACE_EXISTS {
cmd.ui.Ok()
cmd.ui.Warn("Space %s already exists", spaceName)
return
}
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
cmd.ui.Say("\nTIP: Use '%s' to target new space", terminal.CommandColor(cf.Name()+" target -s "+spaceName))
}
func (cmd CreateOrg) Run(c *cli.Context) {
name := c.Args()[0]
cmd.ui.Say("Creating org %s as %s...",
terminal.EntityNameColor(name),
terminal.EntityNameColor(cmd.config.Username()),
)
apiResponse := cmd.orgRepo.Create(name)
if apiResponse.IsNotSuccessful() {
if apiResponse.ErrorCode == cf.ORG_EXISTS {
cmd.ui.Ok()
cmd.ui.Warn("Org %s already exists", name)
return
}
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
cmd.ui.Say("\nTIP: Use '%s' to target new org", terminal.CommandColor(cf.Name()+" target -o "+name))
}
func (cmd Api) Run(c *cli.Context) {
if len(c.Args()) == 0 {
if cmd.config.ApiEndpoint() == "" {
cmd.ui.Say(fmt.Sprintf("No api endpoint set. Use '%s' to set an endpoint", terminal.CommandColor(cf.Name()+" api")))
} else {
cmd.ui.Say(
"API endpoint: %s (API version: %s)",
terminal.EntityNameColor(cmd.config.ApiEndpoint()),
terminal.EntityNameColor(cmd.config.ApiVersion()),
)
}
return
}
endpoint := c.Args()[0]
cmd.ui.Say("Setting api endpoint to %s...", terminal.EntityNameColor(endpoint))
cmd.setApiEndpoint(endpoint, c.Bool("skip-ssl-validation"))
cmd.ui.Ok()
cmd.ui.Say("")
cmd.ui.ShowConfiguration(cmd.config)
}
func (cmd CreateBuildpack) Run(c *cli.Context) {
if len(c.Args()) != 3 {
cmd.ui.FailWithUsage(c, "create-buildpack")
return
}
buildpackName := c.Args()[0]
cmd.ui.Say("Creating buildpack %s...", terminal.EntityNameColor(buildpackName))
buildpack, err := cmd.createBuildpack(buildpackName, c)
if err != nil {
if err, ok := err.(errors.HttpError); ok && err.ErrorCode() == errors.BUILDPACK_EXISTS {
cmd.ui.Ok()
cmd.ui.Warn("Buildpack %s already exists", buildpackName)
cmd.ui.Say("TIP: use '%s' to update this buildpack", terminal.CommandColor(cf.Name()+" update-buildpack"))
} else {
cmd.ui.Failed(err.Error())
}
return
}
cmd.ui.Ok()
cmd.ui.Say("")
cmd.ui.Say("Uploading buildpack %s...", terminal.EntityNameColor(buildpackName))
dir := c.Args()[1]
err = cmd.buildpackBitsRepo.UploadBuildpack(buildpack, dir)
if err != nil {
cmd.ui.Failed(err.Error())
return
}
cmd.ui.Ok()
}
func (cmd CreateBuildpack) Run(c *cli.Context) {
if len(c.Args()) != 3 {
cmd.ui.FailWithUsage(c, "create-buildpack")
return
}
buildpackName := c.Args()[0]
cmd.ui.Say("Creating buildpack %s...", terminal.EntityNameColor(buildpackName))
buildpack, apiResponse := cmd.createBuildpack(buildpackName, c)
if apiResponse.IsNotSuccessful() {
if apiResponse.ErrorCode == cf.BUILDPACK_EXISTS {
cmd.ui.Ok()
cmd.ui.Warn("Buildpack %s already exists", buildpackName)
cmd.ui.Say("TIP: use '%s' to update this buildpack", terminal.CommandColor(cf.Name()+" update-buildpack"))
} else {
cmd.ui.Failed(apiResponse.Message)
}
return
}
cmd.ui.Ok()
cmd.ui.Say("")
cmd.ui.Say("Uploading buildpack %s...", terminal.EntityNameColor(buildpackName))
dir := c.Args()[1]
apiResponse = cmd.buildpackBitsRepo.UploadBuildpack(buildpack, dir)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
}