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"),
},
}
}