func main() {
defer func() {
maybeSomething := recover()
if maybeSomething != nil {
displayCrashDialog()
}
}()
fileutils.SetTmpPathPrefix("cf")
if os.Getenv("CF_COLOR") == "" {
os.Setenv("CF_COLOR", "true")
}
termUI := terminal.NewUI()
configRepo := configuration.NewConfigurationDiskRepository()
config := loadConfig(termUI, configRepo)
manifestRepo := manifest.NewManifestDiskRepository()
repoLocator := api.NewRepositoryLocator(config, configRepo, map[string]net.Gateway{
"auth": net.NewUAAGateway(),
"cloud-controller": net.NewCloudControllerGateway(),
"uaa": net.NewUAAGateway(),
})
cmdFactory := commands.NewFactory(termUI, config, configRepo, manifestRepo, repoLocator)
reqFactory := requirements.NewFactory(termUI, config, repoLocator)
cmdRunner := commands.NewRunner(cmdFactory, reqFactory)
app, err := app.NewApp(cmdRunner)
if err != nil {
return
}
app.Run(os.Args)
}
func main() {
fileutils.SetTmpPathPrefix("cf")
if os.Getenv("CF_COLOR") == "" {
os.Setenv("CF_COLOR", "true")
}
termUI := terminal.NewUI()
assignTemplates()
configRepo := configuration.NewConfigurationDiskRepository()
config := loadConfig(termUI, configRepo)
repoLocator := api.NewRepositoryLocator(config, configRepo, map[string]net.Gateway{
"auth": net.NewUAAGateway(),
"cloud-controller": net.NewCloudControllerGateway(),
"uaa": net.NewUAAGateway(),
})
cmdFactory := commands.NewFactory(termUI, config, configRepo, repoLocator)
reqFactory := requirements.NewFactory(termUI, config, repoLocator)
cmdRunner := commands.NewRunner(cmdFactory, reqFactory)
app, err := app.NewApp(cmdRunner)
if err != nil {
return
}
app.Run(os.Args)
}
func setupDependencies() (deps *cliDependencies) {
if os.Getenv("CF_COLOR") == "" {
os.Setenv("CF_COLOR", "true")
}
deps = new(cliDependencies)
deps.termUI = terminal.NewUI(os.Stdin)
deps.manifestRepo = manifest.NewManifestDiskRepository()
deps.configRepo = configuration.NewRepositoryFromFilepath(configuration.DefaultFilePath(), func(err error) {
if err != nil {
deps.termUI.Failed(fmt.Sprintf("Config error: %s", err))
}
})
deps.apiRepoLocator = api.NewRepositoryLocator(deps.configRepo, map[string]net.Gateway{
"auth": net.NewUAAGateway(deps.configRepo),
"cloud-controller": net.NewCloudControllerGateway(deps.configRepo),
"uaa": net.NewUAAGateway(deps.configRepo),
})
return
}
func createCommandFactory() command_factory.Factory {
fakeUI := &testterm.FakeUI{}
configRepo := testconfig.NewRepository()
manifestRepo := manifest.NewManifestDiskRepository()
apiRepoLocator := api.NewRepositoryLocator(configRepo, map[string]net.Gateway{
"auth": net.NewUAAGateway(configRepo),
"cloud-controller": net.NewCloudControllerGateway(configRepo),
"uaa": net.NewUAAGateway(configRepo),
})
return command_factory.NewFactory(fakeUI, configRepo, manifestRepo, apiRepoLocator)
}
func TestCommands(t *testing.T) {
for _, cmdName := range availableCmdNames() {
ui := &testterm.FakeUI{}
config := &configuration.Configuration{}
configRepo := testconfig.FakeConfigRepository{}
repoLocator := api.NewRepositoryLocator(config, configRepo, map[string]net.Gateway{
"auth": net.NewUAAGateway(),
"cloud-controller": net.NewCloudControllerGateway(),
"uaa": net.NewUAAGateway(),
})
cmdFactory := commands.NewFactory(ui, config, configRepo, repoLocator)
cmdRunner := &FakeRunner{cmdFactory: cmdFactory, t: t}
app, _ := NewApp(cmdRunner)
app.Run([]string{"", cmdName})
assert.Equal(t, cmdRunner.cmdName, cmdName)
}
}
func findCommand(cmdName string) (cmd cli.Command) {
fakeUI := &testterm.FakeUI{}
configRepo := testconfig.NewRepository()
manifestRepo := manifest.NewManifestDiskRepository()
apiRepoLocator := api.NewRepositoryLocator(configRepo, map[string]net.Gateway{
"auth": net.NewUAAGateway(configRepo),
"cloud-controller": net.NewCloudControllerGateway(configRepo),
"uaa": net.NewUAAGateway(configRepo),
})
cmdFactory := command_factory.NewFactory(fakeUI, configRepo, manifestRepo, apiRepoLocator)
requirementsFactory := &testreq.FakeReqFactory{}
cmdRunner := command_runner.NewRunner(cmdFactory, requirementsFactory)
myApp := app.NewApp(cmdRunner, cmdFactory.CommandMetadatas()...)
for _, cmd := range myApp.Commands {
if cmd.Name == cmdName {
return cmd
}
}
panic(fmt.Sprintf("command %s does not exist", cmdName))
return
}
"rename-service", "rename-service-broker", "rename-space", "restart", "routes", "scale",
"service", "service-auth-tokens", "service-brokers", "services", "set-env", "set-org-role", "set-quota",
"set-space-role", "create-shared-domain", "space", "space-users", "spaces", "stacks", "start", "stop",
"target", "unbind-service", "unmap-route", "unset-env", "unset-org-role", "unset-space-role",
"update-buildpack", "update-service-broker", "update-service-auth-token", "update-user-provided-service",
}
var _ = Describe("App", func() {
It("#NewApp", func() {
ui := &testterm.FakeUI{}
config := testconfig.NewRepository()
manifestRepo := &testmanifest.FakeManifestRepository{}
repoLocator := api.NewRepositoryLocator(config, map[string]net.Gateway{
"auth": net.NewUAAGateway(),
"cloud-controller": net.NewCloudControllerGateway(),
"uaa": net.NewUAAGateway(),
})
cmdFactory := commands.NewFactory(ui, config, manifestRepo, repoLocator)
cmdRunner := &FakeRunner{cmdFactory: cmdFactory}
for _, cmdName := range expectedCommandNames {
output := bytes.NewBuffer(make([]byte, 1024))
trace.SetStdout(output)
trace.EnableTrace()
app, err := NewApp(cmdRunner)
Expect(err).NotTo(HaveOccurred())
Expect(output.String()).To(ContainSubstring("VERSION:\n" + cf.Version))
func New() (app *cli.App, err error) {
cli.AppHelpTemplate = `NAME:
{{.Name}} - {{.Usage}}
USAGE:
[environment variables] {{.Name}} [global options] command [command options] [arguments...]
VERSION:
{{.Version}}
COMMANDS:
{{range .Commands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Description}}
{{end}}
GLOBAL OPTIONS:
{{range .Flags}}{{.}}
{{end}}
ENVIRONMENT VARIABLES:
CF_TRACE=true - will output HTTP requests and responses during command
HTTP_PROXY=http://proxy.example.com:8080 - set to your proxy
`
cli.CommandHelpTemplate = `NAME:
{{.Name}} - {{.Description}}
USAGE:
{{.Usage}}{{with .Flags}}
OPTIONS:
{{range .}}{{.}}
{{end}}{{else}}
{{end}}`
termUI := new(terminal.TerminalUI)
configRepo := configuration.NewConfigurationDiskRepository()
config, err := configRepo.Get()
if err != nil {
termUI.Failed(fmt.Sprintf("Error loading config. Please reset target (%s) and log in (%s).", terminal.Yellow("cf target"), terminal.Yellow("cf login")), nil)
configRepo.Delete()
os.Exit(1)
return
}
repoLocator := api.NewRepositoryLocator(config)
cmdFactory := commands.NewFactory(termUI, repoLocator)
reqFactory := requirements.NewFactory(termUI, repoLocator)
cmdRunner := commands.NewRunner(reqFactory)
app = cli.NewApp()
app.Name = "cf"
app.Usage = "A command line tool to interact with Cloud Foundry"
app.Version = cf.Version
app.Commands = []cli.Command{
{
Name: "target",
ShortName: "t",
Description: "Set or view the target",
Usage: "cf target <target> --o <organization> --s <space>",
Flags: []cli.Flag{
cli.StringFlag{"o", "", "organization"},
cli.StringFlag{"s", "", "space"},
},
Action: func(c *cli.Context) {
cmd := cmdFactory.NewTarget()
cmdRunner.Run(cmd, c)
},
},
{
Name: "login",
ShortName: "l",
Description: "Log user in",
Usage: "cf login [username]",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewLogin()
cmdRunner.Run(cmd, c)
},
},
{
Name: "set-env",
ShortName: "se",
Description: "Set an environment variable for an application",
Usage: "cf set-env <application> <variable> <value>",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewSetEnv()
cmdRunner.Run(cmd, c)
},
},
{
Name: "logout",
ShortName: "lo",
Description: "Log user out",
Usage: "cf logout",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewLogout()
cmdRunner.Run(cmd, c)
},
},
{
Name: "push",
ShortName: "p",
Description: "Push an application",
Usage: "cf push --name <application> [--domain <domain>] [--host <hostname>] [--instances <num>]\n" +
" [--memory <memory>] [--buildpack <url>] [--no-[re]start] [--path <path to app>]\n" +
" [--stack <stack>]",
Flags: []cli.Flag{
cli.StringFlag{"name", "", "name of the application"},
cli.StringFlag{"domain", "", "domain (for example: cfapps.io)"},
cli.StringFlag{"host", "", "hostname (for example: my-subdomain)"},
cli.IntFlag{"instances", 1, "number of instances"},
cli.StringFlag{"memory", "128", "memory limit (for example: 256, 1G, 1024M)"},
cli.StringFlag{"buildpack", "", "custom buildpack URL (for example: https://github.com/heroku/heroku-buildpack-play.git)"},
cli.BoolFlag{"no-start", "do not start an application after pushing"},
cli.BoolFlag{"no-restart", "do not restart an application after pushing"},
cli.StringFlag{"path", "", "path of application directory or zip file"},
cli.StringFlag{"stack", "", "stack to use"},
},
Action: func(c *cli.Context) {
cmd := cmdFactory.NewPush()
cmdRunner.Run(cmd, c)
},
},
{
Name: "apps",
ShortName: "a",
Description: "List all applications in the currently selected space",
Usage: "cf apps",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewApps()
cmdRunner.Run(cmd, c)
},
},
{
Name: "delete",
ShortName: "d",
Description: "Delete an application",
Usage: "cf delete -f <application>",
Flags: []cli.Flag{
cli.BoolFlag{"f", "force deletion without confirmation"},
},
Action: func(c *cli.Context) {
cmd := cmdFactory.NewDelete()
cmdRunner.Run(cmd, c)
},
},
{
Name: "start",
ShortName: "s",
Description: "Start applications",
Usage: "cf start <application>",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewStart()
cmdRunner.Run(cmd, c)
},
},
{
Name: "stop",
ShortName: "st",
Description: "Stop applications",
Usage: "cf stop <application>",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewStop()
cmdRunner.Run(cmd, c)
},
},
{
Name: "create-service",
ShortName: "cs",
Description: "Create service instance",
Usage: "cf create-service --offering <offering> --plan <plan> --name <service instance name>\n" +
" cf create-service --offering user-provided --name <service name> --parameters \"<comma separated parameter names>\"",
Flags: []cli.Flag{
cli.StringFlag{"name", "", "name of the service instance"},
cli.StringFlag{"offering", "", "name of the service offering to use"},
cli.StringFlag{"plan", "", "name of the service plan to use"},
cli.StringFlag{"parameters", "", "list of comma separated parameter names to use for user-provided services (eg. \"n1,n2\")"},
},
Action: func(c *cli.Context) {
cmd := cmdFactory.NewCreateService()
cmdRunner.Run(cmd, c)
},
},
{
Name: "bind-service",
ShortName: "bs",
Description: "Bind a service instance to an application",
Usage: "cf bind-service --app <application name> --service <service instance name>",
Flags: []cli.Flag{
cli.StringFlag{"app", "", "name of the application"},
cli.StringFlag{"service", "", "name of the service instance to bind to the application"},
},
Action: func(c *cli.Context) {
cmd := cmdFactory.NewBindService()
cmdRunner.Run(cmd, c)
},
},
{
Name: "unbind-service",
ShortName: "us",
Description: "Unbind a service instance from an application",
Usage: "cf unbind-service --app <application name> --service <service instance name>",
Flags: []cli.Flag{
cli.StringFlag{"app", "", "name of the application"},
cli.StringFlag{"service", "", "name of the service instance to unbind from the application"},
},
Action: func(c *cli.Context) {
cmd := cmdFactory.NewUnbindService()
cmdRunner.Run(cmd, c)
},
},
{
Name: "delete-service",
ShortName: "ds",
Description: "Delete a service instance",
Usage: "cf delete-service <service instance name>",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewDeleteService()
cmdRunner.Run(cmd, c)
},
},
{
Name: "routes",
ShortName: "r",
Description: "List all routes",
Usage: "cf routes",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewRoutes()
cmdRunner.Run(cmd, c)
},
},
{
Name: "services",
ShortName: "sv",
Description: "List all services in the currently selected space",
Usage: "cf services [--marketplace]",
Flags: []cli.Flag{
cli.BoolFlag{"marketplace", "use to list available offerings on the marketplace"},
},
Action: func(c *cli.Context) {
var cmd commands.Command
cmd = cmdFactory.NewServices()
if c.Bool("marketplace") {
cmd = cmdFactory.NewMarketplaceServices()
}
cmdRunner.Run(cmd, c)
},
},
{
Name: "stacks",
Description: "List all stacks",
Usage: "cf stacks",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewStacks()
cmdRunner.Run(cmd, c)
},
},
}
return
}
func New() (app *cli.App, err error) {
cli.AppHelpTemplate = `NAME:
{{.Name}} - {{.Usage}}
USAGE:
[environment variables] {{.Name}} [global options] command [command options] [arguments...]
VERSION:
{{.Version}}
COMMANDS:
{{range .Commands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Description}}
{{end}}
GLOBAL OPTIONS:
{{range .Flags}}{{.}}
{{end}}
ENVIRONMENT VARIABLES:
CF_TRACE=true - will output HTTP requests and responses during command
HTTP_PROXY=http://proxy.example.com:8080 - set to your proxy
`
cli.CommandHelpTemplate = `NAME:
{{.Name}} - {{.Description}}
USAGE:
{{.Usage}}{{with .Flags}}
OPTIONS:
{{range .}}{{.}}
{{end}}{{else}}
{{end}}`
termUI := new(terminal.TerminalUI)
configRepo := configuration.NewConfigurationDiskRepository()
config, err := configRepo.Get()
if err != nil {
termUI.Failed(fmt.Sprintf(
"Error loading config. Please reset target (%s) and log in (%s).",
terminal.CommandColor("cf target"),
terminal.CommandColor("cf login"),
))
configRepo.Delete()
os.Exit(1)
return
}
repoLocator := api.NewRepositoryLocator(config)
cmdFactory := commands.NewFactory(termUI, repoLocator)
reqFactory := requirements.NewFactory(termUI, repoLocator)
cmdRunner := commands.NewRunner(reqFactory)
app = cli.NewApp()
app.Name = "cf"
app.Usage = "A command line tool to interact with Cloud Foundry"
app.Version = cf.Version
app.Commands = []cli.Command{
{
Name: "api",
Description: "Set or view target api endpoint",
Usage: "cf api [URL]",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewApi()
cmdRunner.Run(cmd, c)
},
},
{
Name: "app",
Description: "Display health and status for app",
Usage: "cf app APP",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewApp()
cmdRunner.Run(cmd, c)
},
},
{
Name: "apps",
ShortName: "a",
Description: "List all applications in the currently targeted space",
Usage: "cf apps",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewApps()
cmdRunner.Run(cmd, c)
},
},
{
Name: "bind-service",
ShortName: "bs",
Description: "Bind a service instance to an application",
Usage: "cf bind-service --app APP --service SERVICE",
Flags: []cli.Flag{
cli.StringFlag{"app", "", "Which app"},
cli.StringFlag{"service", "", "Which service instance to bind to the app"},
},
Action: func(c *cli.Context) {
cmd := cmdFactory.NewBindService()
cmdRunner.Run(cmd, c)
},
},
{
Name: "create-org",
ShortName: "co",
Description: "Create organization",
Usage: "cf create-org ORG",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewCreateOrganization()
cmdRunner.Run(cmd, c)
},
},
{
Name: "create-service",
ShortName: "cs",
Description: "Create service instance",
Usage: "cf create-service --offering [OFFERING] --plan [PLAN] --name SERVICE\n" +
" cf create-service --offering user-provided --name SERVICE --parameters \"<comma separated parameter names>\"",
Flags: []cli.Flag{
cli.StringFlag{"name", "", "name of the service instance"},
cli.StringFlag{"offering", "", "name of the service offering to use"},
cli.StringFlag{"plan", "", "name of the service plan to use"},
cli.StringFlag{"parameters", "", "list of comma separated parameter names to use for user-provided services (eg. \"n1,n2\")"},
},
Action: func(c *cli.Context) {
cmd := cmdFactory.NewCreateService()
cmdRunner.Run(cmd, c)
},
},
{
Name: "create-space",
Description: "Create a space",
Usage: "cf create-space SPACE",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewCreateSpace()
cmdRunner.Run(cmd, c)
},
},
{
Name: "delete",
ShortName: "d",
Description: "Delete an application",
Usage: "cf delete -f APP",
Flags: []cli.Flag{
cli.BoolFlag{"f", "Force deletion without confirmation"},
},
Action: func(c *cli.Context) {
cmd := cmdFactory.NewDelete()
cmdRunner.Run(cmd, c)
},
},
{
Name: "delete-org",
Description: "Delete an org",
Usage: "cf delete-org ORG",
Flags: []cli.Flag{
cli.BoolFlag{"f", "force deletion without confirmation"},
},
Action: func(c *cli.Context) {
cmd := cmdFactory.NewDeleteOrg()
cmdRunner.Run(cmd, c)
},
},
{
Name: "delete-service",
ShortName: "ds",
Description: "Delete a service instance",
Usage: "cf delete-service SERVICE",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewDeleteService()
cmdRunner.Run(cmd, c)
},
},
{
Name: "delete-space",
Description: "Delete a space",
Usage: "cf delete-space SPACE",
Flags: []cli.Flag{
cli.BoolFlag{"f", "Force deletion without confirmation"},
},
Action: func(c *cli.Context) {
cmd := cmdFactory.NewDeleteSpace()
cmdRunner.Run(cmd, c)
},
},
{
Name: "env",
ShortName: "e",
Description: "Show all env variables for an app",
Usage: "cf env APP",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewEnv()
cmdRunner.Run(cmd, c)
},
},
{
Name: "files",
Description: "Print out a list of files in a directory or the contents of a specific file",
Usage: "cf files APP [PATH]",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewFiles()
cmdRunner.Run(cmd, c)
},
},
{
Name: "login",
ShortName: "l",
Description: "Log user in",
Usage: "cf login [USERNAME] [PASSWORD]\n\n" +
terminal.WarningColor("WARNING:\n Providing your password as a command line option is highly discouraged.\n Your password may be visible to others and may be recorded in your shell history.\n\n") +
"EXAMPLE:\n" +
" cf login (omit username and password to login interactively -- cf will prompt for both)\n" +
" cf login [email protected] pa55woRD (specify username and password to login non-interactively)\n" +
" cf login [email protected] \"my password\" (use quotes for passwords with a space)",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewLogin()
cmdRunner.Run(cmd, c)
},
},
{
Name: "logout",
ShortName: "lo",
Description: "Log user out",
Usage: "cf logout",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewLogout()
cmdRunner.Run(cmd, c)
},
},
{
Name: "logs",
Description: "Show recent logs for CF applications",
Usage: "cf logs APP",
Flags: []cli.Flag{
cli.BoolFlag{"recent", "dump recent logs instead of tailing"},
},
Action: func(c *cli.Context) {
var cmd commands.Command
cmd = cmdFactory.NewLogs()
if c.Bool("recent") {
cmd = cmdFactory.NewRecentLogs()
}
cmdRunner.Run(cmd, c)
},
},
{
Name: "orgs",
ShortName: "o",
Description: "List all organizations",
Usage: "cf orgs",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewListOrganizations()
cmdRunner.Run(cmd, c)
},
},
{
Name: "passwd",
ShortName: "pw",
Description: "Change user password",
Usage: "cf passwd",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewPassword()
cmdRunner.Run(cmd, c)
},
},
{
Name: "push",
ShortName: "p",
Description: "Push an app",
Usage: "cf push --name APP [--domain DOMAIN] [--host HOST] [--instances NUM]\n" +
" [--memory MEMORY] [--buildpack URL] [--no-[re]start] [--path PATH]\n" +
" [--stack STACK]",
Flags: []cli.Flag{
cli.StringFlag{"name", "", "name of the application"},
cli.StringFlag{"domain", "", "domain (for example: cfapps.io)"},
cli.StringFlag{"host", "", "hostname (for example: my-subdomain)"},
cli.IntFlag{"instances", 1, "number of instances"},
cli.StringFlag{"memory", "128", "memory limit (for example: 256, 1G, 1024M)"},
cli.StringFlag{"buildpack", "", "custom buildpack URL (for example: https://github.com/heroku/heroku-buildpack-play.git)"},
cli.BoolFlag{"no-start", "do not start an application after pushing"},
cli.BoolFlag{"no-restart", "do not restart an application after pushing"},
cli.StringFlag{"path", "", "path of application directory or zip file"},
cli.StringFlag{"stack", "", "stack to use"},
},
Action: func(c *cli.Context) {
cmd := cmdFactory.NewPush()
cmdRunner.Run(cmd, c)
},
},
{
Name: "rename",
Description: "Rename an application",
Usage: "cf rename APP NEW_APP",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewRename()
cmdRunner.Run(cmd, c)
},
},
{
Name: "rename-org",
Description: "Rename an organization",
Usage: "cf rename-org ORG NEW_ORG",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewRenameOrg()
cmdRunner.Run(cmd, c)
},
},
{
Name: "rename-space",
Description: "Rename a space",
Usage: "cf rename-space SPACE NEW_SPACE",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewRenameSpace()
cmdRunner.Run(cmd, c)
},
},
{
Name: "restart",
ShortName: "rs",
Description: "Restart an application",
Usage: "cf restart APP",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewRestart()
cmdRunner.Run(cmd, c)
},
},
{
Name: "routes",
ShortName: "r",
Description: "List all routes",
Usage: "cf routes",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewRoutes()
cmdRunner.Run(cmd, c)
},
},
{
Name: "services",
ShortName: "s",
Description: "List all services in the currently targeted space",
Usage: "cf services [--marketplace]",
Flags: []cli.Flag{
cli.BoolFlag{"marketplace", "List available offerings on the marketplace"},
},
Action: func(c *cli.Context) {
var cmd commands.Command
cmd = cmdFactory.NewServices()
if c.Bool("marketplace") {
cmd = cmdFactory.NewMarketplaceServices()
}
cmdRunner.Run(cmd, c)
},
},
{
Name: "set-env",
ShortName: "se",
Description: "Set an env variable for an app",
Usage: "cf set-env APP NAME VALUE",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewSetEnv()
cmdRunner.Run(cmd, c)
},
},
{
Name: "spaces",
Description: "List all spaces in an org",
Usage: "cf spaces",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewSpaces()
cmdRunner.Run(cmd, c)
},
},
{
Name: "stacks",
Description: "List all stacks",
Usage: "cf stacks",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewStacks()
cmdRunner.Run(cmd, c)
},
},
{
Name: "start",
ShortName: "st",
Description: "Start an app",
Usage: "cf start APP",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewStart()
cmdRunner.Run(cmd, c)
},
},
{
Name: "stop",
ShortName: "sp",
Description: "Stop an app",
Usage: "cf stop APP",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewStop()
cmdRunner.Run(cmd, c)
},
},
{
Name: "target",
ShortName: "t",
Description: "Set or view the targeted org or space",
Usage: "cf target [-o ORG] [-s SPACE]",
Flags: []cli.Flag{
cli.StringFlag{"o", "", "organization"},
cli.StringFlag{"s", "", "space"},
},
Action: func(c *cli.Context) {
cmd := cmdFactory.NewTarget()
cmdRunner.Run(cmd, c)
},
},
{
Name: "unbind-service",
ShortName: "us",
Description: "Unbind a service instance from an application",
Usage: "cf unbind-service --app APP --service SERVICE",
Flags: []cli.Flag{
cli.StringFlag{"app", "", "name of the application"},
cli.StringFlag{"service", "", "name of the service instance to unbind from the application"},
},
Action: func(c *cli.Context) {
cmd := cmdFactory.NewUnbindService()
cmdRunner.Run(cmd, c)
},
},
{
Name: "unset-env",
Description: "Remove an env variable",
Usage: "cf unset-env APP NAME",
Action: func(c *cli.Context) {
cmd := cmdFactory.NewUnsetEnv()
cmdRunner.Run(cmd, c)
},
},
}
return
}