func (req LoginRequirement) Execute() (err error) {
if !req.config.IsLoggedIn() {
req.ui.Say("Not logged in. Use '%s' to log in.", terminal.Yellow("cf login"))
err = errors.New("You need to be logged in")
return
}
return
}
func (req SpaceRequirement) Execute() (err error) {
if !req.config.HasOrganization() {
message := fmt.Sprintf("No org and space targeted. See '%s' to target an org and space.",
terminal.Yellow("cf target --o ORGNAME --s SPACENAME"))
req.ui.Failed(message, nil)
err = errors.New("No org and space targeted")
return
}
if !req.config.HasSpace() {
message := fmt.Sprintf("No space targeted. Use '%s' to target a space.", terminal.Yellow("cf target -s"))
req.ui.Failed(message, nil)
err = errors.New("No space targeted")
return
}
return
}
func coloredState(state string) (colored string) {
switch state {
case "started":
colored = term.Green("running")
case "stopped":
colored = term.Yellow("stopped")
default:
colored = term.Red(state)
}
return
}
func (t Target) setNewTarget(target string) {
t.ui.Say("Setting target to %s...", term.Yellow(target))
request, err := api.NewRequest("GET", target+"/v2/info", "", nil)
if err != nil {
t.ui.Failed("URL invalid.", err)
return
}
scheme := request.URL.Scheme
if scheme != "http" && scheme != "https" {
t.ui.Failed("API Endpoints should start with https:// or http://", nil)
return
}
serverResponse := new(InfoResponse)
_, err = api.PerformRequestAndParseResponse(request, &serverResponse)
if err != nil {
t.ui.Failed("", err)
return
}
err = t.saveTarget(target, serverResponse)
if err != nil {
t.ui.Failed("Error saving configuration", err)
return
}
t.ui.Ok()
if scheme == "http" {
t.ui.Say(term.Magenta("\nWarning: Insecure http API Endpoint detected. Secure https API Endpoints are recommended.\n"))
}
t.ui.ShowConfiguration(t.config)
}
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
}