func (cmd *SetSpaceQuota) Execute(c flags.FlagContext) error { spaceName := c.Args()[0] quotaName := c.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 { return err } if space.SpaceQuotaGUID != "" { return errors.New(T("This space already has an assigned space quota.")) } quota, err := cmd.quotaRepo.FindByName(quotaName) if err != nil { return err } err = cmd.quotaRepo.AssociateSpaceWithQuota(space.GUID, quota.GUID) if err != nil { return err } cmd.ui.Ok() return nil }
func (cmd *ListStacks) Execute(c flags.FlagContext) error { cmd.ui.Say(T("Getting stacks in org {{.OrganizationName}} / space {{.SpaceName}} as {{.Username}}...", map[string]interface{}{"OrganizationName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name), "SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name), "Username": terminal.EntityNameColor(cmd.config.Username())})) stacks, err := cmd.stacksRepo.FindAll() if err != nil { return err } cmd.ui.Ok() cmd.ui.Say("") table := cmd.ui.Table([]string{T("name"), T("description")}) for _, stack := range stacks { table.Add(stack.Name, stack.Description) } err = table.Print() if err != nil { return err } return nil }
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 *UnsetSpaceQuota) Execute(c flags.FlagContext) error { spaceName := c.Args()[0] quotaName := c.Args()[1] space, err := cmd.spaceRepo.FindByName(spaceName) if err != nil { return err } quota, err := cmd.quotaRepo.FindByName(quotaName) if err != nil { return err } cmd.ui.Say(T("Unassigning space quota {{.QuotaName}} from space {{.SpaceName}} as {{.Username}}...", map[string]interface{}{ "QuotaName": terminal.EntityNameColor(quota.Name), "SpaceName": terminal.EntityNameColor(space.Name), "Username": terminal.EntityNameColor(cmd.config.Username())})) err = cmd.quotaRepo.UnassignQuotaFromSpace(space.GUID, quota.GUID) if err != nil { return err } cmd.ui.Ok() return nil }
func (cmd *UpdateSecurityGroup) Execute(context flags.FlagContext) error { name := context.Args()[0] securityGroup, err := cmd.securityGroupRepo.Read(name) if err != nil { return err } pathToJSONFile := context.Args()[1] rules, err := json.ParseJSONArray(pathToJSONFile) if err != nil { return err } cmd.ui.Say(T("Updating security group {{.security_group}} as {{.username}}", map[string]interface{}{ "security_group": terminal.EntityNameColor(name), "username": terminal.EntityNameColor(cmd.configRepo.Username()), })) err = cmd.securityGroupRepo.Update(securityGroup.GUID, rules) 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 *RenameService) Execute(c flags.FlagContext) error { newName := c.Args()[1] serviceInstance := cmd.serviceInstanceReq.GetServiceInstance() cmd.ui.Say(T("Renaming service {{.ServiceName}} to {{.NewServiceName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.CurrentUser}}...", map[string]interface{}{ "ServiceName": terminal.EntityNameColor(serviceInstance.Name), "NewServiceName": terminal.EntityNameColor(newName), "OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name), "SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name), "CurrentUser": terminal.EntityNameColor(cmd.config.Username()), })) err := cmd.serviceRepo.RenameService(serviceInstance, newName) if err != nil { if httpError, ok := err.(errors.HTTPError); ok && httpError.ErrorCode() == errors.ServiceInstanceNameTaken { return errors.New(T("{{.ErrorDescription}}\nTIP: Use '{{.CFServicesCommand}}' to view all services in this org and space.", map[string]interface{}{ "ErrorDescription": httpError.Error(), "CFServicesCommand": cf.Name + " " + "services", })) } return err } cmd.ui.Ok() 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 *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 *CreateRoute) CreateRoute(hostName string, path string, port int, randomPort bool, 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, port)), "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, port, randomPort) if err != nil { var findErr error route, findErr = cmd.routeRepo.Find(hostName, domain, path, port) 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() if randomPort { cmd.ui.Say("Route %s:%d has been created", route.Domain.Name, route.Port) } return route, nil }
func (routeActor routeActor) BindRoute(app models.Application, route models.Route) error { if !app.HasRoute(route) { routeActor.ui.Say(T( "Binding {{.URL}} to {{.AppName}}...", map[string]interface{}{ "URL": terminal.EntityNameColor(route.URL()), "AppName": terminal.EntityNameColor(app.Name), }), ) err := routeActor.routeRepo.Bind(route.GUID, app.GUID) switch err := err.(type) { case nil: routeActor.ui.Ok() routeActor.ui.Say("") return nil case errors.HTTPError: if err.ErrorCode() == errors.InvalidRelation { return errors.New(T( "The route {{.URL}} is already in use.\nTIP: Change the hostname with -n HOSTNAME or use --random-route to generate a new route and then push again.", map[string]interface{}{ "URL": route.URL(), }), ) } } return err } return nil }
func (cmd *CreateUser) Execute(c flags.FlagContext) error { username := c.Args()[0] password := c.Args()[1] cmd.ui.Say(T("Creating user {{.TargetUser}}...", map[string]interface{}{ "TargetUser": terminal.EntityNameColor(username), "CurrentUser": terminal.EntityNameColor(cmd.config.Username()), })) err := cmd.userRepo.Create(username, password) switch err.(type) { case nil: case *errors.ModelAlreadyExistsError: cmd.ui.Warn("%s", err.Error()) default: return errors.New(T("Error creating user {{.TargetUser}}.\n{{.Error}}", map[string]interface{}{ "TargetUser": terminal.EntityNameColor(username), "Error": err.Error(), })) } cmd.ui.Ok() cmd.ui.Say(T("\nTIP: Assign roles with '{{.CurrentUser}} set-org-role' and '{{.CurrentUser}} set-space-role'", map[string]interface{}{"CurrentUser": cf.Name})) return nil }
func (cmd *MapRoute) Execute(c flags.FlagContext) error { hostName := c.String("n") path := c.String("path") domain := cmd.domainReq.GetDomain() app := cmd.appReq.GetApplication() port := c.Int("port") randomPort := c.Bool("random-port") route, err := cmd.routeCreator.CreateRoute(hostName, path, port, randomPort, domain, cmd.config.SpaceFields()) if err != nil { return errors.New(T("Error resolving route:\n{{.Err}}", map[string]interface{}{"Err": err.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())})) err = cmd.routeRepo.Bind(route.GUID, app.GUID) if err != nil { return err } cmd.ui.Ok() return nil }
func (cmd *CopySource) findSpaceGUID(targetOrg, targetSpace string) (string, error) { org, err := cmd.orgRepo.FindByName(targetOrg) if err != nil { return "", err } var space models.SpaceFields var foundSpace bool for _, s := range org.Spaces { if s.Name == targetSpace { space = s foundSpace = true } } if !foundSpace { return "", fmt.Errorf(T("Could not find space {{.Space}} in organization {{.Org}}", map[string]interface{}{ "Space": terminal.EntityNameColor(targetSpace), "Org": terminal.EntityNameColor(targetOrg), }, )) } return space.GUID, nil }
func (cmd *ListStack) Execute(c flags.FlagContext) error { stackName := c.Args()[0] stack, err := cmd.stacksRepo.FindByName(stackName) if c.Bool("guid") { cmd.ui.Say(stack.GUID) } else { if err != nil { return err } 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 := cmd.ui.Table([]string{T("name"), T("description")}) table.Add(stack.Name, stack.Description) err = table.Print() if err != nil { return err } } return nil }
func (cmd *DeleteOrphanedRoutes) Execute(c flags.FlagContext) error { 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 nil } } cmd.ui.Say(T("Getting routes as {{.Username}} ...\n", map[string]interface{}{"Username": terminal.EntityNameColor(cmd.config.Username())})) err := 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.URL())})) apiErr := cmd.routeRepo.Delete(route.GUID) if apiErr != nil { cmd.ui.Failed(apiErr.Error()) return false } } return true }) if err != nil { return errors.New(T("Failed fetching routes.\n{{.Err}}", map[string]interface{}{"Err": err.Error()})) } cmd.ui.Ok() return nil }
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 *SetOrgRole) Execute(c flags.FlagContext) error { user := cmd.userReq.GetUser() org := cmd.orgReq.GetOrganization() roleStr := c.Args()[2] role, err := models.RoleFromString(roleStr) if err != nil { return err } cmd.ui.Say(T("Assigning role {{.Role}} to user {{.TargetUser}} in org {{.TargetOrg}} as {{.CurrentUser}}...", map[string]interface{}{ "Role": terminal.EntityNameColor(roleStr), "TargetUser": terminal.EntityNameColor(user.Username), "TargetOrg": terminal.EntityNameColor(org.Name), "CurrentUser": terminal.EntityNameColor(cmd.config.Username()), })) err = cmd.SetOrgRole(org.GUID, role, user.GUID, user.Username) if err != nil { return err } cmd.ui.Ok() return nil }
func (cmd *DeleteSpace) Execute(c flags.FlagContext) error { spaceName := c.Args()[0] if !c.Bool("f") { if !cmd.ui.ConfirmDelete(T("space"), spaceName) { return nil } } 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() err := cmd.spaceRepo.Delete(space.GUID) if err != nil { return err } cmd.ui.Ok() if cmd.config.SpaceFields().GUID == space.GUID { 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 nil }
func (cmd *DeleteUser) Execute(c flags.FlagContext) error { username := c.Args()[0] force := c.Bool("f") if !force && !cmd.ui.ConfirmDelete(T("user"), username) { return nil } cmd.ui.Say(T("Deleting user {{.TargetUser}} as {{.CurrentUser}}...", map[string]interface{}{ "TargetUser": terminal.EntityNameColor(username), "CurrentUser": terminal.EntityNameColor(cmd.config.Username()), })) user, err := cmd.userRepo.FindByUsername(username) switch err.(type) { case nil: case *errors.ModelNotFoundError: cmd.ui.Ok() cmd.ui.Warn(T("User {{.TargetUser}} does not exist.", map[string]interface{}{"TargetUser": username})) return nil default: return err } err = cmd.userRepo.Delete(user.GUID) if err != nil { return err } cmd.ui.Ok() return nil }
func (cmd *CreateServiceKey) Execute(c flags.FlagContext) error { serviceInstance := cmd.serviceInstanceRequirement.GetServiceInstance() serviceKeyName := c.Args()[1] 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("Creating service key {{.ServiceKeyName}} for service instance {{.ServiceInstanceName}} as {{.CurrentUser}}...", map[string]interface{}{ "ServiceInstanceName": terminal.EntityNameColor(serviceInstance.Name), "ServiceKeyName": terminal.EntityNameColor(serviceKeyName), "CurrentUser": terminal.EntityNameColor(cmd.config.Username()), })) err = cmd.serviceKeyRepo.CreateServiceKey(serviceInstance.GUID, serviceKeyName, paramsMap) switch err.(type) { case nil: cmd.ui.Ok() case *errors.ModelAlreadyExistsError: cmd.ui.Ok() cmd.ui.Warn(err.Error()) default: return err } return nil }
func (cmd *ServiceKeys) Execute(c flags.FlagContext) error { serviceInstance := cmd.serviceInstanceRequirement.GetServiceInstance() cmd.ui.Say(T("Getting keys for service instance {{.ServiceInstanceName}} as {{.CurrentUser}}...", map[string]interface{}{ "ServiceInstanceName": terminal.EntityNameColor(serviceInstance.Name), "CurrentUser": terminal.EntityNameColor(cmd.config.Username()), })) serviceKeys, err := cmd.serviceKeyRepo.ListServiceKeys(serviceInstance.GUID) if err != nil { return err } table := cmd.ui.Table([]string{T("name")}) for _, serviceKey := range serviceKeys { table.Add(serviceKey.Fields.Name) } if len(serviceKeys) == 0 { cmd.ui.Say(T("No service key for service instance {{.ServiceInstanceName}}", map[string]interface{}{"ServiceInstanceName": terminal.EntityNameColor(serviceInstance.Name)})) return nil } cmd.ui.Say("") err = table.Print() if err != nil { return err } return nil }
func (cmd *Logs) tailLogsFor(app models.Application) error { onConnect := func() { cmd.ui.Say(T("Connected, tailing logs for app {{.AppName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.Username}}...\n", 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())})) } c := make(chan logs.Loggable) e := make(chan error) go cmd.logsRepo.TailLogsFor(app.GUID, onConnect, c, e) for { select { case msg, ok := <-c: if !ok { return nil } cmd.ui.Say("%s", msg.ToLog(time.Local)) case err := <-e: return cmd.handleError(err) } } }
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 *Push) bindAppToServices(services []string, app models.Application) error { for _, serviceName := range services { serviceInstance, err := cmd.serviceRepo.FindInstanceByName(serviceName) if err != nil { return errors.New(T("Could not find service {{.ServiceName}} to bind to {{.AppName}}", map[string]interface{}{"ServiceName": serviceName, "AppName": app.Name})) } 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, nil) switch httpErr := err.(type) { case errors.HTTPError: if httpErr.ErrorCode() == errors.ServiceBindingAppServiceTaken { err = nil } } if err != nil { return errors.New(T("Could not bind to service {{.ServiceName}}\nError: {{.Err}}", map[string]interface{}{"ServiceName": serviceName, "Err": err.Error()})) } cmd.ui.Ok() } return nil }
func (cmd *DeleteSpaceQuota) Execute(c flags.FlagContext) error { quotaName := c.Args()[0] if !c.Bool("f") { response := cmd.ui.ConfirmDelete("quota", quotaName) if !response { return nil } } cmd.ui.Say(T("Deleting space quota {{.QuotaName}} as {{.Username}}...", map[string]interface{}{ "QuotaName": terminal.EntityNameColor(quotaName), "Username": terminal.EntityNameColor(cmd.config.Username()), })) quota, err := cmd.spaceQuotaRepo.FindByName(quotaName) switch (err).(type) { case nil: // no error case *errors.ModelNotFoundError: cmd.ui.Ok() cmd.ui.Warn(T("Quota {{.QuotaName}} does not exist", map[string]interface{}{"QuotaName": quotaName})) return nil default: return err } err = cmd.spaceQuotaRepo.Delete(quota.GUID) if err != nil { return err } cmd.ui.Ok() return nil }
func (cmd *UnbindService) Execute(c flags.FlagContext) error { 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, err := cmd.serviceBindingRepo.Delete(instance, app.GUID) if err != nil { return err } 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})) } return 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 *DeleteSecurityGroup) Execute(context flags.FlagContext) error { 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 nil } } 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 nil default: return err } err = cmd.securityGroupRepo.Delete(group.GUID) if err != nil { return err } cmd.ui.Ok() return nil }
func (cmd *UnsetOrgRole) Execute(c flags.FlagContext) error { user := cmd.userReq.GetUser() org := cmd.orgReq.GetOrganization() roleStr := c.Args()[2] role, err := models.RoleFromString(roleStr) if err != nil { return err } cmd.ui.Say(T("Removing role {{.Role}} from user {{.TargetUser}} in org {{.TargetOrg}} as {{.CurrentUser}}...", map[string]interface{}{ "Role": terminal.EntityNameColor(roleStr), "TargetUser": terminal.EntityNameColor(c.Args()[0]), "TargetOrg": terminal.EntityNameColor(c.Args()[1]), "CurrentUser": terminal.EntityNameColor(cmd.config.Username()), })) if len(user.GUID) > 0 { err = cmd.userRepo.UnsetOrgRoleByGUID(user.GUID, org.GUID, role) } else { err = cmd.userRepo.UnsetOrgRoleByUsername(user.Username, org.GUID, role) } if err != nil { return err } cmd.ui.Ok() return nil }
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"), }, } }