// Main runs the Command specified by req, and fills in resp. A single command // is run at a time. func (j *Jujuc) Main(req Request, resp *Response) error { if req.CommandName == "" { return badReqErrorf("command not specified") } if !filepath.IsAbs(req.Dir) { return badReqErrorf("Dir is not absolute") } c, err := j.getCmd(req.ContextId, req.CommandName) if err != nil { return badReqErrorf("%s", err) } var stdin, stdout, stderr bytes.Buffer ctx := &cmd.Context{ Dir: req.Dir, Stdin: &stdin, Stdout: &stdout, Stderr: &stderr, } j.mu.Lock() defer j.mu.Unlock() log.Infof("worker/uniter/jujuc: running hook tool %q %q", req.CommandName, req.Args) log.Debugf("worker/uniter/jujuc: hook context id %q; dir %q", req.ContextId, req.Dir) resp.Code = cmd.Main(c, ctx, req.Args) resp.Stdout = stdout.Bytes() resp.Stderr = stderr.Bytes() return nil }
func (s *RelationListSuite) TestRelationListHelp(c *C) { template := ` usage: relation-list [options] %s purpose: list relation units options: --format (= smart) specify output format (json|smart|yaml) -o, --output (= "") specify an output file %s`[1:] for relid, t := range map[int]struct { usage, doc string }{ -1: {"<id>", ""}, 0: {"[<id>]", "\nCurrent default relation id is \"peer0:0\".\n"}, } { c.Logf("test relid %d", relid) hctx := s.GetHookContext(c, relid, "") com, err := jujuc.NewCommand(hctx, "relation-list") c.Assert(err, IsNil) ctx := dummyContext(c) code := cmd.Main(com, ctx, []string{"--help"}) c.Assert(code, Equals, 0) c.Assert(bufferString(ctx.Stdout), Equals, "") expect := fmt.Sprintf(template, t.usage, t.doc) c.Assert(bufferString(ctx.Stderr), Equals, expect) } }
func (s *SSHSuite) TestSSHCommand(c *C) { m := s.makeMachines(3, c) ch := coretesting.Charms.Dir("series", "dummy") curl := charm.MustParseURL( fmt.Sprintf("local:series/%s-%d", ch.Meta().Name, ch.Revision()), ) bundleURL, err := url.Parse("http://bundles.example.com/dummy-1") c.Assert(err, IsNil) dummy, err := s.State.AddCharm(ch, curl, bundleURL, "dummy-1-sha256") c.Assert(err, IsNil) srv, err := s.State.AddService("mysql", dummy) c.Assert(err, IsNil) s.addUnit(srv, m[0], c) srv, err = s.State.AddService("mongodb", dummy) c.Assert(err, IsNil) s.addUnit(srv, m[1], c) s.addUnit(srv, m[2], c) for _, t := range sshTests { c.Logf("testing juju ssh %s", t.args) ctx := &cmd.Context{c.MkDir(), &bytes.Buffer{}, &bytes.Buffer{}, &bytes.Buffer{}} code := cmd.Main(&SSHCommand{}, ctx, t.args) c.Check(code, Equals, 0) c.Check(ctx.Stderr.(*bytes.Buffer).String(), Equals, "") c.Check(ctx.Stdout.(*bytes.Buffer).String(), Equals, t.result) } }
func (s *BootstrapSuite) TestAutoSync(c *gc.C) { // Prepare a mock storage for testing and store the // dummy tools in there. restore := createToolsStore(c) defer restore() // Change the tools location to be the test location and also // the version and ensure their later restoring. origVersion := version.Current version.Current.Number = version.MustParse("1.2.3") defer func() { version.Current = origVersion }() // Create home with dummy provider and remove all // of its tools. env, fake := makeEmptyFakeHome(c) defer fake.Restore() // Bootstrap the environment now detects the missing // tools and automatically synchronizes them from the // storage above. ctx := coretesting.Context(c) code := cmd.Main(&BootstrapCommand{}, ctx, nil) c.Check(code, gc.Equals, 0) // Now check the available tools which are the 1.0.0 tools. checkTools(c, env, v100All) }
func (s *RelationIdsSuite) TestHelp(c *C) { template := ` usage: %s purpose: list all relation ids with the given relation name options: --format (= smart) specify output format (json|smart|yaml) -o, --output (= "") specify an output file %s`[1:] for relid, t := range map[int]struct { usage, doc string }{ -1: {"relation-ids [options] <name>", ""}, 0: {"relation-ids [options] [<name>]", "\nCurrent default relation name is \"x\".\n"}, 3: {"relation-ids [options] [<name>]", "\nCurrent default relation name is \"y\".\n"}, } { c.Logf("relid %d", relid) hctx := s.GetHookContext(c, relid, "") com, err := jujuc.NewCommand(hctx, "relation-ids") c.Assert(err, IsNil) ctx := testing.Context(c) code := cmd.Main(com, ctx, []string{"--help"}) c.Assert(code, Equals, 0) expect := fmt.Sprintf(template, t.usage, t.doc) c.Assert(bufferString(ctx.Stdout), Equals, expect) c.Assert(bufferString(ctx.Stderr), Equals, "") } }
func assertLogs(c *C, ctx jujuc.Context, badge string) { loggo.ConfigureLoggers("juju=DEBUG") writer := &loggo.TestWriter{} old_writer, err := loggo.ReplaceDefaultWriter(writer) c.Assert(err, IsNil) defer loggo.ReplaceDefaultWriter(old_writer) msg1 := "the chickens" msg2 := "are 110% AWESOME" com, err := jujuc.NewCommand(ctx, "juju-log") c.Assert(err, IsNil) for _, t := range commonLogTests { writer.Clear() c.Assert(err, IsNil) var args []string if t.debugFlag { args = []string{"--debug", msg1, msg2} } else { args = []string{msg1, msg2} } code := cmd.Main(com, &cmd.Context{}, args) c.Assert(code, Equals, 0) c.Assert(writer.Log, HasLen, 1) c.Assert(writer.Log[0].Level, Equals, t.level) c.Assert(writer.Log[0].Message, Equals, fmt.Sprintf("%s: %s %s", badge, msg1, msg2)) } }
func (s *ConfigSuite) TestGetConfig(c *C) { sch := s.AddTestingCharm(c, "dummy") svc, err := s.State.AddService("dummy-service", sch) c.Assert(err, IsNil) err = svc.UpdateConfigSettings(charm.Settings{"title": "Nearly There"}) c.Assert(err, IsNil) for _, t := range getTests { ctx := coretesting.Context(c) code := cmd.Main(&GetCommand{}, ctx, []string{t.service}) c.Check(code, Equals, 0) c.Assert(ctx.Stderr.(*bytes.Buffer).String(), Equals, "") // round trip via goyaml to avoid being sucked into a quagmire of // map[interface{}]interface{} vs map[string]interface{}. This is // also required if we add json support to this command. buf, err := goyaml.Marshal(t.expected) c.Assert(err, IsNil) expected := make(map[string]interface{}) err = goyaml.Unmarshal(buf, &expected) c.Assert(err, IsNil) actual := make(map[string]interface{}) err = goyaml.Unmarshal(ctx.Stdout.(*bytes.Buffer).Bytes(), &actual) c.Assert(err, IsNil) c.Assert(actual, DeepEquals, expected) } }
func assertLogs(c *C, ctx jujuc.Context, badge string) { msg1 := "the chickens" msg2 := "are 110% AWESOME" com, err := jujuc.NewCommand(ctx, "juju-log") c.Assert(err, IsNil) for _, t := range commonLogTests { buf, pop := pushLog(t.debugEnabled) defer pop() var args []string if t.debugFlag { args = []string{"--debug", msg1, msg2} } else { args = []string{msg1, msg2} } code := cmd.Main(com, &cmd.Context{}, args) c.Assert(code, Equals, 0) if t.target == "" { c.Assert(buf.String(), Equals, "") } else { expect := fmt.Sprintf("%s %s: %s %s\n", t.target, badge, msg1, msg2) c.Assert(buf.String(), Equals, expect) } } }
func (s *CmdSuite) TestMainRunSilentError(c *C) { ctx := dummyContext(c) result := cmd.Main(&TestCommand{Name: "verb"}, ctx, []string{"--option", "silent-error"}) c.Assert(result, Equals, 1) c.Assert(bufferString(ctx.Stdout), Equals, "") c.Assert(bufferString(ctx.Stderr), Equals, "") }
func (s *CmdSuite) TestMainSuccess(c *C) { ctx := dummyContext(c) result := cmd.Main(&TestCommand{Name: "verb"}, ctx, []string{"--option", "success!"}) c.Assert(result, Equals, 0) c.Assert(bufferString(ctx.Stdout), Equals, "success!\n") c.Assert(bufferString(ctx.Stderr), Equals, "") }
func (s *CmdSuite) TestMainRunError(c *C) { ctx := testing.Context(c) result := cmd.Main(&TestCommand{Name: "verb"}, ctx, []string{"--option", "error"}) c.Assert(result, Equals, 1) c.Assert(bufferString(ctx.Stdout), Equals, "") c.Assert(bufferString(ctx.Stderr), Equals, "error: BAM!\n") }
func (s *RelationListSuite) TestRelationList(c *C) { for i, t := range relationListTests { c.Logf("test %d: %s", i, t.summary) hctx := s.GetHookContext(c, t.relid, "") setMembers(hctx.rels[0], t.members0) setMembers(hctx.rels[1], t.members1) com, err := jujuc.NewCommand(hctx, "relation-list") c.Assert(err, IsNil) ctx := dummyContext(c) code := cmd.Main(com, ctx, t.args) c.Logf(bufferString(ctx.Stderr)) c.Assert(code, Equals, t.code) if code == 0 { c.Assert(bufferString(ctx.Stderr), Equals, "") expect := t.out if expect != "" { expect = expect + "\n" } c.Assert(bufferString(ctx.Stdout), Equals, expect) } else { c.Assert(bufferString(ctx.Stdout), Equals, "") expect := fmt.Sprintf(`(.|\n)*error: %s\n`, t.out) c.Assert(bufferString(ctx.Stderr), Matches, expect) } } }
func runStatus(c *C, args ...string) (code int, stdout, stderr []byte) { ctx := coretesting.Context(c) code = cmd.Main(&StatusCommand{}, ctx, args) stdout = ctx.Stdout.(*bytes.Buffer).Bytes() stderr = ctx.Stderr.(*bytes.Buffer).Bytes() return }
func (s *RelationListSuite) TestRelationListHelp(c *C) { template := ` usage: relation-list [options] purpose: list relation units options: --format (= smart) specify output format (json|smart|yaml) -o, --output (= "") specify an output file -r (= %s) specify a relation by id %s`[1:] for relid, t := range map[int]struct { usage, doc string }{ -1: {"", "\n-r must be specified when not in a relation hook\n"}, 0: {"peer0:0", ""}, } { c.Logf("test relid %d", relid) hctx := s.GetHookContext(c, relid, "") com, err := jujuc.NewCommand(hctx, "relation-list") c.Assert(err, IsNil) ctx := testing.Context(c) code := cmd.Main(com, ctx, []string{"--help"}) c.Assert(code, Equals, 0) expect := fmt.Sprintf(template, t.usage, t.doc) c.Assert(bufferString(ctx.Stdout), Equals, expect) c.Assert(bufferString(ctx.Stderr), Equals, "") } }
func (s *ValidateMetadataSuite) TestOpenstackLocalMetadataNoMatch(c *gc.C) { s.makeLocalMetadata(c, "1234", "region-2", "raring", "some-auth-url") ctx := coretesting.Context(c) metadataDir := config.JujuHomePath("") code := cmd.Main( &ValidateImageMetadataCommand{}, ctx, []string{ "-p", "openstack", "-s", "precise", "-r", "region-2", "-u", "some-auth-url", "-d", metadataDir}, ) c.Assert(code, gc.Equals, 1) code = cmd.Main( &ValidateImageMetadataCommand{}, ctx, []string{ "-p", "openstack", "-s", "raring", "-r", "region-3", "-u", "some-auth-url", "-d", metadataDir}, ) c.Assert(code, gc.Equals, 1) }
func (s *ValidateMetadataSuite) TestEc2LocalMetadataNoMatch(c *gc.C) { s.setupEc2LocalMetadata(c, "us-east-1") ctx := coretesting.Context(c) metadataDir := config.JujuHomePath("") code := cmd.Main( &ValidateImageMetadataCommand{}, ctx, []string{ "-p", "ec2", "-s", "raring", "-r", "us-west-1", "-u", "https://ec2.us-west-1.amazonaws.com", "-d", metadataDir}, ) c.Assert(code, gc.Equals, 1) code = cmd.Main( &ValidateImageMetadataCommand{}, ctx, []string{ "-p", "ec2", "-s", "precise", "-r", "region", "-u", "https://ec2.region.amazonaws.com", "-d", metadataDir}, ) c.Assert(code, gc.Equals, 1) }
// Main registers subcommands for the jujud executable, and hands over control // to the cmd package. This function is not redundant with main, because it // provides an entry point for testing with arbitrary command line arguments. func Main(args []string) { jujud := &cmd.SuperCommand{Name: "jujud", Doc: jujudDoc, Log: &cmd.Log{}} jujud.Register(&BootstrapCommand{}) jujud.Register(&MachineAgent{}) jujud.Register(&UnitAgent{}) jujud.Register(&VersionCommand{}) os.Exit(cmd.Main(jujud, cmd.DefaultContext(), args[1:])) }
func (s *SuperCommandSuite) TestDescription(c *C) { jc := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "jujutest", Purpose: "blow up the death star"}) jc.Register(&TestCommand{Name: "blah"}) ctx := testing.Context(c) code := cmd.Main(jc, ctx, []string{"blah", "--description"}) c.Assert(code, Equals, 0) c.Assert(bufferString(ctx.Stdout), Equals, "blow up the death star\n") }
func runCmdLine(c *C, com cmd.Command, args ...string) (code int, stdout, stderr string) { ctx := coretesting.Context(c) code = cmd.Main(com, ctx, args) stdout = ctx.Stdout.(*bytes.Buffer).String() stderr = ctx.Stderr.(*bytes.Buffer).String() c.Logf("args: %#v\ncode: %d\nstdout: %q\nstderr: %q", args, code, stdout, stderr) return }
func (s *ImageMetadataSuite) TestImageMetadataBadArgs(c *gc.C) { defer testing.MakeEmptyFakeHome(c).Restore() for i, t := range errTests { c.Logf("test: %d", i) ctx := testing.Context(c) code := cmd.Main(&ImageMetadataCommand{}, ctx, t.args) c.Check(code, gc.Equals, 2) } }
func (s *CmdSuite) TestMainHelp(c *C) { for _, arg := range []string{"-h", "--help"} { ctx := dummyContext(c) result := cmd.Main(&TestCommand{Name: "verb"}, ctx, []string{arg}) c.Assert(result, Equals, 0) c.Assert(bufferString(ctx.Stdout), Equals, "") c.Assert(bufferString(ctx.Stderr), Equals, fullHelp) } }
func (s *SuperCommandSuite) TestHelpWithPrefix(c *C) { jc := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "jujutest", UsagePrefix: "juju"}) jc.Register(&TestCommand{Name: "blah"}) ctx := testing.Context(c) code := cmd.Main(jc, ctx, []string{"blah", "--help"}) c.Assert(code, Equals, 0) stripped := strings.Replace(bufferString(ctx.Stdout), "\n", "", -1) c.Assert(stripped, Matches, ".*usage: juju jujutest blah.*blah-doc.*") }
func (s *CmdSuite) TestStdin(c *C) { const phrase = "Do you, Juju?" ctx := dummyContext(c) ctx.Stdin = bytes.NewBuffer([]byte(phrase)) result := cmd.Main(&TestCommand{Name: "verb"}, ctx, []string{"--option", "echo"}) c.Assert(result, Equals, 0) c.Assert(bufferString(ctx.Stdout), Equals, phrase) c.Assert(bufferString(ctx.Stderr), Equals, "") }
func (s *ConfigGetSuite) TestAllPlusKey(c *C) { hctx := s.GetHookContext(c, -1, "") com, err := jujuc.NewCommand(hctx, "config-get") c.Assert(err, IsNil) ctx := testing.Context(c) code := cmd.Main(com, ctx, []string{"--all", "--format", "json", "monsters"}) c.Assert(code, Equals, 2) c.Assert(bufferString(ctx.Stderr), Equals, "error: cannot use argument --all together with key \"monsters\"\n") }
func (*BootstrapSuite) TestMissingEnvironment(c *C) { defer testing.MakeFakeHomeNoEnvironments(c, "empty").Restore() ctx := testing.Context(c) code := cmd.Main(&BootstrapCommand{}, ctx, nil) c.Check(code, Equals, 1) errStr := ctx.Stderr.(*bytes.Buffer).String() strippedErr := strings.Replace(errStr, "\n", "", -1) c.Assert(strippedErr, Matches, ".*No juju environment configuration file exists.*") }
func (s *CmdSuite) TestMainInitError(c *C) { for _, t := range initErrorTests { ctx := dummyContext(c) result := cmd.Main(t.c, ctx, []string{"--unknown"}) c.Assert(result, Equals, 2) c.Assert(bufferString(ctx.Stdout), Equals, "") expected := "error: flag provided but not defined: --unknown\n" c.Assert(bufferString(ctx.Stderr), Equals, expected) } }
func (s *ImageMetadataSuite) TestImageMetadataFilesDefaultArch(c *gc.C) { defer testing.MakeEmptyFakeHome(c).Restore() ctx := testing.Context(c) code := cmd.Main( &ImageMetadataCommand{}, ctx, []string{"-i", "1234", "-r", "region", "-u", "endpoint", "-s", "raring"}) c.Assert(code, gc.Equals, 0) errOut := ctx.Stdout.(*bytes.Buffer).String() s.assertCommandOutput(c, errOut, "raring", "amd64", defaultIndexFileName, defaultImageFileName) }
func (s *SuperCommandSuite) TestLogging(c *C) { jc := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "jujutest", Log: &cmd.Log{}}) jc.Register(&TestCommand{Name: "blah"}) ctx := testing.Context(c) code := cmd.Main(jc, ctx, []string{"blah", "--option", "error", "--debug"}) c.Assert(code, Equals, 1) c.Assert(bufferString(ctx.Stderr), Matches, `^.* ERROR .* command failed: BAM! error: BAM! `) }
func (s *UnitGetSuite) TestOutputFormat(c *C) { for _, t := range unitGetTests { com := s.createCommand(c) ctx := testing.Context(c) code := cmd.Main(com, ctx, t.args) c.Assert(code, Equals, 0) c.Assert(bufferString(ctx.Stderr), Equals, "") c.Assert(bufferString(ctx.Stdout), Matches, t.out) } }
func (s *ImageMetadataSuite) TestImageMetadataFilesUsingEnvEndpoint(c *gc.C) { defer testing.MakeEmptyFakeHome(c).Restore() os.Setenv("OS_AUTH_URL", "endpoint") ctx := testing.Context(c) code := cmd.Main( &ImageMetadataCommand{}, ctx, []string{"-i", "1234", "-r", "region"}) c.Assert(code, gc.Equals, 0) errOut := ctx.Stdout.(*bytes.Buffer).String() s.assertCommandOutput(c, errOut, "precise", "amd64", defaultIndexFileName, defaultImageFileName) }