func findCommand(cmdName string) (cmd cli.Command) { fakeUI := &testterm.FakeUI{} configRepo := testconfig.NewRepository() pluginConfig := &testPluginConfig.FakePluginConfiguration{} manifestRepo := manifest.NewManifestDiskRepository() apiRepoLocator := api.NewRepositoryLocator(configRepo, map[string]net.Gateway{ "auth": net.NewUAAGateway(configRepo, fakeUI), "cloud-controller": net.NewCloudControllerGateway(configRepo, time.Now, fakeUI), "uaa": net.NewUAAGateway(configRepo, fakeUI), }) rpcService, _ := rpc.NewRpcService(nil, nil, nil, nil, api.RepositoryLocator{}, nil) cmdFactory := command_factory.NewFactory(fakeUI, configRepo, manifestRepo, apiRepoLocator, pluginConfig, rpcService) requirementsFactory := &testreq.FakeReqFactory{} cmdRunner := command_runner.NewRunner(cmdFactory, requirementsFactory, fakeUI) myApp := app.NewApp(cmdRunner, cmdFactory.CommandMetadatas()...) for _, cmd := range myApp.Commands { if cmd.Name == cmdName { return cmd } } panic(fmt.Sprintf("command %s does not exist", cmdName)) return }
func newCliRpcServer(outputCapture terminal.OutputCapture, terminalOutputSwitch terminal.TerminalOutputSwitch) *rpc.CliRpcService { cliServer, err := rpc.NewRpcService(outputCapture, terminalOutputSwitch, deps.Config, deps.RepoLocator, rpc.NewNonCodegangstaRunner()) if err != nil { deps.Ui.Say(T("Error initializing RPC service: ") + err.Error()) os.Exit(1) } return cliServer }
func newCliRpcServer(outputCapture terminal.OutputCapture, terminalOutputSwitch terminal.TerminalOutputSwitch) *rpc.CliRpcService { cliServer, err := rpc.NewRpcService(nil, outputCapture, terminalOutputSwitch, deps.configRepo) if err != nil { fmt.Println("Error initializing RPC service: ", err) os.Exit(1) } return cliServer }
func createCommandFactory() command_factory.Factory { fakeUI := &testterm.FakeUI{} configRepo := testconfig.NewRepository() pluginConfig := &testPluginConfig.FakePluginConfiguration{} manifestRepo := manifest.NewManifestDiskRepository() apiRepoLocator := api.NewRepositoryLocator(configRepo, map[string]net.Gateway{ "auth": net.NewUAAGateway(configRepo, fakeUI), "cloud-controller": net.NewCloudControllerGateway(configRepo, time.Now, fakeUI), "uaa": net.NewUAAGateway(configRepo, fakeUI), }) rpcService, _ := rpc.NewRpcService(nil, nil, nil, nil) return command_factory.NewFactory(fakeUI, configRepo, manifestRepo, apiRepoLocator, pluginConfig, rpcService) }
func (cmd *PluginUninstall) SetDependency(deps commandregistry.Dependency, pluginCall bool) commandregistry.Command { cmd.ui = deps.UI cmd.config = deps.PluginConfig //reset rpc registration in case there is other running instance, //each service can only be registered once server := rpc.NewServer() RPCService, err := rpcService.NewRpcService(deps.TeePrinter, deps.TeePrinter, deps.Config, deps.RepoLocator, rpcService.NewCommandRunner(), deps.Logger, cmd.ui.Writer(), server) if err != nil { cmd.ui.Failed("Error initializing RPC service: " + err.Error()) } cmd.rpcService = RPCService return cmd }
func (cmd *PluginUninstall) SetDependency(deps command_registry.Dependency, pluginCall bool) command_registry.Command { cmd.ui = deps.Ui cmd.config = deps.PluginConfig //reset rpc registration in case there is other running instance, //each service can only be registered once rpc.DefaultServer = rpc.NewServer() rpcService, err := rpcService.NewRpcService(nil, deps.TeePrinter, deps.TeePrinter, deps.Config, deps.RepoLocator, rpcService.NewNonCodegangstaRunner()) if err != nil { cmd.ui.Failed("Error initializing RPC service: " + err.Error()) } cmd.rpcService = rpcService return cmd }
cmdRunner *FakeRunner ) JustBeforeEach(func() { ui := &testterm.FakeUI{} config := testconfig.NewRepository() pluginConfig := &testPluginConfig.FakePluginConfiguration{} manifestRepo := &testmanifest.FakeManifestRepository{} repoLocator := api.NewRepositoryLocator(config, map[string]net.Gateway{ "auth": net.NewUAAGateway(config, ui), "cloud-controller": net.NewCloudControllerGateway(config, time.Now, &testterm.FakeUI{}), "uaa": net.NewUAAGateway(config, ui), }) rpcService, _ := rpc.NewRpcService(nil, nil, nil, nil, api.RepositoryLocator{}, nil) cmdFactory := command_factory.NewFactory(ui, config, manifestRepo, repoLocator, pluginConfig, rpcService) cmdRunner = &FakeRunner{cmdFactory: cmdFactory} app = NewApp(cmdRunner, cmdFactory.CommandMetadatas()...) }) Describe("trace file integration", func() { var ( output *bytes.Buffer ) BeforeEach(func() { output = bytes.NewBuffer(make([]byte, 1024)) trace.SetStdout(output) trace.EnableTrace() })
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) } }
var ( factory Factory ) BeforeEach(func() { fakeUI := &testterm.FakeUI{} config := testconfig.NewRepository() manifestRepo := manifest.NewManifestDiskRepository() pluginConfig := &testPluginConfig.FakePluginConfiguration{} repoLocator := api.NewRepositoryLocator(config, map[string]net.Gateway{ "auth": net.NewUAAGateway(config, fakeUI), "cloud-controller": net.NewCloudControllerGateway(config, time.Now, fakeUI), "uaa": net.NewUAAGateway(config, fakeUI), }) rpcService, _ := rpc.NewRpcService(nil, nil, nil, nil) factory = NewFactory(fakeUI, config, manifestRepo, repoLocator, pluginConfig, rpcService) }) It("provides the metadata for its commands", func() { commands := factory.CommandMetadatas() suffixesToIgnore := []string{ "i18n_init.go", // ignore all i18n initializers "_test.go", // ignore test files ".test", // ignore generated .test (temporary files) "#", // emacs autosave files } err := filepath.Walk("../commands", func(path string, info os.FileInfo, err error) error { if info.IsDir() {
if runtime.GOOS != "windows" { err = os.Chmod(test_1, 0700) Expect(err).ToNot(HaveOccurred()) } }) AfterEach(func() { os.Remove(filepath.Join(curDir, pluginFile.Name())) os.Remove(homeDir) }) 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) cmd := NewPluginInstall(ui, config, pluginConfig, coreCmds, fakePluginRepo, fakeChecksum, rpcService) return testcmd.RunCommand(cmd, args, requirementsFactory) } Describe("requirements", func() { It("fails with usage when not provided a path to the plugin executable", func() { Expect(runCommand()).ToNot(HavePassedRequirements()) }) }) Describe("Locating binary file", func() { Describe("install from plugin repository when '-r' provided", func() { Context("gets metadata of the plugin from repo", func() { Context("when repo is not found in config", func() {