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() {
