func (cmd *CliRpcCmd) GetService(serviceInstance string, retVal *plugin_models.GetService_Model) error { defer func() { recover() }() 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) }
func (cmd *CliRpcCmd) GetOrgUsers(args []string, retVal *[]plugin_models.GetOrgUsers_Model) error { defer func() { recover() }() deps := commandregistry.NewDependency(cmd.stdout, cmd.logger) //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.OrgUsers = retVal cmd.terminalOutputSwitch.DisableTerminalOutput(true) deps.UI = terminal.NewUI(os.Stdin, cmd.stdout, cmd.terminalOutputSwitch.(*terminal.TeePrinter), cmd.logger) return cmd.newCmdRunner.Command(append([]string{"org-users"}, args...), deps, true) }
func (cmd *CliRpcCmd) CallCoreCommand(args []string, retVal *bool) error { defer func() { recover() }() 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 }
) updateCommandDependency := func(pluginCall bool) { deps.UI = ui deps.RepoLocator = deps.RepoLocator.SetAuthenticationRepository(authRepo) deps.Config = configRepo commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("oauth-token").SetDependency(deps, pluginCall)) } BeforeEach(func() { ui = &testterm.FakeUI{} fakeLogger := new(tracefakes.FakePrinter) authRepo = new(authenticationfakes.FakeRepository) configRepo = testconfig.NewRepositoryWithDefaults() requirementsFactory = new(requirementsfakes.FakeFactory) deps = commandregistry.NewDependency(os.Stdout, fakeLogger) }) runCommand := func() bool { return testcmd.RunCLICommand("oauth-token", []string{}, requirementsFactory, updateCommandDependency, false, ui) } Describe("requirements", func() { It("fails when the user is not logged in", func() { requirementsFactory.NewLoginRequirementReturns(requirements.Failing{Message: "not logged in"}) Expect(runCommand()).ToNot(HavePassedRequirements()) }) }) Describe("when logged in", func() { BeforeEach(func() {
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) } 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)
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)) } } // 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 handlePanics(args, deps.TeePrinter, deps.Logger) defer deps.Config.Close() //handle `cf --build` if len(args) == 2 && (args[1] == "--build" || args[1] == "-b") { deps.UI.Say(T("{{.CFName}} was built with Go version: {{.GoVersion}}", map[string]interface{}{ "CFName": args[0], "GoVersion": runtime.Version(), })) os.Exit(0) } 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 := cmd.Requirements(requirementsFactory, flagContext) for _, req := range reqs { err = req.Execute() if err != nil { deps.UI.Failed(err.Error()) } } err = cmd.Execute(flagContext) if err != nil { ui := terminal.NewUI(os.Stdin, Writer, terminal.NewTeePrinter(Writer), traceLogger) ui.Failed(err.Error()) } warningsCollector.PrintWarnings() 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) } }