func NewSSHOptions(fc flags.FlagContext) (*SSHOptions, error) {
sshOptions := &SSHOptions{}
sshOptions.AppName = fc.Args()[0]
sshOptions.Index = uint(fc.Int("i"))
sshOptions.SkipHostValidation = fc.Bool("k")
sshOptions.SkipRemoteExecution = fc.Bool("N")
sshOptions.Command = fc.StringSlice("c")
if fc.IsSet("L") {
for _, arg := range fc.StringSlice("L") {
forwardSpec, err := sshOptions.parseLocalForwardingSpec(arg)
if err != nil {
return sshOptions, err
}
sshOptions.ForwardSpecs = append(sshOptions.ForwardSpecs, *forwardSpec)
}
}
if fc.IsSet("t") && fc.Bool("t") {
sshOptions.TerminalRequest = RequestTTYYes
}
if fc.IsSet("tt") && fc.Bool("tt") {
sshOptions.TerminalRequest = RequestTTYForce
}
if fc.Bool("T") {
sshOptions.TerminalRequest = RequestTTYNo
}
return sshOptions, 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 *CreateServiceBroker) Execute(c flags.FlagContext) error {
name := c.Args()[0]
username := c.Args()[1]
password := c.Args()[2]
url := c.Args()[3]
var err error
if c.Bool("space-scoped") {
cmd.ui.Say(T("Creating service broker {{.Name}} in org {{.Org}} / space {{.Space}} as {{.Username}}...",
map[string]interface{}{
"Name": terminal.EntityNameColor(name),
"Org": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"Space": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
err = cmd.serviceBrokerRepo.Create(name, url, username, password, cmd.config.SpaceFields().GUID)
} else {
cmd.ui.Say(T("Creating service broker {{.Name}} as {{.Username}}...",
map[string]interface{}{
"Name": terminal.EntityNameColor(name),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
err = cmd.serviceBrokerRepo.Create(name, url, username, password, "")
}
if err != nil {
return err
}
cmd.ui.Ok()
return err
}
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 *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 *Push) getAppParamsFromManifest(c flags.FlagContext) ([]models.AppParams, error) {
if c.Bool("no-manifest") {
return []models.AppParams{}, nil
}
var path string
if c.String("f") != "" {
path = c.String("f")
} else {
var err error
path, err = os.Getwd()
if err != nil {
return nil, errors.New(fmt.Sprint(T("Could not determine the current working directory!"), err))
}
}
m, err := cmd.manifestRepo.ReadManifest(path)
if err != nil {
if m.Path == "" && c.String("f") == "" {
return []models.AppParams{}, nil
}
return nil, errors.New(T("Error reading manifest file:\n{{.Err}}", map[string]interface{}{"Err": err.Error()}))
}
apps, err := m.Applications()
if err != nil {
return nil, errors.New(T("Error reading manifest file:\n{{.Err}}", map[string]interface{}{"Err": err.Error()}))
}
cmd.ui.Say(T("Using manifest file {{.Path}}\n",
map[string]interface{}{"Path": terminal.EntityNameColor(m.Path)}))
return apps, nil
}
func (cmd *PurgeServiceInstance) Execute(c flags.FlagContext) error {
instanceName := c.Args()[0]
instance, err := cmd.serviceRepo.FindInstanceByName(instanceName)
if err != nil {
if _, ok := err.(*errors.ModelNotFoundError); ok {
cmd.ui.Warn(T("Service instance {{.InstanceName}} not found", map[string]interface{}{"InstanceName": instanceName}))
return nil
}
return err
}
force := c.Bool("f")
if !force {
cmd.ui.Warn(cmd.scaryWarningMessage())
confirmed := cmd.ui.Confirm(T("Really purge service instance {{.InstanceName}} from Cloud Foundry?",
map[string]interface{}{"InstanceName": instanceName},
))
if !confirmed {
return nil
}
}
cmd.ui.Say(T("Purging service {{.InstanceName}}...", map[string]interface{}{"InstanceName": instanceName}))
err = cmd.serviceRepo.PurgeServiceInstance(instance)
if err != nil {
return err
}
cmd.ui.Ok()
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 CreateBuildpack) createBuildpack(buildpackName string, c flags.FlagContext) (buildpack models.Buildpack, apiErr error) {
position, err := strconv.Atoi(c.Args()[2])
if err != nil {
apiErr = fmt.Errorf(T("Error {{.ErrorDescription}} is being passed in as the argument for 'Position' but 'Position' requires an integer. For more syntax help, see `cf create-buildpack -h`.", map[string]interface{}{"ErrorDescription": c.Args()[2]}))
return
}
enabled := c.Bool("enable")
disabled := c.Bool("disable")
if enabled && disabled {
apiErr = errors.New(T("Cannot specify both {{.Enabled}} and {{.Disabled}}.", map[string]interface{}{
"Enabled": "enabled",
"Disabled": "disabled",
}))
return
}
var enableOption *bool
if enabled {
enableOption = &enabled
}
if disabled {
disabled = false
enableOption = &disabled
}
buildpack, apiErr = cmd.buildpackRepo.Create(buildpackName, &position, enableOption, nil)
return
}
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 *DeleteServiceAuthTokenFields) Execute(c flags.FlagContext) error {
tokenLabel := c.Args()[0]
tokenProvider := c.Args()[1]
if c.Bool("f") == false {
if !cmd.ui.ConfirmDelete(T("service auth token"), fmt.Sprintf("%s %s", tokenLabel, tokenProvider)) {
return nil
}
}
cmd.ui.Say(T("Deleting service auth token as {{.CurrentUser}}",
map[string]interface{}{
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
}))
token, err := cmd.authTokenRepo.FindByLabelAndProvider(tokenLabel, tokenProvider)
switch err.(type) {
case nil:
case *errors.ModelNotFoundError:
cmd.ui.Ok()
cmd.ui.Warn(T("Service Auth Token {{.Label}} {{.Provider}} does not exist.", map[string]interface{}{"Label": tokenLabel, "Provider": tokenProvider}))
return nil
default:
return err
}
err = cmd.authTokenRepo.Delete(token)
if err != nil {
return err
}
cmd.ui.Ok()
return nil
}
func (cmd *OrgUsers) printer(c flags.FlagContext) userprint.UserPrinter {
var roles []models.Role
if c.Bool("a") {
roles = []models.Role{models.RoleOrgUser}
} else {
roles = []models.Role{models.RoleOrgManager, models.RoleBillingManager, models.RoleOrgAuditor}
}
if cmd.pluginCall {
return userprint.NewOrgUsersPluginPrinter(
cmd.pluginModel,
cmd.userLister(),
roles,
)
}
return &userprint.OrgUsersUIPrinter{
UI: cmd.ui,
UserLister: cmd.userLister(),
Roles: roles,
RoleDisplayNames: map[models.Role]string{
models.RoleOrgUser: T("USERS"),
models.RoleOrgManager: T("ORG MANAGER"),
models.RoleBillingManager: T("BILLING MANAGER"),
models.RoleOrgAuditor: T("ORG AUDITOR"),
},
}
}
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 *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 *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 *Login) Execute(c flags.FlagContext) error {
cmd.config.ClearSession()
endpoint, skipSSL := cmd.decideEndpoint(c)
api := API{
ui: cmd.ui,
config: cmd.config,
endpointRepo: cmd.endpointRepo,
}
err := api.setAPIEndpoint(endpoint, skipSSL, cmd.MetaData().Name)
if err != nil {
return err
}
defer func() {
cmd.ui.Say("")
cmd.ui.ShowConfiguration(cmd.config)
}()
// We thought we would never need to explicitly branch in this code
// for anything as simple as authentication, but it turns out that our
// assumptions did not match reality.
// When SAML is enabled (but not configured) then the UAA/Login server
// will always returns password prompts that includes the Passcode field.
// Users can authenticate with:
// EITHER username and password
// OR a one-time passcode
if c.Bool("sso") {
err = cmd.authenticateSSO(c)
if err != nil {
return err
}
} else {
err = cmd.authenticate(c)
if err != nil {
return err
}
}
orgIsSet, err := cmd.setOrganization(c)
if err != nil {
return err
}
if orgIsSet {
err = cmd.setSpace(c)
if err != nil {
return err
}
}
cmd.ui.NotifyUpdateIfNeeded(cmd.config)
return nil
}
func (cmd *Scale) confirmRestart(context flags.FlagContext, appName string) bool {
if context.Bool("f") {
return true
}
result := cmd.ui.Confirm(T("This will cause the app to restart. Are you sure you want to scale {{.AppName}}?",
map[string]interface{}{"AppName": terminal.EntityNameColor(appName)}))
cmd.ui.Say("")
return result
}
func (cmd *Curl) Execute(c flags.FlagContext) error {
path := c.Args()[0]
headers := c.StringSlice("H")
var method string
var body string
if c.IsSet("d") {
method = "POST"
jsonBytes, err := util.GetContentsFromOptionalFlagValue(c.String("d"))
if err != nil {
return err
}
body = string(jsonBytes)
}
if c.IsSet("X") {
method = c.String("X")
}
reqHeader := strings.Join(headers, "\n")
responseHeader, responseBody, apiErr := cmd.curlRepo.Request(method, path, reqHeader, body)
if apiErr != nil {
return errors.New(T("Error creating request:\n{{.Err}}", map[string]interface{}{"Err": apiErr.Error()}))
}
if trace.LoggingToStdout && !cmd.pluginCall {
return nil
}
if c.Bool("i") {
cmd.ui.Say(responseHeader)
}
if c.String("output") != "" {
err := cmd.writeToFile(responseBody, c.String("output"))
if err != nil {
return errors.New(T("Error creating request:\n{{.Err}}", map[string]interface{}{"Err": err}))
}
} else {
if strings.Contains(responseHeader, "application/json") {
buffer := bytes.Buffer{}
err := json.Indent(&buffer, []byte(responseBody), "", " ")
if err == nil {
responseBody = buffer.String()
}
}
cmd.ui.Say(responseBody)
}
return nil
}
func (cmd *UnbindRouteService) Execute(c flags.FlagContext) error {
var port int
host := c.String("hostname")
domain := cmd.domainReq.GetDomain()
path := c.String("path")
if !strings.HasPrefix(path, "/") && len(path) > 0 {
path = fmt.Sprintf("/%s", path)
}
route, err := cmd.routeRepo.Find(host, domain, path, port)
if err != nil {
return err
}
serviceInstance := cmd.serviceInstanceReq.GetServiceInstance()
confirmed := c.Bool("f")
if !confirmed {
confirmed = cmd.ui.Confirm(T("Unbinding may leave apps mapped to route {{.URL}} vulnerable; e.g. if service instance {{.ServiceInstanceName}} provides authentication. Do you want to proceed?",
map[string]interface{}{
"URL": route.URL(),
"ServiceInstanceName": serviceInstance.Name,
}))
if !confirmed {
cmd.ui.Warn(T("Unbind cancelled"))
return nil
}
}
cmd.ui.Say(T("Unbinding route {{.URL}} from service instance {{.ServiceInstanceName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.CurrentUser}}...",
map[string]interface{}{
"ServiceInstanceName": terminal.EntityNameColor(serviceInstance.Name),
"URL": terminal.EntityNameColor(route.URL()),
"OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
}))
err = cmd.UnbindRoute(route, serviceInstance)
if err != nil {
httpError, ok := err.(errors.HTTPError)
if ok && httpError.ErrorCode() == errors.InvalidRelation {
cmd.ui.Warn(T("Route {{.Route}} was not bound to service instance {{.ServiceInstance}}.", map[string]interface{}{"Route": route.URL(), "ServiceInstance": serviceInstance.Name}))
} else {
return err
}
}
cmd.ui.Ok()
return nil
}
func (cmd *ShowApp) Execute(c flags.FlagContext) error {
app := cmd.appReq.GetApplication()
if c.Bool("guid") {
cmd.ui.Say(app.GUID)
} else {
err := cmd.ShowApp(app, cmd.config.OrganizationFields().Name, cmd.config.SpaceFields().Name)
if err != nil {
return err
}
}
return nil
}
func (cmd *CreateRoute) Execute(c flags.FlagContext) error {
hostName := c.String("n")
space := cmd.spaceReq.GetSpace()
domain := cmd.domainReq.GetDomain()
path := c.String("path")
port := c.Int("port")
randomPort := c.Bool("random-port")
_, err := cmd.CreateRoute(hostName, path, port, randomPort, domain, space.SpaceFields)
if err != nil {
return err
}
return nil
}
func (cmd *PurgeServiceOffering) Execute(c flags.FlagContext) error {
serviceName := c.Args()[0]
var offering models.ServiceOffering
if c.IsSet("p") {
var err error
offering, err = cmd.serviceRepo.FindServiceOfferingByLabelAndProvider(serviceName, c.String("p"))
if err != nil {
if _, ok := err.(*errors.ModelNotFoundError); ok {
cmd.ui.Warn(T("Service offering does not exist\nTIP: If you are trying to purge a v1 service offering, you must set the -p flag."))
return nil
}
return err
}
} else {
offerings, err := cmd.serviceRepo.FindServiceOfferingsByLabel(serviceName)
if err != nil {
if _, ok := err.(*errors.ModelNotFoundError); ok {
cmd.ui.Warn(T("Service offering does not exist\nTIP: If you are trying to purge a v1 service offering, you must set the -p flag."))
return nil
}
return err
}
offering = offerings[0]
}
confirmed := c.Bool("f")
if !confirmed {
cmd.ui.Warn(scaryWarningMessage())
confirmed = cmd.ui.Confirm(T("Really purge service offering {{.ServiceName}} from Cloud Foundry?",
map[string]interface{}{"ServiceName": serviceName},
))
}
if !confirmed {
return nil
}
cmd.ui.Say(T("Purging service {{.ServiceName}}...", map[string]interface{}{"ServiceName": serviceName}))
err := cmd.serviceRepo.PurgeServiceOffering(offering)
if err != nil {
return err
}
cmd.ui.Ok()
return nil
}
func (cmd Login) decideEndpoint(c flags.FlagContext) (string, bool) {
endpoint := c.String("a")
skipSSL := c.Bool("skip-ssl-validation")
if endpoint == "" {
endpoint = cmd.config.APIEndpoint()
skipSSL = cmd.config.IsSSLDisabled() || skipSSL
}
if endpoint == "" {
endpoint = cmd.ui.Ask(T("API endpoint"))
} else {
cmd.ui.Say(T("API endpoint: {{.Endpoint}}", map[string]interface{}{"Endpoint": terminal.EntityNameColor(endpoint)}))
}
return endpoint, skipSSL
}
func (cmd *DeleteSharedDomain) Execute(c flags.FlagContext) error {
domainName := c.Args()[0]
force := c.Bool("f")
cmd.ui.Say(T("Deleting domain {{.DomainName}} as {{.Username}}...",
map[string]interface{}{
"DomainName": terminal.EntityNameColor(domainName),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
domain, err := cmd.domainRepo.FindByNameInOrg(domainName, cmd.orgReq.GetOrganizationFields().GUID)
switch err.(type) {
case nil:
if !domain.Shared {
return errors.New(T("domain {{.DomainName}} is an owned domain, not a shared domain.",
map[string]interface{}{"DomainName": domainName}))
}
case *errors.ModelNotFoundError:
cmd.ui.Ok()
cmd.ui.Warn(err.Error())
return nil
default:
return errors.New(T("Error finding domain {{.DomainName}}\n{{.Err}}",
map[string]interface{}{
"DomainName": domainName,
"Err": err.Error()}))
}
if !force {
answer := cmd.ui.Confirm(T("This domain is shared across all orgs.\nDeleting it will remove all associated routes, and will make any app with this domain unreachable.\nAre you sure you want to delete the domain {{.DomainName}}? ", map[string]interface{}{"DomainName": domainName}))
if !answer {
return nil
}
}
err = cmd.domainRepo.DeleteSharedDomain(domain.GUID)
if err != nil {
return errors.New(T("Error deleting domain {{.DomainName}}\n{{.Err}}",
map[string]interface{}{"DomainName": domainName, "Err": err.Error()}))
}
cmd.ui.Ok()
return nil
}
func (cmd *DeleteRoute) Execute(c flags.FlagContext) error {
host := c.String("n")
path := c.String("path")
domainName := c.Args()[0]
port := c.Int("port")
url := (&models.RoutePresenter{
Host: host,
Domain: domainName,
Path: path,
Port: port,
}).URL()
if !c.Bool("f") {
if !cmd.ui.ConfirmDelete("route", url) {
return nil
}
}
cmd.ui.Say(T("Deleting route {{.URL}}...", map[string]interface{}{"URL": terminal.EntityNameColor(url)}))
domain := cmd.domainReq.GetDomain()
route, err := cmd.routeRepo.Find(host, domain, path, port)
if err != nil {
if _, ok := err.(*errors.ModelNotFoundError); ok {
cmd.ui.Warn(T("Unable to delete, route '{{.URL}}' does not exist.",
map[string]interface{}{"URL": url}))
return nil
}
return err
}
err = cmd.routeRepo.Delete(route.GUID)
if err != nil {
return err
}
cmd.ui.Ok()
return nil
}
func (cmd *DeleteOrg) Execute(c flags.FlagContext) error {
orgName := c.Args()[0]
if !c.Bool("f") {
if !cmd.ui.ConfirmDeleteWithAssociations(T("org"), orgName) {
return nil
}
}
cmd.ui.Say(T("Deleting org {{.OrgName}} as {{.Username}}...",
map[string]interface{}{
"OrgName": terminal.EntityNameColor(orgName),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
org, err := cmd.orgRepo.FindByName(orgName)
switch err.(type) {
case nil:
case *errors.ModelNotFoundError:
cmd.ui.Ok()
cmd.ui.Warn(T("Org {{.OrgName}} does not exist.",
map[string]interface{}{"OrgName": orgName}))
return nil
default:
return err
}
err = cmd.orgRepo.Delete(org.GUID)
if err != nil {
return err
}
if org.GUID == cmd.config.OrganizationFields().GUID {
cmd.config.SetOrganizationFields(models.OrganizationFields{})
cmd.config.SetSpaceFields(models.SpaceFields{})
}
cmd.ui.Ok()
return nil
}
func (cmd *DeleteDomain) Execute(c flags.FlagContext) error {
domainName := c.Args()[0]
domain, err := cmd.domainRepo.FindByNameInOrg(domainName, cmd.orgReq.GetOrganizationFields().GUID)
switch err.(type) {
case nil:
if domain.Shared {
return errors.New(T("domain {{.DomainName}} is a shared domain, not an owned domain.",
map[string]interface{}{
"DomainName": domainName}))
}
case *errors.ModelNotFoundError:
cmd.ui.Ok()
cmd.ui.Warn(err.Error())
return nil
default:
return errors.New(T("Error finding domain {{.DomainName}}\n{{.APIErr}}",
map[string]interface{}{"DomainName": domainName, "APIErr": err.Error()}))
}
if !c.Bool("f") {
if !cmd.ui.ConfirmDelete(T("domain"), domainName) {
return nil
}
}
cmd.ui.Say(T("Deleting domain {{.DomainName}} as {{.Username}}...",
map[string]interface{}{
"DomainName": terminal.EntityNameColor(domainName),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
err = cmd.domainRepo.Delete(domain.GUID)
if err != nil {
return errors.New(T("Error deleting domain {{.DomainName}}\n{{.APIErr}}",
map[string]interface{}{"DomainName": domainName, "APIErr": err.Error()}))
}
cmd.ui.Ok()
return nil
}
func (cmd *Push) restart(app models.Application, params models.AppParams, c flags.FlagContext) error {
if app.State != T("stopped") {
cmd.ui.Say("")
app, _ = cmd.appStopper.ApplicationStop(app, cmd.config.OrganizationFields().Name, cmd.config.SpaceFields().Name)
}
cmd.ui.Say("")
if c.Bool("no-start") {
return nil
}
if params.HealthCheckTimeout != nil {
cmd.appStarter.SetStartTimeoutInSeconds(*params.HealthCheckTimeout)
}
_, err := cmd.appStarter.ApplicationStart(app, cmd.config.OrganizationFields().Name, cmd.config.SpaceFields().Name)
if err != nil {
return err
}
return nil
}
func (cmd *DeleteBuildpack) Execute(c flags.FlagContext) error {
buildpackName := c.Args()[0]
force := c.Bool("f")
if !force {
answer := cmd.ui.ConfirmDelete("buildpack", buildpackName)
if !answer {
return nil
}
}
cmd.ui.Say(T("Deleting buildpack {{.BuildpackName}}...", map[string]interface{}{"BuildpackName": terminal.EntityNameColor(buildpackName)}))
buildpack, err := cmd.buildpackRepo.FindByName(buildpackName)
switch err.(type) {
case nil: //do nothing
case *errors.ModelNotFoundError:
cmd.ui.Ok()
cmd.ui.Warn(T("Buildpack {{.BuildpackName}} does not exist.", map[string]interface{}{"BuildpackName": buildpackName}))
return nil
default:
return err
}
err = cmd.buildpackRepo.Delete(buildpack.GUID)
if err != nil {
return errors.New(T("Error deleting buildpack {{.Name}}\n{{.Error}}", map[string]interface{}{
"Name": terminal.EntityNameColor(buildpack.Name),
"Error": err.Error(),
}))
}
cmd.ui.Ok()
return nil
}
func (cmd *ShowSpace) Execute(c flags.FlagContext) error {
space := cmd.spaceReq.GetSpace()
if cmd.pluginCall {
cmd.populatePluginModel(space)
return nil
}
if c.Bool("guid") {
cmd.ui.Say(space.GUID)
} else {
cmd.ui.Say(T("Getting info for space {{.TargetSpace}} in org {{.OrgName}} as {{.CurrentUser}}...",
map[string]interface{}{
"TargetSpace": terminal.EntityNameColor(space.Name),
"OrgName": terminal.EntityNameColor(space.Organization.Name),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
}))
quotaString, err := cmd.quotaString(space)
if err != nil {
return err
}
cmd.ui.Ok()
cmd.ui.Say("")
table := cmd.ui.Table([]string{terminal.EntityNameColor(space.Name), "", ""})
table.Add("", T("Org:"), terminal.EntityNameColor(space.Organization.Name))
apps := []string{}
for _, app := range space.Applications {
apps = append(apps, terminal.EntityNameColor(app.Name))
}
table.Add("", T("Apps:"), strings.Join(apps, ", "))
domains := []string{}
for _, domain := range space.Domains {
domains = append(domains, terminal.EntityNameColor(domain.Name))
}
table.Add("", T("Domains:"), strings.Join(domains, ", "))
services := []string{}
for _, service := range space.ServiceInstances {
services = append(services, terminal.EntityNameColor(service.Name))
}
table.Add("", T("Services:"), strings.Join(services, ", "))
securityGroups := []string{}
for _, group := range space.SecurityGroups {
securityGroups = append(securityGroups, terminal.EntityNameColor(group.Name))
}
table.Add("", T("Security Groups:"), strings.Join(securityGroups, ", "))
table.Add("", T("Space Quota:"), terminal.EntityNameColor(quotaString))
err = table.Print()
if err != nil {
return err
}
}
if c.Bool("security-group-rules") {
cmd.ui.Say("")
for _, group := range space.SecurityGroups {
cmd.ui.Say(T("Getting rules for the security group : {{.SecurityGroupName}}...",
map[string]interface{}{"SecurityGroupName": terminal.EntityNameColor(group.Name)}))
table := cmd.ui.Table([]string{"", "", "", ""})
for _, rules := range group.Rules {
for ruleName, ruleValue := range rules {
table.Add("", ruleName, ":", fmt.Sprintf("%v", ruleValue))
}
table.Add("", "", "", "")
}
err := table.Print()
if err != nil {
return err
}
}
}
return nil
}