func RunCommandMoreBetter(cmdName string, args []string, requirementsFactory *testreq.FakeReqFactory, updateFunc func(bool), pluginCall bool) (result RunCommandResult) {
updateFunc(pluginCall)
cmd := command_registry.Commands.FindCommand(cmdName)
context := flags.NewFlagContext(cmd.MetaData().Flags)
context.SkipFlagParsing(cmd.MetaData().SkipFlagParsing)
err := context.Parse(args...)
if err != nil {
fmt.Println("ERROR:", err)
return RunCommandResultFailed
}
defer func() {
errMsg := recover()
if errMsg != nil && errMsg != testterm.QuietPanic {
panic(errMsg)
}
result = RunCommandResultFailed
}()
requirements, err := cmd.Requirements(requirementsFactory, context)
if err != nil {
return RunCommandResultRequirementsFailed
}
for _, requirement := range requirements {
if !requirement.Execute() {
return RunCommandResultRequirementsFailed
}
}
cmd.Execute(context)
return RunCommandResultSuccess
}
func RunCliCommandWithoutDependency(cmdName string, args []string, requirementsFactory *testreq.FakeReqFactory) (passedRequirements bool) {
cmd := command_registry.Commands.FindCommand(cmdName)
context := flags.NewFlagContext(cmd.MetaData().Flags)
context.SkipFlagParsing(cmd.MetaData().SkipFlagParsing)
err := context.Parse(args...)
if err != nil {
fmt.Println("ERROR:", err)
os.Exit(1)
}
defer func() {
errMsg := recover()
if errMsg != nil && errMsg != testterm.QuietPanic {
panic(errMsg)
}
}()
requirements, err := cmd.Requirements(requirementsFactory, context)
if err != nil {
return false
}
for _, requirement := range requirements {
if !requirement.Execute() {
return false
}
}
passedRequirements = true
cmd.Execute(context)
return
}
func (c *nonCodegangstaRunner) Command(args []string, deps command_registry.Dependency, pluginApiCall bool) error {
var err error
cmdRegistry := command_registry.Commands
if cmdRegistry.CommandExists(args[0]) {
fc := flags.NewFlagContext(cmdRegistry.FindCommand(args[0]).MetaData().Flags)
err = fc.Parse(args[1:]...)
if err != nil {
return err
}
cfCmd := cmdRegistry.FindCommand(args[0])
cfCmd = cfCmd.SetDependency(deps, pluginApiCall)
reqs, err := cfCmd.Requirements(requirements.NewFactory(deps.Ui, deps.Config, deps.RepoLocator), fc)
if err != nil {
return err
}
for _, r := range reqs {
if !r.Execute() {
return errors.New("Error in requirement")
}
}
cfCmd.Execute(fc)
}
return nil
}
func (r *registry) CommandUsage(cmdName string) string {
output := ""
cmd := r.FindCommand(cmdName)
output = T("NAME") + ":" + "\n"
output += " " + cmd.MetaData().Name + " - " + cmd.MetaData().Description + "\n\n"
output += T("USAGE") + ":" + "\n"
output += " " + strings.Replace(cmd.MetaData().Usage, "CF_NAME", cf.Name(), -1) + "\n"
if cmd.MetaData().ShortName != "" {
output += "\n" + T("ALIAS") + ":" + "\n"
output += " " + cmd.MetaData().ShortName + "\n"
}
if cmd.MetaData().Flags != nil {
output += "\n" + T("OPTIONS") + ":" + "\n"
output += flags.NewFlagContext(cmd.MetaData().Flags).ShowUsage(3)
}
return output
}
func RunCliCommand(cmdName string, args []string, requirementsFactory *testreq.FakeReqFactory, updateFunc func(bool), pluginCall bool) (passedRequirements bool) {
if cf.Version == "" {
cf.Version = "6.13.0+abc123"
}
updateFunc(pluginCall)
cmd := command_registry.Commands.FindCommand(cmdName)
context := flags.NewFlagContext(cmd.MetaData().Flags)
context.SkipFlagParsing(cmd.MetaData().SkipFlagParsing)
err := context.Parse(args...)
if err != nil {
fmt.Println("ERROR:", err)
os.Exit(1)
}
defer func() {
errMsg := recover()
if errMsg != nil && errMsg != testterm.QuietPanic {
panic(errMsg)
}
}()
requirements, err := cmd.Requirements(requirementsFactory, context)
if err != nil {
return false
}
for _, requirement := range requirements {
if !requirement.Execute() {
return false
}
}
passedRequirements = true
cmd.Execute(context)
return
}
spaceRepo = &testapi.FakeSpaceRepository{}
deps := command_registry.Dependency{}
repoLocator := deps.RepoLocator
repoLocator = repoLocator.SetUserRepository(userRepo)
repoLocator = repoLocator.SetSpaceRepository(spaceRepo)
deps.Ui = ui
deps.Config = configRepo
deps.RepoLocator = repoLocator
cmd = &user.SetSpaceRole{}
cmd.SetDependency(deps, false)
requirementsFactory = &testreq.FakeReqFactory{}
flagContext = flags.NewFlagContext(map[string]flags.FlagSet{})
})
Describe("Requirements", func() {
Context("when not provided exactly four args", func() {
BeforeEach(func() {
flagContext.Parse("the-username", "the-org-name", "the-space-name")
})
It("fails with usage", func() {
Expect(func() { cmd.Requirements(requirementsFactory, flagContext) }).To(Panic())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Incorrect Usage. Requires USERNAME, ORG, SPACE, ROLE as arguments"},
[]string{"NAME"},
[]string{"USAGE"},
))
BeforeEach(func() {
ui = &testterm.FakeUI{}
configRepo = testconfig.NewRepositoryWithDefaults()
routeRepo = &fakeapi.FakeRouteRepository{}
repoLocator := deps.RepoLocator.SetRouteRepository(routeRepo)
deps = command_registry.Dependency{
Ui: ui,
Config: configRepo,
RepoLocator: repoLocator,
}
cmd = route.CreateRoute{}
cmd.SetDependency(deps, false)
flagContext = flags.NewFlagContext(cmd.MetaData().Flags)
factory = &fakerequirements.FakeFactory{}
spaceRequirement = &fakerequirements.FakeSpaceRequirement{}
space := models.Space{}
space.Guid = "space-guid"
space.Name = "space-name"
spaceRequirement.GetSpaceReturns(space)
factory.NewSpaceRequirementReturns(spaceRequirement)
domainRequirement = &fakerequirements.FakeDomainRequirement{}
domainRequirement.GetDomainReturns(models.DomainFields{
Guid: "domain-guid",
Name: "domain-name",
})
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)
}
}