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 *DeleteServiceBroker) Execute(c flags.FlagContext) error { brokerName := c.Args()[0] if !c.Bool("f") && !cmd.ui.ConfirmDelete(T("service-broker"), brokerName) { return nil } cmd.ui.Say(T("Deleting service broker {{.Name}} as {{.Username}}...", map[string]interface{}{ "Name": terminal.EntityNameColor(brokerName), "Username": terminal.EntityNameColor(cmd.config.Username()), })) broker, err := cmd.repo.FindByName(brokerName) switch err.(type) { case nil: case *errors.ModelNotFoundError: cmd.ui.Ok() cmd.ui.Warn(T("Service Broker {{.Name}} does not exist.", map[string]interface{}{"Name": brokerName})) return nil default: return err } err = cmd.repo.Delete(broker.GUID) if err != nil { return err } cmd.ui.Ok() return nil }
func (cmd *UnsetSpaceRole) Execute(c flags.FlagContext) { spaceName := c.Args()[2] role := models.UserInputToSpaceRole[c.Args()[3]] user := cmd.userReq.GetUser() org := cmd.orgReq.GetOrganization() space, err := cmd.spaceRepo.FindByNameInOrg(spaceName, org.Guid) if err != nil { cmd.ui.Failed(err.Error()) } cmd.ui.Say(T("Removing role {{.Role}} from user {{.TargetUser}} in org {{.TargetOrg}} / space {{.TargetSpace}} as {{.CurrentUser}}...", map[string]interface{}{ "Role": terminal.EntityNameColor(role), "TargetUser": terminal.EntityNameColor(user.Username), "TargetOrg": terminal.EntityNameColor(org.Name), "TargetSpace": terminal.EntityNameColor(space.Name), "CurrentUser": terminal.EntityNameColor(cmd.config.Username()), })) if len(user.Guid) > 0 { err = cmd.userRepo.UnsetSpaceRoleByGuid(user.Guid, space.Guid, role) } else { err = cmd.userRepo.UnsetSpaceRoleByUsername(user.Username, space.Guid, role) } if err != nil { cmd.ui.Failed(err.Error()) } cmd.ui.Ok() }
func (cmd *Push) updateApp(app models.Application, appParams models.AppParams) (updatedApp models.Application) { cmd.ui.Say(T("Updating app {{.AppName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.Username}}...", map[string]interface{}{ "AppName": terminal.EntityNameColor(app.Name), "OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name), "SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name), "Username": 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()) } cmd.ui.Ok() cmd.ui.Say("") return }
func (cmd *UnsetSpaceRole) Execute(c flags.FlagContext) error { spaceName := c.Args()[2] roleStr := c.Args()[3] role, err := models.RoleFromString(roleStr) if err != nil { return err } user := cmd.userReq.GetUser() org := cmd.orgReq.GetOrganization() space, err := cmd.spaceRepo.FindByNameInOrg(spaceName, org.GUID) if err != nil { return err } cmd.ui.Say(T("Removing role {{.Role}} from user {{.TargetUser}} in org {{.TargetOrg}} / space {{.TargetSpace}} as {{.CurrentUser}}...", map[string]interface{}{ "Role": terminal.EntityNameColor(roleStr), "TargetUser": terminal.EntityNameColor(user.Username), "TargetOrg": terminal.EntityNameColor(org.Name), "TargetSpace": terminal.EntityNameColor(space.Name), "CurrentUser": terminal.EntityNameColor(cmd.config.Username()), })) if len(user.GUID) > 0 { err = cmd.userRepo.UnsetSpaceRoleByGUID(user.GUID, space.GUID, role) } else { err = cmd.userRepo.UnsetSpaceRoleByUsername(user.Username, space.GUID, role) } if err != nil { return err } cmd.ui.Ok() return nil }
func (cmd UpdateServiceBroker) Run(c *cli.Context) { serviceBroker, apiErr := cmd.repo.FindByName(c.Args()[0]) if apiErr != nil { cmd.ui.Failed(apiErr.Error()) 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] apiErr = cmd.repo.Update(serviceBroker) if apiErr != nil { cmd.ui.Failed(apiErr.Error()) return } cmd.ui.Ok() }
func (cmd Api) Execute(c flags.FlagContext) { 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)})) cmd.setAPIEndpoint(endpoint, c.Bool("skip-ssl-validation"), cmd.MetaData().Name) cmd.ui.Ok() cmd.ui.Say("") cmd.ui.ShowConfiguration(cmd.config) } }
func (cmd *RestartAppInstance) Execute(fc flags.FlagContext) error { app := cmd.appReq.GetApplication() instance, err := strconv.Atoi(fc.Args()[1]) if err != nil { return errors.New(T("Instance must be a non-negative integer")) } cmd.ui.Say(T("Restarting instance {{.Instance}} of application {{.AppName}} as {{.Username}}", map[string]interface{}{ "Instance": instance, "AppName": terminal.EntityNameColor(app.Name), "Username": terminal.EntityNameColor(cmd.config.Username()), })) err = cmd.appInstancesRepo.DeleteInstance(app.GUID, instance) if err != nil { return err } cmd.ui.Ok() cmd.ui.Say("") return nil }
func (cmd *DeleteOrphanedRoutes) Execute(c flags.FlagContext) { force := c.Bool("f") if !force { response := cmd.ui.Confirm(T("Really delete orphaned routes?{{.Prompt}}", map[string]interface{}{"Prompt": terminal.PromptColor(">")})) if !response { return } } cmd.ui.Say(T("Getting routes as {{.Username}} ...\n", map[string]interface{}{"Username": terminal.EntityNameColor(cmd.config.Username())})) apiErr := cmd.routeRepo.ListRoutes(func(route models.Route) bool { if len(route.Apps) == 0 { cmd.ui.Say(T("Deleting route {{.Route}}...", map[string]interface{}{"Route": terminal.EntityNameColor(route.Host + "." + route.Domain.Name)})) apiErr := cmd.routeRepo.Delete(route.Guid) if apiErr != nil { cmd.ui.Failed(apiErr.Error()) return false } } return true }) if apiErr != nil { cmd.ui.Failed(T("Failed fetching routes.\n{{.Err}}", map[string]interface{}{"Err": apiErr.Error()})) return } cmd.ui.Ok() }
func (cmd *UnbindService) Run(c *cli.Context) { app := cmd.appReq.GetApplication() instance := cmd.serviceInstanceReq.GetServiceInstance() cmd.ui.Say(T("Unbinding app {{.AppName}} from service {{.ServiceName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.CurrentUser}}...", map[string]interface{}{ "AppName": terminal.EntityNameColor(app.Name), "ServiceName": terminal.EntityNameColor(instance.Name), "OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name), "SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name), "CurrentUser": 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(T("Binding between {{.InstanceName}} and {{.AppName}} did not exist", map[string]interface{}{"InstanceName": instance.Name, "AppName": app.Name})) } }
func (cmd *SpaceUsers) printer(org models.Organization, space models.Space, username string) userprint.UserPrinter { var roles = []models.Role{models.RoleSpaceManager, models.RoleSpaceDeveloper, models.RoleSpaceAuditor} if cmd.pluginCall { return userprint.NewSpaceUsersPluginPrinter( cmd.pluginModel, cmd.userLister(), roles, ) } cmd.ui.Say(T("Getting users in org {{.TargetOrg}} / space {{.TargetSpace}} as {{.CurrentUser}}", map[string]interface{}{ "TargetOrg": terminal.EntityNameColor(org.Name), "TargetSpace": terminal.EntityNameColor(space.Name), "CurrentUser": terminal.EntityNameColor(username), })) return &userprint.SpaceUsersUIPrinter{ UI: cmd.ui, UserLister: cmd.userLister(), Roles: roles, RoleDisplayNames: map[models.Role]string{ models.RoleSpaceManager: T("SPACE MANAGER"), models.RoleSpaceDeveloper: T("SPACE DEVELOPER"), models.RoleSpaceAuditor: T("SPACE AUDITOR"), }, } }
func (cmd SetSpaceQuota) Run(context *cli.Context) { spaceName := context.Args()[0] quotaName := context.Args()[1] cmd.ui.Say(T("Assigning space quota {{.QuotaName}} to space {{.SpaceName}} as {{.Username}}...", map[string]interface{}{ "QuotaName": terminal.EntityNameColor(quotaName), "SpaceName": terminal.EntityNameColor(spaceName), "Username": terminal.EntityNameColor(cmd.config.Username()), })) space, err := cmd.spaceRepo.FindByName(spaceName) if err != nil { cmd.ui.Failed(err.Error()) } if space.SpaceQuotaGuid != "" { cmd.ui.Failed(T("This space already has an assigned space quota.")) } quota, err := cmd.quotaRepo.FindByName(quotaName) if err != nil { cmd.ui.Failed(err.Error()) } err = cmd.quotaRepo.AssociateSpaceWithQuota(space.Guid, quota.Guid) if err != nil { cmd.ui.Failed(err.Error()) } cmd.ui.Ok() }
func (cmd *SetOrgRole) Execute(c flags.FlagContext) { user := cmd.userReq.GetUser() org := cmd.orgReq.GetOrganization() role := models.UserInputToOrgRole[c.Args()[2]] setRolesByUsername, err := cmd.flagRepo.FindByName("set_roles_by_username") if err != nil { cmd.ui.Failed(err.Error()) } cmd.ui.Say(T("Assigning role {{.Role}} to user {{.TargetUser}} in org {{.TargetOrg}} as {{.CurrentUser}}...", map[string]interface{}{ "Role": terminal.EntityNameColor(role), "TargetUser": terminal.EntityNameColor(user.Username), "TargetOrg": terminal.EntityNameColor(org.Name), "CurrentUser": terminal.EntityNameColor(cmd.config.Username()), })) var apiErr error if cmd.config.IsMinApiVersion("2.37.0") && setRolesByUsername.Enabled { apiErr = cmd.userRepo.SetOrgRoleByUsername(user.Username, org.Guid, role) } else { apiErr = cmd.userRepo.SetOrgRole(user.Guid, org.Guid, role) } if apiErr != nil { cmd.ui.Failed(apiErr.Error()) } cmd.ui.Ok() }
func (cmd *CreateRoute) CreateRoute(hostName string, path string, domain models.DomainFields, space models.SpaceFields) (models.Route, error) { cmd.ui.Say(T("Creating route {{.URL}} for org {{.OrgName}} / space {{.SpaceName}} as {{.Username}}...", map[string]interface{}{ "URL": terminal.EntityNameColor(domain.UrlForHostAndPath(hostName, path)), "OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name), "SpaceName": terminal.EntityNameColor(space.Name), "Username": terminal.EntityNameColor(cmd.config.Username())})) route, err := cmd.routeRepo.CreateInSpace(hostName, path, domain.Guid, space.Guid) if err != nil { var findErr error route, findErr = cmd.routeRepo.Find(hostName, domain, path) if findErr != nil { return models.Route{}, err } if route.Space.Guid != space.Guid || route.Domain.Guid != domain.Guid { return models.Route{}, err } cmd.ui.Ok() cmd.ui.Warn(T("Route {{.URL}} already exists", map[string]interface{}{"URL": route.URL()})) return route, nil } cmd.ui.Ok() return route, nil }
func (cmd *removeFromRunningGroup) Run(context *cli.Context) { name := context.Args()[0] securityGroup, err := cmd.securityGroupRepo.Read(name) switch (err).(type) { case nil: case *errors.ModelNotFoundError: cmd.ui.Ok() cmd.ui.Warn(T("Security group {{.security_group}} {{.error_message}}", map[string]interface{}{ "security_group": terminal.EntityNameColor(name), "error_message": terminal.WarningColor(T("does not exist.")), })) return default: cmd.ui.Failed(err.Error()) } cmd.ui.Say(T("Removing security group {{.security_group}} from defaults for running as {{.username}}", map[string]interface{}{ "security_group": terminal.EntityNameColor(securityGroup.Name), "username": terminal.EntityNameColor(cmd.configRepo.Username()), })) err = cmd.runningGroupRepo.RemoveFromRunningSet(securityGroup.Guid) if err != nil { cmd.ui.Failed(err.Error()) } cmd.ui.Ok() }
func (cmd ListStack) Run(c *cli.Context) { stackName := c.Args()[0] stack, apiErr := cmd.stacksRepo.FindByName(stackName) if c.Bool("guid") { cmd.ui.Say(stack.Guid) } else { if apiErr != nil { cmd.ui.Failed(apiErr.Error()) return } cmd.ui.Say(T("Getting stack '{{.Stack}}' in org {{.OrganizationName}} / space {{.SpaceName}} as {{.Username}}...", map[string]interface{}{"Stack": stackName, "OrganizationName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name), "SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name), "Username": terminal.EntityNameColor(cmd.config.Username())})) cmd.ui.Ok() cmd.ui.Say("") table := terminal.NewTable(cmd.ui, []string{T("name"), T("description")}) table.Add(stack.Name, stack.Description) table.Print() } }
func (cmd *UpdateService) printUpdatingServiceInstanceMessage(serviceInstanceName string) { cmd.ui.Say(T("Updating service instance {{.ServiceName}} as {{.UserName}}...", map[string]interface{}{ "ServiceName": terminal.EntityNameColor(serviceInstanceName), "UserName": terminal.EntityNameColor(cmd.config.Username()), })) }
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, apiErr := cmd.spaceRepo.FindByNameInOrg(spaceName, org.Guid) if apiErr != nil { cmd.ui.Failed(apiErr.Error()) 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()), ) apiErr = cmd.userRepo.UnsetSpaceRole(user.Guid, space.Guid, role) if apiErr != nil { cmd.ui.Failed(apiErr.Error()) return } cmd.ui.Ok() }
func (cmd CreateSecurityGroup) Run(context *cli.Context) { name := context.Args()[0] pathToJSONFile := context.String("json") rules, err := json.ParseJSON(pathToJSONFile) if err != nil { cmd.ui.Failed(err.Error()) } cmd.ui.Say(T("Creating security group {{.security_group}} as {{.username}}", map[string]interface{}{ "security_group": terminal.EntityNameColor(name), "username": terminal.EntityNameColor(cmd.configRepo.Username()), })) err = cmd.securityGroupRepo.Create(name, rules) httpErr, ok := err.(errors.HttpError) if ok && httpErr.ErrorCode() == errors.SECURITY_GROUP_EXISTS { cmd.ui.Ok() cmd.ui.Warn(T("Security group {{.security_group}} {{.error_message}}", map[string]interface{}{ "security_group": terminal.EntityNameColor(name), "error_message": terminal.WarningColor(T("already exists")), })) return } if err != nil { cmd.ui.Failed(err.Error()) } cmd.ui.Ok() }
func (cmd *SpaceQuota) Run(c *cli.Context) { name := c.Args()[0] cmd.ui.Say(T("Getting space quota {{.Quota}} info as {{.Username}}...", map[string]interface{}{ "Quota": terminal.EntityNameColor(name), "Username": terminal.EntityNameColor(cmd.config.Username()), })) spaceQuota, apiErr := cmd.spaceQuotaRepo.FindByName(name) if apiErr != nil { cmd.ui.Failed(apiErr.Error()) return } cmd.ui.Ok() cmd.ui.Say("") var megabytes string table := terminal.NewTable(cmd.ui, []string{"", ""}) table.Add(T("total memory limit"), formatters.ByteSize(spaceQuota.MemoryLimit*formatters.MEGABYTE)) if spaceQuota.InstanceMemoryLimit == -1 { megabytes = "-1" } else { megabytes = formatters.ByteSize(spaceQuota.InstanceMemoryLimit * formatters.MEGABYTE) } table.Add(T("instance memory limit"), megabytes) table.Add(T("routes"), fmt.Sprintf("%d", spaceQuota.RoutesLimit)) table.Add(T("services"), fmt.Sprintf("%d", spaceQuota.ServicesLimit)) table.Add(T("non basic services"), formatters.Allowed(spaceQuota.NonBasicServicesAllowed)) table.Print() }
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(T("Could not find service {{.ServiceName}} to bind to {{.AppName}}", map[string]interface{}{"ServiceName": serviceName, "AppName": app.Name})) return } cmd.ui.Say(T("Binding service {{.ServiceName}} to app {{.AppName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.Username}}...", map[string]interface{}{ "ServiceName": terminal.EntityNameColor(serviceInstance.Name), "AppName": terminal.EntityNameColor(app.Name), "OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name), "SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name), "Username": 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(T("Could not bind to service {{.ServiceName}}\nError: {{.Err}}", map[string]interface{}{"ServiceName": serviceName, "Err": err.Error()})) } cmd.ui.Ok() } }
func (cmd *DeleteUser) Execute(c flags.FlagContext) { username := c.Args()[0] force := c.Bool("f") if !force && !cmd.ui.ConfirmDelete(T("user"), username) { return } cmd.ui.Say(T("Deleting user {{.TargetUser}} as {{.CurrentUser}}...", map[string]interface{}{ "TargetUser": terminal.EntityNameColor(username), "CurrentUser": terminal.EntityNameColor(cmd.config.Username()), })) user, apiErr := cmd.userRepo.FindByUsername(username) switch apiErr.(type) { case nil: case *errors.ModelNotFoundError: cmd.ui.Ok() cmd.ui.Warn(T("User {{.TargetUser}} does not exist.", map[string]interface{}{"TargetUser": username})) return default: cmd.ui.Failed(apiErr.Error()) return } apiErr = cmd.userRepo.Delete(user.Guid) if apiErr != nil { cmd.ui.Failed(apiErr.Error()) return } cmd.ui.Ok() }
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 *MapRoute) Run(c *cli.Context) { hostName := c.String("n") domain := cmd.domainReq.GetDomain() app := cmd.appReq.GetApplication() route, apiErr := cmd.routeCreator.CreateRoute(hostName, domain, cmd.config.SpaceFields()) if apiErr != nil { cmd.ui.Failed(T("Error resolving route:\n{{.Err}}", map[string]interface{}{"Err": apiErr.Error()})) } cmd.ui.Say(T("Adding route {{.URL}} to app {{.AppName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.Username}}...", map[string]interface{}{ "URL": terminal.EntityNameColor(route.URL()), "AppName": terminal.EntityNameColor(app.Name), "OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name), "SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name), "Username": terminal.EntityNameColor(cmd.config.Username())})) apiErr = cmd.routeRepo.Bind(route.Guid, app.Guid) if apiErr != nil { cmd.ui.Failed(apiErr.Error()) return } cmd.ui.Ok() }
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 *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 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]interface{}) err := json.Unmarshal([]byte(params), ¶msMap) if err != nil && params != "" { paramsMap = cmd.mapValuesFromPrompt(params, paramsMap) } cmd.ui.Say(T("Creating user provided service {{.ServiceName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.CurrentUser}}...", map[string]interface{}{ "ServiceName": terminal.EntityNameColor(name), "OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name), "SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name), "CurrentUser": 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 *unbindFromStagingGroup) Execute(context flags.FlagContext) error { name := context.Args()[0] cmd.ui.Say(T("Unbinding security group {{.security_group}} from defaults for staging as {{.username}}", map[string]interface{}{ "security_group": terminal.EntityNameColor(name), "username": terminal.EntityNameColor(cmd.configRepo.Username()), })) securityGroup, err := cmd.securityGroupRepo.Read(name) switch (err).(type) { case nil: case *errors.ModelNotFoundError: cmd.ui.Ok() cmd.ui.Warn(T("Security group {{.security_group}} {{.error_message}}", map[string]interface{}{ "security_group": terminal.EntityNameColor(name), "error_message": terminal.WarningColor(T("does not exist.")), })) return nil default: return err } err = cmd.stagingGroupRepo.UnbindFromStagingSet(securityGroup.GUID) if err != nil { return err } cmd.ui.Ok() cmd.ui.Say("\n\n") cmd.ui.Say(T("TIP: Changes will not apply to existing running applications until they are restarted.")) return nil }
func (cmd *Env) Execute(c flags.FlagContext) { app, err := cmd.appRepo.Read(c.Args()[0]) if notFound, ok := err.(*errors.ModelNotFoundError); ok { cmd.ui.Failed(notFound.Error()) } cmd.ui.Say(T("Getting env variables for app {{.AppName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.Username}}...", map[string]interface{}{ "AppName": terminal.EntityNameColor(app.Name), "OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name), "SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name), "Username": terminal.EntityNameColor(cmd.config.Username())})) env, err := cmd.appRepo.ReadEnv(app.GUID) if err != nil { cmd.ui.Failed(err.Error()) } cmd.ui.Ok() cmd.ui.Say("") cmd.displaySystemiAndAppProvidedEnvironment(env.System, env.Application) cmd.ui.Say("") cmd.displayUserProvidedEnvironment(env.Environment) cmd.ui.Say("") cmd.displayRunningEnvironment(env.Running) cmd.ui.Say("") cmd.displayStagingEnvironment(env.Staging) cmd.ui.Say("") }
func (cmd *DeleteSecurityGroup) Execute(context flags.FlagContext) { name := context.Args()[0] cmd.ui.Say(T("Deleting security group {{.security_group}} as {{.username}}", map[string]interface{}{ "security_group": terminal.EntityNameColor(name), "username": terminal.EntityNameColor(cmd.configRepo.Username()), })) if !context.Bool("f") { response := cmd.ui.ConfirmDelete(T("security group"), name) if !response { return } } group, err := cmd.securityGroupRepo.Read(name) switch err.(type) { case nil: case *errors.ModelNotFoundError: cmd.ui.Ok() cmd.ui.Warn(T("Security group {{.security_group}} does not exist", map[string]interface{}{"security_group": name})) return default: cmd.ui.Failed(err.Error()) } err = cmd.securityGroupRepo.Delete(group.Guid) if err != nil { cmd.ui.Failed(err.Error()) } cmd.ui.Ok() }