func (cmd *CliRpcCmd) CallCoreCommand(args []string, retVal *bool) error {
var err error
cmdRegistry := commandregistry.Commands
cmd.outputBucket = &bytes.Buffer{}
cmd.outputCapture.SetOutputBucket(cmd.outputBucket)
if cmdRegistry.CommandExists(args[0]) {
deps := commandregistry.NewDependency(cmd.stdout, cmd.logger, dialTimeout)
//set deps objs to be the one used by all other commands
//once all commands are converted, we can make fresh deps for each command run
deps.Config = cmd.cliConfig
deps.RepoLocator = cmd.repoLocator
//set command ui's TeePrinter to be the one used by RpcService, for output to be captured
deps.UI = terminal.NewUI(os.Stdin, cmd.stdout, cmd.outputCapture.(*terminal.TeePrinter), cmd.logger)
err = cmd.newCmdRunner.Command(args, deps, false)
} else {
*retVal = false
return nil
}
if err != nil {
*retVal = false
return err
}
*retVal = true
return nil
}
func (cmd *CliRpcCmd) GetService(serviceInstance string, retVal *plugin_models.GetService_Model) error {
deps := commandregistry.NewDependency(cmd.stdout, cmd.logger, dialTimeout)
//set deps objs to be the one used by all other commands
//once all commands are converted, we can make fresh deps for each command run
deps.Config = cmd.cliConfig
deps.RepoLocator = cmd.repoLocator
deps.PluginModels.Service = retVal
cmd.terminalOutputSwitch.DisableTerminalOutput(true)
deps.UI = terminal.NewUI(os.Stdin, cmd.stdout, cmd.terminalOutputSwitch.(*terminal.TeePrinter), cmd.logger)
return cmd.newCmdRunner.Command([]string{"service", serviceInstance}, deps, true)
}
app.Routes = app1Routes
app.AppPorts = []int{8080, 9090}
app2 := models.Application{}
app2.Name = "Application-2"
app2.GUID = "Application-2-guid"
app2.State = "started"
app2.RunningInstances = 1
app2.InstanceCount = 2
app2.Memory = 256
app2.DiskQuota = 1024
app2.Routes = app2Routes
appSummaryRepo.GetSummariesInCurrentSpaceApps = []models.Application{app, app2}
deps = commandregistry.NewDependency(os.Stdout, new(tracefakes.FakePrinter), "")
})
runCommand := func(args ...string) bool {
return testcmd.RunCLICommand("apps", args, requirementsFactory, updateCommandDependency, false, ui)
}
Describe("requirements", func() {
var cmd commandregistry.Command
var flagContext flags.FlagContext
BeforeEach(func() {
cmd = &application.ListApps{}
cmd.SetDependency(deps, false)
flagContext = flags.NewFlagContext(cmd.MetaData().Flags)
)
var _ = Describe("calling commands in commandregistry", func() {
_ = FakeCommand1{} //make sure fake_command is imported and self-registered with init()
_ = FakeCommand3{} //make sure fake_command is imported and self-registered with init()
_ = FakeCommand4{} //make sure fake_command is imported and self-registered with init()
var (
ui *terminalfakes.FakeUI
deps commandregistry.Dependency
fakeLogger *tracefakes.FakePrinter
)
BeforeEach(func() {
fakeLogger = new(tracefakes.FakePrinter)
deps = commandregistry.NewDependency(os.Stdout, fakeLogger, "")
ui = new(terminalfakes.FakeUI)
deps.UI = ui
cmd := commandregistry.Commands.FindCommand("fake-command")
commandregistry.Commands.SetCommand(cmd.SetDependency(deps, true))
cmd2 := commandregistry.Commands.FindCommand("fake-command2")
commandregistry.Commands.SetCommand(cmd2.SetDependency(deps, true))
})
Context("when command exists and the correct flags are passed", func() {
BeforeEach(func() {
err := NewCommandRunner().Command([]string{"fake-command"}, deps, false)
Expect(err).NotTo(HaveOccurred())
})
func Main(traceEnv string, args []string) {
//handle `cf -v` for cf version
if len(args) == 2 && (args[1] == "-v" || args[1] == "--version") {
args[1] = "version"
}
//handles `cf`
if len(args) == 1 {
args = []string{args[0], "help"}
}
//handles `cf [COMMAND] -h ...`
//rearrange args to `cf help COMMAND` and let `command help` to print out usage
args = append([]string{args[0]}, handleHelp(args[1:])...)
newArgs, isVerbose := handleVerbose(args)
args = newArgs
errFunc := func(err error) {
if err != nil {
ui := terminal.NewUI(
os.Stdin,
Writer,
terminal.NewTeePrinter(Writer),
trace.NewLogger(Writer, isVerbose, traceEnv, ""),
)
ui.Failed(fmt.Sprintf("Config error: %s", err))
os.Exit(1)
}
}
// Only used to get Trace, so our errorHandler doesn't matter, since it's not used
configPath, err := confighelpers.DefaultFilePath()
if err != nil {
errFunc(err)
}
config := coreconfig.NewRepositoryFromFilepath(configPath, errFunc)
defer config.Close()
traceConfigVal := config.Trace()
// Writer is assigned in writer_unix.go/writer_windows.go
traceLogger := trace.NewLogger(Writer, isVerbose, traceEnv, traceConfigVal)
deps := commandregistry.NewDependency(Writer, traceLogger, os.Getenv("CF_DIAL_TIMEOUT"))
defer deps.Config.Close()
warningProducers := []net.WarningProducer{}
for _, warningProducer := range deps.Gateways {
warningProducers = append(warningProducers, warningProducer)
}
warningsCollector := net.NewWarningsCollector(deps.UI, warningProducers...)
commandsloader.Load()
//run core command
cmdName := args[1]
cmd := cmdRegistry.FindCommand(cmdName)
if cmd != nil {
meta := cmd.MetaData()
flagContext := flags.NewFlagContext(meta.Flags)
flagContext.SkipFlagParsing(meta.SkipFlagParsing)
cmdArgs := args[2:]
err = flagContext.Parse(cmdArgs...)
if err != nil {
usage := cmdRegistry.CommandUsage(cmdName)
deps.UI.Failed(T("Incorrect Usage") + "\n\n" + err.Error() + "\n\n" + usage)
}
cmd = cmd.SetDependency(deps, false)
cmdRegistry.SetCommand(cmd)
requirementsFactory := requirements.NewFactory(deps.Config, deps.RepoLocator)
reqs, reqErr := cmd.Requirements(requirementsFactory, flagContext)
if reqErr != nil {
os.Exit(1)
}
for _, req := range reqs {
err = req.Execute()
if err != nil {
deps.UI.Failed(err.Error())
os.Exit(1)
}
}
err = cmd.Execute(flagContext)
if err != nil {
deps.UI.Failed(err.Error())
os.Exit(1)
}
err = warningsCollector.PrintWarnings()
if err != nil {
deps.UI.Failed(err.Error())
os.Exit(1)
}
os.Exit(0)
}
//non core command, try plugin command
server := netrpc.NewServer()
rpcService, err := rpc.NewRpcService(deps.TeePrinter, deps.TeePrinter, deps.Config, deps.RepoLocator, rpc.NewCommandRunner(), deps.Logger, Writer, server)
if err != nil {
deps.UI.Say(T("Error initializing RPC service: ") + err.Error())
os.Exit(1)
}
pluginPath := filepath.Join(confighelpers.PluginRepoDir(), ".cf", "plugins")
pluginConfig := pluginconfig.NewPluginConfig(
func(err error) {
deps.UI.Failed(fmt.Sprintf("Error read/writing plugin config: %s, ", err.Error()))
},
configuration.NewDiskPersistor(filepath.Join(pluginPath, "config.json")),
pluginPath,
)
pluginList := pluginConfig.Plugins()
ran := rpc.RunMethodIfExists(rpcService, args[1:], pluginList)
if !ran {
deps.UI.Say("'" + args[1] + T("' is not a registered command. See 'cf help'"))
suggestCommands(cmdName, deps.UI, append(cmdRegistry.ListCommands(), pluginConfig.ListCommands()...))
os.Exit(1)
}
}