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()),
)
apiResponse := cmd.BindApplication(app, serviceInstance)
if apiResponse.IsNotSuccessful() && apiResponse.ErrorCode != AppAlreadyBoundErrorCode {
cmd.ui.Failed(apiResponse.Message)
}
cmd.ui.Ok()
if apiResponse.ErrorCode == AppAlreadyBoundErrorCode {
cmd.ui.Warn("App %s is already bound to %s.", app.Name, serviceInstance.Name)
return
}
cmd.ui.Say("TIP: Use '%s push' to ensure your env variable changes take effect", cf.Name())
}
func (cmd *Events) Run(c *cli.Context) {
app := cmd.appReq.GetApplication()
cmd.ui.Say("Getting events for app %s in org %s / space %s as %s...\n",
terminal.EntityNameColor(app.Name),
terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
terminal.EntityNameColor(cmd.config.SpaceFields().Name),
terminal.EntityNameColor(cmd.config.Username()),
)
table := cmd.ui.Table([]string{"time", "event", "description"})
events, apiErr := cmd.eventsRepo.RecentEvents(app.Guid, 50)
if apiErr != nil {
cmd.ui.Failed("Failed fetching events.\n%s", apiErr.Error())
return
}
for _, event := range events {
table.Print([][]string{{
event.Timestamp.Local().Format(TIMESTAMP_FORMAT),
event.Name,
event.Description,
}})
}
if len(events) == 0 {
cmd.ui.Say("No events for app %s", terminal.EntityNameColor(app.Name))
return
}
}
func (cmd *Files) Run(c *cli.Context) {
app := cmd.appReq.GetApplication()
cmd.ui.Say("Getting files for 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()),
)
path := "/"
if len(c.Args()) > 1 {
path = c.Args()[1]
}
list, apiResponse := cmd.appFilesRepo.ListFiles(app.Guid, path)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
cmd.ui.Say("")
cmd.ui.Say("%s", list)
}
func (cmd UpdateServiceBroker) Run(c *cli.Context) {
serviceBroker, apiResponse := cmd.repo.FindByName(c.Args()[0])
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Say("Updating service broker %s as %s...",
terminal.EntityNameColor(serviceBroker.Name),
terminal.EntityNameColor(cmd.config.Username()),
)
serviceBroker.Username = c.Args()[1]
serviceBroker.Password = c.Args()[2]
serviceBroker.Url = c.Args()[3]
apiResponse = cmd.repo.Update(serviceBroker)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
}
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 *UnsetSpaceRole) Run(c *cli.Context) {
spaceName := c.Args()[2]
role := models.UserInputToSpaceRole[c.Args()[3]]
user := cmd.userReq.GetUser()
org := cmd.orgReq.GetOrganization()
space, apiResponse := cmd.spaceRepo.FindByNameInOrg(spaceName, org.Guid)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Say("Removing role %s from user %s in org %s / space %s as %s...",
terminal.EntityNameColor(role),
terminal.EntityNameColor(user.Username),
terminal.EntityNameColor(org.Name),
terminal.EntityNameColor(space.Name),
terminal.EntityNameColor(cmd.config.Username()),
)
apiResponse = cmd.userRepo.UnsetSpaceRole(user.Guid, space.Guid, role)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
}
func (cmd *BindService) Run(c *cli.Context) {
app := cmd.appReq.GetApplication()
instance := cmd.serviceInstanceReq.GetServiceInstance()
cmd.ui.Say("Binding service %s to app %s in org %s / space %s as %s...",
terminal.EntityNameColor(instance.Name),
terminal.EntityNameColor(app.Name),
terminal.EntityNameColor(cmd.config.Organization.Name),
terminal.EntityNameColor(cmd.config.Space.Name),
terminal.EntityNameColor(cmd.config.Username()),
)
apiResponse := cmd.serviceBindingRepo.Create(instance, app)
if apiResponse.IsNotSuccessful() && apiResponse.ErrorCode != "90003" {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
if apiResponse.ErrorCode == "90003" {
cmd.ui.Warn("App %s is already bound to %s.", app.Name, instance.Name)
return
}
cmd.ui.Say("TIP: Use 'cf push' to ensure your env variable changes take effect")
}
func (cmd *MapRoute) Run(c *cli.Context) {
hostName := c.String("n")
domain := cmd.domainReq.GetDomain()
app := cmd.appReq.GetApplication()
route, apiResponse := cmd.routeCreator.CreateRoute(hostName, domain.DomainFields, cmd.config.SpaceFields)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed("Error resolving route:\n%s", apiResponse.Message)
}
cmd.ui.Say("Adding route %s to app %s in org %s / space %s as %s...",
terminal.EntityNameColor(route.URL()),
terminal.EntityNameColor(app.Name),
terminal.EntityNameColor(cmd.config.OrganizationFields.Name),
terminal.EntityNameColor(cmd.config.SpaceFields.Name),
terminal.EntityNameColor(cmd.config.Username()),
)
apiResponse = cmd.routeRepo.Bind(route.Guid, app.Guid)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
}
func (cmd ListStacks) Run(c *cli.Context) {
cmd.ui.Say("Getting stacks in org %s / space %s as %s...",
terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
terminal.EntityNameColor(cmd.config.SpaceFields().Name),
terminal.EntityNameColor(cmd.config.Username()),
)
stacks, apiResponse := cmd.stacksRepo.FindAll()
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
cmd.ui.Say("")
table := [][]string{
[]string{"name", "description"},
}
for _, stack := range stacks {
table = append(table, []string{
stack.Name,
stack.Description,
})
}
cmd.ui.DisplayTable(table)
}
func (cmd MarketplaceServices) Run(c *cli.Context) {
var (
serviceOfferings models.ServiceOfferings
apiErr errors.Error
)
if cmd.config.HasSpace() {
cmd.ui.Say("Getting services from marketplace in org %s / space %s as %s...",
terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
terminal.EntityNameColor(cmd.config.SpaceFields().Name),
terminal.EntityNameColor(cmd.config.Username()),
)
serviceOfferings, apiErr = cmd.serviceRepo.GetServiceOfferingsForSpace(cmd.config.SpaceFields().Guid)
} else if !cmd.config.IsLoggedIn() {
cmd.ui.Say("Getting all services from marketplace...")
serviceOfferings, apiErr = cmd.serviceRepo.GetAllServiceOfferings()
} else {
cmd.ui.Failed("Cannot list marketplace services without a targetted space")
}
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say("")
if len(serviceOfferings) == 0 {
cmd.ui.Say("No service offerings found")
return
}
table := [][]string{
[]string{"service", "plans", "description"},
}
sort.Sort(serviceOfferings)
for _, offering := range serviceOfferings {
planNames := ""
for _, plan := range offering.Plans {
if plan.Name == "" {
continue
}
planNames = planNames + ", " + plan.Name
}
planNames = strings.TrimPrefix(planNames, ", ")
table = append(table, []string{
offering.Label,
planNames,
offering.Description,
})
}
cmd.ui.DisplayTable(table)
return
}
func (cmd *Stop) ApplicationStop(app models.Application) (updatedApp models.Application, err error) {
if app.State == "stopped" {
updatedApp = app
cmd.ui.Say(terminal.WarningColor("App " + app.Name + " is already stopped"))
return
}
cmd.ui.Say("Stopping 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 := "STOPPED"
updatedApp, apiErr := cmd.appRepo.Update(app.Guid, models.AppParams{State: &state})
if apiErr != nil {
err = errors.New(apiErr.Error())
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
return
}
func (cmd *UnmapRoute) Run(c *cli.Context) {
hostName := c.String("n")
domain := cmd.domainReq.GetDomain()
app := cmd.appReq.GetApplication()
route, apiErr := cmd.routeRepo.FindByHostAndDomain(hostName, domain.Name)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
}
cmd.ui.Say("Removing route %s from app %s in org %s / space %s as %s...",
terminal.EntityNameColor(route.URL()),
terminal.EntityNameColor(app.Name),
terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
terminal.EntityNameColor(cmd.config.SpaceFields().Name),
terminal.EntityNameColor(cmd.config.Username()),
)
apiErr = cmd.routeRepo.Unbind(route.Guid, app.Guid)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
}
func (cmd *ListDomains) Run(c *cli.Context) {
org := cmd.orgReq.GetOrganizationFields()
cmd.ui.Say("Getting domains in org %s as %s...",
terminal.EntityNameColor(org.Name),
terminal.EntityNameColor(cmd.config.Username()),
)
noDomains := true
table := cmd.ui.Table([]string{"name ", "status"})
apiResponse := cmd.domainRepo.ListSharedDomains(domainsCallback(table, &noDomains))
if apiResponse.IsNotSuccessful() && !apiResponse.IsNotFound() {
cmd.ui.Failed("Failed fetching shared domains.\n%s", apiResponse.Message)
return
}
apiResponse = cmd.domainRepo.ListDomainsForOrg(org.Guid, domainsCallback(table, &noDomains))
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed("Failed fetching private domains.\n%s", apiResponse.Message)
return
}
if noDomains {
cmd.ui.Say("No domains found")
}
}
func (cmd *UpdateBuildpack) Run(c *cli.Context) {
buildpack := cmd.buildpackReq.GetBuildpack()
cmd.ui.Say("Updating buildpack %s...", terminal.EntityNameColor(buildpack.Name))
updateBuildpack := false
if c.String("i") != "" {
val := c.Int("i")
buildpack.Position = &val
updateBuildpack = true
}
if updateBuildpack {
buildpack, apiResponse := cmd.buildpackRepo.Update(buildpack)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed("Error updating buildpack %s\n%s", terminal.EntityNameColor(buildpack.Name), apiResponse.Message)
return
}
}
dir := c.String("p")
if dir != "" {
apiResponse := cmd.buildpackBitsRepo.UploadBuildpack(buildpack, dir)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed("Error uploading buildpack %s\n%s", terminal.EntityNameColor(buildpack.Name), apiResponse.Message)
return
}
}
cmd.ui.Ok()
}
func (cmd *DeleteSpace) Run(c *cli.Context) {
space := cmd.spaceReq.GetSpace()
force := c.Bool("f")
if !force {
response := strings.ToLower(cmd.ui.Ask(
"Really delete space %s and everything associated with it?%s",
term.EntityNameColor(space.Name),
term.PromptColor(">"),
))
if response != "y" && response != "yes" {
return
}
}
cmd.ui.Say("Deleting space %s...", term.EntityNameColor(space.Name))
err := cmd.spaceRepo.Delete(space)
if err != nil {
cmd.ui.Failed(err.Error())
return
}
cmd.ui.Ok()
return
}
func (cmd CreateUserProvidedService) Run(c *cli.Context) {
name := c.Args()[0]
drainUrl := c.String("l")
params := c.String("p")
params = strings.Trim(params, `"`)
paramsMap := make(map[string]string)
err := json.Unmarshal([]byte(params), ¶msMap)
if err != nil && params != "" {
paramsMap = cmd.mapValuesFromPrompt(params, paramsMap)
}
cmd.ui.Say("Creating user provided service %s in org %s / space %s as %s...",
terminal.EntityNameColor(name),
terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
terminal.EntityNameColor(cmd.config.SpaceFields().Name),
terminal.EntityNameColor(cmd.config.Username()),
)
apiErr := cmd.userProvidedServiceInstanceRepo.Create(name, drainUrl, paramsMap)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
}
func (cmd *Push) updateApp(app models.Application, appParams models.AppParams) (updatedApp models.Application) {
cmd.ui.Say("Updating 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()),
)
if appParams.EnvironmentVars != nil {
for key, val := range app.EnvironmentVars {
if _, ok := (*appParams.EnvironmentVars)[key]; !ok {
(*appParams.EnvironmentVars)[key] = val
}
}
}
var apiErr error
updatedApp, apiErr = cmd.appRepo.Update(app.Guid, appParams)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
cmd.ui.Say("")
return
}
func (cmd *Scale) Run(c *cli.Context) {
currentApp := cmd.appReq.GetApplication()
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()),
)
params := cf.NewEmptyAppParams()
if c.String("m") != "" {
memory, err := formatters.ToMegabytes(c.String("m"))
if err != nil {
cmd.ui.Say("Invalid value for memory")
cmd.ui.FailWithUsage(c, "scale")
return
}
params.Set("memory", memory)
}
if c.Int("i") != -1 {
params.Set("instances", c.Int("i"))
}
_, apiResponse := cmd.appRepo.Update(currentApp.Guid, params)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
cmd.ui.Say("")
}
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 (cmd *Events) Run(c *cli.Context) {
app := cmd.appReq.GetApplication()
cmd.ui.Say("Getting events for app %s in org %s / space %s as %s...\n",
terminal.EntityNameColor(app.Name),
terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
terminal.EntityNameColor(cmd.config.SpaceFields().Name),
terminal.EntityNameColor(cmd.config.Username()),
)
table := cmd.ui.Table([]string{"time", "event", "description"})
noEvents := true
apiResponse := cmd.eventsRepo.ListEvents(app.Guid, func(event models.EventFields) bool {
table.Print([][]string{{
event.Timestamp.Local().Format(TIMESTAMP_FORMAT),
event.Name,
event.Description,
}})
noEvents = false
return true
})
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed("Failed fetching events.\n%s", apiResponse.Message)
return
}
if noEvents {
cmd.ui.Say("No events for app %s", terminal.EntityNameColor(app.Name))
return
}
}
func (cmd DeleteUser) Run(c *cli.Context) {
username := c.Args()[0]
force := c.Bool("f")
if !force && !cmd.ui.Confirm("Really delete user %s?%s",
terminal.EntityNameColor(username),
terminal.PromptColor(">"),
) {
return
}
cmd.ui.Say("Deleting user %s as %s...",
terminal.EntityNameColor(username),
terminal.EntityNameColor(cmd.config.Username()),
)
user, apiResponse := cmd.userRepo.FindByUsername(username)
if apiResponse.IsError() {
cmd.ui.Failed(apiResponse.Message)
return
}
if apiResponse.IsNotFound() {
cmd.ui.Ok()
cmd.ui.Warn("User %s does not exist.", username)
return
}
apiResponse = cmd.userRepo.Delete(user)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
}
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 *UnbindService) Run(c *cli.Context) {
app := cmd.appReq.GetApplication()
instance := cmd.serviceInstanceReq.GetServiceInstance()
cmd.ui.Say("Unbinding app %s from service %s in org %s / space %s as %s...",
terminal.EntityNameColor(app.Name),
terminal.EntityNameColor(instance.Name),
terminal.EntityNameColor(cmd.config.Organization.Name),
terminal.EntityNameColor(cmd.config.Space.Name),
terminal.EntityNameColor(cmd.config.Username()),
)
found, apiResponse := cmd.serviceBindingRepo.Delete(instance, app)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
if !found {
cmd.ui.Warn("Binding between %s and %s did not exist", instance.Name, app.Name)
}
}
func (cmd ListSpaces) Run(c *cli.Context) {
cmd.ui.Say("Getting spaces in org %s as %s...\n",
terminal.EntityNameColor(cmd.config.OrganizationFields.Name),
terminal.EntityNameColor(cmd.config.Username()))
stopChan := make(chan bool)
defer close(stopChan)
spacesChan, statusChan := cmd.spaceRepo.ListSpaces(stopChan)
table := cmd.ui.Table([]string{"name"})
noSpaces := true
for spaces := range spacesChan {
rows := [][]string{}
for _, space := range spaces {
rows = append(rows, []string{space.Name})
}
table.Print(rows)
noSpaces = false
}
apiStatus := <-statusChan
if apiStatus.IsNotSuccessful() {
cmd.ui.Failed("Failed fetching spaces.\n%s", apiStatus.Message)
return
}
if noSpaces {
cmd.ui.Say("No spaces found")
}
}
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 DeleteServiceAuthToken) Run(c *cli.Context) {
tokenLabel := c.Args()[0]
tokenProvider := c.Args()[1]
if c.Bool("f") == false {
response := cmd.ui.Confirm(
"Are you sure you want to delete %s?%s",
terminal.EntityNameColor(fmt.Sprintf("%s %s", tokenLabel, tokenProvider)),
terminal.PromptColor(">"),
)
if response == false {
return
}
}
cmd.ui.Say("Deleting service auth token as %s", terminal.EntityNameColor(cmd.config.Username()))
token, apiResponse := cmd.authTokenRepo.FindByLabelAndProvider(tokenLabel, tokenProvider)
if apiResponse.IsError() {
cmd.ui.Failed(apiResponse.Message)
return
}
if apiResponse.IsNotFound() {
cmd.ui.Ok()
cmd.ui.Warn("Service Auth Token %s %s does not exist.", tokenLabel, tokenProvider)
return
}
apiResponse = cmd.authTokenRepo.Delete(token)
if apiResponse.IsNotSuccessful() {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
}
func (cmd *UnbindService) Run(c *cli.Context) {
app := cmd.appReq.GetApplication()
instance := cmd.serviceInstanceReq.GetServiceInstance()
cmd.ui.Say("Unbinding app %s from service %s in org %s / space %s as %s...",
terminal.EntityNameColor(app.Name),
terminal.EntityNameColor(instance.Name),
terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
terminal.EntityNameColor(cmd.config.SpaceFields().Name),
terminal.EntityNameColor(cmd.config.Username()),
)
found, apiErr := cmd.serviceBindingRepo.Delete(instance, app.Guid)
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
cmd.ui.Ok()
if !found {
cmd.ui.Warn("Binding between %s and %s did not exist", instance.Name, app.Name)
}
}
func (cmd *Push) bindAppToServices(services []string, app models.Application) {
for _, serviceName := range services {
serviceInstance, err := cmd.serviceRepo.FindInstanceByName(serviceName)
if err != nil {
cmd.ui.Failed("Could not find service %s to bind to %s", serviceName, app.Name)
return
}
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.serviceBinder.BindApplication(app, serviceInstance)
switch httpErr := err.(type) {
case errors.HttpError:
if httpErr.ErrorCode() == errors.APP_ALREADY_BOUND {
err = nil
}
}
if err != nil {
cmd.ui.Failed("Could not bind to service %s\nError: %s", serviceName, err)
}
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)
} 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()
}
func (cmd *ShowApp) ShowApp(app cf.Application) {
cmd.ui.Say("Showing health and status for 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()),
)
appSummary, apiResponse := cmd.appSummaryRepo.GetSummary(app.Guid)
appIsStopped := apiResponse.ErrorCode == cf.APP_STOPPED ||
apiResponse.ErrorCode == cf.APP_NOT_STAGED ||
appSummary.State == "stopped"
if apiResponse.IsNotSuccessful() && !appIsStopped {
cmd.ui.Failed(apiResponse.Message)
return
}
var instances []cf.AppInstanceFields
instances, apiResponse = cmd.appInstancesRepo.GetInstances(app.Guid)
if apiResponse.IsNotSuccessful() && !appIsStopped {
cmd.ui.Failed(apiResponse.Message)
return
}
cmd.ui.Ok()
cmd.ui.Say("\n%s %s", terminal.HeaderColor("requested state:"), coloredAppState(appSummary.ApplicationFields))
cmd.ui.Say("%s %s", terminal.HeaderColor("instances:"), coloredAppInstances(appSummary.ApplicationFields))
cmd.ui.Say("%s %s x %d instances", terminal.HeaderColor("usage:"), formatters.ByteSize(appSummary.Memory*formatters.MEGABYTE), appSummary.InstanceCount)
var urls []string
for _, route := range appSummary.RouteSummaries {
urls = append(urls, route.URL())
}
cmd.ui.Say("%s %s\n", terminal.HeaderColor("urls:"), strings.Join(urls, ", "))
if appIsStopped {
cmd.ui.Say("There are no running instances of this app.")
return
}
table := [][]string{
[]string{"", "state", "since", "cpu", "memory", "disk"},
}
for index, instance := range instances {
table = append(table, []string{
fmt.Sprintf("#%d", index),
coloredInstanceState(instance),
instance.Since.Format("2006-01-02 03:04:05 PM"),
fmt.Sprintf("%.1f%%", instance.CpuUsage*100),
fmt.Sprintf("%s of %s", formatters.ByteSize(instance.MemUsage), formatters.ByteSize(instance.MemQuota)),
fmt.Sprintf("%s of %s", formatters.ByteSize(instance.DiskUsage), formatters.ByteSize(instance.DiskQuota)),
})
}
cmd.ui.DisplayTable(table)
}