func (cmd *UnmapRoute) Requirements(requirementsFactory requirements.Factory, fc flags.FlagContext) ([]requirements.Requirement, error) {
if len(fc.Args()) != 2 {
cmd.ui.Failed(T("Incorrect Usage. Requires app_name, domain_name as arguments\n\n") + commandregistry.Commands.CommandUsage("unmap-route"))
return nil, fmt.Errorf("Incorrect usage: %d arguments of %d required", len(fc.Args()), 2)
}
if fc.IsSet("port") && (fc.IsSet("hostname") || fc.IsSet("path")) {
cmd.ui.Failed(T("Cannot specify port together with hostname and/or path."))
return nil, fmt.Errorf("Cannot specify port together with hostname and/or path.")
}
domainName := fc.Args()[1]
cmd.appReq = requirementsFactory.NewApplicationRequirement(fc.Args()[0])
cmd.domainReq = requirementsFactory.NewDomainRequirement(domainName)
var reqs []requirements.Requirement
if fc.String("path") != "" {
reqs = append(reqs, requirementsFactory.NewMinAPIVersionRequirement("Option '--path'", cf.RoutePathMinimumAPIVersion))
}
if fc.IsSet("port") {
reqs = append(reqs, requirementsFactory.NewMinAPIVersionRequirement("Option '--port'", cf.TCPRoutingMinimumAPIVersion))
}
reqs = append(reqs, []requirements.Requirement{
requirementsFactory.NewLoginRequirement(),
cmd.appReq,
cmd.domainReq,
}...)
return reqs, nil
}
func (cmd *DisableServiceAccess) Execute(c flags.FlagContext) error {
_, err := cmd.tokenRefresher.RefreshAuthToken()
if err != nil {
return err
}
serviceName := c.Args()[0]
planName := c.String("p")
orgName := c.String("o")
if planName != "" && orgName != "" {
err = cmd.disablePlanAndOrgForService(serviceName, planName, orgName)
} else if planName != "" {
err = cmd.disableSinglePlanForService(serviceName, planName)
} else if orgName != "" {
err = cmd.disablePlansForSingleOrgForService(serviceName, orgName)
} else {
err = cmd.disableServiceForAll(serviceName)
}
if err != nil {
return err
}
cmd.ui.Ok()
return nil
}
func (cmd *Push) Requirements(requirementsFactory requirements.Factory, fc flags.FlagContext) ([]requirements.Requirement, error) {
var reqs []requirements.Requirement
usageReq := requirementsFactory.NewUsageRequirement(commandregistry.CLICommandUsagePresenter(cmd), "",
func() bool {
return len(fc.Args()) > 1
},
)
reqs = append(reqs, usageReq)
if fc.String("route-path") != "" {
reqs = append(reqs, requirementsFactory.NewMinAPIVersionRequirement("Option '--route-path'", cf.RoutePathMinimumAPIVersion))
}
if fc.String("app-ports") != "" {
reqs = append(reqs, requirementsFactory.NewMinAPIVersionRequirement("Option '--app-ports'", cf.MultipleAppPortsMinimumAPIVersion))
}
reqs = append(reqs, []requirements.Requirement{
requirementsFactory.NewLoginRequirement(),
requirementsFactory.NewTargetedSpaceRequirement(),
}...)
return reqs, 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 *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 Login) setOrganization(c flags.FlagContext) (bool, error) {
orgName := c.String("o")
if orgName == "" {
orgs, err := cmd.orgRepo.ListOrgs(maxChoices)
if err != nil {
return false, errors.New(T("Error finding available orgs\n{{.APIErr}}",
map[string]interface{}{"APIErr": err.Error()}))
}
switch len(orgs) {
case 0:
return false, nil
case 1:
cmd.targetOrganization(orgs[0])
return true, nil
default:
orgName = cmd.promptForOrgName(orgs)
if orgName == "" {
cmd.ui.Say("")
return false, nil
}
}
}
org, err := cmd.orgRepo.FindByName(orgName)
if err != nil {
return false, errors.New(T("Error finding org {{.OrgName}}\n{{.Err}}",
map[string]interface{}{"OrgName": terminal.EntityNameColor(orgName), "Err": err.Error()}))
}
cmd.targetOrganization(org)
return true, nil
}
func (cmd *Target) Execute(c flags.FlagContext) error {
orgName := c.String("o")
spaceName := c.String("s")
if orgName != "" {
err := cmd.setOrganization(orgName)
if err != nil {
return err
} else if spaceName == "" {
spaceList, apiErr := cmd.getSpaceList()
if apiErr == nil && len(spaceList) == 1 {
cmd.setSpace(spaceList[0].Name)
}
}
}
if spaceName != "" {
err := cmd.setSpace(spaceName)
if err != nil {
return err
}
}
err := cmd.ui.ShowConfiguration(cmd.config)
if err != nil {
return err
}
cmd.ui.NotifyUpdateIfNeeded(cmd.config)
if !cmd.config.IsLoggedIn() {
return fmt.Errorf(terminal.NotLoggedInText())
}
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 *MapRoute) Requirements(requirementsFactory requirements.Factory, fc flags.FlagContext) ([]requirements.Requirement, error) {
if len(fc.Args()) != 2 {
cmd.ui.Failed(T("Incorrect Usage. Requires APP_NAME and DOMAIN as arguments\n\n") + commandregistry.Commands.CommandUsage("map-route"))
return nil, fmt.Errorf("Incorrect usage: %d arguments of %d required", len(fc.Args()), 2)
}
if fc.IsSet("port") && (fc.IsSet("hostname") || fc.IsSet("path")) {
cmd.ui.Failed(T("Cannot specify port together with hostname and/or path."))
return nil, fmt.Errorf("Cannot specify port together with hostname and/or path.")
}
if fc.IsSet("random-port") && (fc.IsSet("port") || fc.IsSet("hostname") || fc.IsSet("path")) {
cmd.ui.Failed(T("Cannot specify random-port together with port, hostname and/or path."))
return nil, fmt.Errorf("Cannot specify random-port together with port, hostname and/or path.")
}
appName := fc.Args()[0]
domainName := fc.Args()[1]
requirement := requirementsFactory.NewApplicationRequirement(appName)
cmd.appReq = requirement
cmd.domainReq = requirementsFactory.NewDomainRequirement(domainName)
var reqs []requirements.Requirement
if fc.String("path") != "" {
reqs = append(reqs, requirementsFactory.NewMinAPIVersionRequirement("Option '--path'", cf.RoutePathMinimumAPIVersion))
}
var flag string
switch {
case fc.IsSet("port"):
flag = "port"
case fc.IsSet("random-port"):
flag = "random-port"
}
if flag != "" {
reqs = append(reqs, requirementsFactory.NewMinAPIVersionRequirement(fmt.Sprintf("Option '--%s'", flag), cf.TCPRoutingMinimumAPIVersion))
reqs = append(reqs, requirementsFactory.NewDiegoApplicationRequirement(appName))
}
reqs = append(reqs, []requirements.Requirement{
requirementsFactory.NewLoginRequirement(),
cmd.appReq,
cmd.domainReq,
}...)
return reqs, nil
}
func (cmd *CreateService) Execute(c flags.FlagContext) error {
serviceName := c.Args()[0]
planName := c.Args()[1]
serviceInstanceName := c.Args()[2]
params := c.String("c")
tags := c.String("t")
tagsList := uihelpers.ParseTags(tags)
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 instance {{.ServiceName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.CurrentUser}}...",
map[string]interface{}{
"ServiceName": terminal.EntityNameColor(serviceInstanceName),
"OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
}))
plan, err := cmd.CreateService(serviceName, planName, serviceInstanceName, paramsMap, tagsList)
switch err.(type) {
case nil:
err := printSuccessMessageForServiceInstance(serviceInstanceName, cmd.serviceRepo, cmd.ui)
if err != nil {
return err
}
if !plan.Free {
cmd.ui.Say("")
cmd.ui.Say(T("Attention: The plan `{{.PlanName}}` of service `{{.ServiceName}}` is not free. The instance `{{.ServiceInstanceName}}` will incur a cost. Contact your administrator if you think this is in error.",
map[string]interface{}{
"PlanName": terminal.EntityNameColor(plan.Name),
"ServiceName": terminal.EntityNameColor(serviceName),
"ServiceInstanceName": terminal.EntityNameColor(serviceInstanceName),
}))
cmd.ui.Say("")
}
case *errors.ModelAlreadyExistsError:
cmd.ui.Ok()
cmd.ui.Warn(err.Error())
default:
return err
}
return nil
}
func (cmd *MarketplaceServices) Execute(c flags.FlagContext) error {
serviceName := c.String("s")
var err error
if serviceName != "" {
err = cmd.marketplaceByService(serviceName)
} else {
err = cmd.marketplace()
}
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 *CreateSpace) Requirements(requirementsFactory requirements.Factory, fc flags.FlagContext) ([]requirements.Requirement, error) {
if len(fc.Args()) != 1 {
cmd.ui.Failed(T("Incorrect Usage. Requires an argument\n\n") + commandregistry.Commands.CommandUsage("create-space"))
return nil, fmt.Errorf("Incorrect usage: %d arguments of %d required", len(fc.Args()), 1)
}
reqs := []requirements.Requirement{
requirementsFactory.NewLoginRequirement(),
}
if fc.String("o") == "" {
reqs = append(reqs, requirementsFactory.NewTargetedOrgRequirement())
}
return reqs, 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 *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 *CreateSharedDomain) Requirements(requirementsFactory requirements.Factory, fc flags.FlagContext) ([]requirements.Requirement, error) {
if len(fc.Args()) != 1 {
cmd.ui.Failed(T("Incorrect Usage. Requires DOMAIN as an argument\n\n") + commandregistry.Commands.CommandUsage("create-shared-domain"))
return nil, fmt.Errorf("Incorrect usage: %d arguments of %d required", len(fc.Args()), 1)
}
reqs := []requirements.Requirement{
requirementsFactory.NewLoginRequirement(),
}
if fc.String("router-group") != "" {
reqs = append(reqs, []requirements.Requirement{
requirementsFactory.NewMinAPIVersionRequirement("Option '--router-group'", cf.RoutePathMinimumAPIVersion),
requirementsFactory.NewRoutingAPIRequirement(),
}...)
}
return reqs, nil
}
func (cmd *CheckRoute) Requirements(requirementsFactory requirements.Factory, fc flags.FlagContext) ([]requirements.Requirement, error) {
if len(fc.Args()) != 2 {
cmd.ui.Failed(T("Incorrect Usage. Requires host and domain as arguments\n\n") + commandregistry.Commands.CommandUsage("check-route"))
return nil, fmt.Errorf("Incorrect usage: %d arguments of %d required", len(fc.Args()), 2)
}
var reqs []requirements.Requirement
if fc.String("path") != "" {
reqs = append(reqs, requirementsFactory.NewMinAPIVersionRequirement("Option '--path'", cf.RoutePathMinimumAPIVersion))
}
reqs = append(reqs, []requirements.Requirement{
requirementsFactory.NewTargetedOrgRequirement(),
requirementsFactory.NewLoginRequirement(),
}...)
return reqs, nil
}
func (cmd *CreateAppManifest) Execute(c flags.FlagContext) error {
application, apiErr := cmd.appSummaryRepo.GetSummary(cmd.appReq.GetApplication().GUID)
if apiErr != nil {
return errors.New(T("Error getting application summary: ") + apiErr.Error())
}
stack, err := cmd.stackRepo.FindByGUID(application.StackGUID)
if err != nil {
return errors.New(T("Error retrieving stack: ") + err.Error())
}
application.Stack = &stack
cmd.ui.Say(T("Creating an app manifest from current settings of app ") + application.Name + " ...")
cmd.ui.Say("")
savePath := "./" + application.Name + "_manifest.yml"
if c.String("p") != "" {
savePath = c.String("p")
}
f, err := os.Create(savePath)
if err != nil {
return errors.New(T("Error creating manifest file: ") + err.Error())
}
defer f.Close()
err = cmd.createManifest(application)
if err != nil {
return err
}
err = cmd.manifest.Save(f)
if err != nil {
return errors.New(T("Error creating manifest file: ") + err.Error())
}
cmd.ui.Ok()
cmd.ui.Say(T("Manifest file created successfully at ") + savePath)
cmd.ui.Say("")
return nil
}
func (cmd *CheckRoute) Execute(c flags.FlagContext) error {
hostName := c.Args()[0]
domainName := c.Args()[1]
path := c.String("path")
cmd.ui.Say(T("Checking for route..."))
exists, err := cmd.CheckRoute(hostName, domainName, path)
if err != nil {
return err
}
cmd.ui.Ok()
var existence string
if exists {
existence = "does exist"
} else {
existence = "does not exist"
}
if path != "" {
cmd.ui.Say(T("Route {{.HostName}}.{{.DomainName}}/{{.Path}} {{.Existence}}",
map[string]interface{}{
"HostName": hostName,
"DomainName": domainName,
"Existence": existence,
"Path": strings.TrimPrefix(path, `/`),
},
))
} else {
cmd.ui.Say(T("Route {{.HostName}}.{{.DomainName}} {{.Existence}}",
map[string]interface{}{
"HostName": hostName,
"DomainName": domainName,
"Existence": existence,
},
))
}
return nil
}
func (cmd *CreateSharedDomain) Execute(c flags.FlagContext) error {
var routerGroup models.RouterGroup
domainName := c.Args()[0]
routerGroupName := c.String("router-group")
if routerGroupName != "" {
var routerGroupFound bool
err := cmd.routingAPIRepo.ListRouterGroups(func(group models.RouterGroup) bool {
if group.Name == routerGroupName {
routerGroup = group
routerGroupFound = true
return false
}
return true
})
if err != nil {
return err
}
if !routerGroupFound {
return errors.New(T("Router group {{.RouterGroup}} not found", map[string]interface{}{
"RouterGroup": routerGroupName,
}))
}
}
cmd.ui.Say(T("Creating shared domain {{.DomainName}} as {{.Username}}...",
map[string]interface{}{
"DomainName": terminal.EntityNameColor(domainName),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
err := cmd.domainRepo.CreateSharedDomain(domainName, routerGroup.GUID)
if err != nil {
return err
}
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 *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 *UnmapRoute) Execute(c flags.FlagContext) error {
hostName := c.String("n")
path := c.String("path")
port := c.Int("port")
domain := cmd.domainReq.GetDomain()
app := cmd.appReq.GetApplication()
route, err := cmd.routeRepo.Find(hostName, domain, path, port)
if err != nil {
return err
}
cmd.ui.Say(T("Removing route {{.URL}} from 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())}))
var routeFound bool
for _, routeApp := range route.Apps {
if routeApp.GUID == app.GUID {
routeFound = true
err = cmd.routeRepo.Unbind(route.GUID, app.GUID)
if err != nil {
return err
}
break
}
}
cmd.ui.Ok()
if !routeFound {
cmd.ui.Warn(T("\nRoute to be unmapped is not currently mapped to the application."))
}
return nil
}
func (cmd *BindService) Execute(c flags.FlagContext) error {
app := cmd.appReq.GetApplication()
serviceInstance := cmd.serviceInstanceReq.GetServiceInstance()
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("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, paramsMap)
if err != nil {
if httperr, ok := err.(errors.HTTPError); ok && httperr.ErrorCode() == errors.ServiceBindingAppServiceTaken {
cmd.ui.Ok()
cmd.ui.Warn(T("App {{.AppName}} is already bound to {{.ServiceName}}.",
map[string]interface{}{
"AppName": app.Name,
"ServiceName": serviceInstance.Name,
}))
return nil
}
return err
}
cmd.ui.Ok()
cmd.ui.Say(T("TIP: Use '{{.CFCommand}} {{.AppName}}' to ensure your env variable changes take effect",
map[string]interface{}{"CFCommand": terminal.CommandColor(cf.Name + " restage"), "AppName": app.Name}))
return nil
}
func (cmd Login) setSpace(c flags.FlagContext) error {
spaceName := c.String("s")
if spaceName == "" {
var availableSpaces []models.Space
err := cmd.spaceRepo.ListSpaces(func(space models.Space) bool {
availableSpaces = append(availableSpaces, space)
return (len(availableSpaces) < maxChoices)
})
if err != nil {
return errors.New(T("Error finding available spaces\n{{.Err}}",
map[string]interface{}{"Err": err.Error()}))
}
if len(availableSpaces) == 0 {
return nil
} else if len(availableSpaces) == 1 {
cmd.targetSpace(availableSpaces[0])
return nil
} else {
spaceName = cmd.promptForSpaceName(availableSpaces)
if spaceName == "" {
cmd.ui.Say("")
return nil
}
}
}
space, err := cmd.spaceRepo.FindByName(spaceName)
if err != nil {
return errors.New(T("Error finding space {{.SpaceName}}\n{{.Err}}",
map[string]interface{}{"SpaceName": terminal.EntityNameColor(spaceName), "Err": err.Error()}))
}
cmd.targetSpace(space)
return nil
}
func (cmd *ConfigCommands) Execute(context flags.FlagContext) error {
if !context.IsSet("trace") && !context.IsSet("async-timeout") && !context.IsSet("color") && !context.IsSet("locale") {
return errors.New(T("Incorrect Usage") + "\n\n" + commandregistry.Commands.CommandUsage("config"))
}
if context.IsSet("async-timeout") {
asyncTimeout := context.Int("async-timeout")
if asyncTimeout < 0 {
return errors.New(T("Incorrect Usage") + "\n\n" + commandregistry.Commands.CommandUsage("config"))
}
cmd.config.SetAsyncTimeout(uint(asyncTimeout))
}
if context.IsSet("trace") {
cmd.config.SetTrace(context.String("trace"))
}
if context.IsSet("color") {
value := context.String("color")
switch value {
case "true":
cmd.config.SetColorEnabled("true")
case "false":
cmd.config.SetColorEnabled("false")
default:
return errors.New(T("Incorrect Usage") + "\n\n" + commandregistry.Commands.CommandUsage("config"))
}
}
if context.IsSet("locale") {
locale := context.String("locale")
if locale == "CLEAR" {
cmd.config.SetLocale("")
return nil
}
if IsSupportedLocale(locale) {
cmd.config.SetLocale(locale)
return nil
}
unsupportedLocaleMessage := T("Could not find locale '{{.UnsupportedLocale}}'. The known locales are:\n", map[string]interface{}{
"UnsupportedLocale": locale,
})
supportedLocales := SupportedLocales()
sort.Strings(supportedLocales)
for i := range supportedLocales {
unsupportedLocaleMessage = unsupportedLocaleMessage + "\n" + supportedLocales[i]
}
return errors.New(unsupportedLocaleMessage)
}
return nil
}
func (cmd *RepoPlugins) Execute(c flags.FlagContext) error {
var repos []models.PluginRepo
repoName := c.String("r")
repos = cmd.config.PluginRepos()
for i := range repos {
if repos[i].URL == "http://plugins.cloudfoundry.org" {
repos[i].URL = "https://plugins.cloudfoundry.org"
}
}
if repoName == "" {
cmd.ui.Say(T("Getting plugins from all repositories ... "))
} else {
index := cmd.findRepoIndex(repoName)
if index != -1 {
cmd.ui.Say(T("Getting plugins from repository '") + repoName + "' ...")
repos = []models.PluginRepo{repos[index]}
} else {
return errors.New(repoName + T(" does not exist as an available plugin repo."+"\nTip: use `add-plugin-repo` command to add repos."))
}
}
cmd.ui.Say("")
repoPlugins, repoError := cmd.pluginRepo.GetPlugins(repos)
err := cmd.printTable(repoPlugins)
cmd.printErrors(repoError)
if err != nil {
return err
}
return nil
}
func (cmd *UpdateUserProvidedService) Execute(c flags.FlagContext) error {
serviceInstance := cmd.serviceInstanceReq.GetServiceInstance()
if !serviceInstance.IsUserProvided() {
return errors.New(T("Service Instance is not user provided"))
}
drainURL := c.String("l")
credentials := strings.Trim(c.String("p"), `'"`)
routeServiceURL := c.String("r")
credentialsMap := make(map[string]interface{})
if c.IsSet("p") {
jsonBytes, err := util.GetContentsFromFlagValue(credentials)
if err != nil {
return err
}
err = json.Unmarshal(jsonBytes, &credentialsMap)
if err != nil {
for _, param := range strings.Split(credentials, ",") {
param = strings.Trim(param, " ")
credentialsMap[param] = cmd.ui.Ask(param)
}
}
}
cmd.ui.Say(T("Updating user provided service {{.ServiceName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.CurrentUser}}...",
map[string]interface{}{
"ServiceName": terminal.EntityNameColor(serviceInstance.Name),
"OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"CurrentUser": terminal.EntityNameColor(cmd.config.Username()),
}))
serviceInstance.Params = credentialsMap
serviceInstance.SysLogDrainURL = drainURL
serviceInstance.RouteServiceURL = routeServiceURL
err := cmd.userProvidedServiceInstanceRepo.Update(serviceInstance.ServiceInstanceFields)
if err != nil {
return err
}
cmd.ui.Ok()
cmd.ui.Say(T("TIP: Use '{{.CFRestageCommand}}' for any bound apps to ensure your env variable changes take effect",
map[string]interface{}{
"CFRestageCommand": terminal.CommandColor(cf.Name + " restage"),
}))
if routeServiceURL == "" && credentials == "" && drainURL == "" {
cmd.ui.Warn(T("No flags specified. No changes were made."))
}
return nil
}
func (cmd *ServiceAccess) Execute(c flags.FlagContext) error {
_, err := cmd.tokenRefresher.RefreshAuthToken()
if err != nil {
return err
}
brokerName := c.String("b")
serviceName := c.String("e")
orgName := c.String("o")
if brokerName != "" && serviceName != "" && orgName != "" {
cmd.ui.Say(T("Getting service access for broker {{.Broker}} and service {{.Service}} and organization {{.Organization}} as {{.Username}}...", map[string]interface{}{
"Broker": terminal.EntityNameColor(brokerName),
"Service": terminal.EntityNameColor(serviceName),
"Organization": terminal.EntityNameColor(orgName),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
} else if serviceName != "" && orgName != "" {
cmd.ui.Say(T("Getting service access for service {{.Service}} and organization {{.Organization}} as {{.Username}}...", map[string]interface{}{
"Service": terminal.EntityNameColor(serviceName),
"Organization": terminal.EntityNameColor(orgName),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
} else if brokerName != "" && orgName != "" {
cmd.ui.Say(T("Getting service access for broker {{.Broker}} and organization {{.Organization}} as {{.Username}}...", map[string]interface{}{
"Broker": terminal.EntityNameColor(brokerName),
"Organization": terminal.EntityNameColor(orgName),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
} else if brokerName != "" && serviceName != "" {
cmd.ui.Say(T("Getting service access for broker {{.Broker}} and service {{.Service}} as {{.Username}}...", map[string]interface{}{
"Broker": terminal.EntityNameColor(brokerName),
"Service": terminal.EntityNameColor(serviceName),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
} else if brokerName != "" {
cmd.ui.Say(T("Getting service access for broker {{.Broker}} as {{.Username}}...", map[string]interface{}{
"Broker": terminal.EntityNameColor(brokerName),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
} else if serviceName != "" {
cmd.ui.Say(T("Getting service access for service {{.Service}} as {{.Username}}...", map[string]interface{}{
"Service": terminal.EntityNameColor(serviceName),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
} else if orgName != "" {
cmd.ui.Say(T("Getting service access for organization {{.Organization}} as {{.Username}}...", map[string]interface{}{
"Organization": terminal.EntityNameColor(orgName),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
} else {
cmd.ui.Say(T("Getting service access as {{.Username}}...", map[string]interface{}{
"Username": terminal.EntityNameColor(cmd.config.Username())}))
}
brokers, err := cmd.actor.FilterBrokers(brokerName, serviceName, orgName)
if err != nil {
return err
}
cmd.printTable(brokers)
return nil
}