func NewDependency() Dependency {
deps := Dependency{}
deps.TeePrinter = terminal.NewTeePrinter()
deps.Ui = terminal.NewUI(os.Stdin, deps.TeePrinter)
deps.ManifestRepo = manifest.NewManifestDiskRepository()
errorHandler := func(err error) {
if err != nil {
deps.Ui.Failed(fmt.Sprintf("Config error: %s", err))
}
}
deps.Config = core_config.NewRepositoryFromFilepath(config_helpers.DefaultFilePath(), errorHandler)
deps.PluginConfig = plugin_config.NewPluginConfig(errorHandler)
deps.Detector = &detection.JibberJabberDetector{}
terminal.UserAskedForColors = deps.Config.ColorEnabled()
terminal.InitColorSupport()
if os.Getenv("CF_TRACE") != "" {
trace.Logger = trace.NewLogger(os.Getenv("CF_TRACE"))
} else {
trace.Logger = trace.NewLogger(deps.Config.Trace())
}
deps.Gateways = map[string]net.Gateway{
"auth": net.NewUAAGateway(deps.Config, deps.Ui),
"cloud-controller": net.NewCloudControllerGateway(deps.Config, time.Now, deps.Ui),
"uaa": net.NewUAAGateway(deps.Config, deps.Ui),
}
deps.RepoLocator = api.NewRepositoryLocator(deps.Config, deps.Gateways)
deps.PluginModels = &pluginModels{Application: nil}
return deps
}
func main() {
defer handlePanics(deps.teePrinter)
defer deps.configRepo.Close()
rpcService := newCliRpcServer(deps.teePrinter, deps.teePrinter)
cmdFactory := command_factory.NewFactory(deps.termUI, deps.configRepo, deps.manifestRepo, deps.apiRepoLocator, deps.pluginConfig, rpcService)
requirementsFactory := requirements.NewFactory(deps.termUI, deps.configRepo, deps.apiRepoLocator)
cmdRunner := command_runner.NewRunner(cmdFactory, requirementsFactory, deps.termUI)
pluginsConfig := plugin_config.NewPluginConfig(func(err error) { panic(err) })
pluginList := pluginsConfig.Plugins()
var badFlags string
metaDatas := cmdFactory.CommandMetadatas()
//return only metadata for current command
metaDatas = mergePluginMetaData(metaDatas, pluginList)
if len(os.Args) > 1 {
flags := cmdFactory.GetCommandFlags(os.Args[1])
totalArgs, _ := cmdFactory.GetCommandTotalArgs(os.Args[1])
if args2skip := totalArgs + 2; len(os.Args) >= args2skip {
badFlags = matchArgAndFlags(flags, os.Args[args2skip:])
}
if badFlags != "" {
badFlags = badFlags + "\n\n"
}
}
injectHelpTemplate(badFlags)
theApp := app.NewApp(cmdRunner, metaDatas...)
rpcService.SetTheApp(theApp)
//command `cf` without argument
if len(os.Args) == 1 || os.Args[1] == "help" || requestHelp(os.Args[2:]) {
theApp.Run(os.Args)
} else if cmdFactory.CheckIfCoreCmdExists(os.Args[1]) {
callCoreCommand(os.Args[0:], theApp)
} else {
// run each plugin and find the method/
// run method if exist
ran := rpc.RunMethodIfExists(rpcService, os.Args[1:], pluginList)
if !ran {
theApp.Run(os.Args)
}
}
}
func setupDependencies() (deps *cliDependencies) {
deps = new(cliDependencies)
deps.teePrinter = terminal.NewTeePrinter()
deps.termUI = terminal.NewUI(os.Stdin, deps.teePrinter)
deps.manifestRepo = manifest.NewManifestDiskRepository()
errorHandler := func(err error) {
if err != nil {
deps.termUI.Failed(fmt.Sprintf("Config error: %s", err))
}
}
deps.configRepo = core_config.NewRepositoryFromFilepath(config_helpers.DefaultFilePath(), errorHandler)
deps.pluginConfig = plugin_config.NewPluginConfig(errorHandler)
deps.detector = &detection.JibberJabberDetector{}
T = Init(deps.configRepo, deps.detector)
terminal.UserAskedForColors = deps.configRepo.ColorEnabled()
terminal.InitColorSupport()
if os.Getenv("CF_TRACE") != "" {
trace.Logger = trace.NewLogger(os.Getenv("CF_TRACE"))
} else {
trace.Logger = trace.NewLogger(deps.configRepo.Trace())
}
deps.gateways = map[string]net.Gateway{
"auth": net.NewUAAGateway(deps.configRepo, deps.termUI),
"cloud-controller": net.NewCloudControllerGateway(deps.configRepo, time.Now, deps.termUI),
"uaa": net.NewUAAGateway(deps.configRepo, deps.termUI),
}
deps.apiRepoLocator = api.NewRepositoryLocator(deps.configRepo, deps.gateways)
return
}
func newAppPresenter() (presenter appPresenter) {
pluginConfig := plugin_config.NewPluginConfig(func(err error) {
//fail silently when running help
})
plugins := pluginConfig.Plugins()
maxNameLen := command_registry.Commands.MaxCommandNameLength()
maxNameLen = maxPluginCommandNameLength(plugins, maxNameLen)
presentCommand := func(commandName string) (presenter cmdPresenter) {
cmd := command_registry.Commands.FindCommand(commandName)
presenter.Name = cmd.MetaData().Name
padding := strings.Repeat(" ", maxNameLen-utf8.RuneCountInString(presenter.Name))
presenter.Name = presenter.Name + padding
presenter.Description = cmd.MetaData().Description
return
}
presentPluginCommands := func() []cmdPresenter {
var presenters []cmdPresenter
var pluginPresenter cmdPresenter
for _, pluginMetadata := range plugins {
for _, cmd := range pluginMetadata.Commands {
pluginPresenter.Name = cmd.Name
padding := strings.Repeat(" ", maxNameLen-utf8.RuneCountInString(pluginPresenter.Name))
pluginPresenter.Name = pluginPresenter.Name + padding
pluginPresenter.Description = cmd.HelpText
presenters = append(presenters, pluginPresenter)
}
}
return presenters
}
presenter.Name = os.Args[0]
presenter.Usage = T("A command line tool to interact with Cloud Foundry")
presenter.Version = cf.Version + "-" + cf.BuiltOnDate
presenter.Commands = []groupedCommands{
{
Name: T("GETTING STARTED"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("help"),
presentCommand("version"),
presentCommand("login"),
presentCommand("logout"),
presentCommand("passwd"),
presentCommand("target"),
}, {
presentCommand("api"),
presentCommand("auth"),
},
},
}, {
Name: T("APPS"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("apps"),
presentCommand("app"),
}, {
presentCommand("push"),
presentCommand("scale"),
presentCommand("delete"),
presentCommand("rename"),
}, {
presentCommand("start"),
presentCommand("stop"),
presentCommand("restart"),
presentCommand("restage"),
presentCommand("restart-app-instance"),
}, {
presentCommand("events"),
presentCommand("files"),
presentCommand("logs"),
}, {
presentCommand("env"),
presentCommand("set-env"),
presentCommand("unset-env"),
}, {
presentCommand("stacks"),
presentCommand("stack"),
}, {
presentCommand("copy-source"),
}, {
presentCommand("create-app-manifest"),
}, {
presentCommand("get-health-check"),
presentCommand("set-health-check"),
presentCommand("enable-ssh"),
presentCommand("disable-ssh"),
presentCommand("ssh-enabled"),
presentCommand("ssh"),
},
},
}, {
Name: T("SERVICES"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("marketplace"),
presentCommand("services"),
presentCommand("service"),
}, {
presentCommand("create-service"),
presentCommand("update-service"),
presentCommand("delete-service"),
presentCommand("rename-service"),
}, {
presentCommand("create-service-key"),
presentCommand("service-keys"),
presentCommand("service-key"),
presentCommand("delete-service-key"),
}, {
presentCommand("bind-service"),
presentCommand("unbind-service"),
}, {
presentCommand("bind-route-service"),
presentCommand("unbind-route-service"),
}, {
presentCommand("create-user-provided-service"),
presentCommand("update-user-provided-service"),
},
},
}, {
Name: T("ORGS"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("orgs"),
presentCommand("org"),
}, {
presentCommand("create-org"),
presentCommand("delete-org"),
presentCommand("rename-org"),
},
},
}, {
Name: T("SPACES"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("spaces"),
presentCommand("space"),
}, {
presentCommand("create-space"),
presentCommand("delete-space"),
presentCommand("rename-space"),
}, {
presentCommand("allow-space-ssh"),
presentCommand("disallow-space-ssh"),
presentCommand("space-ssh-allowed"),
},
},
}, {
Name: T("DOMAINS"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("domains"),
presentCommand("create-domain"),
presentCommand("delete-domain"),
presentCommand("create-shared-domain"),
presentCommand("delete-shared-domain"),
},
},
}, {
Name: T("ROUTES"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("routes"),
presentCommand("create-route"),
presentCommand("check-route"),
presentCommand("map-route"),
presentCommand("unmap-route"),
presentCommand("delete-route"),
presentCommand("delete-orphaned-routes"),
},
},
}, {
Name: T("ROUTER GROUPS"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("router-groups"),
},
},
}, {
Name: T("BUILDPACKS"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("buildpacks"),
presentCommand("create-buildpack"),
presentCommand("update-buildpack"),
presentCommand("rename-buildpack"),
presentCommand("delete-buildpack"),
},
},
}, {
Name: T("USER ADMIN"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("create-user"),
presentCommand("delete-user"),
}, {
presentCommand("org-users"),
presentCommand("set-org-role"),
presentCommand("unset-org-role"),
}, {
presentCommand("space-users"),
presentCommand("set-space-role"),
presentCommand("unset-space-role"),
},
},
}, {
Name: T("ORG ADMIN"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("quotas"),
presentCommand("quota"),
presentCommand("set-quota"),
}, {
presentCommand("create-quota"),
presentCommand("delete-quota"),
presentCommand("update-quota"),
},
{
presentCommand("share-private-domain"),
presentCommand("unshare-private-domain"),
},
},
}, {
Name: T("SPACE ADMIN"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("space-quotas"),
presentCommand("space-quota"),
presentCommand("create-space-quota"),
presentCommand("update-space-quota"),
presentCommand("delete-space-quota"),
presentCommand("set-space-quota"),
presentCommand("unset-space-quota"),
},
},
}, {
Name: T("SERVICE ADMIN"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("service-auth-tokens"),
presentCommand("create-service-auth-token"),
presentCommand("update-service-auth-token"),
presentCommand("delete-service-auth-token"),
}, {
presentCommand("service-brokers"),
presentCommand("create-service-broker"),
presentCommand("update-service-broker"),
presentCommand("delete-service-broker"),
presentCommand("rename-service-broker"),
}, {
presentCommand("migrate-service-instances"),
presentCommand("purge-service-offering"),
presentCommand("purge-service-instance"),
}, {
presentCommand("service-access"),
presentCommand("enable-service-access"),
presentCommand("disable-service-access"),
},
},
}, {
Name: T("SECURITY GROUP"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("security-group"),
presentCommand("security-groups"),
presentCommand("create-security-group"),
presentCommand("update-security-group"),
presentCommand("delete-security-group"),
presentCommand("bind-security-group"),
presentCommand("unbind-security-group"),
}, {
presentCommand("bind-staging-security-group"),
presentCommand("staging-security-groups"),
presentCommand("unbind-staging-security-group"),
}, {
presentCommand("bind-running-security-group"),
presentCommand("running-security-groups"),
presentCommand("unbind-running-security-group"),
},
},
}, {
Name: T("ENVIRONMENT VARIABLE GROUPS"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("running-environment-variable-group"),
presentCommand("staging-environment-variable-group"),
presentCommand("set-staging-environment-variable-group"),
presentCommand("set-running-environment-variable-group"),
},
},
},
{
Name: T("FEATURE FLAGS"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("feature-flags"),
presentCommand("feature-flag"),
presentCommand("enable-feature-flag"),
presentCommand("disable-feature-flag"),
},
},
}, {
Name: T("ADVANCED"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("curl"),
presentCommand("config"),
presentCommand("oauth-token"),
presentCommand("ssh-code"),
},
},
}, {
Name: T("ADD/REMOVE PLUGIN REPOSITORY"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("add-plugin-repo"),
presentCommand("remove-plugin-repo"),
presentCommand("list-plugin-repos"),
presentCommand("repo-plugins"),
},
},
}, {
Name: T("ADD/REMOVE PLUGIN"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("plugins"),
presentCommand("install-plugin"),
presentCommand("uninstall-plugin"),
},
},
}, {
Name: T("INSTALLED PLUGIN COMMANDS"),
CommandSubGroups: [][]cmdPresenter{
presentPluginCommands(),
},
},
}
return
}
func NewDependency(logger trace.Printer) Dependency {
deps := Dependency{}
deps.TeePrinter = terminal.NewTeePrinter()
deps.Ui = terminal.NewUI(os.Stdin, deps.TeePrinter, logger)
errorHandler := func(err error) {
if err != nil {
deps.Ui.Failed(fmt.Sprintf("Config error: %s", err))
}
}
deps.Config = core_config.NewRepositoryFromFilepath(config_helpers.DefaultFilePath(), errorHandler)
deps.ManifestRepo = manifest.NewManifestDiskRepository()
deps.AppManifest = manifest.NewGenerator()
deps.PluginConfig = plugin_config.NewPluginConfig(errorHandler)
terminal.UserAskedForColors = deps.Config.ColorEnabled()
terminal.InitColorSupport()
deps.Gateways = map[string]net.Gateway{
"cloud-controller": net.NewCloudControllerGateway(deps.Config, time.Now, deps.Ui, logger),
"uaa": net.NewUAAGateway(deps.Config, deps.Ui, logger),
"routing-api": net.NewRoutingApiGateway(deps.Config, time.Now, deps.Ui, logger),
}
deps.RepoLocator = api.NewRepositoryLocator(deps.Config, deps.Gateways, logger)
deps.PluginModels = &PluginModels{Application: nil}
deps.PlanBuilder = plan_builder.NewBuilder(
deps.RepoLocator.GetServicePlanRepository(),
deps.RepoLocator.GetServicePlanVisibilityRepository(),
deps.RepoLocator.GetOrganizationRepository(),
)
deps.ServiceBuilder = service_builder.NewBuilder(
deps.RepoLocator.GetServiceRepository(),
deps.PlanBuilder,
)
deps.BrokerBuilder = broker_builder.NewBuilder(
deps.RepoLocator.GetServiceBrokerRepository(),
deps.ServiceBuilder,
)
deps.PluginRepo = plugin_repo.NewPluginRepo()
deps.ServiceHandler = actors.NewServiceHandler(
deps.RepoLocator.GetOrganizationRepository(),
deps.BrokerBuilder,
deps.ServiceBuilder,
)
deps.ServicePlanHandler = actors.NewServicePlanHandler(
deps.RepoLocator.GetServicePlanRepository(),
deps.RepoLocator.GetServicePlanVisibilityRepository(),
deps.RepoLocator.GetOrganizationRepository(),
deps.PlanBuilder,
deps.ServiceBuilder,
)
deps.WordGenerator = generator.NewWordGenerator()
deps.AppZipper = app_files.ApplicationZipper{}
deps.AppFiles = app_files.ApplicationFiles{}
deps.PushActor = actors.NewPushActor(deps.RepoLocator.GetApplicationBitsRepository(), deps.AppZipper, deps.AppFiles)
deps.ChecksumUtil = utils.NewSha1Checksum("")
deps.Logger = logger
return deps
}
func newAppPresenter(app *cli.App) (presenter appPresenter) {
maxNameLen := 0
for _, cmd := range app.Commands {
name := presentCmdName(cmd)
if utf8.RuneCountInString(name) > maxNameLen {
maxNameLen = len(name)
}
}
presentCommand := func(commandName string) (presenter cmdPresenter) {
cmd := app.Command(commandName)
presenter.Name = presentCmdName(*cmd)
padding := strings.Repeat(" ", maxNameLen-utf8.RuneCountInString(presenter.Name))
presenter.Name = presenter.Name + padding
presenter.Description = cmd.Description
return
}
presentNonCodegangstaCommand := func(commandName string) (presenter cmdPresenter) {
cmd := command_registry.Commands.FindCommand(commandName)
presenter.Name = cmd.MetaData().Name
padding := strings.Repeat(" ", maxNameLen-utf8.RuneCountInString(presenter.Name))
presenter.Name = presenter.Name + padding
presenter.Description = cmd.MetaData().Description
return
}
presentPluginCommands := func() []cmdPresenter {
pluginConfig := plugin_config.NewPluginConfig(func(err error) {
//fail silently when running help?
})
plugins := pluginConfig.Plugins()
var presenters []cmdPresenter
var pluginPresenter cmdPresenter
for _, pluginMetadata := range plugins {
for _, cmd := range pluginMetadata.Commands {
if cmd.Alias == "" {
pluginPresenter.Name = cmd.Name
} else {
pluginPresenter.Name = cmd.Name + ", " + cmd.Alias
}
padding := strings.Repeat(" ", maxNameLen-utf8.RuneCountInString(pluginPresenter.Name))
pluginPresenter.Name = pluginPresenter.Name + padding
pluginPresenter.Description = cmd.HelpText
presenters = append(presenters, pluginPresenter)
}
}
return presenters
}
presenter.Name = app.Name
presenter.Flags = app.Flags
presenter.Usage = app.Usage
presenter.Version = app.Version
presenter.Compiled = app.Compiled
presenter.Commands = []groupedCommands{
{
Name: T("GETTING STARTED"),
CommandSubGroups: [][]cmdPresenter{
{
presentNonCodegangstaCommand("login"),
presentNonCodegangstaCommand("logout"),
presentNonCodegangstaCommand("passwd"),
presentNonCodegangstaCommand("target"),
}, {
presentNonCodegangstaCommand("api"),
presentNonCodegangstaCommand("auth"),
},
},
}, {
Name: T("APPS"),
CommandSubGroups: [][]cmdPresenter{
{
presentNonCodegangstaCommand("apps"),
presentNonCodegangstaCommand("app"),
}, {
presentCommand("push"), //needs start/restart ...
presentCommand("scale"), //needs stop/restart
presentNonCodegangstaCommand("delete"),
presentNonCodegangstaCommand("rename"),
}, {
presentCommand("start"),
presentCommand("stop"),
presentCommand("restart"), //needs start
presentCommand("restage"),
presentCommand("restart-app-instance"),
}, {
presentNonCodegangstaCommand("events"),
presentNonCodegangstaCommand("files"),
presentNonCodegangstaCommand("logs"),
}, {
presentNonCodegangstaCommand("env"),
presentNonCodegangstaCommand("set-env"),
presentNonCodegangstaCommand("unset-env"),
}, {
presentNonCodegangstaCommand("stacks"),
presentNonCodegangstaCommand("stack"),
}, {
presentCommand("copy-source"),
}, {
presentNonCodegangstaCommand("create-app-manifest"),
},
},
}, {
Name: T("SERVICES"),
CommandSubGroups: [][]cmdPresenter{
{
presentNonCodegangstaCommand("marketplace"),
presentNonCodegangstaCommand("services"),
presentNonCodegangstaCommand("service"),
}, {
presentNonCodegangstaCommand("create-service"),
presentCommand("update-service"),
presentNonCodegangstaCommand("delete-service"),
presentNonCodegangstaCommand("rename-service"),
}, {
presentCommand("create-service-key"),
presentCommand("service-keys"),
presentCommand("service-key"),
presentCommand("delete-service-key"),
}, {
presentCommand("bind-service"),
presentCommand("unbind-service"),
}, {
presentCommand("create-user-provided-service"),
presentCommand("update-user-provided-service"),
},
},
}, {
Name: T("ORGS"),
CommandSubGroups: [][]cmdPresenter{
{
presentNonCodegangstaCommand("orgs"),
presentNonCodegangstaCommand("org"),
}, {
presentNonCodegangstaCommand("create-org"),
presentNonCodegangstaCommand("delete-org"),
presentNonCodegangstaCommand("rename-org"),
},
},
}, {
Name: T("SPACES"),
CommandSubGroups: [][]cmdPresenter{
{
presentNonCodegangstaCommand("spaces"),
presentNonCodegangstaCommand("space"),
}, {
presentCommand("create-space"),
presentNonCodegangstaCommand("delete-space"),
presentNonCodegangstaCommand("rename-space"),
},
},
}, {
Name: T("DOMAINS"),
CommandSubGroups: [][]cmdPresenter{
{
presentNonCodegangstaCommand("domains"),
presentNonCodegangstaCommand("create-domain"),
presentNonCodegangstaCommand("delete-domain"),
presentNonCodegangstaCommand("create-shared-domain"),
presentNonCodegangstaCommand("delete-shared-domain"),
},
},
}, {
Name: T("ROUTES"),
CommandSubGroups: [][]cmdPresenter{
{
presentNonCodegangstaCommand("routes"),
presentCommand("create-route"),
presentNonCodegangstaCommand("check-route"),
presentCommand("map-route"),
presentNonCodegangstaCommand("unmap-route"),
presentNonCodegangstaCommand("delete-route"),
presentNonCodegangstaCommand("delete-orphaned-routes"),
},
},
}, {
Name: T("BUILDPACKS"),
CommandSubGroups: [][]cmdPresenter{
{
presentNonCodegangstaCommand("buildpacks"),
presentNonCodegangstaCommand("create-buildpack"),
presentNonCodegangstaCommand("update-buildpack"),
presentNonCodegangstaCommand("rename-buildpack"),
presentNonCodegangstaCommand("delete-buildpack"),
},
},
}, {
Name: T("USER ADMIN"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("create-user"),
presentNonCodegangstaCommand("delete-user"),
}, {
presentNonCodegangstaCommand("org-users"),
presentNonCodegangstaCommand("set-org-role"),
presentNonCodegangstaCommand("unset-org-role"),
}, {
presentNonCodegangstaCommand("space-users"),
presentCommand("set-space-role"),
presentNonCodegangstaCommand("unset-space-role"),
},
},
}, {
Name: T("ORG ADMIN"),
CommandSubGroups: [][]cmdPresenter{
{
presentNonCodegangstaCommand("quotas"),
presentNonCodegangstaCommand("quota"),
presentNonCodegangstaCommand("set-quota"),
}, {
presentNonCodegangstaCommand("create-quota"),
presentNonCodegangstaCommand("delete-quota"),
presentNonCodegangstaCommand("update-quota"),
},
{
presentNonCodegangstaCommand("share-private-domain"),
presentNonCodegangstaCommand("unshare-private-domain"),
},
},
}, {
Name: T("SPACE ADMIN"),
CommandSubGroups: [][]cmdPresenter{
{
presentNonCodegangstaCommand("space-quotas"),
presentNonCodegangstaCommand("space-quota"),
presentNonCodegangstaCommand("create-space-quota"),
presentNonCodegangstaCommand("update-space-quota"),
presentNonCodegangstaCommand("delete-space-quota"),
presentNonCodegangstaCommand("set-space-quota"),
presentNonCodegangstaCommand("unset-space-quota"),
},
},
}, {
Name: T("SERVICE ADMIN"),
CommandSubGroups: [][]cmdPresenter{
{
presentNonCodegangstaCommand("service-auth-tokens"),
presentNonCodegangstaCommand("create-service-auth-token"),
presentNonCodegangstaCommand("update-service-auth-token"),
presentNonCodegangstaCommand("delete-service-auth-token"),
}, {
presentNonCodegangstaCommand("service-brokers"),
presentNonCodegangstaCommand("create-service-broker"),
presentNonCodegangstaCommand("update-service-broker"),
presentNonCodegangstaCommand("delete-service-broker"),
presentNonCodegangstaCommand("rename-service-broker"),
}, {
presentNonCodegangstaCommand("migrate-service-instances"),
presentNonCodegangstaCommand("purge-service-offering"),
}, {
presentCommand("service-access"),
presentCommand("enable-service-access"),
presentCommand("disable-service-access"),
},
},
}, {
Name: T("SECURITY GROUP"),
CommandSubGroups: [][]cmdPresenter{
{
presentNonCodegangstaCommand("security-group"),
presentNonCodegangstaCommand("security-groups"),
presentNonCodegangstaCommand("create-security-group"),
presentNonCodegangstaCommand("update-security-group"),
presentNonCodegangstaCommand("delete-security-group"),
presentCommand("bind-security-group"),
presentCommand("unbind-security-group"),
}, {
presentCommand("bind-staging-security-group"),
presentCommand("staging-security-groups"),
presentCommand("unbind-staging-security-group"),
}, {
presentCommand("bind-running-security-group"),
presentCommand("running-security-groups"),
presentCommand("unbind-running-security-group"),
},
},
}, {
Name: T("ENVIRONMENT VARIABLE GROUPS"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("running-environment-variable-group"),
presentCommand("staging-environment-variable-group"),
presentCommand("set-staging-environment-variable-group"),
presentCommand("set-running-environment-variable-group"),
},
},
},
{
Name: T("FEATURE FLAGS"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("feature-flags"),
presentCommand("feature-flag"),
presentCommand("enable-feature-flag"),
presentCommand("disable-feature-flag"),
},
},
}, {
Name: T("ADVANCED"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("curl"),
presentCommand("config"),
presentCommand("oauth-token"),
},
},
}, {
Name: T("ADD/REMOVE PLUGIN REPOSITORY"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("add-plugin-repo"),
presentCommand("remove-plugin-repo"),
presentCommand("list-plugin-repos"),
presentCommand("repo-plugins"),
},
},
}, {
Name: T("ADD/REMOVE PLUGIN"),
CommandSubGroups: [][]cmdPresenter{
{
presentCommand("plugins"),
presentCommand("install-plugin"),
presentCommand("uninstall-plugin"),
},
},
}, {
Name: T("INSTALLED PLUGIN COMMANDS"),
CommandSubGroups: [][]cmdPresenter{
presentPluginCommands(),
},
},
}
return
}
func main() {
commands_loader.Load()
defer handlePanics(deps.TeePrinter)
defer deps.Config.Close()
//handles `cf` | `cf -h` || `cf -help`
if len(os.Args) == 1 || os.Args[1] == "--help" || os.Args[1] == "-help" ||
os.Args[1] == "--h" || os.Args[1] == "-h" {
help.ShowHelp(help.GetHelpTemplate())
os.Exit(0)
}
//handle `cf -v` for cf version
if len(os.Args) == 2 && (os.Args[1] == "-v" || os.Args[1] == "--version") {
deps.Ui.Say(os.Args[0] + " version " + cf.Version + "-" + cf.BuiltOnDate)
os.Exit(0)
}
//handle `cf --build`
if len(os.Args) == 2 && (os.Args[1] == "--build" || os.Args[1] == "-b") {
deps.Ui.Say(T("{{.CFName}} was built with Go version: {{.GoVersion}}",
map[string]interface{}{
"CFName": os.Args[0],
"GoVersion": runtime.Version(),
}))
os.Exit(0)
}
//handles `cf [COMMAND] -h ...`
//rearrage args to `cf help COMMAND` and let `command help` to print out usage
if requestHelp(os.Args[2:]) {
os.Args[2] = os.Args[1]
os.Args[1] = "help"
}
//run core command
cmd := os.Args[1]
if cmdRegistry.CommandExists(cmd) {
meta := cmdRegistry.FindCommand(os.Args[1]).MetaData()
fc := flags.NewFlagContext(meta.Flags)
fc.SkipFlagParsing(meta.SkipFlagParsing)
err := fc.Parse(os.Args[2:]...)
if err != nil {
deps.Ui.Failed("Incorrect Usage\n\n" + err.Error() + "\n\n" + cmdRegistry.CommandUsage(cmd))
}
cmdRegistry.SetCommand(cmdRegistry.FindCommand(cmd).SetDependency(deps, false))
cfCmd := cmdRegistry.FindCommand(cmd)
reqs, err := cfCmd.Requirements(requirements.NewFactory(deps.Ui, deps.Config, deps.RepoLocator), fc)
if err != nil {
deps.Ui.Failed(err.Error())
}
for _, r := range reqs {
if !r.Execute() {
os.Exit(1)
}
}
cfCmd.Execute(fc)
os.Exit(0)
}
//non core command, try plugin command
rpcService := newCliRpcServer(deps.TeePrinter, deps.TeePrinter)
pluginsConfig := plugin_config.NewPluginConfig(func(err error) { deps.Ui.Failed(fmt.Sprintf("Error read/writing plugin config: %s, ", err.Error())) })
pluginList := pluginsConfig.Plugins()
ran := rpc.RunMethodIfExists(rpcService, os.Args[1:], pluginList)
if !ran {
deps.Ui.Say("'" + os.Args[1] + T("' is not a registered command. See 'cf help'"))
os.Exit(1)
}
}
func main() {
commands_loader.Load()
defer handlePanics(deps.TeePrinter)
defer deps.Config.Close()
//////////////// non-codegangsta path ///////////////////////
//handles `cf` | `cf -h` || `cf -help`
if len(os.Args) == 1 || os.Args[1] == "--help" || os.Args[1] == "-help" ||
os.Args[1] == "--h" || os.Args[1] == "-h" {
help.ShowHelp(help.GetHelpTemplate())
os.Exit(0)
}
//handle `cf -v` for cf version
if len(os.Args) == 2 && os.Args[1] == "-v" {
deps.Ui.Say(os.Args[0] + " version " + cf.Version + "-" + cf.BuiltOnDate)
os.Exit(0)
}
//handles `cf [COMMAND] -h ...`
//rearrage args to `cf help COMMAND` and let `command help` to print out usage
if requestHelp(os.Args[2:]) {
os.Args[2] = os.Args[1]
os.Args[1] = "help"
}
if len(os.Args) > 1 {
cmd := os.Args[1]
if cmdRegistry.CommandExists(cmd) {
meta := cmdRegistry.FindCommand(os.Args[1]).MetaData()
fc := flags.NewFlagContext(meta.Flags)
fc.SkipFlagParsing(meta.SkipFlagParsing)
if requestHelp(os.Args[2:]) {
deps.Ui.Say(cmdRegistry.CommandUsage(cmd))
os.Exit(0)
} else {
err := fc.Parse(os.Args[2:]...)
if err != nil {
deps.Ui.Failed("Incorrect Usage\n\n" + err.Error() + "\n\n" + cmdRegistry.CommandUsage(cmd))
}
}
cmdRegistry.SetCommand(cmdRegistry.FindCommand(cmd).SetDependency(deps, false))
cfCmd := cmdRegistry.FindCommand(cmd)
reqs, err := cfCmd.Requirements(requirements.NewFactory(deps.Ui, deps.Config, deps.RepoLocator), fc)
if err != nil {
deps.Ui.Failed(err.Error())
}
for _, r := range reqs {
if !r.Execute() {
os.Exit(1)
}
}
cfCmd.Execute(fc)
os.Exit(0)
}
}
//////////////////////////////////////////
rpcService := newCliRpcServer(deps.TeePrinter, deps.TeePrinter)
cmdFactory := command_factory.NewFactory(deps.Ui, deps.Config, deps.ManifestRepo, deps.RepoLocator, deps.PluginConfig, rpcService)
requirementsFactory := requirements.NewFactory(deps.Ui, deps.Config, deps.RepoLocator)
cmdRunner := command_runner.NewRunner(cmdFactory, requirementsFactory, deps.Ui)
pluginsConfig := plugin_config.NewPluginConfig(func(err error) { deps.Ui.Failed(fmt.Sprintf("Error read/writing plugin config: %s, ", err.Error())) })
pluginList := pluginsConfig.Plugins()
var badFlags string
metaDatas := cmdFactory.CommandMetadatas()
//return only metadata for current command
metaDatas = mergePluginMetaData(metaDatas, pluginList)
if len(os.Args) > 1 {
flags := cmdFactory.GetCommandFlags(os.Args[1])
totalArgs, _ := cmdFactory.GetCommandTotalArgs(os.Args[1])
if args2skip := totalArgs + 2; len(os.Args) >= args2skip {
badFlags = matchArgAndFlags(flags, os.Args[args2skip:])
}
if badFlags != "" {
badFlags = badFlags + "\n\n"
}
}
injectHelpTemplate(badFlags)
theApp := app.NewApp(cmdRunner, metaDatas...)
rpcService.SetTheApp(theApp)
if cmdFactory.CheckIfCoreCmdExists(os.Args[1]) {
callCoreCommand(os.Args[0:], theApp)
} else {
// run each plugin and find the method/
// run method if exist
ran := rpc.RunMethodIfExists(rpcService, os.Args[1:], pluginList)
if !ran {
deps.Ui.Say("'" + os.Args[1] + "' is not a registered command. See 'cf help'")
os.Exit(1)
}
}
}
func main() {
//make a reference to something in cf/commands/domain, so all init() in the directory will run
_ = domain.CreateDomain{}
defer handlePanics(deps.TeePrinter)
defer deps.Config.Close()
//////////////// non-codegangsta path ///////////////////////
if len(os.Args) > 1 {
cmd := os.Args[1]
if cmdRegistry.CommandExists(cmd) {
meta := cmdRegistry.FindCommand(os.Args[1]).MetaData()
fc := flags.NewFlagContext(meta.Flags)
fc.SkipFlagParsing(meta.SkipFlagParsing)
if requestHelp(os.Args[2:]) {
deps.Ui.Say(cmdRegistry.CommandUsage(cmd))
os.Exit(0)
} else {
err := fc.Parse(os.Args[2:]...)
if err != nil {
deps.Ui.Failed("Incorrect Usage\n\n" + err.Error() + "\n\n" + cmdRegistry.CommandUsage(cmd))
}
}
cmdRegistry.SetCommand(cmdRegistry.FindCommand(cmd).SetDependency(deps, false))
cfCmd := cmdRegistry.FindCommand(cmd)
reqs, err := cfCmd.Requirements(requirements.NewFactory(deps.Ui, deps.Config, deps.RepoLocator), fc)
if err != nil {
deps.Ui.Failed(err.Error())
}
for _, r := range reqs {
if !r.Execute() {
os.Exit(1)
}
}
cfCmd.Execute(fc)
os.Exit(0)
}
}
//////////////////////////////////////////
rpcService := newCliRpcServer(deps.TeePrinter, deps.TeePrinter)
cmdFactory := command_factory.NewFactory(deps.Ui, deps.Config, deps.ManifestRepo, deps.RepoLocator, deps.PluginConfig, rpcService)
requirementsFactory := requirements.NewFactory(deps.Ui, deps.Config, deps.RepoLocator)
cmdRunner := command_runner.NewRunner(cmdFactory, requirementsFactory, deps.Ui)
pluginsConfig := plugin_config.NewPluginConfig(func(err error) { deps.Ui.Failed(fmt.Sprintf("Error read/writing plugin config: %s, ", err.Error())) })
pluginList := pluginsConfig.Plugins()
var badFlags string
metaDatas := cmdFactory.CommandMetadatas()
//return only metadata for current command
metaDatas = mergePluginMetaData(metaDatas, pluginList)
if len(os.Args) > 1 {
flags := cmdFactory.GetCommandFlags(os.Args[1])
totalArgs, _ := cmdFactory.GetCommandTotalArgs(os.Args[1])
if args2skip := totalArgs + 2; len(os.Args) >= args2skip {
badFlags = matchArgAndFlags(flags, os.Args[args2skip:])
}
if badFlags != "" {
badFlags = badFlags + "\n\n"
}
}
injectHelpTemplate(badFlags)
theApp := app.NewApp(cmdRunner, metaDatas...)
rpcService.SetTheApp(theApp)
//command `cf` without argument
if len(os.Args) == 1 || os.Args[1] == "help" || requestHelp(os.Args[2:]) {
theApp.Run(os.Args)
} else if cmdFactory.CheckIfCoreCmdExists(os.Args[1]) {
callCoreCommand(os.Args[0:], theApp)
} else {
// run each plugin and find the method/
// run method if exist
ran := rpc.RunMethodIfExists(rpcService, os.Args[1:], pluginList)
if !ran {
theApp.Run(os.Args)
}
}
}
Expect(err).ToNot(HaveOccurred())
fixtureDir := filepath.Join("..", "..", "..", "fixtures", "plugins")
pluginDir = filepath.Join(fakePluginRepoDir, ".cf", "plugins")
err = os.MkdirAll(pluginDir, 0700)
Expect(err).NotTo(HaveOccurred())
fileutils.CopyFile(filepath.Join(pluginDir, "test_1.exe"), filepath.Join(fixtureDir, "test_1.exe"))
fileutils.CopyFile(filepath.Join(pluginDir, "test_2.exe"), filepath.Join(fixtureDir, "test_2.exe"))
config_helpers.PluginRepoDir = func() string {
return fakePluginRepoDir
}
pluginConfig = plugin_config.NewPluginConfig(func(err error) { Expect(err).ToNot(HaveOccurred()) })
pluginConfig.SetPlugin("test_1.exe", plugin_config.PluginMetadata{Location: filepath.Join(pluginDir, "test_1.exe")})
pluginConfig.SetPlugin("test_2.exe", plugin_config.PluginMetadata{Location: filepath.Join(pluginDir, "test_2.exe")})
})
AfterEach(func() {
os.Remove(fakePluginRepoDir)
})
runCommand := func(args ...string) bool {
//reset rpc registration, each service can only be registered once
rpc.DefaultServer = rpc.NewServer()
rpcService, _ := cliRpc.NewRpcService(nil, nil, nil, nil, api.RepositoryLocator{}, nil)
cmd := NewPluginUninstall(ui, pluginConfig, rpcService)
return testcmd.RunCommand(cmd, args, requirementsFactory)