Merge "jiri: Make sure that project Revision exists on RemoteBranch"
diff --git a/cmd/jiri/bootstrap_jiri_test.go b/cmd/jiri/bootstrap_jiri_test.go
new file mode 100644
index 0000000..3bdca29
--- /dev/null
+++ b/cmd/jiri/bootstrap_jiri_test.go
@@ -0,0 +1,62 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+
+ "v.io/x/lib/gosh"
+)
+
+func TestBootstrapJiri(t *testing.T) {
+ sh := gosh.NewShell(gosh.Opts{Fatalf: t.Fatalf, Logf: t.Logf, PropagateChildOutput: true})
+ defer sh.Cleanup()
+
+ bootstrap, err := filepath.Abs("./scripts/bootstrap_jiri")
+ if err != nil {
+ t.Fatalf("couldn't determine absolute path to bootstrap_jiri script")
+ }
+ rootDir := filepath.Join(sh.MakeTempDir(), "root")
+ stdout, stderr := sh.Cmd(bootstrap, rootDir).StdoutStderr()
+ if got, want := stdout, fmt.Sprintf("Please add %s to your PATH.\n", filepath.Join(rootDir, ".jiri_root", "scripts")); got != want {
+ t.Errorf("stdout got %q, want %q", got, want)
+ }
+ if got, want := stderr, ""; got != want {
+ t.Errorf("stderr got %q, want %q", got, want)
+ }
+ if _, err := os.Stat(filepath.Join(rootDir, ".jiri_root", "bin", "jiri")); err != nil {
+ t.Error(err)
+ }
+ if _, err := os.Stat(filepath.Join(rootDir, ".jiri_root", "scripts", "jiri")); err != nil {
+ t.Error(err)
+ }
+}
+
+func TestBootstrapJiriAlreadyExists(t *testing.T) {
+ sh := gosh.NewShell(gosh.Opts{Fatalf: t.Fatalf, Logf: t.Logf, PropagateChildOutput: true})
+ defer sh.Cleanup()
+
+ bootstrap, err := filepath.Abs("./scripts/bootstrap_jiri")
+ if err != nil {
+ t.Fatalf("couldn't determine absolute path to bootstrap_jiri script")
+ }
+ rootDir := sh.MakeTempDir()
+ c := sh.Cmd(bootstrap, rootDir)
+ c.ExitErrorIsOk = true
+ stdout, stderr := c.StdoutStderr()
+ if c.Err == nil {
+ t.Errorf("error got %q, want nil", c.Err)
+ }
+ if got, want := stdout, ""; got != want {
+ t.Errorf("stdout got %q, want %q", got, want)
+ }
+ if got, want := stderr, rootDir+" already exists"; !strings.Contains(got, want) {
+ t.Errorf("stderr got %q, want substr %q", got, want)
+ }
+}
diff --git a/cmd/jiri/cl.go b/cmd/jiri/cl.go
new file mode 100644
index 0000000..b5a8721
--- /dev/null
+++ b/cmd/jiri/cl.go
@@ -0,0 +1,1120 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "net/url"
+ "os"
+ "path/filepath"
+ "regexp"
+ "strings"
+
+ "v.io/jiri/collect"
+ "v.io/jiri/gerrit"
+ "v.io/jiri/gitutil"
+ "v.io/jiri/jiri"
+ "v.io/jiri/project"
+ "v.io/jiri/runutil"
+ "v.io/x/lib/cmdline"
+)
+
+const (
+ commitMessageFileName = ".gerrit_commit_message"
+ dependencyPathFileName = ".dependency_path"
+)
+
+var (
+ autosubmitFlag bool
+ ccsFlag string
+ draftFlag bool
+ editFlag bool
+ forceFlag bool
+ hostFlag string
+ messageFlag string
+ presubmitFlag string
+ remoteBranchFlag string
+ reviewersFlag string
+ setTopicFlag bool
+ topicFlag string
+ uncommittedFlag bool
+ verifyFlag bool
+)
+
+// Special labels stored in the commit message.
+var (
+ // Auto submit label.
+ autosubmitLabelRE *regexp.Regexp = regexp.MustCompile("AutoSubmit")
+
+ // Change-Ids start with 'I' and are followed by 40 characters of hex.
+ changeIDRE *regexp.Regexp = regexp.MustCompile("Change-Id: (I[0123456789abcdefABCDEF]{40})")
+
+ // Presubmit test label.
+ // PresubmitTest: <type>
+ presubmitTestLabelRE *regexp.Regexp = regexp.MustCompile(`PresubmitTest:\s*(.*)`)
+)
+
+// init carries out the package initialization.
+func init() {
+ cmdCLCleanup.Flags.BoolVar(&forceFlag, "f", false, `Ignore unmerged changes.`)
+ cmdCLCleanup.Flags.StringVar(&remoteBranchFlag, "remote-branch", "master", `Name of the remote branch the CL pertains to, without the leading "origin/".`)
+ cmdCLMail.Flags.BoolVar(&autosubmitFlag, "autosubmit", false, `Automatically submit the changelist when feasible.`)
+ cmdCLMail.Flags.StringVar(&ccsFlag, "cc", "", `Comma-seperated list of emails or LDAPs to cc.`)
+ cmdCLMail.Flags.BoolVar(&draftFlag, "d", false, `Send a draft changelist.`)
+ cmdCLMail.Flags.BoolVar(&editFlag, "edit", true, `Open an editor to edit the CL description.`)
+ cmdCLMail.Flags.StringVar(&hostFlag, "host", "", `Gerrit host to use. Defaults to gerrit host specified in manifest.`)
+ cmdCLMail.Flags.StringVar(&messageFlag, "m", "", `CL description.`)
+ cmdCLMail.Flags.StringVar(&presubmitFlag, "presubmit", string(gerrit.PresubmitTestTypeAll),
+ fmt.Sprintf("The type of presubmit tests to run. Valid values: %s.", strings.Join(gerrit.PresubmitTestTypes(), ",")))
+ cmdCLMail.Flags.StringVar(&remoteBranchFlag, "remote-branch", "master", `Name of the remote branch the CL pertains to, without the leading "origin/".`)
+ cmdCLMail.Flags.StringVar(&reviewersFlag, "r", "", `Comma-seperated list of emails or LDAPs to request review.`)
+ cmdCLMail.Flags.BoolVar(&setTopicFlag, "set-topic", true, `Set Gerrit CL topic.`)
+ cmdCLMail.Flags.StringVar(&topicFlag, "topic", "", `CL topic, defaults to <username>-<branchname>.`)
+ cmdCLMail.Flags.BoolVar(&uncommittedFlag, "check-uncommitted", true, `Check that no uncommitted changes exist.`)
+ cmdCLMail.Flags.BoolVar(&verifyFlag, "verify", true, `Run pre-push git hooks.`)
+ cmdCLSync.Flags.StringVar(&remoteBranchFlag, "remote-branch", "master", `Name of the remote branch the CL pertains to, without the leading "origin/".`)
+}
+
+func getCommitMessageFileName(jirix *jiri.X, branch string) (string, error) {
+ topLevel, err := gitutil.New(jirix.NewSeq()).TopLevel()
+ if err != nil {
+ return "", err
+ }
+ return filepath.Join(topLevel, jiri.ProjectMetaDir, branch, commitMessageFileName), nil
+}
+
+func getDependencyPathFileName(jirix *jiri.X, branch string) (string, error) {
+ topLevel, err := gitutil.New(jirix.NewSeq()).TopLevel()
+ if err != nil {
+ return "", err
+ }
+ return filepath.Join(topLevel, jiri.ProjectMetaDir, branch, dependencyPathFileName), nil
+}
+
+func getDependentCLs(jirix *jiri.X, branch string) ([]string, error) {
+ file, err := getDependencyPathFileName(jirix, branch)
+ if err != nil {
+ return nil, err
+ }
+ data, err := jirix.NewSeq().ReadFile(file)
+ var branches []string
+ if err != nil {
+ if !runutil.IsNotExist(err) {
+ return nil, err
+ }
+ if branch != remoteBranchFlag {
+ branches = []string{remoteBranchFlag}
+ }
+ } else {
+ branches = strings.Split(strings.TrimSpace(string(data)), "\n")
+ }
+ return branches, nil
+}
+
+// cmdCL represents the "jiri cl" command.
+var cmdCL = &cmdline.Command{
+ Name: "cl",
+ Short: "Manage project changelists",
+ Long: "Manage project changelists.",
+ Children: []*cmdline.Command{cmdCLCleanup, cmdCLMail, cmdCLNew, cmdCLSync},
+}
+
+// cmdCLCleanup represents the "jiri cl cleanup" command.
+//
+// TODO(jsimsa): Replace this with a "submit" command that talks to
+// Gerrit to submit the CL and then (optionally) removes it locally.
+var cmdCLCleanup = &cmdline.Command{
+ Runner: jiri.RunnerFunc(runCLCleanup),
+ Name: "cleanup",
+ Short: "Clean up changelists that have been merged",
+ Long: `
+Command "cleanup" checks that the given branches have been merged into
+the corresponding remote branch. If a branch differs from the
+corresponding remote branch, the command reports the difference and
+stops. Otherwise, it deletes the given branches.
+`,
+ ArgsName: "<branches>",
+ ArgsLong: "<branches> is a list of branches to cleanup.",
+}
+
+func cleanupCL(jirix *jiri.X, branches []string) (e error) {
+ originalBranch, err := gitutil.New(jirix.NewSeq()).CurrentBranchName()
+ if err != nil {
+ return err
+ }
+ stashed, err := gitutil.New(jirix.NewSeq()).Stash()
+ if err != nil {
+ return err
+ }
+ if stashed {
+ defer collect.Error(func() error { return gitutil.New(jirix.NewSeq()).StashPop() }, &e)
+ }
+ if err := gitutil.New(jirix.NewSeq()).CheckoutBranch(remoteBranchFlag); err != nil {
+ return err
+ }
+ checkoutOriginalBranch := true
+ defer collect.Error(func() error {
+ if checkoutOriginalBranch {
+ return gitutil.New(jirix.NewSeq()).CheckoutBranch(originalBranch)
+ }
+ return nil
+ }, &e)
+ if err := gitutil.New(jirix.NewSeq()).FetchRefspec("origin", remoteBranchFlag); err != nil {
+ return err
+ }
+ s := jirix.NewSeq()
+ for _, branch := range branches {
+ cleanupFn := func() error { return cleanupBranch(jirix, branch) }
+ if err := s.Call(cleanupFn, "Cleaning up branch: %s", branch).Done(); err != nil {
+ return err
+ }
+ if branch == originalBranch {
+ checkoutOriginalBranch = false
+ }
+ }
+ return nil
+}
+
+func cleanupBranch(jirix *jiri.X, branch string) error {
+ if err := gitutil.New(jirix.NewSeq()).CheckoutBranch(branch); err != nil {
+ return err
+ }
+ if !forceFlag {
+ trackingBranch := "origin/" + remoteBranchFlag
+ if err := gitutil.New(jirix.NewSeq()).Merge(trackingBranch); err != nil {
+ return err
+ }
+ files, err := gitutil.New(jirix.NewSeq()).ModifiedFiles(trackingBranch, branch)
+ if err != nil {
+ return err
+ }
+ if len(files) != 0 {
+ return fmt.Errorf("unmerged changes in\n%s", strings.Join(files, "\n"))
+ }
+ }
+ if err := gitutil.New(jirix.NewSeq()).CheckoutBranch(remoteBranchFlag); err != nil {
+ return err
+ }
+ if err := gitutil.New(jirix.NewSeq()).DeleteBranch(branch, gitutil.ForceOpt(true)); err != nil {
+ return err
+ }
+ reviewBranch := branch + "-REVIEW"
+ if gitutil.New(jirix.NewSeq()).BranchExists(reviewBranch) {
+ if err := gitutil.New(jirix.NewSeq()).DeleteBranch(reviewBranch, gitutil.ForceOpt(true)); err != nil {
+ return err
+ }
+ }
+ // Delete branch metadata.
+ topLevel, err := gitutil.New(jirix.NewSeq()).TopLevel()
+ if err != nil {
+ return err
+ }
+ s := jirix.NewSeq()
+ // Remove the branch from all dependency paths.
+ metadataDir := filepath.Join(topLevel, jiri.ProjectMetaDir)
+ fileInfos, err := s.RemoveAll(filepath.Join(metadataDir, branch)).
+ ReadDir(metadataDir)
+ if err != nil {
+ return err
+ }
+ for _, fileInfo := range fileInfos {
+ if !fileInfo.IsDir() {
+ continue
+ }
+ file, err := getDependencyPathFileName(jirix, fileInfo.Name())
+ if err != nil {
+ return err
+ }
+ data, err := s.ReadFile(file)
+ if err != nil {
+ if !runutil.IsNotExist(err) {
+ return err
+ }
+ continue
+ }
+ branches := strings.Split(string(data), "\n")
+ for i, tmpBranch := range branches {
+ if branch == tmpBranch {
+ data := []byte(strings.Join(append(branches[:i], branches[i+1:]...), "\n"))
+ if err := s.WriteFile(file, data, os.FileMode(0644)).Done(); err != nil {
+ return err
+ }
+ break
+ }
+ }
+ }
+ return nil
+}
+
+func runCLCleanup(jirix *jiri.X, args []string) error {
+ if len(args) == 0 {
+ return jirix.UsageErrorf("cleanup requires at least one argument")
+ }
+ return cleanupCL(jirix, args)
+}
+
+// cmdCLMail represents the "jiri cl mail" command.
+var cmdCLMail = &cmdline.Command{
+ Runner: jiri.RunnerFunc(runCLMail),
+ Name: "mail",
+ Short: "Mail a changelist for review",
+ Long: `
+Command "mail" squashes all commits of a local branch into a single
+"changelist" and mails this changelist to Gerrit as a single
+commit. First time the command is invoked, it generates a Change-Id
+for the changelist, which is appended to the commit
+message. Consecutive invocations of the command use the same Change-Id
+by default, informing Gerrit that the incomming commit is an update of
+an existing changelist.
+`,
+}
+
+type changeConflictError struct {
+ localBranch string
+ message string
+ remoteBranch string
+}
+
+func (e changeConflictError) Error() string {
+ result := "changelist conflicts with the remote " + e.remoteBranch + " branch\n\n"
+ result += "To resolve this problem, run 'git pull origin " + e.remoteBranch + ":" + e.localBranch + "',\n"
+ result += "resolve the conflicts identified below, and then try again.\n"
+ result += e.message
+ return result
+}
+
+type emptyChangeError struct{}
+
+func (_ emptyChangeError) Error() string {
+ return "current branch has no commits"
+}
+
+type gerritError string
+
+func (e gerritError) Error() string {
+ result := "sending code review failed\n\n"
+ result += string(e)
+ return result
+}
+
+type noChangeIDError struct{}
+
+func (_ noChangeIDError) Error() string {
+ result := "changelist is missing a Change-ID"
+ return result
+}
+
+type uncommittedChangesError []string
+
+func (e uncommittedChangesError) Error() string {
+ result := "uncommitted local changes in files:\n"
+ result += " " + strings.Join(e, "\n ")
+ return result
+}
+
+var defaultMessageHeader = `
+# Describe your changelist, specifying what package(s) your change
+# pertains to, followed by a short summary and, in case of non-trivial
+# changelists, provide a detailed description.
+#
+# For example:
+#
+# rpc/stream/proxy: add publish address
+#
+# The listen address is not always the same as the address that external
+# users need to connect to. This CL adds a new argument to proxy.New()
+# to specify the published address that clients should connect to.
+
+# FYI, you are about to submit the following local commits for review:
+#
+`
+
+// currentProject returns the Project containing the current working directory.
+// The current working directory must be inside JIRI_ROOT.
+func currentProject(jirix *jiri.X) (project.Project, error) {
+ dir, err := os.Getwd()
+ if err != nil {
+ return project.Project{}, fmt.Errorf("os.Getwd() failed: %v", err)
+ }
+
+ // Error if current working dir is not inside jirix.Root.
+ if !strings.HasPrefix(dir, jirix.Root) {
+ return project.Project{}, fmt.Errorf("'jiri cl mail' must be run from within a project in JIRI_ROOT")
+ }
+
+ // Walk up the path until we find a project at that path, or hit the jirix.Root.
+ for dir != jirix.Root {
+ p, err := project.ProjectAtPath(jirix, dir)
+ if err != nil {
+ dir = filepath.Dir(dir)
+ continue
+ }
+ return p, nil
+ }
+ return project.Project{}, fmt.Errorf("directory %q is not contained in a project", dir)
+}
+
+// runCLMail is a wrapper that sets up and runs a review instance.
+func runCLMail(jirix *jiri.X, _ []string) error {
+ // Sanity checks for the <presubmitFlag> flag.
+ if !checkPresubmitFlag() {
+ return jirix.UsageErrorf("invalid value for the -presubmit flag. Valid values: %s.",
+ strings.Join(gerrit.PresubmitTestTypes(), ","))
+ }
+
+ p, err := currentProject(jirix)
+ if err != nil {
+ return err
+ }
+
+ host := hostFlag
+ if host == "" {
+ if p.GerritHost == "" {
+ return fmt.Errorf("No gerrit host found. Please use the '--host' flag, or add a 'gerrithost' attribute for project %q.", p.Name)
+ }
+ host = p.GerritHost
+ }
+ hostUrl, err := url.Parse(host)
+ if err != nil {
+ return fmt.Errorf("invalid Gerrit host %q: %v", host, err)
+ }
+ projectRemoteUrl, err := url.Parse(p.Remote)
+ if err != nil {
+ return fmt.Errorf("invalid project remote: %v", p.Remote, err)
+ }
+ gerritRemote := *hostUrl
+ gerritRemote.Path = projectRemoteUrl.Path
+
+ // Create and run the review.
+ review, err := newReview(jirix, gerrit.CLOpts{
+ Autosubmit: autosubmitFlag,
+ Ccs: parseEmails(ccsFlag),
+ Draft: draftFlag,
+ Edit: editFlag,
+ Remote: gerritRemote.String(),
+ Host: hostUrl,
+ Presubmit: gerrit.PresubmitTestType(presubmitFlag),
+ RemoteBranch: remoteBranchFlag,
+ Reviewers: parseEmails(reviewersFlag),
+ Verify: verifyFlag,
+ })
+ if err != nil {
+ return err
+ }
+ if confirmed, err := review.confirmFlagChanges(); err != nil {
+ return err
+ } else if !confirmed {
+ return nil
+ }
+ return review.run()
+}
+
+// parseEmails input a list of comma separated tokens and outputs a
+// list of email addresses. The tokens can either be email addresses
+// or Google LDAPs in which case the suffix @google.com is appended to
+// them to turn them into email addresses.
+func parseEmails(value string) []string {
+ var emails []string
+ tokens := strings.Split(value, ",")
+ for _, token := range tokens {
+ if token == "" {
+ continue
+ }
+ if !strings.Contains(token, "@") {
+ token += "@google.com"
+ }
+ emails = append(emails, token)
+ }
+ return emails
+}
+
+// checkDependents makes sure that all CLs in the sequence of
+// dependent CLs leading to (but not including) the current branch
+// have been exported to Gerrit.
+func checkDependents(jirix *jiri.X) (e error) {
+ originalBranch, err := gitutil.New(jirix.NewSeq()).CurrentBranchName()
+ if err != nil {
+ return err
+ }
+ branches, err := getDependentCLs(jirix, originalBranch)
+ if err != nil {
+ return err
+ }
+ for i := 1; i < len(branches); i++ {
+ file, err := getCommitMessageFileName(jirix, branches[i])
+ if err != nil {
+ return err
+ }
+ if _, err := jirix.NewSeq().Stat(file); err != nil {
+ if !runutil.IsNotExist(err) {
+ return err
+ }
+ return fmt.Errorf(`Failed to export the branch %q to Gerrit because its ancestor %q has not been exported to Gerrit yet.
+The following steps are needed before the operation can be retried:
+$ git checkout %v
+$ jiri cl mail
+$ git checkout %v
+# retry the original command
+`, originalBranch, branches[i], branches[i], originalBranch)
+ }
+ }
+
+ return nil
+}
+
+type review struct {
+ jirix *jiri.X
+ reviewBranch string
+ gerrit.CLOpts
+}
+
+func newReview(jirix *jiri.X, opts gerrit.CLOpts) (*review, error) {
+ // Sync all CLs in the sequence of dependent CLs ending in the
+ // current branch.
+ if err := syncCL(jirix); err != nil {
+ return nil, err
+ }
+
+ // Make sure that all CLs in the above sequence (possibly except for
+ // the current branch) have been exported to Gerrit. This is needed
+ // to make sure we have commit messages for all but the last CL.
+ //
+ // NOTE: The alternative here is to prompt the user for multiple
+ // commit messages, which seems less user friendly.
+ if err := checkDependents(jirix); err != nil {
+ return nil, err
+ }
+
+ branch, err := gitutil.New(jirix.NewSeq()).CurrentBranchName()
+ if err != nil {
+ return nil, err
+ }
+ opts.Branch = branch
+ if opts.Topic == "" {
+ opts.Topic = fmt.Sprintf("%s-%s", os.Getenv("USER"), branch) // use <username>-<branchname> as the default
+ }
+ if opts.Presubmit == gerrit.PresubmitTestType("") {
+ opts.Presubmit = gerrit.PresubmitTestTypeAll // use gerrit.PresubmitTestTypeAll as the default
+ }
+ if opts.RemoteBranch == "" {
+ opts.RemoteBranch = "master" // use master as the default
+ }
+ return &review{
+ jirix: jirix,
+ reviewBranch: branch + "-REVIEW",
+ CLOpts: opts,
+ }, nil
+}
+
+func checkPresubmitFlag() bool {
+ for _, t := range gerrit.PresubmitTestTypes() {
+ if presubmitFlag == t {
+ return true
+ }
+ }
+ return false
+}
+
+// confirmFlagChanges asks users to confirm if any of the
+// presubmit and autosubmit flags changes.
+func (review *review) confirmFlagChanges() (bool, error) {
+ file, err := getCommitMessageFileName(review.jirix, review.CLOpts.Branch)
+ if err != nil {
+ return false, err
+ }
+ bytes, err := review.jirix.NewSeq().ReadFile(file)
+ if err != nil {
+ if runutil.IsNotExist(err) {
+ return true, nil
+ }
+ return false, err
+ }
+ content := string(bytes)
+ changes := []string{}
+
+ // Check presubmit label change.
+ prevPresubmitType := string(gerrit.PresubmitTestTypeAll)
+ matches := presubmitTestLabelRE.FindStringSubmatch(content)
+ if matches != nil {
+ prevPresubmitType = matches[1]
+ }
+ if presubmitFlag != prevPresubmitType {
+ changes = append(changes, fmt.Sprintf("- presubmit=%s to presubmit=%s", prevPresubmitType, presubmitFlag))
+ }
+
+ // Check autosubmit label change.
+ prevAutosubmit := autosubmitLabelRE.MatchString(content)
+ if autosubmitFlag != prevAutosubmit {
+ changes = append(changes, fmt.Sprintf("- autosubmit=%v to autosubmit=%v", prevAutosubmit, autosubmitFlag))
+
+ }
+
+ if len(changes) > 0 {
+ fmt.Printf("Changes:\n%s\n", strings.Join(changes, "\n"))
+ fmt.Print("Are you sure you want to make the above changes? y/N:")
+ var response string
+ if _, err := fmt.Scanf("%s\n", &response); err != nil || response != "y" {
+ return false, nil
+ }
+ }
+ return true, nil
+}
+
+// cleanup cleans up after the review.
+func (review *review) cleanup(stashed bool) error {
+ if err := gitutil.New(review.jirix.NewSeq()).CheckoutBranch(review.CLOpts.Branch); err != nil {
+ return err
+ }
+ if gitutil.New(review.jirix.NewSeq()).BranchExists(review.reviewBranch) {
+ if err := gitutil.New(review.jirix.NewSeq()).DeleteBranch(review.reviewBranch, gitutil.ForceOpt(true)); err != nil {
+ return err
+ }
+ }
+ if stashed {
+ if err := gitutil.New(review.jirix.NewSeq()).StashPop(); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// createReviewBranch creates a clean review branch from the remote
+// branch this CL pertains to and then iterates over the sequence of
+// dependent CLs leading to the current branch, creating one commit
+// per CL by squashing all commits of each individual CL. The commit
+// message for all but that last CL is derived from their
+// <commitMessageFileName>, while the <message> argument is used as
+// the commit message for the last commit.
+func (review *review) createReviewBranch(message string) (e error) {
+ // Create the review branch.
+ if err := gitutil.New(review.jirix.NewSeq()).FetchRefspec("origin", review.CLOpts.RemoteBranch); err != nil {
+ return err
+ }
+ if gitutil.New(review.jirix.NewSeq()).BranchExists(review.reviewBranch) {
+ if err := gitutil.New(review.jirix.NewSeq()).DeleteBranch(review.reviewBranch, gitutil.ForceOpt(true)); err != nil {
+ return err
+ }
+ }
+ upstream := "origin/" + review.CLOpts.RemoteBranch
+ if err := gitutil.New(review.jirix.NewSeq()).CreateBranchWithUpstream(review.reviewBranch, upstream); err != nil {
+ return err
+ }
+ if err := gitutil.New(review.jirix.NewSeq()).CheckoutBranch(review.reviewBranch); err != nil {
+ return err
+ }
+ // Register a cleanup handler in case of subsequent errors.
+ cleanup := true
+ defer collect.Error(func() error {
+ if !cleanup {
+ return gitutil.New(review.jirix.NewSeq()).CheckoutBranch(review.CLOpts.Branch)
+ }
+ gitutil.New(review.jirix.NewSeq()).CheckoutBranch(review.CLOpts.Branch, gitutil.ForceOpt(true))
+ gitutil.New(review.jirix.NewSeq()).DeleteBranch(review.reviewBranch, gitutil.ForceOpt(true))
+ return nil
+ }, &e)
+
+ // Report an error if the CL is empty.
+ if !review.jirix.DryRun() {
+ hasDiff, err := gitutil.New(review.jirix.NewSeq()).BranchesDiffer(review.CLOpts.Branch, review.reviewBranch)
+ if err != nil {
+ return err
+ }
+ if !hasDiff {
+ return emptyChangeError(struct{}{})
+ }
+ }
+
+ // If <message> is empty, replace it with the default message.
+ if len(message) == 0 {
+ var err error
+ message, err = review.defaultCommitMessage()
+ if err != nil {
+ return err
+ }
+ }
+
+ // Iterate over all dependent CLs leading to (and including) the
+ // current branch, creating one commit in the review branch per CL
+ // by squashing all commits of each individual CL.
+ branches, err := getDependentCLs(review.jirix, review.CLOpts.Branch)
+ if err != nil {
+ return err
+ }
+ branches = append(branches, review.CLOpts.Branch)
+ if err := review.squashBranches(branches, message); err != nil {
+ return err
+ }
+
+ cleanup = false
+ return nil
+}
+
+// squashBranches iterates over the given list of branches, creating
+// one commit per branch in the current branch by squashing all
+// commits of each individual branch.
+//
+// TODO(jsimsa): Consider using "git rebase --onto" to avoid having to
+// deal with merge conflicts.
+func (review *review) squashBranches(branches []string, message string) (e error) {
+ for i := 1; i < len(branches); i++ {
+ // We want to merge the <branches[i]> branch on top of the review
+ // branch, forcing all conflicts to be reviewed in favor of the
+ // <branches[i]> branch. Unfortunately, git merge does not offer a
+ // strategy that would do that for us. The solution implemented
+ // here is based on:
+ //
+ // http://stackoverflow.com/questions/173919/is-there-a-theirs-version-of-git-merge-s-ours
+ if err := gitutil.New(review.jirix.NewSeq()).Merge(branches[i], gitutil.SquashOpt(true), gitutil.StrategyOpt("ours")); err != nil {
+ return changeConflictError{
+ localBranch: branches[i],
+ remoteBranch: review.CLOpts.RemoteBranch,
+ message: err.Error(),
+ }
+ }
+ // Fetch the timestamp of the last commit of <branches[i]> and use
+ // it to create the squashed commit. This is needed to make sure
+ // that the commit hash of the squashed commit stays the same as
+ // long as the squashed sequence of commits does not change. If
+ // this was not the case, consecutive invocations of "jiri cl mail"
+ // could fail if some, but not all, of the dependent CLs submitted
+ // to Gerrit have changed.
+ output, err := gitutil.New(review.jirix.NewSeq()).Log(branches[i], branches[i]+"^", "%ad%n%cd")
+ if err != nil {
+ return err
+ }
+ if len(output) < 1 || len(output[0]) < 2 {
+ return fmt.Errorf("unexpected output length: %v", output)
+ }
+ authorDate := gitutil.AuthorDateOpt(output[0][0])
+ committer := gitutil.CommitterDateOpt(output[0][1])
+ git := gitutil.New(review.jirix.NewSeq(), authorDate, committer)
+ if i < len(branches)-1 {
+ file, err := getCommitMessageFileName(review.jirix, branches[i])
+ if err != nil {
+ return err
+ }
+ message, err := review.jirix.NewSeq().ReadFile(file)
+ if err != nil {
+ return err
+ }
+ if err := git.CommitWithMessage(string(message)); err != nil {
+ return err
+ }
+ } else {
+ committer := git.NewCommitter(review.CLOpts.Edit)
+ if err := committer.Commit(message); err != nil {
+ return err
+ }
+ }
+ tmpBranch := review.reviewBranch + "-" + branches[i] + "-TMP"
+ if err := git.CreateBranch(tmpBranch); err != nil {
+ return err
+ }
+ defer collect.Error(func() error {
+ return gitutil.New(review.jirix.NewSeq()).DeleteBranch(tmpBranch, gitutil.ForceOpt(true))
+ }, &e)
+ if err := git.Reset(branches[i]); err != nil {
+ return err
+ }
+ if err := git.Reset(tmpBranch, gitutil.ModeOpt("soft")); err != nil {
+ return err
+ }
+ if err := git.CommitAmend(); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// defaultCommitMessage creates the default commit message from the
+// list of commits on the branch.
+func (review *review) defaultCommitMessage() (string, error) {
+ commitMessages, err := gitutil.New(review.jirix.NewSeq()).CommitMessages(review.CLOpts.Branch, review.reviewBranch)
+ if err != nil {
+ return "", err
+ }
+ // Strip "Change-Id: ..." from the commit messages.
+ strippedMessages := changeIDRE.ReplaceAllLiteralString(commitMessages, "")
+ // Add comment markers (#) to every line.
+ commentedMessages := "# " + strings.Replace(strippedMessages, "\n", "\n# ", -1)
+ message := defaultMessageHeader + commentedMessages
+ return message, nil
+}
+
+// ensureChangeID makes sure that the last commit contains a Change-Id, and
+// returns an error if it does not.
+func (review *review) ensureChangeID() error {
+ latestCommitMessage, err := gitutil.New(review.jirix.NewSeq()).LatestCommitMessage()
+ if err != nil {
+ return err
+ }
+ changeID := changeIDRE.FindString(latestCommitMessage)
+ if changeID == "" {
+ return noChangeIDError(struct{}{})
+ }
+ return nil
+}
+
+// processLabels adds/removes labels for the given commit message.
+func (review *review) processLabels(message string) string {
+ // Find the Change-ID line.
+ changeIDLine := changeIDRE.FindString(message)
+
+ // Strip existing labels and change-ID.
+ message = autosubmitLabelRE.ReplaceAllLiteralString(message, "")
+ message = presubmitTestLabelRE.ReplaceAllLiteralString(message, "")
+ message = changeIDRE.ReplaceAllLiteralString(message, "")
+
+ // Insert labels and change-ID back.
+ if review.CLOpts.Autosubmit {
+ message += fmt.Sprintf("AutoSubmit\n")
+ }
+ if review.CLOpts.Presubmit != gerrit.PresubmitTestTypeAll {
+ message += fmt.Sprintf("PresubmitTest: %s\n", review.CLOpts.Presubmit)
+ }
+ if changeIDLine != "" && !strings.HasSuffix(message, "\n") {
+ message += "\n"
+ }
+ message += changeIDLine
+
+ return message
+}
+
+// run implements checks that the review passes all local checks
+// and then mails it to Gerrit.
+func (review *review) run() (e error) {
+ if uncommittedFlag {
+ changes, err := gitutil.New(review.jirix.NewSeq()).FilesWithUncommittedChanges()
+ if err != nil {
+ return err
+ }
+ if len(changes) != 0 {
+ return uncommittedChangesError(changes)
+ }
+ }
+ if review.CLOpts.Branch == remoteBranchFlag {
+ return fmt.Errorf("cannot do a review from the %q branch.", remoteBranchFlag)
+ }
+ stashed, err := gitutil.New(review.jirix.NewSeq()).Stash()
+ if err != nil {
+ return err
+ }
+ wd, err := os.Getwd()
+ if err != nil {
+ return fmt.Errorf("Getwd() failed: %v", err)
+ }
+ defer collect.Error(func() error { return review.jirix.NewSeq().Chdir(wd).Done() }, &e)
+ topLevel, err := gitutil.New(review.jirix.NewSeq()).TopLevel()
+ if err != nil {
+ return err
+ }
+ s := review.jirix.NewSeq()
+ if err := s.Chdir(topLevel).Done(); err != nil {
+ return err
+ }
+ defer collect.Error(func() error { return review.cleanup(stashed) }, &e)
+ file, err := getCommitMessageFileName(review.jirix, review.CLOpts.Branch)
+ if err != nil {
+ return err
+ }
+ message := messageFlag
+ if message == "" {
+ // Message was not passed in flag. Attempt to read it from file.
+ data, err := s.ReadFile(file)
+ if err != nil {
+ if !runutil.IsNotExist(err) {
+ return err
+ }
+ } else {
+ message = string(data)
+ }
+ }
+
+ // Add/remove labels to/from the commit message before asking users
+ // to edit it. We do this only when this is not the initial commit
+ // where the message is empty.
+ //
+ // For the initial commit, the labels will be processed after the
+ // message is edited by users, which happens in the
+ // updateReviewMessage method.
+ if message != "" {
+ message = review.processLabels(message)
+ }
+ if err := review.createReviewBranch(message); err != nil {
+ return err
+ }
+ if err := review.updateReviewMessage(file); err != nil {
+ return err
+ }
+ if err := review.send(); err != nil {
+ return err
+ }
+ if setTopicFlag {
+ if err := review.setTopic(); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// send mails the current branch out for review.
+func (review *review) send() error {
+ if !review.jirix.DryRun() {
+ if err := review.ensureChangeID(); err != nil {
+ return err
+ }
+ }
+ if err := gerrit.Push(review.jirix.NewSeq(), review.CLOpts); err != nil {
+ return gerritError(err.Error())
+ }
+ return nil
+}
+
+// getChangeID reads the commit message and extracts the change-Id.
+func (review *review) getChangeID() (string, error) {
+ file, err := getCommitMessageFileName(review.jirix, review.CLOpts.Branch)
+ if err != nil {
+ return "", err
+ }
+ bytes, err := review.jirix.NewSeq().ReadFile(file)
+ if err != nil {
+ return "", err
+ }
+ changeID := changeIDRE.FindSubmatch(bytes)
+ if changeID == nil || len(changeID) < 2 {
+ return "", fmt.Errorf("could not find Change-Id in:\n%s", bytes)
+ }
+ return string(changeID[1]), nil
+}
+
+// setTopic sets the topic for the CL corresponding to the branch the
+// review was created for.
+func (review *review) setTopic() error {
+ changeID, err := review.getChangeID()
+ if err != nil {
+ return err
+ }
+ host := review.CLOpts.Host
+ if host.Scheme != "http" && host.Scheme != "https" {
+ return fmt.Errorf("Cannot set topic for gerrit host %q. Please use a host url with 'https' scheme or run with '--set-topic=false'.", host.String())
+ }
+ if err := review.jirix.Gerrit(host).SetTopic(changeID, review.CLOpts); err != nil {
+ return err
+ }
+ return nil
+}
+
+// updateReviewMessage writes the commit message to the given file.
+func (review *review) updateReviewMessage(file string) error {
+ if err := gitutil.New(review.jirix.NewSeq()).CheckoutBranch(review.reviewBranch); err != nil {
+ return err
+ }
+ newMessage, err := gitutil.New(review.jirix.NewSeq()).LatestCommitMessage()
+ if err != nil {
+ return err
+ }
+ s := review.jirix.NewSeq()
+ // For the initial commit where the commit message file doesn't exist,
+ // add/remove labels after users finish editing the commit message.
+ //
+ // This behavior is consistent with how Change-ID is added for the
+ // initial commit so we don't confuse users.
+ if _, err := s.Stat(file); err != nil {
+ if runutil.IsNotExist(err) {
+ newMessage = review.processLabels(newMessage)
+ if err := gitutil.New(review.jirix.NewSeq()).CommitAmendWithMessage(newMessage); err != nil {
+ return err
+ }
+ } else {
+ return err
+ }
+ }
+ topLevel, err := gitutil.New(review.jirix.NewSeq()).TopLevel()
+ if err != nil {
+ return err
+ }
+ newMetadataDir := filepath.Join(topLevel, jiri.ProjectMetaDir, review.CLOpts.Branch)
+ if err := s.MkdirAll(newMetadataDir, os.FileMode(0755)).
+ WriteFile(file, []byte(newMessage), 0644).Done(); err != nil {
+ return err
+ }
+ return nil
+}
+
+// cmdCLNew represents the "jiri cl new" command.
+var cmdCLNew = &cmdline.Command{
+ Runner: jiri.RunnerFunc(runCLNew),
+ Name: "new",
+ Short: "Create a new local branch for a changelist",
+ Long: fmt.Sprintf(`
+Command "new" creates a new local branch for a changelist. In
+particular, it forks a new branch with the given name from the current
+branch and records the relationship between the current branch and the
+new branch in the %v metadata directory. The information recorded in
+the %v metadata directory tracks dependencies between CLs and is used
+by the "jiri cl sync" and "jiri cl mail" commands.
+`, jiri.ProjectMetaDir, jiri.ProjectMetaDir),
+ ArgsName: "<name>",
+ ArgsLong: "<name> is the changelist name.",
+}
+
+func runCLNew(jirix *jiri.X, args []string) error {
+ if got, want := len(args), 1; got != want {
+ return jirix.UsageErrorf("unexpected number of arguments: got %v, want %v", got, want)
+ }
+ return newCL(jirix, args)
+}
+
+func newCL(jirix *jiri.X, args []string) error {
+ topLevel, err := gitutil.New(jirix.NewSeq()).TopLevel()
+ if err != nil {
+ return err
+ }
+ originalBranch, err := gitutil.New(jirix.NewSeq()).CurrentBranchName()
+ if err != nil {
+ return err
+ }
+
+ // Create a new branch using the current branch.
+ newBranch := args[0]
+ if err := gitutil.New(jirix.NewSeq()).CreateAndCheckoutBranch(newBranch); err != nil {
+ return err
+ }
+
+ // Register a cleanup handler in case of subsequent errors.
+ cleanup := true
+ defer func() {
+ if cleanup {
+ gitutil.New(jirix.NewSeq()).CheckoutBranch(originalBranch, gitutil.ForceOpt(true))
+ gitutil.New(jirix.NewSeq()).DeleteBranch(newBranch, gitutil.ForceOpt(true))
+ }
+ }()
+
+ s := jirix.NewSeq()
+ // Record the dependent CLs for the new branch. The dependent CLs
+ // are recorded in a <dependencyPathFileName> file as a
+ // newline-separated list of branch names.
+ branches, err := getDependentCLs(jirix, originalBranch)
+ if err != nil {
+ return err
+ }
+ branches = append(branches, originalBranch)
+ newMetadataDir := filepath.Join(topLevel, jiri.ProjectMetaDir, newBranch)
+ if err := s.MkdirAll(newMetadataDir, os.FileMode(0755)).Done(); err != nil {
+ return err
+ }
+ file, err := getDependencyPathFileName(jirix, newBranch)
+ if err != nil {
+ return err
+ }
+ if err := s.WriteFile(file, []byte(strings.Join(branches, "\n")), os.FileMode(0644)).Done(); err != nil {
+ return err
+ }
+
+ cleanup = false
+ return nil
+}
+
+// cmdCLSync represents the "jiri cl sync" command.
+var cmdCLSync = &cmdline.Command{
+ Runner: jiri.RunnerFunc(runCLSync),
+ Name: "sync",
+ Short: "Bring a changelist up to date",
+ Long: fmt.Sprintf(`
+Command "sync" brings the CL identified by the current branch up to
+date with the branch tracking the remote branch this CL pertains
+to. To do that, the command uses the information recorded in the %v
+metadata directory to identify the sequence of dependent CLs leading
+to the current branch. The command then iterates over this sequence
+bringing each of the CLs up to date with its ancestor. The end result
+of this process is that all CLs in the sequence are up to date with
+the branch that tracks the remote branch this CL pertains to.
+
+NOTE: It is possible that the command cannot automatically merge
+changes in an ancestor into its dependent. When that occurs, the
+command is aborted and prints instructions that need to be followed
+before the command can be retried.
+`, jiri.ProjectMetaDir),
+}
+
+func runCLSync(jirix *jiri.X, _ []string) error {
+ return syncCL(jirix)
+}
+
+func syncCL(jirix *jiri.X) (e error) {
+ stashed, err := gitutil.New(jirix.NewSeq()).Stash()
+ if err != nil {
+ return err
+ }
+ if stashed {
+ defer collect.Error(func() error { return gitutil.New(jirix.NewSeq()).StashPop() }, &e)
+ }
+
+ // Register a cleanup handler in case of subsequent errors.
+ forceOriginalBranch := true
+ originalBranch, err := gitutil.New(jirix.NewSeq()).CurrentBranchName()
+ if err != nil {
+ return err
+ }
+ originalWd, err := os.Getwd()
+ if err != nil {
+ return err
+ }
+
+ defer func() {
+ if forceOriginalBranch {
+ gitutil.New(jirix.NewSeq()).CheckoutBranch(originalBranch, gitutil.ForceOpt(true))
+ }
+ jirix.NewSeq().Chdir(originalWd)
+ }()
+
+ s := jirix.NewSeq()
+ // Switch to an existing directory in master so we can run commands.
+ topLevel, err := gitutil.New(jirix.NewSeq()).TopLevel()
+ if err != nil {
+ return err
+ }
+ if err := s.Chdir(topLevel).Done(); err != nil {
+ return err
+ }
+
+ // Identify the dependents CLs leading to (and including) the
+ // current branch.
+ branches, err := getDependentCLs(jirix, originalBranch)
+ if err != nil {
+ return err
+ }
+ branches = append(branches, originalBranch)
+
+ // Sync from upstream.
+ if err := gitutil.New(jirix.NewSeq()).CheckoutBranch(branches[0]); err != nil {
+ return err
+ }
+ if err := gitutil.New(jirix.NewSeq()).Pull("origin", branches[0]); err != nil {
+ return err
+ }
+
+ // Bring all CLs in the sequence of dependent CLs leading to the
+ // current branch up to date with the <remoteBranchFlag> branch.
+ for i := 1; i < len(branches); i++ {
+ if err := gitutil.New(jirix.NewSeq()).CheckoutBranch(branches[i]); err != nil {
+ return err
+ }
+ if err := gitutil.New(jirix.NewSeq()).Merge(branches[i-1]); err != nil {
+ return fmt.Errorf(`Failed to automatically merge branch %v into branch %v: %v
+The following steps are needed before the operation can be retried:
+$ git checkout %v
+$ git merge %v
+# resolve all conflicts
+$ git commit -a
+$ git checkout %v
+# retry the original operation
+`, branches[i], branches[i-1], err, branches[i], branches[i-1], originalBranch)
+ }
+ }
+
+ forceOriginalBranch = false
+ return nil
+}
diff --git a/cmd/jiri/cl_test.go b/cmd/jiri/cl_test.go
new file mode 100644
index 0000000..e92f35b
--- /dev/null
+++ b/cmd/jiri/cl_test.go
@@ -0,0 +1,1033 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "bytes"
+ "os"
+ "path"
+ "path/filepath"
+ "runtime"
+ "strings"
+ "testing"
+
+ "v.io/jiri/gerrit"
+ "v.io/jiri/gitutil"
+ "v.io/jiri/jiri"
+ "v.io/jiri/jiritest"
+ "v.io/jiri/runutil"
+)
+
+// assertCommitCount asserts that the commit count between two
+// branches matches the expectedCount.
+func assertCommitCount(t *testing.T, jirix *jiri.X, branch, baseBranch string, expectedCount int) {
+ got, err := gitutil.New(jirix.NewSeq()).CountCommits(branch, baseBranch)
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ if want := 1; got != want {
+ t.Fatalf("unexpected number of commits: got %v, want %v", got, want)
+ }
+}
+
+// assertFileContent asserts that the content of the given file
+// matches the expected content.
+func assertFileContent(t *testing.T, jirix *jiri.X, file, want string) {
+ got, err := jirix.NewSeq().ReadFile(file)
+ if err != nil {
+ t.Fatalf("%v\n", err)
+ }
+ if string(got) != want {
+ t.Fatalf("unexpected content of file %v: got %v, want %v", file, got, want)
+ }
+}
+
+// assertFilesExist asserts that the files exist.
+func assertFilesExist(t *testing.T, jirix *jiri.X, files []string) {
+ s := jirix.NewSeq()
+ for _, file := range files {
+ if _, err := s.Stat(file); err != nil {
+ if runutil.IsNotExist(err) {
+ t.Fatalf("expected file %v to exist but it did not", file)
+ }
+ t.Fatalf("%v", err)
+ }
+ }
+}
+
+// assertFilesDoNotExist asserts that the files do not exist.
+func assertFilesDoNotExist(t *testing.T, jirix *jiri.X, files []string) {
+ s := jirix.NewSeq()
+ for _, file := range files {
+ if _, err := s.Stat(file); err != nil && !runutil.IsNotExist(err) {
+ t.Fatalf("%v", err)
+ } else if err == nil {
+ t.Fatalf("expected file %v to not exist but it did", file)
+ }
+ }
+}
+
+// assertFilesCommitted asserts that the files exist and are committed
+// in the current branch.
+func assertFilesCommitted(t *testing.T, jirix *jiri.X, files []string) {
+ assertFilesExist(t, jirix, files)
+ for _, file := range files {
+ if !gitutil.New(jirix.NewSeq()).IsFileCommitted(file) {
+ t.Fatalf("expected file %v to be committed but it is not", file)
+ }
+ }
+}
+
+// assertFilesNotCommitted asserts that the files exist and are *not*
+// committed in the current branch.
+func assertFilesNotCommitted(t *testing.T, jirix *jiri.X, files []string) {
+ assertFilesExist(t, jirix, files)
+ for _, file := range files {
+ if gitutil.New(jirix.NewSeq()).IsFileCommitted(file) {
+ t.Fatalf("expected file %v not to be committed but it is", file)
+ }
+ }
+}
+
+// assertFilesPushedToRef asserts that the given files have been
+// pushed to the given remote repository reference.
+func assertFilesPushedToRef(t *testing.T, jirix *jiri.X, repoPath, gerritPath, pushedRef string, files []string) {
+ chdir(t, jirix, gerritPath)
+ assertCommitCount(t, jirix, pushedRef, "master", 1)
+ if err := gitutil.New(jirix.NewSeq()).CheckoutBranch(pushedRef); err != nil {
+ t.Fatalf("%v", err)
+ }
+ assertFilesCommitted(t, jirix, files)
+ chdir(t, jirix, repoPath)
+}
+
+// assertStashSize asserts that the stash size matches the expected
+// size.
+func assertStashSize(t *testing.T, jirix *jiri.X, want int) {
+ got, err := gitutil.New(jirix.NewSeq()).StashSize()
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ if got != want {
+ t.Fatalf("unxpected stash size: got %v, want %v", got, want)
+ }
+}
+
+// commitFile commits a file with the specified content into a branch
+func commitFile(t *testing.T, jirix *jiri.X, filename string, content string) {
+ s := jirix.NewSeq()
+ if err := s.WriteFile(filename, []byte(content), 0644).Done(); err != nil {
+ t.Fatalf("%v", err)
+ }
+ commitMessage := "Commit " + filename
+ if err := gitutil.New(jirix.NewSeq()).CommitFile(filename, commitMessage); err != nil {
+ t.Fatalf("%v", err)
+ }
+}
+
+// commitFiles commits the given files into to current branch.
+func commitFiles(t *testing.T, jirix *jiri.X, filenames []string) {
+ // Create and commit the files one at a time.
+ for _, filename := range filenames {
+ content := "This is file " + filename
+ commitFile(t, jirix, filename, content)
+ }
+}
+
+// createRepo creates a new repository with the given prefix.
+func createRepo(t *testing.T, jirix *jiri.X, prefix string) string {
+ s := jirix.NewSeq()
+ repoPath, err := s.TempDir(jirix.Root, "repo-"+prefix)
+ if err != nil {
+ t.Fatalf("TempDir() failed: %v", err)
+ }
+ if err := os.Chmod(repoPath, 0777); err != nil {
+ t.Fatalf("Chmod(%v) failed: %v", repoPath, err)
+ }
+ if err := gitutil.New(jirix.NewSeq()).Init(repoPath); err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := s.MkdirAll(filepath.Join(repoPath, jiri.ProjectMetaDir), os.FileMode(0755)).Done(); err != nil {
+ t.Fatalf("%v", err)
+ }
+ return repoPath
+}
+
+// Simple commit-msg hook that adds a fake Change Id.
+var commitMsgHook string = `#!/bin/sh
+MSG="$1"
+echo "Change-Id: I0000000000000000000000000000000000000000" >> $MSG
+`
+
+// installCommitMsgHook links the gerrit commit-msg hook into a different repo.
+func installCommitMsgHook(t *testing.T, jirix *jiri.X, repoPath string) {
+ hookLocation := path.Join(repoPath, ".git/hooks/commit-msg")
+ if err := jirix.NewSeq().WriteFile(hookLocation, []byte(commitMsgHook), 0755).Done(); err != nil {
+ t.Fatalf("WriteFile(%v) failed: %v", hookLocation, err)
+ }
+}
+
+// chdir changes the runtime working directory and traps any errors.
+func chdir(t *testing.T, jirix *jiri.X, path string) {
+ if err := jirix.NewSeq().Chdir(path).Done(); err != nil {
+ _, file, line, _ := runtime.Caller(1)
+ t.Fatalf("%s: %d: Chdir(%v) failed: %v", file, line, path, err)
+ }
+}
+
+// createRepoFromOrigin creates a Git repo tracking origin/master.
+func createRepoFromOrigin(t *testing.T, jirix *jiri.X, subpath string, originPath string) string {
+ repoPath := createRepo(t, jirix, subpath)
+ chdir(t, jirix, repoPath)
+ if err := gitutil.New(jirix.NewSeq()).AddRemote("origin", originPath); err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := gitutil.New(jirix.NewSeq()).Pull("origin", "master"); err != nil {
+ t.Fatalf("%v", err)
+ }
+ return repoPath
+}
+
+// createTestRepos sets up three local repositories: origin, gerrit,
+// and the main test repository which pulls from origin and can push
+// to gerrit.
+func createTestRepos(t *testing.T, jirix *jiri.X) (string, string, string) {
+ // Create origin.
+ originPath := createRepo(t, jirix, "origin")
+ chdir(t, jirix, originPath)
+ if err := gitutil.New(jirix.NewSeq()).CommitWithMessage("initial commit"); err != nil {
+ t.Fatalf("%v", err)
+ }
+ // Create test repo.
+ repoPath := createRepoFromOrigin(t, jirix, "test", originPath)
+ // Add Gerrit remote.
+ gerritPath := createRepoFromOrigin(t, jirix, "gerrit", originPath)
+ // Switch back to test repo.
+ chdir(t, jirix, repoPath)
+ return repoPath, originPath, gerritPath
+}
+
+// submit mocks a Gerrit review submit by pushing the Gerrit remote to origin.
+// Actually origin pulls from Gerrit since origin isn't actually a bare git repo.
+// Some of our tests actually rely on accessing .git in origin, so it must be non-bare.
+func submit(t *testing.T, jirix *jiri.X, originPath string, gerritPath string, review *review) {
+ cwd, err := os.Getwd()
+ if err != nil {
+ t.Fatalf("Getwd() failed: %v", err)
+ }
+ chdir(t, jirix, originPath)
+ expectedRef := gerrit.Reference(review.CLOpts)
+ if err := gitutil.New(jirix.NewSeq()).Pull(gerritPath, expectedRef); err != nil {
+ t.Fatalf("Pull gerrit to origin failed: %v", err)
+ }
+ chdir(t, jirix, cwd)
+}
+
+// setupTest creates a setup for testing the review tool.
+func setupTest(t *testing.T, installHook bool) (fake *jiritest.FakeJiriRoot, repoPath, originPath, gerritPath string, cleanup func()) {
+ oldWD, err := os.Getwd()
+ if err != nil {
+ t.Fatalf("Getwd() failed: %v", err)
+ }
+ var cleanupFake func()
+ if fake, cleanupFake = jiritest.NewFakeJiriRoot(t); err != nil {
+ t.Fatalf("%v", err)
+ }
+ repoPath, originPath, gerritPath = createTestRepos(t, fake.X)
+ if installHook == true {
+ for _, path := range []string{repoPath, originPath, gerritPath} {
+ installCommitMsgHook(t, fake.X, path)
+ }
+ }
+ chdir(t, fake.X, repoPath)
+ cleanup = func() {
+ chdir(t, fake.X, oldWD)
+ cleanupFake()
+ }
+ return
+}
+
+func createCLWithFiles(t *testing.T, jirix *jiri.X, branch string, files ...string) {
+ if err := newCL(jirix, []string{branch}); err != nil {
+ t.Fatalf("%v", err)
+ }
+ commitFiles(t, jirix, files)
+}
+
+// TestCleanupClean checks that cleanup succeeds if the branch to be
+// cleaned up has been merged with the master.
+func TestCleanupClean(t *testing.T) {
+ fake, repoPath, originPath, _, cleanup := setupTest(t, true)
+ defer cleanup()
+ branch := "my-branch"
+ if err := gitutil.New(fake.X.NewSeq()).CreateAndCheckoutBranch(branch); err != nil {
+ t.Fatalf("%v", err)
+ }
+ commitFiles(t, fake.X, []string{"file1", "file2"})
+ if err := gitutil.New(fake.X.NewSeq()).CheckoutBranch("master"); err != nil {
+ t.Fatalf("%v", err)
+ }
+ chdir(t, fake.X, originPath)
+ commitFiles(t, fake.X, []string{"file1", "file2"})
+ chdir(t, fake.X, repoPath)
+ if err := cleanupCL(fake.X, []string{branch}); err != nil {
+ t.Fatalf("cleanup() failed: %v", err)
+ }
+ if gitutil.New(fake.X.NewSeq()).BranchExists(branch) {
+ t.Fatalf("cleanup failed to remove the feature branch")
+ }
+}
+
+// TestCleanupDirty checks that cleanup is a no-op if the branch to be
+// cleaned up has unmerged changes.
+func TestCleanupDirty(t *testing.T) {
+ fake, _, _, _, cleanup := setupTest(t, true)
+ defer cleanup()
+ branch := "my-branch"
+ if err := gitutil.New(fake.X.NewSeq()).CreateAndCheckoutBranch(branch); err != nil {
+ t.Fatalf("%v", err)
+ }
+ files := []string{"file1", "file2"}
+ commitFiles(t, fake.X, files)
+ if err := gitutil.New(fake.X.NewSeq()).CheckoutBranch("master"); err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := cleanupCL(fake.X, []string{branch}); err == nil {
+ t.Fatalf("cleanup did not fail when it should")
+ }
+ if err := gitutil.New(fake.X.NewSeq()).CheckoutBranch(branch); err != nil {
+ t.Fatalf("%v", err)
+ }
+ assertFilesCommitted(t, fake.X, files)
+}
+
+// TestCreateReviewBranch checks that the temporary review branch is
+// created correctly.
+func TestCreateReviewBranch(t *testing.T) {
+ fake, _, _, _, cleanup := setupTest(t, true)
+ defer cleanup()
+ branch := "my-branch"
+ if err := gitutil.New(fake.X.NewSeq()).CreateAndCheckoutBranch(branch); err != nil {
+ t.Fatalf("%v", err)
+ }
+ files := []string{"file1", "file2", "file3"}
+ commitFiles(t, fake.X, files)
+ review, err := newReview(fake.X, gerrit.CLOpts{})
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ if expected, got := branch+"-REVIEW", review.reviewBranch; expected != got {
+ t.Fatalf("Unexpected review branch name: expected %v, got %v", expected, got)
+ }
+ commitMessage := "squashed commit"
+ if err := review.createReviewBranch(commitMessage); err != nil {
+ t.Fatalf("%v", err)
+ }
+ // Verify that the branch exists.
+ if !gitutil.New(fake.X.NewSeq()).BranchExists(review.reviewBranch) {
+ t.Fatalf("review branch not found")
+ }
+ if err := gitutil.New(fake.X.NewSeq()).CheckoutBranch(review.reviewBranch); err != nil {
+ t.Fatalf("%v", err)
+ }
+ assertCommitCount(t, fake.X, review.reviewBranch, "master", 1)
+ assertFilesCommitted(t, fake.X, files)
+}
+
+// TestCreateReviewBranchWithEmptyChange checks that running
+// createReviewBranch() on a branch with no changes will result in an
+// EmptyChangeError.
+func TestCreateReviewBranchWithEmptyChange(t *testing.T) {
+ fake, _, _, _, cleanup := setupTest(t, true)
+ defer cleanup()
+ branch := "my-branch"
+ if err := gitutil.New(fake.X.NewSeq()).CreateAndCheckoutBranch(branch); err != nil {
+ t.Fatalf("%v", err)
+ }
+ review, err := newReview(fake.X, gerrit.CLOpts{Remote: branch})
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ commitMessage := "squashed commit"
+ err = review.createReviewBranch(commitMessage)
+ if err == nil {
+ t.Fatalf("creating a review did not fail when it should")
+ }
+ if _, ok := err.(emptyChangeError); !ok {
+ t.Fatalf("unexpected error type: %v", err)
+ }
+}
+
+// TestSendReview checks the various options for sending a review.
+func TestSendReview(t *testing.T) {
+ fake, repoPath, _, gerritPath, cleanup := setupTest(t, true)
+ defer cleanup()
+ branch := "my-branch"
+ if err := gitutil.New(fake.X.NewSeq()).CreateAndCheckoutBranch(branch); err != nil {
+ t.Fatalf("%v", err)
+ }
+ files := []string{"file1"}
+ commitFiles(t, fake.X, files)
+ {
+ // Test with draft = false, no reviewiers, and no ccs.
+ review, err := newReview(fake.X, gerrit.CLOpts{Remote: gerritPath})
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := review.send(); err != nil {
+ t.Fatalf("failed to send a review: %v", err)
+ }
+ expectedRef := gerrit.Reference(review.CLOpts)
+ assertFilesPushedToRef(t, fake.X, repoPath, gerritPath, expectedRef, files)
+ }
+ {
+ // Test with draft = true, no reviewers, and no ccs.
+ review, err := newReview(fake.X, gerrit.CLOpts{
+ Draft: true,
+ Remote: gerritPath,
+ })
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := review.send(); err != nil {
+ t.Fatalf("failed to send a review: %v", err)
+ }
+ expectedRef := gerrit.Reference(review.CLOpts)
+ assertFilesPushedToRef(t, fake.X, repoPath, gerritPath, expectedRef, files)
+ }
+ {
+ // Test with draft = false, reviewers, and no ccs.
+ review, err := newReview(fake.X, gerrit.CLOpts{
+ Remote: gerritPath,
+ Reviewers: parseEmails("reviewer1,reviewer2@example.org"),
+ })
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := review.send(); err != nil {
+ t.Fatalf("failed to send a review: %v", err)
+ }
+ expectedRef := gerrit.Reference(review.CLOpts)
+ assertFilesPushedToRef(t, fake.X, repoPath, gerritPath, expectedRef, files)
+ }
+ {
+ // Test with draft = true, reviewers, and ccs.
+ review, err := newReview(fake.X, gerrit.CLOpts{
+ Ccs: parseEmails("cc1@example.org,cc2"),
+ Draft: true,
+ Remote: gerritPath,
+ Reviewers: parseEmails("reviewer3@example.org,reviewer4"),
+ })
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := review.send(); err != nil {
+ t.Fatalf("failed to send a review: %v", err)
+ }
+ expectedRef := gerrit.Reference(review.CLOpts)
+ assertFilesPushedToRef(t, fake.X, repoPath, gerritPath, expectedRef, files)
+ }
+}
+
+// TestSendReviewNoChangeID checks that review.send() correctly errors when
+// not run with a commit hook that adds a Change-Id.
+func TestSendReviewNoChangeID(t *testing.T) {
+ // Pass 'false' to setup so it doesn't install the commit-msg hook.
+ fake, _, _, gerritPath, cleanup := setupTest(t, false)
+ defer cleanup()
+ branch := "my-branch"
+ if err := gitutil.New(fake.X.NewSeq()).CreateAndCheckoutBranch(branch); err != nil {
+ t.Fatalf("%v", err)
+ }
+ commitFiles(t, fake.X, []string{"file1"})
+ review, err := newReview(fake.X, gerrit.CLOpts{Remote: gerritPath})
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ err = review.send()
+ if err == nil {
+ t.Fatalf("sending a review did not fail when it should")
+ }
+ if _, ok := err.(noChangeIDError); !ok {
+ t.Fatalf("unexpected error type: %v", err)
+ }
+}
+
+// TestEndToEnd checks the end-to-end functionality of the review tool.
+func TestEndToEnd(t *testing.T) {
+ fake, repoPath, _, gerritPath, cleanup := setupTest(t, true)
+ defer cleanup()
+ branch := "my-branch"
+ if err := gitutil.New(fake.X.NewSeq()).CreateAndCheckoutBranch(branch); err != nil {
+ t.Fatalf("%v", err)
+ }
+ files := []string{"file1", "file2", "file3"}
+ commitFiles(t, fake.X, files)
+ review, err := newReview(fake.X, gerrit.CLOpts{Remote: gerritPath})
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ setTopicFlag = false
+ if err := review.run(); err != nil {
+ t.Fatalf("run() failed: %v", err)
+ }
+ expectedRef := gerrit.Reference(review.CLOpts)
+ assertFilesPushedToRef(t, fake.X, repoPath, gerritPath, expectedRef, files)
+}
+
+// TestLabelsInCommitMessage checks the labels are correctly processed
+// for the commit message.
+//
+// HACK ALERT: This test runs the review.run() function multiple
+// times. The function ends up pushing a commit to a fake "gerrit"
+// repository created by the setupTest() function. For the real gerrit
+// repository, it is possible to push to the refs/for/change reference
+// multiple times, because it is a special reference that "maps"
+// incoming commits to CL branches based on the commit message
+// Change-Id. The fake "gerrit" repository does not implement this
+// logic and thus the same reference cannot be pushed to multiple
+// times. To overcome this obstacle, the test takes advantage of the
+// fact that the reference name is a function of the reviewers and
+// uses different reviewers for different review runs.
+func TestLabelsInCommitMessage(t *testing.T) {
+ fake, repoPath, _, gerritPath, cleanup := setupTest(t, true)
+ defer cleanup()
+ s := fake.X.NewSeq()
+ branch := "my-branch"
+ if err := gitutil.New(fake.X.NewSeq()).CreateAndCheckoutBranch(branch); err != nil {
+ t.Fatalf("%v", err)
+ }
+
+ // Test setting -presubmit=none and autosubmit.
+ files := []string{"file1", "file2", "file3"}
+ commitFiles(t, fake.X, files)
+ review, err := newReview(fake.X, gerrit.CLOpts{
+ Autosubmit: true,
+ Presubmit: gerrit.PresubmitTestTypeNone,
+ Remote: gerritPath,
+ Reviewers: parseEmails("run1"),
+ })
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ setTopicFlag = false
+ if err := review.run(); err != nil {
+ t.Fatalf("%v", err)
+ }
+ expectedRef := gerrit.Reference(review.CLOpts)
+ assertFilesPushedToRef(t, fake.X, repoPath, gerritPath, expectedRef, files)
+ // The last three lines of the gerrit commit message file should be:
+ // AutoSubmit
+ // PresubmitTest: none
+ // Change-Id: ...
+ file, err := getCommitMessageFileName(review.jirix, review.CLOpts.Branch)
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ bytes, err := s.ReadFile(file)
+ if err != nil {
+ t.Fatalf("%v\n", err)
+ }
+ content := string(bytes)
+ lines := strings.Split(content, "\n")
+ // Make sure the Change-Id line is the last line.
+ if got := lines[len(lines)-1]; !strings.HasPrefix(got, "Change-Id") {
+ t.Fatalf("no Change-Id line found: %s", got)
+ }
+ // Make sure the "AutoSubmit" label exists.
+ if autosubmitLabelRE.FindString(content) == "" {
+ t.Fatalf("AutoSubmit label doesn't exist in the commit message: %s", content)
+ }
+ // Make sure the "PresubmitTest" label exists.
+ if presubmitTestLabelRE.FindString(content) == "" {
+ t.Fatalf("PresubmitTest label doesn't exist in the commit message: %s", content)
+ }
+
+ // Test setting -presubmit=all but keep autosubmit=true.
+ review, err = newReview(fake.X, gerrit.CLOpts{
+ Autosubmit: true,
+ Remote: gerritPath,
+ Reviewers: parseEmails("run2"),
+ })
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := review.run(); err != nil {
+ t.Fatalf("%v", err)
+ }
+ expectedRef = gerrit.Reference(review.CLOpts)
+ assertFilesPushedToRef(t, fake.X, repoPath, gerritPath, expectedRef, files)
+ bytes, err = s.ReadFile(file)
+ if err != nil {
+ t.Fatalf("%v\n", err)
+ }
+ content = string(bytes)
+ // Make sure there is no PresubmitTest=none any more.
+ match := presubmitTestLabelRE.FindString(content)
+ if match != "" {
+ t.Fatalf("want no presubmit label line, got: %s", match)
+ }
+ // Make sure the "AutoSubmit" label still exists.
+ if autosubmitLabelRE.FindString(content) == "" {
+ t.Fatalf("AutoSubmit label doesn't exist in the commit message: %s", content)
+ }
+
+ // Test setting autosubmit=false.
+ review, err = newReview(fake.X, gerrit.CLOpts{
+ Remote: gerritPath,
+ Reviewers: parseEmails("run3"),
+ })
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := review.run(); err != nil {
+ t.Fatalf("%v", err)
+ }
+ expectedRef = gerrit.Reference(review.CLOpts)
+ assertFilesPushedToRef(t, fake.X, repoPath, gerritPath, expectedRef, files)
+ bytes, err = s.ReadFile(file)
+ if err != nil {
+ t.Fatalf("%v\n", err)
+ }
+ content = string(bytes)
+ // Make sure there is no AutoSubmit label any more.
+ match = autosubmitLabelRE.FindString(content)
+ if match != "" {
+ t.Fatalf("want no AutoSubmit label line, got: %s", match)
+ }
+}
+
+// TestDirtyBranch checks that the tool correctly handles unstaged and
+// untracked changes in a working branch with stashed changes.
+func TestDirtyBranch(t *testing.T) {
+ fake, _, _, gerritPath, cleanup := setupTest(t, true)
+ defer cleanup()
+ s := fake.X.NewSeq()
+ branch := "my-branch"
+ if err := gitutil.New(fake.X.NewSeq()).CreateAndCheckoutBranch(branch); err != nil {
+ t.Fatalf("%v", err)
+ }
+ files := []string{"file1", "file2"}
+ commitFiles(t, fake.X, files)
+ assertStashSize(t, fake.X, 0)
+ stashedFile, stashedFileContent := "stashed-file", "stashed-file content"
+ if err := s.WriteFile(stashedFile, []byte(stashedFileContent), 0644).Done(); err != nil {
+ t.Fatalf("WriteFile(%v, %v) failed: %v", stashedFile, stashedFileContent, err)
+ }
+ if err := gitutil.New(fake.X.NewSeq()).Add(stashedFile); err != nil {
+ t.Fatalf("%v", err)
+ }
+ if _, err := gitutil.New(fake.X.NewSeq()).Stash(); err != nil {
+ t.Fatalf("%v", err)
+ }
+ assertStashSize(t, fake.X, 1)
+ modifiedFile, modifiedFileContent := "file1", "modified-file content"
+ if err := s.WriteFile(modifiedFile, []byte(modifiedFileContent), 0644).Done(); err != nil {
+ t.Fatalf("WriteFile(%v, %v) failed: %v", modifiedFile, modifiedFileContent, err)
+ }
+ stagedFile, stagedFileContent := "file2", "staged-file content"
+ if err := s.WriteFile(stagedFile, []byte(stagedFileContent), 0644).Done(); err != nil {
+ t.Fatalf("WriteFile(%v, %v) failed: %v", stagedFile, stagedFileContent, err)
+ }
+ if err := gitutil.New(fake.X.NewSeq()).Add(stagedFile); err != nil {
+ t.Fatalf("%v", err)
+ }
+ untrackedFile, untrackedFileContent := "file3", "untracked-file content"
+ if err := s.WriteFile(untrackedFile, []byte(untrackedFileContent), 0644).Done(); err != nil {
+ t.Fatalf("WriteFile(%v, %v) failed: %v", untrackedFile, untrackedFileContent, err)
+ }
+ review, err := newReview(fake.X, gerrit.CLOpts{Remote: gerritPath})
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ setTopicFlag = false
+ if err := review.run(); err == nil {
+ t.Fatalf("run() didn't fail when it should")
+ }
+ assertFilesNotCommitted(t, fake.X, []string{stagedFile})
+ assertFilesNotCommitted(t, fake.X, []string{untrackedFile})
+ assertFileContent(t, fake.X, modifiedFile, modifiedFileContent)
+ assertFileContent(t, fake.X, stagedFile, stagedFileContent)
+ assertFileContent(t, fake.X, untrackedFile, untrackedFileContent)
+ // As of git 2.4.3 "git stash pop" fails if there are uncommitted
+ // changes in the index. So we need to commit them first.
+ if err := gitutil.New(fake.X.NewSeq()).Commit(); err != nil {
+ t.Fatalf("%v", err)
+ }
+ assertStashSize(t, fake.X, 1)
+ if err := gitutil.New(fake.X.NewSeq()).StashPop(); err != nil {
+ t.Fatalf("%v", err)
+ }
+ assertStashSize(t, fake.X, 0)
+ assertFilesNotCommitted(t, fake.X, []string{stashedFile})
+ assertFileContent(t, fake.X, stashedFile, stashedFileContent)
+}
+
+// TestRunInSubdirectory checks that the command will succeed when run from
+// within a subdirectory of a branch that does not exist on master branch, and
+// will return the user to the subdirectory after completion.
+func TestRunInSubdirectory(t *testing.T) {
+ fake, repoPath, _, gerritPath, cleanup := setupTest(t, true)
+ defer cleanup()
+ s := fake.X.NewSeq()
+ branch := "my-branch"
+ if err := gitutil.New(fake.X.NewSeq()).CreateAndCheckoutBranch(branch); err != nil {
+ t.Fatalf("%v", err)
+ }
+ subdir := "sub/directory"
+ subdirPerms := os.FileMode(0744)
+ if err := s.MkdirAll(subdir, subdirPerms).Done(); err != nil {
+ t.Fatalf("MkdirAll(%v, %v) failed: %v", subdir, subdirPerms, err)
+ }
+ files := []string{path.Join(subdir, "file1")}
+ commitFiles(t, fake.X, files)
+ chdir(t, fake.X, subdir)
+ review, err := newReview(fake.X, gerrit.CLOpts{Remote: gerritPath})
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ setTopicFlag = false
+ if err := review.run(); err != nil {
+ t.Fatalf("run() failed: %v", err)
+ }
+ path := path.Join(repoPath, subdir)
+ want, err := filepath.EvalSymlinks(path)
+ if err != nil {
+ t.Fatalf("EvalSymlinks(%v) failed: %v", path, err)
+ }
+ cwd, err := os.Getwd()
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ got, err := filepath.EvalSymlinks(cwd)
+ if err != nil {
+ t.Fatalf("EvalSymlinks(%v) failed: %v", cwd, err)
+ }
+ if got != want {
+ t.Fatalf("unexpected working directory: got %v, want %v", got, want)
+ }
+ expectedRef := gerrit.Reference(review.CLOpts)
+ assertFilesPushedToRef(t, fake.X, repoPath, gerritPath, expectedRef, files)
+}
+
+// TestProcessLabels checks that the processLabels function works as expected.
+func TestProcessLabels(t *testing.T) {
+ fake, _, _, _, cleanup := setupTest(t, true)
+ defer cleanup()
+ testCases := []struct {
+ autosubmit bool
+ presubmitType gerrit.PresubmitTestType
+ originalMessage string
+ expectedMessage string
+ }{
+ {
+ presubmitType: gerrit.PresubmitTestTypeNone,
+ originalMessage: "",
+ expectedMessage: "PresubmitTest: none\n",
+ },
+ {
+ autosubmit: true,
+ presubmitType: gerrit.PresubmitTestTypeNone,
+ originalMessage: "",
+ expectedMessage: "AutoSubmit\nPresubmitTest: none\n",
+ },
+ {
+ presubmitType: gerrit.PresubmitTestTypeNone,
+ originalMessage: "review message\n",
+ expectedMessage: "review message\nPresubmitTest: none\n",
+ },
+ {
+ autosubmit: true,
+ presubmitType: gerrit.PresubmitTestTypeNone,
+ originalMessage: "review message\n",
+ expectedMessage: "review message\nAutoSubmit\nPresubmitTest: none\n",
+ },
+ {
+ presubmitType: gerrit.PresubmitTestTypeNone,
+ originalMessage: `review message
+
+Change-Id: I0000000000000000000000000000000000000000`,
+ expectedMessage: `review message
+
+PresubmitTest: none
+Change-Id: I0000000000000000000000000000000000000000`,
+ },
+ {
+ autosubmit: true,
+ presubmitType: gerrit.PresubmitTestTypeNone,
+ originalMessage: `review message
+
+Change-Id: I0000000000000000000000000000000000000000`,
+ expectedMessage: `review message
+
+AutoSubmit
+PresubmitTest: none
+Change-Id: I0000000000000000000000000000000000000000`,
+ },
+ {
+ presubmitType: gerrit.PresubmitTestTypeAll,
+ originalMessage: "",
+ expectedMessage: "",
+ },
+ {
+ presubmitType: gerrit.PresubmitTestTypeAll,
+ originalMessage: "review message\n",
+ expectedMessage: "review message\n",
+ },
+ {
+ presubmitType: gerrit.PresubmitTestTypeAll,
+ originalMessage: `review message
+
+Change-Id: I0000000000000000000000000000000000000000`,
+ expectedMessage: `review message
+
+Change-Id: I0000000000000000000000000000000000000000`,
+ },
+ }
+ for _, test := range testCases {
+ review, err := newReview(fake.X, gerrit.CLOpts{
+ Autosubmit: test.autosubmit,
+ Presubmit: test.presubmitType,
+ })
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ if got := review.processLabels(test.originalMessage); got != test.expectedMessage {
+ t.Fatalf("want %s, got %s", test.expectedMessage, got)
+ }
+ }
+}
+
+// TestCLNew checks the operation of the "jiri cl new" command.
+func TestCLNew(t *testing.T) {
+ fake, _, _, _, cleanup := setupTest(t, true)
+ defer cleanup()
+
+ // Create some dependent CLs.
+ if err := newCL(fake.X, []string{"feature1"}); err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := newCL(fake.X, []string{"feature2"}); err != nil {
+ t.Fatalf("%v", err)
+ }
+
+ // Check that their dependency paths have been recorded correctly.
+ testCases := []struct {
+ branch string
+ data []byte
+ }{
+ {
+ branch: "feature1",
+ data: []byte("master"),
+ },
+ {
+ branch: "feature2",
+ data: []byte("master\nfeature1"),
+ },
+ }
+ s := fake.X.NewSeq()
+ for _, testCase := range testCases {
+ file, err := getDependencyPathFileName(fake.X, testCase.branch)
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ data, err := s.ReadFile(file)
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ if bytes.Compare(data, testCase.data) != 0 {
+ t.Fatalf("unexpected data:\ngot\n%v\nwant\n%v", string(data), string(testCase.data))
+ }
+ }
+}
+
+// TestDependentClsWithEditDelete exercises a previously observed failure case
+// where if a CL edits a file and a dependent CL deletes it, jiri cl mail after
+// the deletion failed with unrecoverable merge errors.
+func TestDependentClsWithEditDelete(t *testing.T) {
+ fake, repoPath, originPath, gerritPath, cleanup := setupTest(t, true)
+ defer cleanup()
+ chdir(t, fake.X, originPath)
+ commitFiles(t, fake.X, []string{"A", "B"})
+
+ chdir(t, fake.X, repoPath)
+ if err := syncCL(fake.X); err != nil {
+ t.Fatalf("%v", err)
+ }
+ assertFilesExist(t, fake.X, []string{"A", "B"})
+
+ createCLWithFiles(t, fake.X, "editme", "C")
+ if err := fake.X.NewSeq().WriteFile("B", []byte("Will I dream?"), 0644).Done(); err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := gitutil.New(fake.X.NewSeq()).Add("B"); err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := gitutil.New(fake.X.NewSeq()).CommitWithMessage("editing stuff"); err != nil {
+ t.Fatalf("git commit failed: %v", err)
+ }
+ review, err := newReview(fake.X, gerrit.CLOpts{
+ Remote: gerritPath,
+ Reviewers: parseEmails("run1"), // See hack note about TestLabelsInCommitMessage
+ })
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ setTopicFlag = false
+ if err := review.run(); err != nil {
+ t.Fatalf("run() failed: %v", err)
+ }
+
+ if err := newCL(fake.X, []string{"deleteme"}); err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := gitutil.New(fake.X.NewSeq()).Remove("B", "C"); err != nil {
+ t.Fatalf("git rm B C failed: %v", err)
+ }
+ if err := gitutil.New(fake.X.NewSeq()).CommitWithMessage("deleting stuff"); err != nil {
+ t.Fatalf("git commit failed: %v", err)
+ }
+ review, err = newReview(fake.X, gerrit.CLOpts{
+ Remote: gerritPath,
+ Reviewers: parseEmails("run2"),
+ })
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := review.run(); err != nil {
+ t.Fatalf("run() failed: %v", err)
+ }
+
+ chdir(t, fake.X, gerritPath)
+ expectedRef := gerrit.Reference(review.CLOpts)
+ if err := gitutil.New(fake.X.NewSeq()).CheckoutBranch(expectedRef); err != nil {
+ t.Fatalf("%v", err)
+ }
+ assertFilesExist(t, fake.X, []string{"A"})
+ assertFilesDoNotExist(t, fake.X, []string{"B", "C"})
+}
+
+// TestParallelDev checks "jiri cl mail" behavior when parallel development has
+// been submitted upstream.
+func TestParallelDev(t *testing.T) {
+ fake, repoPath, originPath, gerritAPath, cleanup := setupTest(t, true)
+ defer cleanup()
+ gerritBPath := createRepoFromOrigin(t, fake.X, "gerritB", originPath)
+ chdir(t, fake.X, repoPath)
+
+ // Create parallel branches with:
+ // * non-conflicting changes in different files
+ // * conflicting changes in a file
+ createCLWithFiles(t, fake.X, "feature1-A", "A")
+
+ if err := gitutil.New(fake.X.NewSeq()).CheckoutBranch("master"); err != nil {
+ t.Fatalf("%v", err)
+ }
+ createCLWithFiles(t, fake.X, "feature1-B", "B")
+ commitFile(t, fake.X, "A", "Don't tread on me.")
+
+ reviewB, err := newReview(fake.X, gerrit.CLOpts{Remote: gerritBPath})
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ setTopicFlag = false
+ if err := reviewB.run(); err != nil {
+ t.Fatalf("run() failed: %v", err)
+ }
+
+ // Submit B and verify A doesn't revert it.
+ submit(t, fake.X, originPath, gerritBPath, reviewB)
+
+ // Assert files pushed to origin.
+ chdir(t, fake.X, originPath)
+ assertFilesExist(t, fake.X, []string{"A", "B"})
+ chdir(t, fake.X, repoPath)
+
+ if err := gitutil.New(fake.X.NewSeq()).CheckoutBranch("feature1-A"); err != nil {
+ t.Fatalf("%v", err)
+ }
+
+ reviewA, err := newReview(fake.X, gerrit.CLOpts{Remote: gerritAPath})
+ if err == nil {
+ t.Fatalf("creating a review did not fail when it should")
+ }
+ // Assert state restored after failed review.
+ assertFileContent(t, fake.X, "A", "This is file A")
+ assertFilesDoNotExist(t, fake.X, []string{"B"})
+
+ // Manual conflict resolution.
+ if err := gitutil.New(fake.X.NewSeq()).Merge("master", gitutil.ResetOnFailureOpt(false)); err == nil {
+ t.Fatalf("merge applied cleanly when it shouldn't")
+ }
+ assertFilesNotCommitted(t, fake.X, []string{"A", "B"})
+ assertFileContent(t, fake.X, "B", "This is file B")
+
+ if err := fake.X.NewSeq().WriteFile("A", []byte("This is file A. Don't tread on me."), 0644).Done(); err != nil {
+ t.Fatalf("%v", err)
+ }
+
+ if err := gitutil.New(fake.X.NewSeq()).Add("A"); err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := gitutil.New(fake.X.NewSeq()).Add("B"); err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := gitutil.New(fake.X.NewSeq()).CommitWithMessage("Conflict resolution"); err != nil {
+ t.Fatalf("%v", err)
+ }
+
+ // Retry review.
+ reviewA, err = newReview(fake.X, gerrit.CLOpts{Remote: gerritAPath})
+ if err != nil {
+ t.Fatalf("review failed: %v", err)
+ }
+
+ if err := reviewA.run(); err != nil {
+ t.Fatalf("run() failed: %v", err)
+ }
+
+ chdir(t, fake.X, gerritAPath)
+ expectedRef := gerrit.Reference(reviewA.CLOpts)
+ if err := gitutil.New(fake.X.NewSeq()).CheckoutBranch(expectedRef); err != nil {
+ t.Fatalf("%v", err)
+ }
+ assertFilesExist(t, fake.X, []string{"B"})
+}
+
+// TestCLSync checks the operation of the "jiri cl sync" command.
+func TestCLSync(t *testing.T) {
+ fake, _, _, _, cleanup := setupTest(t, true)
+ defer cleanup()
+
+ // Create some dependent CLs.
+ if err := newCL(fake.X, []string{"feature1"}); err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := newCL(fake.X, []string{"feature2"}); err != nil {
+ t.Fatalf("%v", err)
+ }
+
+ // Add the "test" file to the master.
+ if err := gitutil.New(fake.X.NewSeq()).CheckoutBranch("master"); err != nil {
+ t.Fatalf("%v", err)
+ }
+ commitFiles(t, fake.X, []string{"test"})
+
+ // Sync the dependent CLs.
+ if err := gitutil.New(fake.X.NewSeq()).CheckoutBranch("feature2"); err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := syncCL(fake.X); err != nil {
+ t.Fatalf("%v", err)
+ }
+
+ // Check that the "test" file exists in the dependent CLs.
+ for _, branch := range []string{"feature1", "feature2"} {
+ if err := gitutil.New(fake.X.NewSeq()).CheckoutBranch(branch); err != nil {
+ t.Fatalf("%v", err)
+ }
+ assertFilesExist(t, fake.X, []string{"test"})
+ }
+}
diff --git a/cmd/jiri/cmd.go b/cmd/jiri/cmd.go
new file mode 100644
index 0000000..0d4d2ee
--- /dev/null
+++ b/cmd/jiri/cmd.go
@@ -0,0 +1,158 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// The following enables go generate to generate the doc.go file.
+//go:generate go run $JIRI_ROOT/release/go/src/v.io/x/lib/cmdline/testdata/gendoc.go -env="" .
+
+package main
+
+import (
+ "runtime"
+
+ "v.io/jiri/tool"
+ "v.io/x/lib/cmdline"
+)
+
+func init() {
+ runtime.GOMAXPROCS(runtime.NumCPU())
+
+ tool.InitializeRunFlags(&cmdRoot.Flags)
+}
+
+func main() {
+ cmdline.Main(cmdRoot)
+}
+
+// cmdRoot represents the root of the jiri tool.
+var cmdRoot = &cmdline.Command{
+ Name: "jiri",
+ Short: "Multi-purpose tool for multi-repo development",
+ Long: `
+Command jiri is a multi-purpose tool for multi-repo development.
+`,
+ LookPath: true,
+ Children: []*cmdline.Command{
+ cmdCL,
+ cmdContributors,
+ cmdImport,
+ cmdProfile,
+ cmdProject,
+ cmdRebuild,
+ cmdSnapshot,
+ cmdUpdate,
+ cmdUpgrade,
+ cmdWhich,
+ },
+ Topics: []cmdline.Topic{
+ topicFileSystem,
+ topicManifest,
+ },
+}
+
+var topicFileSystem = cmdline.Topic{
+ Name: "filesystem",
+ Short: "Description of jiri file system layout",
+ Long: `
+All data managed by the jiri tool is located in the file system under a root
+directory, colloquially called the jiri root directory. The file system layout
+looks like this:
+
+ [root] # root directory (name picked by user)
+ [root]/.jiri_root # root metadata directory
+ [root]/.jiri_root/bin # contains tool binaries (jiri, etc.)
+ [root]/.jiri_root/update_history # contains history of update snapshots
+ [root]/.manifest # contains jiri manifests
+ [root]/[project1] # project directory (name picked by user)
+ [root]/[project1]/.jiri # project metadata directory
+ [root]/[project1]/.jiri/metadata.v2 # project metadata file
+ [root]/[project1]/.jiri/<<cls>> # project per-cl metadata directories
+ [root]/[project1]/<<files>> # project files
+ [root]/[project2]...
+
+The [root] and [projectN] directory names are picked by the user. The <<cls>>
+are named via jiri cl new, and the <<files>> are named as the user adds files
+and directories to their project. All other names above have special meaning to
+the jiri tool, and cannot be changed; you must ensure your path names don't
+collide with these special names.
+
+There are two ways to run the jiri tool:
+
+1) Shim script (recommended approach). This is a shell script that looks for
+the [root] directory. If the JIRI_ROOT environment variable is set, that is
+assumed to be the [root] directory. Otherwise the script looks for the
+.jiri_root directory, starting in the current working directory and walking up
+the directory chain. The search is terminated successfully when the .jiri_root
+directory is found; it fails after it reaches the root of the file system. Thus
+the shim must be invoked from the [root] directory or one of its subdirectories.
+
+Once the [root] is found, the JIRI_ROOT environment variable is set to its
+location, and [root]/.jiri_root/bin/jiri is invoked. That file contains the
+actual jiri binary.
+
+The point of the shim script is to make it easy to use the jiri tool with
+multiple [root] directories on your file system. Keep in mind that when "jiri
+update" is run, the jiri tool itself is automatically updated along with all
+projects. By using the shim script, you only need to remember to invoke the
+jiri tool from within the appropriate [root] directory, and the projects and
+tools under that [root] directory will be updated.
+
+The shim script is located at [root]/release/go/src/v.io/jiri/scripts/jiri
+
+2) Direct binary. This is the jiri binary, containing all of the actual jiri
+tool logic. The binary requires the JIRI_ROOT environment variable to point to
+the [root] directory.
+
+Note that if you have multiple [root] directories on your file system, you must
+remember to run the jiri binary corresponding to the setting of your JIRI_ROOT
+environment variable. Things may fail if you mix things up, since the jiri
+binary is updated with each call to "jiri update", and you may encounter version
+mismatches between the jiri binary and the various metadata files or other
+logic. This is the reason the shim script is recommended over running the
+binary directly.
+
+The binary is located at [root]/.jiri_root/bin/jiri
+`,
+}
+
+// TODO(toddw): Update the description of manifest files.
+var topicManifest = cmdline.Topic{
+ Name: "manifest",
+ Short: "Description of manifest files",
+ Long: `
+Jiri manifests are revisioned and stored in a "manifest" repository, that is
+available locally in $JIRI_ROOT/.manifest. The manifest uses the following XML
+schema:
+
+ <manifest>
+ <imports>
+ <import name="default"/>
+ ...
+ </imports>
+ <projects>
+ <project name="release.go.jiri"
+ path="release/go/src/v.io/jiri"
+ protocol="git"
+ name="https://vanadium.googlesource.com/release.go.jiri"
+ revision="HEAD"/>
+ ...
+ </projects>
+ <tools>
+ <tool name="jiri" package="v.io/jiri"/>
+ ...
+ </tools>
+ </manifest>
+
+The <import> element can be used to share settings across multiple
+manifests. Import names are interpreted relative to the $JIRI_ROOT/.manifest/v2
+directory. Import cycles are not allowed and if a project or a tool is specified
+multiple times, the last specification takes effect. In particular, the elements
+<project name="foo" exclude="true"/> and <tool name="bar" exclude="true"/> can
+be used to exclude previously included projects and tools.
+
+The tool identifies which manifest to use using the following algorithm. If the
+$JIRI_ROOT/.local_manifest file exists, then it is used. Otherwise, the
+$JIRI_ROOT/.manifest/v2/<manifest>.xml file is used, where <manifest> is the
+value of the -manifest command-line flag, which defaults to "default".
+`,
+}
diff --git a/cmd/jiri/contrib.go b/cmd/jiri/contrib.go
new file mode 100644
index 0000000..1fb31e6
--- /dev/null
+++ b/cmd/jiri/contrib.go
@@ -0,0 +1,223 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "encoding/xml"
+ "fmt"
+ "path/filepath"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+
+ "v.io/jiri/collect"
+ "v.io/jiri/gitutil"
+ "v.io/jiri/jiri"
+ "v.io/jiri/project"
+ "v.io/jiri/tool"
+ "v.io/x/lib/cmdline"
+ "v.io/x/lib/set"
+)
+
+const (
+ aliasesFileName = "aliases.v1.xml"
+)
+
+var (
+ countFlag bool
+ aliasesFlag string
+)
+
+func init() {
+ cmdContributors.Flags.BoolVar(&countFlag, "n", false, "Show number of contributions.")
+ cmdContributors.Flags.StringVar(&aliasesFlag, "aliases", "", "Path to the aliases file.")
+}
+
+// cmdContributors represents the "jiri contributors" command.
+var cmdContributors = &cmdline.Command{
+ Runner: jiri.RunnerFunc(runContributors),
+ Name: "contributors",
+ Short: "List project contributors",
+ Long: `
+Lists project contributors. Projects to consider can be specified as
+an argument. If no projects are specified, all projects in the current
+manifest are considered by default.
+`,
+ ArgsName: "<projects>",
+ ArgsLong: "<projects> is a list of projects to consider.",
+}
+
+type contributor struct {
+ count int
+ email string
+ name string
+}
+
+var (
+ contributorRE = regexp.MustCompile("^(.*)\t(.*) <(.*)>$")
+)
+
+type aliasesSchema struct {
+ XMLName xml.Name `xml:"aliases"`
+ Names []nameSchema `xml:"name"`
+ Emails []emailSchema `xml:"email"`
+}
+
+type nameSchema struct {
+ Canonical string `xml:"canonical"`
+ Aliases []string `xml:"alias"`
+}
+
+type emailSchema struct {
+ Canonical string `xml:"canonical"`
+ Aliases []string `xml:"alias"`
+}
+
+type aliasMaps struct {
+ emails map[string]string
+ names map[string]string
+}
+
+func canonicalize(aliases *aliasMaps, email, name string) (string, string) {
+ canonicalEmail, canonicalName := email, name
+ if email, ok := aliases.emails[email]; ok {
+ canonicalEmail = email
+ }
+ if name, ok := aliases.names[name]; ok {
+ canonicalName = name
+ }
+ return canonicalEmail, canonicalName
+}
+
+func loadAliases(jirix *jiri.X) (*aliasMaps, error) {
+ aliasesFile := aliasesFlag
+ if aliasesFile == "" {
+ dataDir, err := project.DataDirPath(jirix, tool.Name)
+ if err != nil {
+ return nil, err
+ }
+ aliasesFile = filepath.Join(dataDir, aliasesFileName)
+ }
+ bytes, err := jirix.NewSeq().ReadFile(aliasesFile)
+ if err != nil {
+ return nil, err
+ }
+ var data aliasesSchema
+ if err := xml.Unmarshal(bytes, &data); err != nil {
+ return nil, fmt.Errorf("Unmarshal(%v) failed: %v", string(bytes), err)
+ }
+ aliases := &aliasMaps{
+ emails: map[string]string{},
+ names: map[string]string{},
+ }
+ for _, email := range data.Emails {
+ for _, alias := range email.Aliases {
+ aliases.emails[alias] = email.Canonical
+ }
+ }
+ for _, name := range data.Names {
+ for _, alias := range name.Aliases {
+ aliases.names[alias] = name.Canonical
+ }
+ }
+ return aliases, nil
+}
+
+func runContributors(jirix *jiri.X, args []string) error {
+ localProjects, err := project.LocalProjects(jirix, project.FastScan)
+ if err != nil {
+ return err
+ }
+ projectNames := map[string]struct{}{}
+ if len(args) != 0 {
+ projectNames = set.String.FromSlice(args)
+ } else {
+ for _, p := range localProjects {
+ projectNames[p.Name] = struct{}{}
+ }
+ }
+
+ aliases, err := loadAliases(jirix)
+ if err != nil {
+ return err
+ }
+ contributors := map[string]*contributor{}
+ for name, _ := range projectNames {
+ projects := localProjects.Find(name)
+ if len(projects) == 0 {
+ continue
+ }
+
+ for _, project := range projects {
+ if err := jirix.NewSeq().Chdir(project.Path).Done(); err != nil {
+ return err
+ }
+ switch project.Protocol {
+ case "git":
+ lines, err := listCommitters(jirix)
+ if err != nil {
+ return err
+ }
+ for _, line := range lines {
+ matches := contributorRE.FindStringSubmatch(line)
+ if got, want := len(matches), 4; got != want {
+ return fmt.Errorf("unexpected length of %v: got %v, want %v", matches, got, want)
+ }
+ count, err := strconv.Atoi(strings.TrimSpace(matches[1]))
+ if err != nil {
+ return fmt.Errorf("Atoi(%v) failed: %v", strings.TrimSpace(matches[1]), err)
+ }
+ c := &contributor{
+ count: count,
+ email: strings.TrimSpace(matches[3]),
+ name: strings.TrimSpace(matches[2]),
+ }
+ if c.email == "jenkins.veyron@gmail.com" || c.email == "jenkins.veyron.rw@gmail.com" {
+ continue
+ }
+ c.email, c.name = canonicalize(aliases, c.email, c.name)
+ if existing, ok := contributors[c.name]; ok {
+ existing.count += c.count
+ } else {
+ contributors[c.name] = c
+ }
+ }
+ }
+ }
+ }
+ names := []string{}
+ for name, _ := range contributors {
+ names = append(names, name)
+ }
+ sort.Strings(names)
+ for _, name := range names {
+ c := contributors[name]
+ if countFlag {
+ fmt.Fprintf(jirix.Stdout(), "%4d ", c.count)
+ }
+ fmt.Fprintf(jirix.Stdout(), "%v <%v>\n", c.name, c.email)
+ }
+ return nil
+}
+
+func listCommitters(jirix *jiri.X) (_ []string, e error) {
+ branch, err := gitutil.New(jirix.NewSeq()).CurrentBranchName()
+ if err != nil {
+ return nil, err
+ }
+ stashed, err := gitutil.New(jirix.NewSeq()).Stash()
+ if err != nil {
+ return nil, err
+ }
+ if stashed {
+ defer collect.Error(func() error { return gitutil.New(jirix.NewSeq()).StashPop() }, &e)
+ }
+ if err := gitutil.New(jirix.NewSeq()).CheckoutBranch("master"); err != nil {
+ return nil, err
+ }
+ defer collect.Error(func() error { return gitutil.New(jirix.NewSeq()).CheckoutBranch(branch) }, &e)
+ return gitutil.New(jirix.NewSeq()).Committers()
+}
diff --git a/cmd/jiri/doc.go b/cmd/jiri/doc.go
new file mode 100644
index 0000000..bfe847c
--- /dev/null
+++ b/cmd/jiri/doc.go
@@ -0,0 +1,963 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file was auto-generated via go generate.
+// DO NOT UPDATE MANUALLY
+
+/*
+Command jiri is a multi-purpose tool for multi-repo development.
+
+Usage:
+ jiri [flags] <command>
+
+The jiri commands are:
+ cl Manage project changelists
+ contributors List project contributors
+ import Adds imports to .jiri_manifest file
+ profile Display information about installed profiles
+ project Manage the jiri projects
+ rebuild Rebuild all jiri tools
+ snapshot Manage project snapshots
+ update Update all jiri tools and projects
+ upgrade Upgrade jiri to new-style manifests
+ which Show path to the jiri tool
+ help Display help for commands or topics
+
+The jiri additional help topics are:
+ filesystem Description of jiri file system layout
+ manifest Description of manifest files
+
+The jiri flags are:
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+The global flags are:
+ -metadata=<just specify -metadata to activate>
+ Displays metadata for the program and exits.
+ -time=false
+ Dump timing information to stderr before exiting the program.
+
+Jiri cl - Manage project changelists
+
+Manage project changelists.
+
+Usage:
+ jiri cl [flags] <command>
+
+The jiri cl commands are:
+ cleanup Clean up changelists that have been merged
+ mail Mail a changelist for review
+ new Create a new local branch for a changelist
+ sync Bring a changelist up to date
+
+The jiri cl flags are:
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri cl cleanup - Clean up changelists that have been merged
+
+Command "cleanup" checks that the given branches have been merged into the
+corresponding remote branch. If a branch differs from the corresponding remote
+branch, the command reports the difference and stops. Otherwise, it deletes the
+given branches.
+
+Usage:
+ jiri cl cleanup [flags] <branches>
+
+<branches> is a list of branches to cleanup.
+
+The jiri cl cleanup flags are:
+ -f=false
+ Ignore unmerged changes.
+ -remote-branch=master
+ Name of the remote branch the CL pertains to, without the leading "origin/".
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri cl mail - Mail a changelist for review
+
+Command "mail" squashes all commits of a local branch into a single "changelist"
+and mails this changelist to Gerrit as a single commit. First time the command
+is invoked, it generates a Change-Id for the changelist, which is appended to
+the commit message. Consecutive invocations of the command use the same
+Change-Id by default, informing Gerrit that the incomming commit is an update of
+an existing changelist.
+
+Usage:
+ jiri cl mail [flags]
+
+The jiri cl mail flags are:
+ -autosubmit=false
+ Automatically submit the changelist when feasible.
+ -cc=
+ Comma-seperated list of emails or LDAPs to cc.
+ -check-uncommitted=true
+ Check that no uncommitted changes exist.
+ -d=false
+ Send a draft changelist.
+ -edit=true
+ Open an editor to edit the CL description.
+ -host=
+ Gerrit host to use. Defaults to gerrit host specified in manifest.
+ -m=
+ CL description.
+ -presubmit=all
+ The type of presubmit tests to run. Valid values: none,all.
+ -r=
+ Comma-seperated list of emails or LDAPs to request review.
+ -remote-branch=master
+ Name of the remote branch the CL pertains to, without the leading "origin/".
+ -set-topic=true
+ Set Gerrit CL topic.
+ -topic=
+ CL topic, defaults to <username>-<branchname>.
+ -verify=true
+ Run pre-push git hooks.
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri cl new - Create a new local branch for a changelist
+
+Command "new" creates a new local branch for a changelist. In particular, it
+forks a new branch with the given name from the current branch and records the
+relationship between the current branch and the new branch in the .jiri metadata
+directory. The information recorded in the .jiri metadata directory tracks
+dependencies between CLs and is used by the "jiri cl sync" and "jiri cl mail"
+commands.
+
+Usage:
+ jiri cl new [flags] <name>
+
+<name> is the changelist name.
+
+The jiri cl new flags are:
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri cl sync - Bring a changelist up to date
+
+Command "sync" brings the CL identified by the current branch up to date with
+the branch tracking the remote branch this CL pertains to. To do that, the
+command uses the information recorded in the .jiri metadata directory to
+identify the sequence of dependent CLs leading to the current branch. The
+command then iterates over this sequence bringing each of the CLs up to date
+with its ancestor. The end result of this process is that all CLs in the
+sequence are up to date with the branch that tracks the remote branch this CL
+pertains to.
+
+NOTE: It is possible that the command cannot automatically merge changes in an
+ancestor into its dependent. When that occurs, the command is aborted and prints
+instructions that need to be followed before the command can be retried.
+
+Usage:
+ jiri cl sync [flags]
+
+The jiri cl sync flags are:
+ -remote-branch=master
+ Name of the remote branch the CL pertains to, without the leading "origin/".
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri contributors - List project contributors
+
+Lists project contributors. Projects to consider can be specified as an
+argument. If no projects are specified, all projects in the current manifest are
+considered by default.
+
+Usage:
+ jiri contributors [flags] <projects>
+
+<projects> is a list of projects to consider.
+
+The jiri contributors flags are:
+ -aliases=
+ Path to the aliases file.
+ -n=false
+ Show number of contributions.
+
+ -color=true
+ Use color to format output.
+ -v=false
+ Print verbose output.
+
+Jiri import
+
+Command "import" adds imports to the $JIRI_ROOT/.jiri_manifest file, which
+specifies manifest information for the jiri tool. The file is created if it
+doesn't already exist, otherwise additional imports are added to the existing
+file.
+
+An <import> element is added to the manifest representing a remote manifest
+import. The manifest file path is relative to the root directory of the remote
+import repository.
+
+Example:
+ $ jiri import myfile https://foo.com/bar.git
+
+Run "jiri help manifest" for details on manifests.
+
+Usage:
+ jiri import [flags] <manifest> <remote>
+
+<manifest> specifies the manifest file to use.
+
+<remote> specifies the remote manifest repository.
+
+The jiri import flags are:
+ -name=
+ The name of the remote manifest project, used to disambiguate manifest
+ projects with the same remote. Typically empty.
+ -out=
+ The output file. Uses $JIRI_ROOT/.jiri_manifest if unspecified. Uses stdout
+ if set to "-".
+ -overwrite=false
+ Write a new .jiri_manifest file with the given specification. If it already
+ exists, the existing content will be ignored and the file will be
+ overwritten.
+ -protocol=git
+ The version control protocol used by the remote manifest project.
+ -remote-branch=master
+ The branch of the remote manifest project to track, without the leading
+ "origin/".
+ -root=
+ Root to store the manifest project locally.
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri profile - Display information about installed profiles
+
+Display information about installed profiles and their configuration.
+
+Usage:
+ jiri profile [flags] <command>
+
+The jiri profile commands are:
+ list List available or installed profiles
+ env Display profile environment variables
+ install Install the given profiles
+ uninstall Uninstall the given profiles
+ update Install the latest default version of the given profiles
+ cleanup Cleanup the locally installed profiles
+ available List the available profiles
+
+The jiri profile flags are:
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri profile list - List available or installed profiles
+
+List available or installed profiles.
+
+Usage:
+ jiri profile list [flags] [<profiles>]
+
+<profiles> is a list of profiles to list, defaulting to all profiles if none are
+specifically requested.
+
+The jiri profile list flags are:
+ -available=false
+ print the list of available profiles
+ -env=
+ specify an environment variable in the form: <var>=[<val>],...
+ -info=
+ The following fields for use with --profile-info are available:
+ SchemaVersion - the version of the profiles implementation.
+ Target.InstallationDir - the installation directory of the requested profile.
+ Target.CommandLineEnv - the environment variables specified via the command line when installing this profile target.
+ Target.Env - the environment variables computed by the profile installation process for this target.
+ Target.Command - a command that can be used to create this profile.
+ Note: if no --target is specified then the requested field will be displayed for all targets.
+ Profile.Description - description of the requested profile.
+ Profile.Root - the root directory of the requested profile.
+ Profile.Versions - the set of supported versions for this profile.
+ Profile.DefaultVersion - the default version of the requested profile.
+ Profile.LatestVersion - the latest version available for the requested profile.
+ Note: if no profiles are specified then the requested field will be displayed for all profiles.
+ -merge-policies=+CCFLAGS,+CGO_CFLAGS,+CGO_CXXFLAGS,+CGO_LDFLAGS,+CXXFLAGS,GOARCH,GOOS,GOPATH:,^GOROOT*,+LDFLAGS,:PATH,VDLPATH:
+ specify policies for merging environment variables
+ -profiles=base,jiri
+ a comma separated list of profiles to use
+ -profiles-db=$JIRI_ROOT/.jiri_root/profile_db
+ specify the profiles database directory or file.
+ -show-profiles-db=false
+ print out the profiles database file
+ -skip-profiles=false
+ if set, no profiles will be used
+ -target=<runtime.GOARCH>-<runtime.GOOS>
+ specifies a profile target in the following form: <arch>-<os>[@<version>]
+ -v=false
+ print more detailed information
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+
+Jiri profile env - Display profile environment variables
+
+List profile specific and target specific environment variables. If the
+requested environment variable name ends in = then only the value will be
+printed, otherwise both name and value are printed, i.e. GOPATH="foo" vs just
+"foo".
+
+If no environment variable names are requested then all will be printed in
+<name>=<val> format.
+
+Usage:
+ jiri profile env [flags] [<environment variable names>]
+
+[<environment variable names>] is an optional list of environment variables to
+display
+
+The jiri profile env flags are:
+ -env=
+ specify an environment variable in the form: <var>=[<val>],...
+ -merge-policies=+CCFLAGS,+CGO_CFLAGS,+CGO_CXXFLAGS,+CGO_LDFLAGS,+CXXFLAGS,GOARCH,GOOS,GOPATH:,^GOROOT*,+LDFLAGS,:PATH,VDLPATH:
+ specify policies for merging environment variables
+ -profiles=base,jiri
+ a comma separated list of profiles to use
+ -profiles-db=$JIRI_ROOT/.jiri_root/profile_db
+ specify the profiles database directory or file.
+ -skip-profiles=false
+ if set, no profiles will be used
+ -target=<runtime.GOARCH>-<runtime.GOOS>
+ specifies a profile target in the following form: <arch>-<os>[@<version>]
+ -v=false
+ print more detailed information
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+
+Jiri profile install - Install the given profiles
+
+Install the given profiles.
+
+Usage:
+ jiri profile install [flags] <profiles>
+
+<profiles> is a list of profiles to install.
+
+The jiri profile install flags are:
+ -env=
+ specify an environment variable in the form: <var>=[<val>],...
+ -force=false
+ force install the profile even if it is already installed
+ -profiles-db=$JIRI_ROOT/.jiri_root/profile_db
+ specify the profiles database directory or file.
+ -profiles-dir=.jiri_root/profiles
+ the directory, relative to JIRI_ROOT, that profiles are installed in
+ -target=<runtime.GOARCH>-<runtime.GOOS>
+ specifies a profile target in the following form: <arch>-<os>[@<version>]
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri profile uninstall - Uninstall the given profiles
+
+Uninstall the given profiles.
+
+Usage:
+ jiri profile uninstall [flags] <profiles>
+
+<profiles> is a list of profiles to uninstall.
+
+The jiri profile uninstall flags are:
+ -all-targets=false
+ apply to all targets for the specified profile(s)
+ -profiles-db=$JIRI_ROOT/.jiri_root/profile_db
+ specify the profiles database directory or file.
+ -profiles-dir=.jiri_root/profiles
+ the directory, relative to JIRI_ROOT, that profiles are installed in
+ -target=<runtime.GOARCH>-<runtime.GOOS>
+ specifies a profile target in the following form: <arch>-<os>[@<version>]
+ -v=false
+ print more detailed information
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+
+Jiri profile update - Install the latest default version of the given profiles
+
+Install the latest default version of the given profiles.
+
+Usage:
+ jiri profile update [flags] <profiles>
+
+<profiles> is a list of profiles to update, if omitted all profiles are updated.
+
+The jiri profile update flags are:
+ -profiles-db=$JIRI_ROOT/.jiri_root/profile_db
+ specify the profiles database directory or file.
+ -profiles-dir=.jiri_root/profiles
+ the directory, relative to JIRI_ROOT, that profiles are installed in
+ -v=false
+ print more detailed information
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+
+Jiri profile cleanup - Cleanup the locally installed profiles
+
+Cleanup the locally installed profiles. This is generally required when
+recovering from earlier bugs or when preparing for a subsequent change to the
+profiles implementation.
+
+Usage:
+ jiri profile cleanup [flags] <profiles>
+
+<profiles> is a list of profiles to cleanup, if omitted all profiles are
+cleaned.
+
+The jiri profile cleanup flags are:
+ -gc=false
+ uninstall profile targets that are older than the current default
+ -profiles-db=$JIRI_ROOT/.jiri_root/profile_db
+ specify the profiles database directory or file.
+ -profiles-dir=.jiri_root/profiles
+ the directory, relative to JIRI_ROOT, that profiles are installed in
+ -rewrite-profiles-db=false
+ rewrite the profiles database to use the latest schema version
+ -rm-all=false
+ remove profiles database and all profile generated output files.
+ -v=false
+ print more detailed information
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+
+Jiri profile available - List the available profiles
+
+List the available profiles.
+
+Usage:
+ jiri profile available [flags]
+
+The jiri profile available flags are:
+ -v=false
+ print more detailed information
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+
+Jiri project - Manage the jiri projects
+
+Manage the jiri projects.
+
+Usage:
+ jiri project [flags] <command>
+
+The jiri project commands are:
+ clean Restore jiri projects to their pristine state
+ list List existing jiri projects and branches
+ shell-prompt Print a succinct status of projects suitable for shell prompts
+ poll Poll existing jiri projects
+
+The jiri project flags are:
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri project clean - Restore jiri projects to their pristine state
+
+Restore jiri projects back to their master branches and get rid of all the local
+branches and changes.
+
+Usage:
+ jiri project clean [flags] <project ...>
+
+<project ...> is a list of projects to clean up.
+
+The jiri project clean flags are:
+ -branches=false
+ Delete all non-master branches.
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri project list - List existing jiri projects and branches
+
+Inspect the local filesystem and list the existing projects and branches.
+
+Usage:
+ jiri project list [flags]
+
+The jiri project list flags are:
+ -branches=false
+ Show project branches.
+ -nopristine=false
+ If true, omit pristine projects, i.e. projects with a clean master branch and
+ no other branches.
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri project shell-prompt - Print a succinct status of projects suitable for shell prompts
+
+Reports current branches of jiri projects (repositories) as well as an
+indication of each project's status:
+ * indicates that a repository contains uncommitted changes
+ % indicates that a repository contains untracked files
+
+Usage:
+ jiri project shell-prompt [flags]
+
+The jiri project shell-prompt flags are:
+ -check-dirty=true
+ If false, don't check for uncommitted changes or untracked files. Setting
+ this option to false is dangerous: dirty master branches will not appear in
+ the output.
+ -show-name=false
+ Show the name of the current repo.
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri project poll - Poll existing jiri projects
+
+Poll jiri projects that can affect the outcome of the given tests and report
+whether any new changes in these projects exist. If no tests are specified, all
+projects are polled by default.
+
+Usage:
+ jiri project poll [flags] <test ...>
+
+<test ...> is a list of tests that determine what projects to poll.
+
+The jiri project poll flags are:
+ -manifest=
+ Name of the project manifest.
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri rebuild - Rebuild all jiri tools
+
+Rebuilds all jiri tools and installs the resulting binaries into
+$JIRI_ROOT/.jiri_root/bin. This is similar to "jiri update", but does not update
+any projects before building the tools. The set of tools to rebuild is described
+in the manifest.
+
+Run "jiri help manifest" for details on manifests.
+
+Usage:
+ jiri rebuild [flags]
+
+The jiri rebuild flags are:
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri snapshot - Manage project snapshots
+
+The "jiri snapshot" command can be used to manage project snapshots. In
+particular, it can be used to create new snapshots and to list existing
+snapshots.
+
+Usage:
+ jiri snapshot [flags] <command>
+
+The jiri snapshot commands are:
+ checkout Checkout a project snapshot
+ create Create a new project snapshot
+ list List existing project snapshots
+
+The jiri snapshot flags are:
+ -dir=
+ Directory where snapshot are stored. Defaults to $JIRI_ROOT/.snapshot.
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri snapshot checkout - Checkout a project snapshot
+
+The "jiri snapshot checkout <snapshot>" command restores local project state to
+the state in the given snapshot manifest.
+
+Usage:
+ jiri snapshot checkout [flags] <snapshot>
+
+<snapshot> is the snapshot manifest file.
+
+The jiri snapshot checkout flags are:
+ -gc=false
+ Garbage collect obsolete repositories.
+
+ -color=true
+ Use color to format output.
+ -dir=
+ Directory where snapshot are stored. Defaults to $JIRI_ROOT/.snapshot.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri snapshot create - Create a new project snapshot
+
+The "jiri snapshot create <label>" command captures the current project state in
+a manifest. If the -push-remote flag is provided, the snapshot is committed and
+pushed upstream.
+
+Internally, snapshots are organized as follows:
+
+ <snapshot-dir>/
+ labels/
+ <label1>/
+ <label1-snapshot1>
+ <label1-snapshot2>
+ ...
+ <label2>/
+ <label2-snapshot1>
+ <label2-snapshot2>
+ ...
+ <label3>/
+ ...
+ <label1> # a symlink to the latest <label1-snapshot*>
+ <label2> # a symlink to the latest <label2-snapshot*>
+ ...
+
+NOTE: Unlike the jiri tool commands, the above internal organization is not an
+API. It is an implementation and can change without notice.
+
+Usage:
+ jiri snapshot create [flags] <label>
+
+<label> is the snapshot label.
+
+The jiri snapshot create flags are:
+ -push-remote=false
+ Commit and push snapshot upstream.
+ -time-format=2006-01-02T15:04:05Z07:00
+ Time format for snapshot file name.
+
+ -color=true
+ Use color to format output.
+ -dir=
+ Directory where snapshot are stored. Defaults to $JIRI_ROOT/.snapshot.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri snapshot list - List existing project snapshots
+
+The "snapshot list" command lists existing snapshots of the labels specified as
+command-line arguments. If no arguments are provided, the command lists
+snapshots for all known labels.
+
+Usage:
+ jiri snapshot list [flags] <label ...>
+
+<label ...> is a list of snapshot labels.
+
+The jiri snapshot list flags are:
+ -color=true
+ Use color to format output.
+ -dir=
+ Directory where snapshot are stored. Defaults to $JIRI_ROOT/.snapshot.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri update - Update all jiri tools and projects
+
+Updates all projects, builds the latest version of all tools, and installs the
+resulting binaries into $JIRI_ROOT/.jiri_root/bin. The sequence in which the
+individual updates happen guarantees that we end up with a consistent set of
+tools and source code. The set of projects and tools to update is described in
+the manifest.
+
+Run "jiri help manifest" for details on manifests.
+
+Usage:
+ jiri update [flags]
+
+The jiri update flags are:
+ -attempts=1
+ Number of attempts before failing.
+ -gc=false
+ Garbage collect obsolete repositories.
+ -manifest=
+ Name of the project manifest.
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri upgrade - Upgrade jiri to new-style manifests
+
+Upgrades jiri to use new-style manifests.
+
+The old (deprecated) behavior only allowed a single manifest repository, located
+in $JIRI_ROOT/.manifest. The initial manifest file is located as follows:
+ 1) Use -manifest flag, if non-empty. If it's empty...
+ 2) Use $JIRI_ROOT/.local_manifest file. If it doesn't exist...
+ 3) Use $JIRI_ROOT/.manifest/v2/default.
+
+The new behavior allows multiple manifest repositories, by allowing imports to
+specify project attributes describing the remote repository. The -manifest flag
+is no longer allowed to be set; the initial manifest file is always located in
+$JIRI_ROOT/.jiri_manifest. The .local_manifest file is ignored.
+
+During the transition phase, both old and new behaviors are supported. The jiri
+tool uses the existence of the $JIRI_ROOT/.jiri_manifest file as the signal; if
+it exists we run the new behavior, otherwise we run the old behavior.
+
+The new behavior includes a "jiri import" command, which writes or updates the
+.jiri_manifest file. The new bootstrap procedure runs "jiri import", and it is
+intended as a regular command to add imports to your jiri environment.
+
+This upgrade command eases the transition by writing an initial .jiri_manifest
+file for you. If you have an existing .local_manifest file, its contents will
+be incorporated into the new .jiri_manifest file, and it will be renamed to
+.local_manifest.BACKUP. The -revert flag deletes the .jiri_manifest file, and
+restores the .local_manifest file.
+
+Usage:
+ jiri upgrade [flags] <kind>
+
+<kind> specifies the kind of upgrade, one of "v23" or "fuchsia".
+
+The jiri upgrade flags are:
+ -revert=false
+ Revert the upgrade by deleting the $JIRI_ROOT/.jiri_manifest file.
+
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri which - Show path to the jiri tool
+
+Which behaves similarly to the unix commandline tool. It is useful in
+determining whether the jiri binary is being run directly, or run via the jiri
+shim script.
+
+If the binary is being run directly, the output looks like this:
+
+ # binary
+ /path/to/binary/jiri
+
+If the script is being run, the output looks like this:
+
+ # script
+ /path/to/script/jiri
+
+Usage:
+ jiri which [flags]
+
+The jiri which flags are:
+ -color=true
+ Use color to format output.
+ -n=false
+ Show what commands will run but do not execute them.
+ -v=false
+ Print verbose output.
+
+Jiri help - Display help for commands or topics
+
+Help with no args displays the usage of the parent command.
+
+Help with args displays the usage of the specified sub-command or help topic.
+
+"help ..." recursively displays help for all commands and topics.
+
+Usage:
+ jiri help [flags] [command/topic ...]
+
+[command/topic ...] optionally identifies a specific sub-command or help topic.
+
+The jiri help flags are:
+ -style=compact
+ The formatting style for help output:
+ compact - Good for compact cmdline output.
+ full - Good for cmdline output, shows all global flags.
+ godoc - Good for godoc processing.
+ shortonly - Only output short description.
+ Override the default by setting the CMDLINE_STYLE environment variable.
+ -width=<terminal width>
+ Format output to this target width in runes, or unlimited if width < 0.
+ Defaults to the terminal width if available. Override the default by setting
+ the CMDLINE_WIDTH environment variable.
+
+Jiri filesystem - Description of jiri file system layout
+
+All data managed by the jiri tool is located in the file system under a root
+directory, colloquially called the jiri root directory. The file system layout
+looks like this:
+
+ [root] # root directory (name picked by user)
+ [root]/.jiri_root # root metadata directory
+ [root]/.jiri_root/bin # contains tool binaries (jiri, etc.)
+ [root]/.jiri_root/update_history # contains history of update snapshots
+ [root]/.manifest # contains jiri manifests
+ [root]/[project1] # project directory (name picked by user)
+ [root]/[project1]/.jiri # project metadata directory
+ [root]/[project1]/.jiri/metadata.v2 # project metadata file
+ [root]/[project1]/.jiri/<<cls>> # project per-cl metadata directories
+ [root]/[project1]/<<files>> # project files
+ [root]/[project2]...
+
+The [root] and [projectN] directory names are picked by the user. The <<cls>>
+are named via jiri cl new, and the <<files>> are named as the user adds files
+and directories to their project. All other names above have special meaning to
+the jiri tool, and cannot be changed; you must ensure your path names don't
+collide with these special names.
+
+There are two ways to run the jiri tool:
+
+1) Shim script (recommended approach). This is a shell script that looks for
+the [root] directory. If the JIRI_ROOT environment variable is set, that is
+assumed to be the [root] directory. Otherwise the script looks for the
+.jiri_root directory, starting in the current working directory and walking up
+the directory chain. The search is terminated successfully when the .jiri_root
+directory is found; it fails after it reaches the root of the file system. Thus
+the shim must be invoked from the [root] directory or one of its subdirectories.
+
+Once the [root] is found, the JIRI_ROOT environment variable is set to its
+location, and [root]/.jiri_root/bin/jiri is invoked. That file contains the
+actual jiri binary.
+
+The point of the shim script is to make it easy to use the jiri tool with
+multiple [root] directories on your file system. Keep in mind that when "jiri
+update" is run, the jiri tool itself is automatically updated along with all
+projects. By using the shim script, you only need to remember to invoke the
+jiri tool from within the appropriate [root] directory, and the projects and
+tools under that [root] directory will be updated.
+
+The shim script is located at [root]/release/go/src/v.io/jiri/scripts/jiri
+
+2) Direct binary. This is the jiri binary, containing all of the actual jiri
+tool logic. The binary requires the JIRI_ROOT environment variable to point to
+the [root] directory.
+
+Note that if you have multiple [root] directories on your file system, you must
+remember to run the jiri binary corresponding to the setting of your JIRI_ROOT
+environment variable. Things may fail if you mix things up, since the jiri
+binary is updated with each call to "jiri update", and you may encounter version
+mismatches between the jiri binary and the various metadata files or other
+logic. This is the reason the shim script is recommended over running the
+binary directly.
+
+The binary is located at [root]/.jiri_root/bin/jiri
+
+Jiri manifest - Description of manifest files
+
+Jiri manifests are revisioned and stored in a "manifest" repository, that is
+available locally in $JIRI_ROOT/.manifest. The manifest uses the following XML
+schema:
+
+ <manifest>
+ <imports>
+ <import name="default"/>
+ ...
+ </imports>
+ <projects>
+ <project name="release.go.jiri"
+ path="release/go/src/v.io/jiri"
+ protocol="git"
+ name="https://vanadium.googlesource.com/release.go.jiri"
+ revision="HEAD"/>
+ ...
+ </projects>
+ <tools>
+ <tool name="jiri" package="v.io/jiri"/>
+ ...
+ </tools>
+ </manifest>
+
+The <import> element can be used to share settings across multiple manifests.
+Import names are interpreted relative to the $JIRI_ROOT/.manifest/v2 directory.
+Import cycles are not allowed and if a project or a tool is specified multiple
+times, the last specification takes effect. In particular, the elements <project
+name="foo" exclude="true"/> and <tool name="bar" exclude="true"/> can be used to
+exclude previously included projects and tools.
+
+The tool identifies which manifest to use using the following algorithm. If the
+$JIRI_ROOT/.local_manifest file exists, then it is used. Otherwise, the
+$JIRI_ROOT/.manifest/v2/<manifest>.xml file is used, where <manifest> is the
+value of the -manifest command-line flag, which defaults to "default".
+*/
+package main
diff --git a/cmd/jiri/import.go b/cmd/jiri/import.go
new file mode 100644
index 0000000..7636f13
--- /dev/null
+++ b/cmd/jiri/import.go
@@ -0,0 +1,101 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "os"
+
+ "v.io/jiri/jiri"
+ "v.io/jiri/project"
+ "v.io/jiri/runutil"
+ "v.io/x/lib/cmdline"
+)
+
+var (
+ // Flags for configuring project attributes for remote imports.
+ flagImportName, flagImportProtocol, flagImportRemoteBranch, flagImportRoot string
+ // Flags for controlling the behavior of the command.
+ flagImportOverwrite bool
+ flagImportOut string
+)
+
+func init() {
+ cmdImport.Flags.StringVar(&flagImportName, "name", "", `The name of the remote manifest project, used to disambiguate manifest projects with the same remote. Typically empty.`)
+ cmdImport.Flags.StringVar(&flagImportProtocol, "protocol", "git", `The version control protocol used by the remote manifest project.`)
+ cmdImport.Flags.StringVar(&flagImportRemoteBranch, "remote-branch", "master", `The branch of the remote manifest project to track, without the leading "origin/".`)
+ cmdImport.Flags.StringVar(&flagImportRoot, "root", "", `Root to store the manifest project locally.`)
+
+ cmdImport.Flags.BoolVar(&flagImportOverwrite, "overwrite", false, `Write a new .jiri_manifest file with the given specification. If it already exists, the existing content will be ignored and the file will be overwritten.`)
+ cmdImport.Flags.StringVar(&flagImportOut, "out", "", `The output file. Uses $JIRI_ROOT/.jiri_manifest if unspecified. Uses stdout if set to "-".`)
+}
+
+var cmdImport = &cmdline.Command{
+ Runner: jiri.RunnerFunc(runImport),
+ Name: "import",
+ Short: "Adds imports to .jiri_manifest file",
+ Long: `
+Command "import" adds imports to the $JIRI_ROOT/.jiri_manifest file, which
+specifies manifest information for the jiri tool. The file is created if it
+doesn't already exist, otherwise additional imports are added to the existing
+file.
+
+An <import> element is added to the manifest representing a remote manifest
+import. The manifest file path is relative to the root directory of the remote
+import repository.
+
+Example:
+ $ jiri import myfile https://foo.com/bar.git
+
+Run "jiri help manifest" for details on manifests.
+`,
+ ArgsName: "<manifest> <remote>",
+ ArgsLong: `
+<manifest> specifies the manifest file to use.
+
+<remote> specifies the remote manifest repository.
+`,
+}
+
+func runImport(jirix *jiri.X, args []string) error {
+ if len(args) != 2 {
+ return jirix.UsageErrorf("wrong number of arguments")
+ }
+ // Initialize manifest.
+ var manifest *project.Manifest
+ if !flagImportOverwrite {
+ m, err := project.ManifestFromFile(jirix, jirix.JiriManifestFile())
+ if err != nil && !runutil.IsNotExist(err) {
+ return err
+ }
+ manifest = m
+ }
+ if manifest == nil {
+ manifest = &project.Manifest{}
+ }
+ // There's not much error checking when writing the .jiri_manifest file;
+ // errors will be reported when "jiri update" is run.
+ manifest.Imports = append(manifest.Imports, project.Import{
+ Manifest: args[0],
+ Name: flagImportName,
+ Protocol: flagImportProtocol,
+ Remote: args[1],
+ RemoteBranch: flagImportRemoteBranch,
+ Root: flagImportRoot,
+ })
+ // Write output to stdout or file.
+ outFile := flagImportOut
+ if outFile == "" {
+ outFile = jirix.JiriManifestFile()
+ }
+ if outFile == "-" {
+ bytes, err := manifest.ToBytes()
+ if err != nil {
+ return err
+ }
+ _, err = os.Stdout.Write(bytes)
+ return err
+ }
+ return manifest.ToFile(jirix, outFile)
+}
diff --git a/cmd/jiri/import_test.go b/cmd/jiri/import_test.go
new file mode 100644
index 0000000..7b13b97
--- /dev/null
+++ b/cmd/jiri/import_test.go
@@ -0,0 +1,199 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+
+ "v.io/jiri/jiri"
+ "v.io/x/lib/gosh"
+)
+
+type importTestCase struct {
+ Args []string
+ Filename string
+ Exist, Want string
+ Stdout, Stderr string
+}
+
+func TestImport(t *testing.T) {
+ tests := []importTestCase{
+ {
+ Stderr: `wrong number of arguments`,
+ },
+ {
+ Args: []string{"a"},
+ Stderr: `wrong number of arguments`,
+ },
+ {
+ Args: []string{"a", "b", "c"},
+ Stderr: `wrong number of arguments`,
+ },
+ // Remote imports, default append behavior
+ {
+ Args: []string{"-name=name", "-remote-branch=remotebranch", "-root=root", "foo", "https://github.com/new.git"},
+ Want: `<manifest>
+ <imports>
+ <import manifest="foo" name="name" remote="https://github.com/new.git" remotebranch="remotebranch" root="root"/>
+ </imports>
+</manifest>
+`,
+ },
+ {
+ Args: []string{"foo", "https://github.com/new.git"},
+ Want: `<manifest>
+ <imports>
+ <import manifest="foo" remote="https://github.com/new.git"/>
+ </imports>
+</manifest>
+`,
+ },
+ {
+ Args: []string{"-out=file", "foo", "https://github.com/new.git"},
+ Filename: `file`,
+ Want: `<manifest>
+ <imports>
+ <import manifest="foo" remote="https://github.com/new.git"/>
+ </imports>
+</manifest>
+`,
+ },
+ {
+ Args: []string{"-out=-", "foo", "https://github.com/new.git"},
+ Stdout: `<manifest>
+ <imports>
+ <import manifest="foo" remote="https://github.com/new.git"/>
+ </imports>
+</manifest>
+`,
+ },
+ {
+ Args: []string{"foo", "https://github.com/new.git"},
+ Exist: `<manifest>
+ <imports>
+ <import manifest="bar" remote="https://github.com/orig.git"/>
+ </imports>
+</manifest>
+`,
+ Want: `<manifest>
+ <imports>
+ <import manifest="bar" remote="https://github.com/orig.git"/>
+ <import manifest="foo" remote="https://github.com/new.git"/>
+ </imports>
+</manifest>
+`,
+ },
+ // Remote imports, explicit overwrite behavior
+ {
+ Args: []string{"-overwrite", "foo", "https://github.com/new.git"},
+ Want: `<manifest>
+ <imports>
+ <import manifest="foo" remote="https://github.com/new.git"/>
+ </imports>
+</manifest>
+`,
+ },
+ {
+ Args: []string{"-overwrite", "-out=file", "foo", "https://github.com/new.git"},
+ Filename: `file`,
+ Want: `<manifest>
+ <imports>
+ <import manifest="foo" remote="https://github.com/new.git"/>
+ </imports>
+</manifest>
+`,
+ },
+ {
+ Args: []string{"-overwrite", "-out=-", "foo", "https://github.com/new.git"},
+ Stdout: `<manifest>
+ <imports>
+ <import manifest="foo" remote="https://github.com/new.git"/>
+ </imports>
+</manifest>
+`,
+ },
+ {
+ Args: []string{"-overwrite", "foo", "https://github.com/new.git"},
+ Exist: `<manifest>
+ <imports>
+ <import manifest="bar" remote="https://github.com/orig.git"/>
+ </imports>
+</manifest>
+`,
+ Want: `<manifest>
+ <imports>
+ <import manifest="foo" remote="https://github.com/new.git"/>
+ </imports>
+</manifest>
+`,
+ },
+ }
+ opts := gosh.Opts{Fatalf: t.Fatalf, Logf: t.Logf}
+ sh := gosh.NewShell(opts)
+ defer sh.Cleanup()
+ jiriTool := sh.BuildGoPkg("v.io/jiri")
+ for _, test := range tests {
+ if err := testImport(opts, jiriTool, test); err != nil {
+ t.Errorf("%v: %v", test.Args, err)
+ }
+ }
+}
+
+func testImport(opts gosh.Opts, jiriTool string, test importTestCase) error {
+ sh := gosh.NewShell(opts)
+ defer sh.Cleanup()
+ tmpDir := sh.MakeTempDir()
+ jiriRoot := filepath.Join(tmpDir, "root")
+ if err := os.Mkdir(jiriRoot, 0755); err != nil {
+ return err
+ }
+ sh.Pushd(jiriRoot)
+ filename := test.Filename
+ if filename == "" {
+ filename = ".jiri_manifest"
+ }
+ // Set up manfile for the local file import tests. It should exist in both
+ // the tmpDir (for ../manfile tests) and jiriRoot.
+ for _, dir := range []string{tmpDir, jiriRoot} {
+ if err := ioutil.WriteFile(filepath.Join(dir, "manfile"), nil, 0644); err != nil {
+ return err
+ }
+ }
+ // Set up an existing file if it was specified.
+ if test.Exist != "" {
+ if err := ioutil.WriteFile(filename, []byte(test.Exist), 0644); err != nil {
+ return err
+ }
+ }
+ // Run import and check the error.
+ sh.Vars[jiri.RootEnv] = jiriRoot
+ cmd := sh.Cmd(jiriTool, append([]string{"import"}, test.Args...)...)
+ if test.Stderr != "" {
+ cmd.ExitErrorIsOk = true
+ }
+ stdout, stderr := cmd.StdoutStderr()
+ if got, want := stdout, test.Stdout; !strings.Contains(got, want) || (got != "" && want == "") {
+ return fmt.Errorf("stdout got %q, want substr %q", got, want)
+ }
+ if got, want := stderr, test.Stderr; !strings.Contains(got, want) || (got != "" && want == "") {
+ return fmt.Errorf("stderr got %q, want substr %q", got, want)
+ }
+ // Make sure the right file is generated.
+ if test.Want != "" {
+ data, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return err
+ }
+ if got, want := string(data), test.Want; got != want {
+ return fmt.Errorf("GOT\n%s\nWANT\n%s", got, want)
+ }
+ }
+ return nil
+}
diff --git a/cmd/jiri/profile.go b/cmd/jiri/profile.go
new file mode 100644
index 0000000..a472a09
--- /dev/null
+++ b/cmd/jiri/profile.go
@@ -0,0 +1,22 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "v.io/jiri/jiri"
+ "v.io/jiri/profiles/profilescmdline"
+ "v.io/x/lib/cmdline"
+)
+
+var cmdProfile = &cmdline.Command{
+ Name: "profile",
+ Short: "Display information about installed profiles",
+ Long: "Display information about installed profiles and their configuration.",
+}
+
+func init() {
+ profilescmdline.RegisterReaderCommands(cmdProfile, jiri.ProfilesDBDir)
+ profilescmdline.RegisterManagementCommands(cmdProfile, "", jiri.ProfilesDBDir, jiri.ProfilesRootDir)
+}
diff --git a/cmd/jiri/project.go b/cmd/jiri/project.go
new file mode 100644
index 0000000..ea94798
--- /dev/null
+++ b/cmd/jiri/project.go
@@ -0,0 +1,252 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "encoding/json"
+ "fmt"
+ "path/filepath"
+ "sort"
+ "strings"
+
+ "v.io/jiri/jiri"
+ "v.io/jiri/project"
+ "v.io/jiri/tool"
+ "v.io/jiri/util"
+ "v.io/x/lib/cmdline"
+ "v.io/x/lib/set"
+)
+
+var (
+ branchesFlag bool
+ cleanupBranchesFlag bool
+ noPristineFlag bool
+ checkDirtyFlag bool
+ showNameFlag bool
+)
+
+func init() {
+ cmdProjectClean.Flags.BoolVar(&cleanupBranchesFlag, "branches", false, "Delete all non-master branches.")
+ cmdProjectList.Flags.BoolVar(&branchesFlag, "branches", false, "Show project branches.")
+ cmdProjectList.Flags.BoolVar(&noPristineFlag, "nopristine", false, "If true, omit pristine projects, i.e. projects with a clean master branch and no other branches.")
+ cmdProjectShellPrompt.Flags.BoolVar(&checkDirtyFlag, "check-dirty", true, "If false, don't check for uncommitted changes or untracked files. Setting this option to false is dangerous: dirty master branches will not appear in the output.")
+ cmdProjectShellPrompt.Flags.BoolVar(&showNameFlag, "show-name", false, "Show the name of the current repo.")
+
+ tool.InitializeProjectFlags(&cmdProjectPoll.Flags)
+
+}
+
+// cmdProject represents the "jiri project" command.
+var cmdProject = &cmdline.Command{
+ Name: "project",
+ Short: "Manage the jiri projects",
+ Long: "Manage the jiri projects.",
+ Children: []*cmdline.Command{cmdProjectClean, cmdProjectList, cmdProjectShellPrompt, cmdProjectPoll},
+}
+
+// cmdProjectClean represents the "jiri project clean" command.
+var cmdProjectClean = &cmdline.Command{
+ Runner: jiri.RunnerFunc(runProjectClean),
+ Name: "clean",
+ Short: "Restore jiri projects to their pristine state",
+ Long: "Restore jiri projects back to their master branches and get rid of all the local branches and changes.",
+ ArgsName: "<project ...>",
+ ArgsLong: "<project ...> is a list of projects to clean up.",
+}
+
+func runProjectClean(jirix *jiri.X, args []string) (e error) {
+ localProjects, err := project.LocalProjects(jirix, project.FullScan)
+ if err != nil {
+ return err
+ }
+ var projects project.Projects
+ if len(args) > 0 {
+ for _, arg := range args {
+ p, err := localProjects.FindUnique(arg)
+ if err != nil {
+ fmt.Fprintf(jirix.Stderr(), "Error finding local project %q: %v.\n", p.Name, err)
+ } else {
+ projects[p.Key()] = p
+ }
+ }
+ } else {
+ projects = localProjects
+ }
+ if err := project.CleanupProjects(jirix, projects, cleanupBranchesFlag); err != nil {
+ return err
+ }
+ return nil
+}
+
+// cmdProjectList represents the "jiri project list" command.
+var cmdProjectList = &cmdline.Command{
+ Runner: jiri.RunnerFunc(runProjectList),
+ Name: "list",
+ Short: "List existing jiri projects and branches",
+ Long: "Inspect the local filesystem and list the existing projects and branches.",
+}
+
+// runProjectList generates a listing of local projects.
+func runProjectList(jirix *jiri.X, _ []string) error {
+ states, err := project.GetProjectStates(jirix, noPristineFlag)
+ if err != nil {
+ return err
+ }
+ var keys project.ProjectKeys
+ for key := range states {
+ keys = append(keys, key)
+ }
+ sort.Sort(keys)
+
+ for _, key := range keys {
+ state := states[key]
+ if noPristineFlag {
+ pristine := len(state.Branches) == 1 && state.CurrentBranch == "master" && !state.HasUncommitted && !state.HasUntracked
+ if pristine {
+ continue
+ }
+ }
+ fmt.Fprintf(jirix.Stdout(), "name=%q remote=%q path=%q\n", state.Project.Name, state.Project.Remote, state.Project.Path)
+ if branchesFlag {
+ for _, branch := range state.Branches {
+ s := " "
+ if branch.Name == state.CurrentBranch {
+ s += "* "
+ }
+ s += branch.Name
+ if branch.HasGerritMessage {
+ s += " (exported to gerrit)"
+ }
+ fmt.Fprintf(jirix.Stdout(), "%v\n", s)
+ }
+ }
+ }
+ return nil
+}
+
+// cmdProjectShellPrompt represents the "jiri project shell-prompt" command.
+var cmdProjectShellPrompt = &cmdline.Command{
+ Runner: jiri.RunnerFunc(runProjectShellPrompt),
+ Name: "shell-prompt",
+ Short: "Print a succinct status of projects suitable for shell prompts",
+ Long: `
+Reports current branches of jiri projects (repositories) as well as an
+indication of each project's status:
+ * indicates that a repository contains uncommitted changes
+ % indicates that a repository contains untracked files
+`,
+}
+
+func runProjectShellPrompt(jirix *jiri.X, args []string) error {
+ states, err := project.GetProjectStates(jirix, checkDirtyFlag)
+ if err != nil {
+ return err
+ }
+ var keys project.ProjectKeys
+ for key := range states {
+ keys = append(keys, key)
+ }
+ sort.Sort(keys)
+
+ // Get the key of the current project.
+ currentProjectKey, err := project.CurrentProjectKey(jirix)
+ if err != nil {
+ return err
+ }
+ var statuses []string
+ for _, key := range keys {
+ state := states[key]
+ status := ""
+ if checkDirtyFlag {
+ if state.HasUncommitted {
+ status += "*"
+ }
+ if state.HasUntracked {
+ status += "%"
+ }
+ }
+ short := state.CurrentBranch + status
+ long := filepath.Base(states[key].Project.Name) + ":" + short
+ if key == currentProjectKey {
+ if showNameFlag {
+ statuses = append([]string{long}, statuses...)
+ } else {
+ statuses = append([]string{short}, statuses...)
+ }
+ } else {
+ pristine := state.CurrentBranch == "master"
+ if checkDirtyFlag {
+ pristine = pristine && !state.HasUncommitted && !state.HasUntracked
+ }
+ if !pristine {
+ statuses = append(statuses, long)
+ }
+ }
+ }
+ fmt.Println(strings.Join(statuses, ","))
+ return nil
+}
+
+// cmdProjectPoll represents the "jiri project poll" command.
+var cmdProjectPoll = &cmdline.Command{
+ Runner: jiri.RunnerFunc(runProjectPoll),
+ Name: "poll",
+ Short: "Poll existing jiri projects",
+ Long: `
+Poll jiri projects that can affect the outcome of the given tests
+and report whether any new changes in these projects exist. If no
+tests are specified, all projects are polled by default.
+`,
+ ArgsName: "<test ...>",
+ ArgsLong: "<test ...> is a list of tests that determine what projects to poll.",
+}
+
+// runProjectPoll generates a description of changes that exist
+// remotely but do not exist locally.
+func runProjectPoll(jirix *jiri.X, args []string) error {
+ projectSet := map[string]struct{}{}
+ if len(args) > 0 {
+ config, err := util.LoadConfig(jirix)
+ if err != nil {
+ return err
+ }
+ // Compute a map from tests to projects that can change the
+ // outcome of the test.
+ testProjects := map[string][]string{}
+ for _, project := range config.Projects() {
+ for _, test := range config.ProjectTests([]string{project}) {
+ testProjects[test] = append(testProjects[test], project)
+ }
+ }
+ for _, arg := range args {
+ projects, ok := testProjects[arg]
+ if !ok {
+ return fmt.Errorf("failed to find any projects for test %q", arg)
+ }
+ set.String.Union(projectSet, set.String.FromSlice(projects))
+ }
+ }
+ update, err := project.PollProjects(jirix, projectSet)
+ if err != nil {
+ return err
+ }
+
+ // Remove projects with empty changes.
+ for project := range update {
+ if changes := update[project]; len(changes) == 0 {
+ delete(update, project)
+ }
+ }
+
+ // Print update if it is not empty.
+ if len(update) > 0 {
+ bytes, err := json.MarshalIndent(update, "", " ")
+ if err != nil {
+ return fmt.Errorf("MarshalIndent() failed: %v", err)
+ }
+ fmt.Fprintf(jirix.Stdout(), "%s\n", bytes)
+ }
+ return nil
+}
diff --git a/cmd/jiri/rebuild.go b/cmd/jiri/rebuild.go
new file mode 100644
index 0000000..dbf30bc
--- /dev/null
+++ b/cmd/jiri/rebuild.go
@@ -0,0 +1,56 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+
+ "v.io/jiri/collect"
+ "v.io/jiri/jiri"
+ "v.io/jiri/project"
+ "v.io/x/lib/cmdline"
+)
+
+// cmdRebuild represents the "jiri rebuild" command.
+var cmdRebuild = &cmdline.Command{
+ Runner: jiri.RunnerFunc(runRebuild),
+ Name: "rebuild",
+ Short: "Rebuild all jiri tools",
+ Long: `
+Rebuilds all jiri tools and installs the resulting binaries into
+$JIRI_ROOT/.jiri_root/bin. This is similar to "jiri update", but does not update
+any projects before building the tools. The set of tools to rebuild is described
+in the manifest.
+
+Run "jiri help manifest" for details on manifests.
+`,
+}
+
+func runRebuild(jirix *jiri.X, args []string) (e error) {
+ projects, tools, err := project.LoadManifest(jirix)
+ if err != nil {
+ return err
+ }
+
+ // Create a temporary directory in which tools will be built.
+ tmpDir, err := jirix.NewSeq().TempDir("", "tmp-jiri-rebuild")
+ if err != nil {
+ return fmt.Errorf("TempDir() failed: %v", err)
+ }
+
+ // Make sure we cleanup the temp directory.
+ defer collect.Error(func() error { return jirix.NewSeq().RemoveAll(tmpDir).Done() }, &e)
+
+ // Paranoid sanity checking.
+ if _, ok := tools[project.JiriName]; !ok {
+ return fmt.Errorf("tool %q not found", project.JiriName)
+ }
+
+ // Build and install tools.
+ if err := project.BuildTools(jirix, projects, tools, tmpDir); err != nil {
+ return err
+ }
+ return project.InstallTools(jirix, tmpDir)
+}
diff --git a/cmd/jiri/scripts/bootstrap_jiri b/cmd/jiri/scripts/bootstrap_jiri
new file mode 100755
index 0000000..8f00a2f
--- /dev/null
+++ b/cmd/jiri/scripts/bootstrap_jiri
@@ -0,0 +1,76 @@
+#!/bin/bash
+# Copyright 2015 The Vanadium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+# bootstrap_jiri initializes a root directory for jiri. The following
+# directories and files will be created:
+# <root_dir> - root directory (picked by user)
+# <root_dir>/.jiri_root - root metadata directory
+# <root_dir>/.jiri_root/bin/jiri - jiri binary
+# <root_dir>/.jiri_root/scripts/jiri - jiri script
+#
+# The jiri sources are downloaded and built into a temp directory, which is
+# always deleted when this script finishes. The <root_dir> is deleted on any
+# failure.
+
+set -euf -o pipefail
+
+# fatal prints an error message, followed by the usage string, and then exits.
+fatal() {
+ usage='
+
+Usage:
+ bootstrap_jiri <root_dir>
+
+A typical bootstrap workflow looks like this:
+
+$ curl -s https://raw.githubusercontent.com/vanadium/go.jiri/master/scripts/bootstrap_jiri | bash -s myroot
+$ export PATH=myroot/.jiri_root/scripts:$PATH
+$ cd myroot
+$ jiri import public https://vanadium.googlesource.com/manifest
+$ jiri update'
+ echo "ERROR: $@${usage}" 1>&2
+ exit 1
+}
+
+# toabs converts the possibly relative argument into an absolute path. Run in a
+# subshell to avoid changing the caller's working directory.
+toabs() (
+ cd $(dirname $1)
+ echo ${PWD}/$(basename $1)
+)
+
+# Check the <root_dir> argument is supplied and doesn't already exist.
+if [[ $# -ne 1 ]]; then
+ fatal "need <root_dir> argument"
+fi
+mkdir -p $(dirname $1)
+root_dir=$(toabs $1)
+if [[ -e ${root_dir} ]]; then
+ fatal "${root_dir} already exists"
+fi
+# Check that go is on the PATH.
+if ! go version >& /dev/null ; then
+ fatal 'ERROR: "go" tool not found, see https://golang.org/doc/install'
+fi
+
+trap "rm -rf ${root_dir}" INT TERM EXIT
+
+# Make the output directories.
+tmp_dir="${root_dir}/.jiri_root/tmp"
+bin_dir="${root_dir}/.jiri_root/bin"
+scripts_dir="${root_dir}/.jiri_root/scripts"
+mkdir -p "${tmp_dir}" "${bin_dir}" "${scripts_dir}"
+
+# Go get the jiri source files, build the jiri binary, and copy the jiri shim
+# script from the sources.
+GOPATH="${tmp_dir}" go get -d v.io/jiri
+GOPATH="${tmp_dir}" go build -o "${bin_dir}/jiri" v.io/jiri
+cp "${tmp_dir}/src/v.io/jiri/scripts/jiri" "${scripts_dir}/jiri"
+
+# Clean up the tmp_dir.
+rm -rf "${tmp_dir}"
+
+echo "Please add ${scripts_dir} to your PATH."
+trap - EXIT
diff --git a/cmd/jiri/scripts/jiri b/cmd/jiri/scripts/jiri
new file mode 100755
index 0000000..6684669
--- /dev/null
+++ b/cmd/jiri/scripts/jiri
@@ -0,0 +1,61 @@
+#!/bin/bash
+# Copyright 2015 The Vanadium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+# jiri is a shim script that determines the jiri root directory and invokes
+# $JIRI_ROOT/.jiri_root/bin/jiri with the given arguments.
+#
+# If the JIRI_ROOT environment variable is set, that is assumed to be the jiri
+# root directory.
+#
+# Otherwise the script looks for the .jiri_root directory, starting in the
+# current working directory and walking up the directory chain. The search is
+# terminated successfully when the .jiri_root directory is found; it fails after
+# it reaches the root of the file system.
+#
+# This script should be invoked from the jiri root directory or one of its
+# subdirectories, unless the JIRI_ROOT environment variable is set.
+
+set -euf -o pipefail
+
+# fatal prints an error message and exits.
+fatal() {
+ echo "ERROR: $@" 1>&2
+ exit 1
+}
+
+# Handle "jiri which" without any arguments. This is handy to determine whether
+# the PATH is set up pointing at this shim script, or a regular binary. If
+# there are any arguments, we pass the command through to the binary.
+if [[ $# -eq 1 ]]; then
+ if [[ "$1" == "which" ]]; then
+ echo "# script"
+ type -p $0
+ exit 0
+ fi
+fi
+
+# If $JIRI_ROOT is set we always use it, otherwise look for a .jiri_root
+# directory starting with the current working directory, and walking up.
+if [[ -z ${JIRI_ROOT+x} ]]; then
+ CWD="$(pwd)"
+ while [[ ! -d "$(pwd)/.jiri_root" ]]; do
+ if [[ "$(pwd)" == "/" ]]; then
+ fatal "could not find .jiri_root directory"
+ fi
+ cd ..
+ done
+ export JIRI_ROOT="$(pwd)"
+ cd "${CWD}"
+fi
+
+# Make sure the jiri binary exists and is executable.
+if [[ ! -e "${JIRI_ROOT}/.jiri_root/bin/jiri" ]]; then
+ fatal "${JIRI_ROOT}/.jiri_root/bin/jiri does not exist"
+elif [[ ! -x "${JIRI_ROOT}/.jiri_root/bin/jiri" ]]; then
+ fatal "${JIRI_ROOT}/.jiri_root/bin/jiri is not executable"
+fi
+
+# Execute the jiri binary.
+exec "${JIRI_ROOT}/.jiri_root/bin/jiri" "$@"
diff --git a/cmd/jiri/scripts/jiri-bash-completion.sh b/cmd/jiri/scripts/jiri-bash-completion.sh
new file mode 100644
index 0000000..92e7e27
--- /dev/null
+++ b/cmd/jiri/scripts/jiri-bash-completion.sh
@@ -0,0 +1,107 @@
+#!/bin/bash
+# Copyright 2015 The Vanadium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+# Check for bash
+[[ -z "$BASH_VERSION" ]] && return
+
+# Extracts subcommands from the help output of a given command ($1).
+# An example help output from "jiri help":
+# ...
+# The jiri commands are:
+# build Tool for managing vanadium builds
+# contributors List vanadium project contributors
+# ...
+# Run "jiri help [command]" for command usage.
+# ...
+_jiri_extract_subcommands() {
+ local -r CMD="$1"
+ local -r START_LINE="The .* commands are"
+ local -r END_LINE="Run \"jiri"
+ ${CMD} -h > /dev/null 2>&1
+ if [[ "$?" = 0 ]]; then
+ ${CMD} -h \
+ | sed -n "/${START_LINE}/,/${END_LINE}/p" | grep '^ '| awk '{print $1}' | sort
+ fi
+}
+
+# Extracts flags from the help output of a given command ($1).
+# Note that we ignore all "global" flags.
+# An example help output from "jiri help update":
+# ...
+# The jiri update flags are:
+# -gc=false
+# Garbage collect obsolete repositories.
+# -n=false
+# ...
+_jiri_extract_flags() {
+ local -r CMD="$1"
+ local -r START_LINE="The .* flags are"
+ local -r END_LINE="^$"
+ ${CMD} -h > /dev/null 2>&1
+ if [[ "$?" = 0 ]]; then
+ ${CMD} -h | sed -n "/${START_LINE}/,/${END_LINE}/p" | grep '^ -'| cut -d= -f1 | tr -d " " | sort
+ fi
+}
+
+# Gets the command line before the word where the current cursor is.
+_jiri_get_cmdline_before_cursor() {
+ local i
+ local CMD=""
+ for(( i=0; i<COMP_CWORD; i++ )); do
+ CMD="${CMD} ${COMP_WORDS[i]}"
+ done
+ echo "${CMD}"
+}
+
+# Gets the names of available projects.
+_jiri_get_project_names() {
+ jiri project list | sed "s/^.*project=\"\(.*\)\" path.*/\1/"
+}
+
+
+# Main bash completion function for the "jiri" command.
+#
+# Completion-related internal Bash vars:
+# - COMP_WORDS: An array variable consisting of the individual words in the
+# current command line
+# - COMP_CWORD: An index into ${COMP_WORDS} of the word containing the current cursor
+# position.
+# - COMPREPLY An array variable from which bash reads the possible completions
+# generated by a completion function.
+_jiri_complete() {
+ local -r CUR="${COMP_WORDS[COMP_CWORD]}"
+ local -r CMD="$(_jiri_get_cmdline_before_cursor)"
+
+ case "${CUR}" in
+ -*)
+ # Complete flags.
+ COMPREPLY=($(compgen -W "$(_jiri_extract_flags "${CMD}")" -- ${CUR}))
+ ;;
+ *)
+ # Complete commands.
+ if [[ "${COMP_LINE}" =~ .*test(\ )+project.* ]]; then
+ # Special handling for completing "jiri test project".
+ COMPREPLY=($(compgen -W "$(_jiri_get_project_names)" -- ${CUR}))
+ elif [[ "${COMP_LINE}" =~ .*test(\ )+run.* ]]; then
+ # Special handling for completing "jiri test run".
+ COMPREPLY=($(compgen -W "$(jiri test list)" -- ${CUR}))
+ else
+ COMPREPLY=($(compgen -W "$(_jiri_extract_subcommands "${CMD}")" -- ${CUR}))
+ fi
+ ;;
+ esac
+
+ return 0
+}
+
+# Main bash completion function for the "vcd" command.
+_jiri_vcd_complete() {
+ local -r CUR="${COMP_WORDS[COMP_CWORD]}"
+
+ COMPREPLY=($(compgen -W "$(_jiri_get_project_names)" -- ${CUR}))
+}
+
+complete -F _jiri_complete jiri
+complete -F _jiri_vcd_complete vcd
diff --git a/cmd/jiri/snapshot.go b/cmd/jiri/snapshot.go
new file mode 100644
index 0000000..de89012
--- /dev/null
+++ b/cmd/jiri/snapshot.go
@@ -0,0 +1,300 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "sort"
+ "strings"
+ "time"
+
+ "v.io/jiri/collect"
+ "v.io/jiri/gitutil"
+ "v.io/jiri/jiri"
+ "v.io/jiri/project"
+ "v.io/jiri/runutil"
+ "v.io/x/lib/cmdline"
+)
+
+const (
+ defaultSnapshotDir = ".snapshot"
+)
+
+var (
+ pushRemoteFlag bool
+ snapshotDirFlag string
+ snapshotGcFlag bool
+ timeFormatFlag string
+)
+
+func init() {
+ cmdSnapshot.Flags.StringVar(&snapshotDirFlag, "dir", "", "Directory where snapshot are stored. Defaults to $JIRI_ROOT/.snapshot.")
+ cmdSnapshotCheckout.Flags.BoolVar(&snapshotGcFlag, "gc", false, "Garbage collect obsolete repositories.")
+ cmdSnapshotCreate.Flags.BoolVar(&pushRemoteFlag, "push-remote", false, "Commit and push snapshot upstream.")
+ cmdSnapshotCreate.Flags.StringVar(&timeFormatFlag, "time-format", time.RFC3339, "Time format for snapshot file name.")
+}
+
+var cmdSnapshot = &cmdline.Command{
+ Name: "snapshot",
+ Short: "Manage project snapshots",
+ Long: `
+The "jiri snapshot" command can be used to manage project snapshots.
+In particular, it can be used to create new snapshots and to list
+existing snapshots.
+`,
+ Children: []*cmdline.Command{cmdSnapshotCheckout, cmdSnapshotCreate, cmdSnapshotList},
+}
+
+// cmdSnapshotCreate represents the "jiri snapshot create" command.
+var cmdSnapshotCreate = &cmdline.Command{
+ Runner: jiri.RunnerFunc(runSnapshotCreate),
+ Name: "create",
+ Short: "Create a new project snapshot",
+ Long: `
+The "jiri snapshot create <label>" command captures the current project state
+in a manifest. If the -push-remote flag is provided, the snapshot is committed
+and pushed upstream.
+
+Internally, snapshots are organized as follows:
+
+ <snapshot-dir>/
+ labels/
+ <label1>/
+ <label1-snapshot1>
+ <label1-snapshot2>
+ ...
+ <label2>/
+ <label2-snapshot1>
+ <label2-snapshot2>
+ ...
+ <label3>/
+ ...
+ <label1> # a symlink to the latest <label1-snapshot*>
+ <label2> # a symlink to the latest <label2-snapshot*>
+ ...
+
+NOTE: Unlike the jiri tool commands, the above internal organization
+is not an API. It is an implementation and can change without notice.
+`,
+ ArgsName: "<label>",
+ ArgsLong: "<label> is the snapshot label.",
+}
+
+func runSnapshotCreate(jirix *jiri.X, args []string) error {
+ if len(args) != 1 {
+ return jirix.UsageErrorf("unexpected number of arguments")
+ }
+ label := args[0]
+ snapshotDir, err := getSnapshotDir(jirix)
+ if err != nil {
+ return err
+ }
+ snapshotFile := filepath.Join(snapshotDir, "labels", label, time.Now().Format(timeFormatFlag))
+
+ if !pushRemoteFlag {
+ // No git operations necessary. Just create the snapshot file.
+ return createSnapshot(jirix, snapshotDir, snapshotFile, label)
+ }
+
+ // Attempt to create a snapshot on a clean master branch. If snapshot
+ // creation fails, return to the state we were in before.
+ createFn := func() error {
+ git := gitutil.New(jirix.NewSeq())
+ revision, err := git.CurrentRevision()
+ if err != nil {
+ return err
+ }
+ if err := createSnapshot(jirix, snapshotDir, snapshotFile, label); err != nil {
+ git.Reset(revision)
+ git.RemoveUntrackedFiles()
+ return err
+ }
+ return commitAndPushChanges(jirix, snapshotDir, snapshotFile, label)
+ }
+
+ // Execute the above function in the snapshot directory on a clean master branch.
+ p := project.Project{
+ Path: snapshotDir,
+ Protocol: "git",
+ RemoteBranch: "master",
+ Revision: "HEAD",
+ }
+ return project.ApplyToLocalMaster(jirix, project.Projects{p.Key(): p}, createFn)
+}
+
+// getSnapshotDir returns the path to the snapshot directory, creating it if
+// necessary.
+func getSnapshotDir(jirix *jiri.X) (string, error) {
+ dir := snapshotDirFlag
+ if dir == "" {
+ dir = filepath.Join(jirix.Root, defaultSnapshotDir)
+ }
+
+ if !filepath.IsAbs(dir) {
+ cwd, err := os.Getwd()
+ if err != nil {
+ return "", err
+ }
+ dir = filepath.Join(cwd, dir)
+ }
+
+ // Make sure directory exists.
+ if err := jirix.NewSeq().MkdirAll(dir, 0755).Done(); err != nil {
+ return "", err
+ }
+ return dir, nil
+}
+
+func createSnapshot(jirix *jiri.X, snapshotDir, snapshotFile, label string) error {
+ // Create a snapshot that encodes the current state of master
+ // branches for all local projects.
+ if err := project.CreateSnapshot(jirix, snapshotFile); err != nil {
+ return err
+ }
+
+ s := jirix.NewSeq()
+ // Update the symlink for this snapshot label to point to the
+ // latest snapshot.
+ symlink := filepath.Join(snapshotDir, label)
+ newSymlink := symlink + ".new"
+ relativeSnapshotPath := strings.TrimPrefix(snapshotFile, snapshotDir+string(os.PathSeparator))
+ return s.RemoveAll(newSymlink).
+ Symlink(relativeSnapshotPath, newSymlink).
+ Rename(newSymlink, symlink).Done()
+}
+
+// commitAndPushChanges commits changes identified by the given manifest file
+// and label to the containing repository and pushes these changes to the
+// remote repository.
+func commitAndPushChanges(jirix *jiri.X, snapshotDir, snapshotFile, label string) (e error) {
+ cwd, err := os.Getwd()
+ if err != nil {
+ return err
+ }
+ defer collect.Error(func() error { return jirix.NewSeq().Chdir(cwd).Done() }, &e)
+ if err := jirix.NewSeq().Chdir(snapshotDir).Done(); err != nil {
+ return err
+ }
+ relativeSnapshotPath := strings.TrimPrefix(snapshotFile, snapshotDir+string(os.PathSeparator))
+ git := gitutil.New(jirix.NewSeq())
+ // Pull from master so we are up-to-date.
+ if err := git.Pull("origin", "master"); err != nil {
+ return err
+ }
+ if err := git.Add(relativeSnapshotPath); err != nil {
+ return err
+ }
+ if err := git.Add(label); err != nil {
+ return err
+ }
+ name := strings.TrimPrefix(snapshotFile, snapshotDir)
+ if err := git.CommitNoVerify(fmt.Sprintf("adding snapshot %q for label %q", name, label)); err != nil {
+ return err
+ }
+ if err := git.Push("origin", "master", gitutil.VerifyOpt(false)); err != nil {
+ return err
+ }
+ return nil
+}
+
+// cmdSnapshotCheckout represents the "jiri snapshot checkout" command.
+var cmdSnapshotCheckout = &cmdline.Command{
+ Runner: jiri.RunnerFunc(runSnapshotCheckout),
+ Name: "checkout",
+ Short: "Checkout a project snapshot",
+ Long: `
+The "jiri snapshot checkout <snapshot>" command restores local project state to
+the state in the given snapshot manifest.
+`,
+ ArgsName: "<snapshot>",
+ ArgsLong: "<snapshot> is the snapshot manifest file.",
+}
+
+func runSnapshotCheckout(jirix *jiri.X, args []string) error {
+ if len(args) != 1 {
+ return jirix.UsageErrorf("unexpected number of arguments")
+ }
+ return project.CheckoutSnapshot(jirix, args[0], snapshotGcFlag)
+}
+
+// cmdSnapshotList represents the "jiri snapshot list" command.
+var cmdSnapshotList = &cmdline.Command{
+ Runner: jiri.RunnerFunc(runSnapshotList),
+ Name: "list",
+ Short: "List existing project snapshots",
+ Long: `
+The "snapshot list" command lists existing snapshots of the labels
+specified as command-line arguments. If no arguments are provided, the
+command lists snapshots for all known labels.
+`,
+ ArgsName: "<label ...>",
+ ArgsLong: "<label ...> is a list of snapshot labels.",
+}
+
+func runSnapshotList(jirix *jiri.X, args []string) error {
+ snapshotDir, err := getSnapshotDir(jirix)
+ if err != nil {
+ return err
+ }
+ if len(args) == 0 {
+ // Identify all known snapshot labels, using a
+ // heuristic that looks for all symbolic links <foo>
+ // in the snapshot directory that point to a file in
+ // the "labels/<foo>" subdirectory of the snapshot
+ // directory.
+ fileInfoList, err := ioutil.ReadDir(snapshotDir)
+ if err != nil {
+ return fmt.Errorf("ReadDir(%v) failed: %v", snapshotDir, err)
+ }
+ for _, fileInfo := range fileInfoList {
+ if fileInfo.Mode()&os.ModeSymlink != 0 {
+ path := filepath.Join(snapshotDir, fileInfo.Name())
+ dst, err := filepath.EvalSymlinks(path)
+ if err != nil {
+ return fmt.Errorf("EvalSymlinks(%v) failed: %v", path, err)
+ }
+ if strings.HasSuffix(filepath.Dir(dst), filepath.Join("labels", fileInfo.Name())) {
+ args = append(args, fileInfo.Name())
+ }
+ }
+ }
+ }
+
+ // Check that all labels exist.
+ failed := false
+ for _, label := range args {
+ labelDir := filepath.Join(snapshotDir, "labels", label)
+ if _, err := jirix.NewSeq().Stat(labelDir); err != nil {
+ if !runutil.IsNotExist(err) {
+ return err
+ }
+ failed = true
+ fmt.Fprintf(jirix.Stderr(), "snapshot label %q not found", label)
+ }
+ }
+ if failed {
+ return cmdline.ErrExitCode(2)
+ }
+
+ // Print snapshots for all labels.
+ sort.Strings(args)
+ for _, label := range args {
+ // Scan the snapshot directory "labels/<label>" printing
+ // all snapshots.
+ labelDir := filepath.Join(snapshotDir, "labels", label)
+ fileInfoList, err := ioutil.ReadDir(labelDir)
+ if err != nil {
+ return fmt.Errorf("ReadDir(%v) failed: %v", labelDir, err)
+ }
+ fmt.Fprintf(jirix.Stdout(), "snapshots of label %q:\n", label)
+ for _, fileInfo := range fileInfoList {
+ fmt.Fprintf(jirix.Stdout(), " %v\n", fileInfo.Name())
+ }
+ }
+ return nil
+}
diff --git a/cmd/jiri/snapshot_test.go b/cmd/jiri/snapshot_test.go
new file mode 100644
index 0000000..d24b5a6
--- /dev/null
+++ b/cmd/jiri/snapshot_test.go
@@ -0,0 +1,341 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "bytes"
+ "fmt"
+ "os"
+ "path/filepath"
+ "testing"
+
+ "v.io/jiri/gitutil"
+ "v.io/jiri/jiri"
+ "v.io/jiri/jiritest"
+ "v.io/jiri/project"
+ "v.io/jiri/tool"
+)
+
+func createLabelDir(t *testing.T, jirix *jiri.X, snapshotDir, name string, snapshots []string) {
+ if snapshotDir == "" {
+ snapshotDir = filepath.Join(jirix.Root, defaultSnapshotDir)
+ }
+ s := jirix.NewSeq()
+ labelDir, perm := filepath.Join(snapshotDir, "labels", name), os.FileMode(0700)
+ if err := s.MkdirAll(labelDir, perm).Done(); err != nil {
+ t.Fatalf("MkdirAll(%v, %v) failed: %v", labelDir, perm, err)
+ }
+ for i, snapshot := range snapshots {
+ path := filepath.Join(labelDir, snapshot)
+ _, err := os.Create(path)
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ if i == 0 {
+ symlinkPath := filepath.Join(snapshotDir, name)
+ if err := s.Symlink(path, symlinkPath).Done(); err != nil {
+ t.Fatalf("Symlink(%v, %v) failed: %v", path, symlinkPath, err)
+ }
+ }
+ }
+}
+
+func generateOutput(labels []label) string {
+ output := ""
+ for _, label := range labels {
+ output += fmt.Sprintf("snapshots of label %q:\n", label.name)
+ for _, snapshot := range label.snapshots {
+ output += fmt.Sprintf(" %v\n", snapshot)
+ }
+ }
+ return output
+}
+
+type config struct {
+ remote bool
+ dir string
+}
+
+type label struct {
+ name string
+ snapshots []string
+}
+
+func TestList(t *testing.T) {
+ resetFlags()
+ fake, cleanup := jiritest.NewFakeJiriRoot(t)
+ defer cleanup()
+
+ snapshotDir1 := "" // Should use default dir.
+ snapshotDir2 := filepath.Join(fake.X.Root, "some/other/dir")
+
+ // Create a test suite.
+ tests := []config{
+ config{
+ dir: snapshotDir1,
+ },
+ config{
+ dir: snapshotDir2,
+ },
+ }
+ labels := []label{
+ label{
+ name: "beta",
+ snapshots: []string{"beta-1", "beta-2", "beta-3"},
+ },
+ label{
+ name: "stable",
+ snapshots: []string{"stable-1", "stable-2", "stable-3"},
+ },
+ }
+
+ for _, test := range tests {
+ snapshotDirFlag = test.dir
+ // Create the snapshots directory and populate it with the
+ // data specified by the test suite.
+ for _, label := range labels {
+ createLabelDir(t, fake.X, test.dir, label.name, label.snapshots)
+ }
+
+ // Check that running "jiri snapshot list" with no arguments
+ // returns the expected output.
+ var stdout bytes.Buffer
+ fake.X.Context = tool.NewContext(tool.ContextOpts{Stdout: &stdout})
+ if err := runSnapshotList(fake.X, nil); err != nil {
+ t.Fatalf("%v", err)
+ }
+ got, want := stdout.String(), generateOutput(labels)
+ if got != want {
+ t.Fatalf("unexpected output:\ngot\n%v\nwant\n%v\n", got, want)
+ }
+
+ // Check that running "jiri snapshot list" with one argument
+ // returns the expected output.
+ stdout.Reset()
+ if err := runSnapshotList(fake.X, []string{"stable"}); err != nil {
+ t.Fatalf("%v", err)
+ }
+ got, want = stdout.String(), generateOutput(labels[1:])
+ if got != want {
+ t.Fatalf("unexpected output:\ngot\n%v\nwant\n%v\n", got, want)
+ }
+
+ // Check that running "jiri snapshot list" with
+ // multiple arguments returns the expected output.
+ stdout.Reset()
+ if err := runSnapshotList(fake.X, []string{"beta", "stable"}); err != nil {
+ t.Fatalf("%v", err)
+ }
+ got, want = stdout.String(), generateOutput(labels)
+ if got != want {
+ t.Fatalf("unexpected output:\ngot\n%v\nwant\n%v\n", got, want)
+ }
+ }
+}
+
+func checkReadme(t *testing.T, jirix *jiri.X, project, message string) {
+ s := jirix.NewSeq()
+ if _, err := s.Stat(project); err != nil {
+ t.Fatalf("%v", err)
+ }
+ readmeFile := filepath.Join(project, "README")
+ data, err := s.ReadFile(readmeFile)
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ if got, want := data, []byte(message); bytes.Compare(got, want) != 0 {
+ t.Fatalf("unexpected content %v:\ngot\n%s\nwant\n%s\n", project, got, want)
+ }
+}
+
+func localProjectName(i int) string {
+ return "test-local-project-" + fmt.Sprintf("%d", i+1)
+}
+
+func remoteProjectName(i int) string {
+ return "test-remote-project-" + fmt.Sprintf("%d", i+1)
+}
+
+func writeReadme(t *testing.T, jirix *jiri.X, projectDir, message string) {
+ s := jirix.NewSeq()
+ path, perm := filepath.Join(projectDir, "README"), os.FileMode(0644)
+ if err := s.WriteFile(path, []byte(message), perm).Done(); err != nil {
+ t.Fatalf("%v", err)
+ }
+ cwd, err := os.Getwd()
+ if err != nil {
+ t.Fatalf("%v", err)
+ }
+ defer jirix.NewSeq().Chdir(cwd)
+ if err := s.Chdir(projectDir).Done(); err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := gitutil.New(jirix.NewSeq()).CommitFile(path, "creating README"); err != nil {
+ t.Fatalf("%v", err)
+ }
+}
+
+func resetFlags() {
+ snapshotDirFlag = ""
+ pushRemoteFlag = false
+}
+
+func TestGetSnapshotDir(t *testing.T) {
+ resetFlags()
+ defer resetFlags()
+ fake, cleanup := jiritest.NewFakeJiriRoot(t)
+ defer cleanup()
+
+ // With all flags at default values, snapshot dir should be default.
+ resetFlags()
+ got, err := getSnapshotDir(fake.X)
+ if err != nil {
+ t.Fatalf("getSnapshotDir() failed: %v\n", err)
+ }
+ if want := filepath.Join(fake.X.Root, defaultSnapshotDir); got != want {
+ t.Errorf("unexpected snapshot dir: got %v want %v", got, want)
+ }
+
+ // With dir flag set to absolute path, snapshot dir should be value of dir
+ // flag.
+ resetFlags()
+ tempDir, err := fake.X.NewSeq().TempDir("", "")
+ if err != nil {
+ t.Fatalf("TempDir() failed: %v", err)
+ }
+ defer fake.X.NewSeq().RemoveAll(tempDir).Done()
+ snapshotDirFlag = tempDir
+ got, err = getSnapshotDir(fake.X)
+ if err != nil {
+ t.Fatalf("getSnapshotDir() failed: %v\n", err)
+ }
+ if want := snapshotDirFlag; got != want {
+ t.Errorf("unexpected snapshot dir: got %v want %v", got, want)
+ }
+
+ // With dir flag set to relative path, snapshot dir should absolute path
+ // rooted at current working dir.
+ resetFlags()
+ snapshotDirFlag = "some/relative/path"
+ cwd, err := os.Getwd()
+ if err != nil {
+ t.Fatalf("os.Getwd() failed: %v", err)
+ }
+ got, err = getSnapshotDir(fake.X)
+ if err != nil {
+ t.Fatalf("getSnapshotDir() failed: %v\n", err)
+ }
+ if want := filepath.Join(cwd, snapshotDirFlag); got != want {
+ t.Errorf("unexpected snapshot dir: got %v want %v", got, want)
+ }
+}
+
+// TestCreate tests creating and checking out a snapshot.
+func TestCreate(t *testing.T) {
+ resetFlags()
+ defer resetFlags()
+ fake, cleanup := jiritest.NewFakeJiriRoot(t)
+ defer cleanup()
+ s := fake.X.NewSeq()
+
+ // Setup the initial remote and local projects.
+ numProjects, remoteProjects := 2, []string{}
+ for i := 0; i < numProjects; i++ {
+ if err := fake.CreateRemoteProject(remoteProjectName(i)); err != nil {
+ t.Fatalf("%v", err)
+ }
+ if err := fake.AddProject(project.Project{
+ Name: remoteProjectName(i),
+ Path: localProjectName(i),
+ Remote: fake.Projects[remoteProjectName(i)],
+ }); err != nil {
+ t.Fatalf("%v", err)
+ }
+ }
+
+ // Create initial commits in the remote projects and use UpdateUniverse()
+ // to mirror them locally.
+ for i := 0; i < numProjects; i++ {
+ writeReadme(t, fake.X, fake.Projects[remoteProjectName(i)], "revision 1")
+ }
+ if err := project.UpdateUniverse(fake.X, true); err != nil {
+ t.Fatalf("%v", err)
+ }
+
+ // Create a snapshot.
+ var stdout bytes.Buffer
+ fake.X.Context = tool.NewContext(tool.ContextOpts{Stdout: &stdout})
+ if err := runSnapshotCreate(fake.X, []string{"test-local"}); err != nil {
+ t.Fatalf("%v", err)
+ }
+
+ // Remove the local project repositories.
+ for i, _ := range remoteProjects {
+ localProject := filepath.Join(fake.X.Root, localProjectName(i))
+ if err := s.RemoveAll(localProject).Done(); err != nil {
+ t.Fatalf("%v", err)
+ }
+ }
+
+ // Check that invoking the UpdateUniverse() with the snapshot restores the
+ // local repositories.
+ snapshotDir := filepath.Join(fake.X.Root, defaultSnapshotDir)
+ snapshotFile := filepath.Join(snapshotDir, "test-local")
+ localX := fake.X.Clone(tool.ContextOpts{
+ Manifest: &snapshotFile,
+ })
+ if err := project.UpdateUniverse(localX, true); err != nil {
+ t.Fatalf("%v", err)
+ }
+ for i, _ := range remoteProjects {
+ localProject := filepath.Join(fake.X.Root, localProjectName(i))
+ checkReadme(t, fake.X, localProject, "revision 1")
+ }
+}
+
+// TestCreatePushRemote checks that creating a snapshot with the -push-remote
+// flag causes the snapshot to be committed and pushed upstream.
+func TestCreatePushRemote(t *testing.T) {
+ resetFlags()
+ defer resetFlags()
+
+ fake, cleanup := jiritest.NewFakeJiriRoot(t)
+ defer cleanup()
+
+ fake.EnableRemoteManifestPush()
+ defer fake.DisableRemoteManifestPush()
+
+ manifestDir := filepath.Join(fake.X.Root, ".manifest")
+ snapshotDir := filepath.Join(manifestDir, "snapshot")
+ label := "test"
+
+ git := gitutil.New(fake.X.NewSeq(), gitutil.RootDirOpt(manifestDir))
+ commitCount, err := git.CountCommits("master", "")
+ if err != nil {
+ t.Fatalf("git.CountCommits(\"master\", \"\") failed: %v", err)
+ }
+
+ // Create snapshot with -push-remote flag set to true.
+ snapshotDirFlag = snapshotDir
+ pushRemoteFlag = true
+ if err := runSnapshotCreate(fake.X, []string{label}); err != nil {
+ t.Fatalf("%v", err)
+ }
+
+ // Check that repo has one new commit.
+ newCommitCount, err := git.CountCommits("master", "")
+ if err != nil {
+ t.Fatalf("git.CountCommits(\"master\", \"\") failed: %v", err)
+ }
+ if got, want := newCommitCount, commitCount+1; got != want {
+ t.Errorf("unexpected commit count: got %v want %v", got, want)
+ }
+
+ // Check that new label is commited.
+ labelFile := filepath.Join(snapshotDir, "labels", label)
+ if !git.IsFileCommitted(labelFile) {
+ t.Errorf("expected file %v to be committed but it was not", labelFile)
+ }
+}
diff --git a/cmd/jiri/update.go b/cmd/jiri/update.go
new file mode 100644
index 0000000..f87107d
--- /dev/null
+++ b/cmd/jiri/update.go
@@ -0,0 +1,67 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "v.io/jiri/jiri"
+ "v.io/jiri/project"
+ "v.io/jiri/retry"
+ "v.io/jiri/tool"
+ "v.io/x/lib/cmdline"
+)
+
+var (
+ gcFlag bool
+ attemptsFlag int
+)
+
+func init() {
+ tool.InitializeProjectFlags(&cmdUpdate.Flags)
+
+ cmdUpdate.Flags.BoolVar(&gcFlag, "gc", false, "Garbage collect obsolete repositories.")
+ cmdUpdate.Flags.IntVar(&attemptsFlag, "attempts", 1, "Number of attempts before failing.")
+}
+
+// cmdUpdate represents the "jiri update" command.
+var cmdUpdate = &cmdline.Command{
+ Runner: jiri.RunnerFunc(runUpdate),
+ Name: "update",
+ Short: "Update all jiri tools and projects",
+ Long: `
+Updates all projects, builds the latest version of all tools, and installs the
+resulting binaries into $JIRI_ROOT/.jiri_root/bin. The sequence in which the
+individual updates happen guarantees that we end up with a consistent set of
+tools and source code. The set of projects and tools to update is described in
+the manifest.
+
+Run "jiri help manifest" for details on manifests.
+`,
+}
+
+func runUpdate(jirix *jiri.X, _ []string) error {
+ seq := jirix.NewSeq()
+ // Create the $JIRI_ROOT/.jiri_root directory if it doesn't already exist.
+ //
+ // TODO(toddw): Remove this logic after the transition to .jiri_root is done.
+ // The bootstrapping logic should create this directory, and jiri should fail
+ // if the directory doesn't exist.
+ if err := seq.MkdirAll(jirix.RootMetaDir(), 0755).Done(); err != nil {
+ return err
+ }
+
+ // Update all projects to their latest version.
+ // Attempt <attemptsFlag> times before failing.
+ updateFn := func() error { return project.UpdateUniverse(jirix, gcFlag) }
+ if err := retry.Function(jirix.Context, updateFn, retry.AttemptsOpt(attemptsFlag)); err != nil {
+ return err
+ }
+ if err := project.WriteUpdateHistorySnapshot(jirix); err != nil {
+ return err
+ }
+
+ // Only attempt the bin dir transition after the update has succeeded, to
+ // avoid messy partial states.
+ return project.TransitionBinDir(jirix)
+}
diff --git a/cmd/jiri/upgrade.go b/cmd/jiri/upgrade.go
new file mode 100644
index 0000000..da6947f
--- /dev/null
+++ b/cmd/jiri/upgrade.go
@@ -0,0 +1,150 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "os"
+ "path/filepath"
+
+ "v.io/jiri/jiri"
+ "v.io/jiri/project"
+ "v.io/jiri/runutil"
+ "v.io/x/lib/cmdline"
+)
+
+// TODO(toddw): Remove the upgrade command after the transition to new-style
+// manifests is complete.
+
+var flagUpgradeRevert bool
+
+func init() {
+ cmdUpgrade.Flags.BoolVar(&flagUpgradeRevert, "revert", false, `Revert the upgrade by deleting the $JIRI_ROOT/.jiri_manifest file.`)
+}
+
+var cmdUpgrade = &cmdline.Command{
+ Runner: jiri.RunnerFunc(runUpgrade),
+ Name: "upgrade",
+ Short: "Upgrade jiri to new-style manifests",
+ Long: `
+Upgrades jiri to use new-style manifests.
+
+The old (deprecated) behavior only allowed a single manifest repository, located
+in $JIRI_ROOT/.manifest. The initial manifest file is located as follows:
+ 1) Use -manifest flag, if non-empty. If it's empty...
+ 2) Use $JIRI_ROOT/.local_manifest file. If it doesn't exist...
+ 3) Use $JIRI_ROOT/.manifest/v2/default.
+
+The new behavior allows multiple manifest repositories, by allowing imports to
+specify project attributes describing the remote repository. The -manifest flag
+is no longer allowed to be set; the initial manifest file is always located in
+$JIRI_ROOT/.jiri_manifest. The .local_manifest file is ignored.
+
+During the transition phase, both old and new behaviors are supported. The jiri
+tool uses the existence of the $JIRI_ROOT/.jiri_manifest file as the signal; if
+it exists we run the new behavior, otherwise we run the old behavior.
+
+The new behavior includes a "jiri import" command, which writes or updates the
+.jiri_manifest file. The new bootstrap procedure runs "jiri import", and it is
+intended as a regular command to add imports to your jiri environment.
+
+This upgrade command eases the transition by writing an initial .jiri_manifest
+file for you. If you have an existing .local_manifest file, its contents will
+be incorporated into the new .jiri_manifest file, and it will be renamed to
+.local_manifest.BACKUP. The -revert flag deletes the .jiri_manifest file, and
+restores the .local_manifest file.
+`,
+ ArgsName: "<kind>",
+ ArgsLong: `
+<kind> specifies the kind of upgrade, one of "v23" or "fuchsia".
+`,
+}
+
+func runUpgrade(jirix *jiri.X, args []string) error {
+ localFile := filepath.Join(jirix.Root, ".local_manifest")
+ backupFile := localFile + ".BACKUP"
+ if flagUpgradeRevert {
+ // Restore .local_manifest.BACKUP if it exists.
+ switch _, err := jirix.NewSeq().Stat(backupFile); {
+ case err != nil && !runutil.IsNotExist(err):
+ return err
+ case err == nil:
+ if err := jirix.NewSeq().Rename(backupFile, localFile).Done(); err != nil {
+ return fmt.Errorf("couldn't restore %v to %v: %v", backupFile, localFile, err)
+ }
+ }
+ // Deleting the .jiri_manifest file reverts to the old behavior.
+ return jirix.NewSeq().Remove(jirix.JiriManifestFile()).Done()
+ }
+ if len(args) != 1 {
+ return jirix.UsageErrorf("must specify upgrade kind")
+ }
+ kind := args[0]
+ var argRemote, argName, argManifest string
+ switch kind {
+ case "v23":
+ argRemote = "https://vanadium.googlesource.com/manifest"
+ argName, argManifest = "manifest", "public"
+ case "fuchsia":
+ argRemote = "https://fuchsia.googlesource.com/fnl-start"
+ argName, argManifest = "fnl-start", "manifest/fuchsia"
+ default:
+ return jirix.UsageErrorf("unknown upgrade kind %q", kind)
+ }
+ // Initialize manifest from .local_manifest.
+ hasLocalFile := true
+ manifest, err := project.ManifestFromFile(jirix, localFile)
+ if err != nil {
+ if !runutil.IsNotExist(err) {
+ return err
+ }
+ hasLocalFile = false
+ manifest = &project.Manifest{}
+ }
+ oldImports := manifest.Imports
+ manifest.Imports = nil
+ for _, oldImport := range oldImports {
+ if oldImport.Remote != "" {
+ // This is a new-style remote import, carry it over directly.
+ manifest.Imports = append(manifest.Imports, oldImport)
+ continue
+ }
+ // This is an old-style import, convert it to the new style.
+ oldName := oldImport.Name
+ switch {
+ case kind == "v23" && oldName == "default":
+ oldName = "public"
+ case kind == "fuchsia" && oldName == "default":
+ oldName = "manifest/fuchsia"
+ }
+ manifest.Imports = append(manifest.Imports, project.Import{
+ Manifest: oldName,
+ Name: argName,
+ Remote: argRemote,
+ })
+ }
+ if len(manifest.Imports) == 0 {
+ manifest.Imports = append(manifest.Imports, project.Import{
+ Manifest: argManifest,
+ Name: argName,
+ Remote: argRemote,
+ })
+ }
+ // Write output to .jiri_manifest file.
+ outFile := jirix.JiriManifestFile()
+ if _, err := os.Stat(outFile); err == nil {
+ return fmt.Errorf("%v already exists", outFile)
+ }
+ if err := manifest.ToFile(jirix, outFile); err != nil {
+ return err
+ }
+ // Backup .local_manifest file, if it exists.
+ if hasLocalFile {
+ if err := jirix.NewSeq().Rename(localFile, backupFile).Done(); err != nil {
+ return fmt.Errorf("couldn't backup %v to %v: %v", localFile, backupFile, err)
+ }
+ }
+ return nil
+}
diff --git a/cmd/jiri/upgrade_test.go b/cmd/jiri/upgrade_test.go
new file mode 100644
index 0000000..a7c5eab
--- /dev/null
+++ b/cmd/jiri/upgrade_test.go
@@ -0,0 +1,311 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "io/ioutil"
+ "os"
+ "strings"
+ "testing"
+
+ "v.io/jiri/jiri"
+ "v.io/x/lib/gosh"
+)
+
+type upgradeTestCase struct {
+ Args []string
+ Exist bool
+ Local, Want string
+ Stderr string
+}
+
+func TestUpgrade(t *testing.T) {
+ tests := []upgradeTestCase{
+ {
+ Stderr: `must specify upgrade kind`,
+ },
+ {
+ Args: []string{"foo"},
+ Stderr: `unknown upgrade kind "foo"`,
+ },
+ // Test v23 upgrades.
+ {
+ Args: []string{"v23"},
+ Exist: true,
+ Stderr: `.jiri_manifest already exists`,
+ },
+ {
+ Args: []string{"v23"},
+ Want: `<manifest>
+ <imports>
+ <import manifest="public" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
+ </imports>
+</manifest>
+`,
+ },
+ {
+ Args: []string{"v23"},
+ Local: `<manifest>
+ <imports>
+ <import name="default"/>
+ </imports>
+</manifest>
+`,
+ Want: `<manifest>
+ <imports>
+ <import manifest="public" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
+ </imports>
+</manifest>
+`,
+ },
+ {
+ Args: []string{"v23"},
+ Local: `<manifest>
+ <imports>
+ <import name="private"/>
+ </imports>
+</manifest>
+`,
+ Want: `<manifest>
+ <imports>
+ <import manifest="private" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
+ </imports>
+</manifest>
+`,
+ },
+ {
+ Args: []string{"v23"},
+ Local: `<manifest>
+ <imports>
+ <import name="private"/>
+ <import name="infrastructure"/>
+ <import name="default"/>
+ </imports>
+</manifest>
+`,
+ Want: `<manifest>
+ <imports>
+ <import manifest="private" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
+ <import manifest="infrastructure" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
+ <import manifest="public" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
+ </imports>
+</manifest>
+`,
+ },
+ {
+ Args: []string{"v23"},
+ Local: `<manifest>
+ <imports>
+ <import name="default"/>
+ <import name="infrastructure"/>
+ <import name="private"/>
+ </imports>
+</manifest>
+`,
+ Want: `<manifest>
+ <imports>
+ <import manifest="public" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
+ <import manifest="infrastructure" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
+ <import manifest="private" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
+ </imports>
+</manifest>
+`,
+ },
+ // Test fuchsia upgrades.
+ {
+ Args: []string{"fuchsia"},
+ Exist: true,
+ Stderr: `.jiri_manifest already exists`,
+ },
+ {
+ Args: []string{"fuchsia"},
+ Want: `<manifest>
+ <imports>
+ <import manifest="manifest/fuchsia" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
+ </imports>
+</manifest>
+`,
+ },
+ {
+ Args: []string{"fuchsia"},
+ Local: `<manifest>
+ <imports>
+ <import name="default"/>
+ </imports>
+</manifest>
+`,
+ Want: `<manifest>
+ <imports>
+ <import manifest="manifest/fuchsia" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
+ </imports>
+</manifest>
+`,
+ },
+ {
+ Args: []string{"fuchsia"},
+ Local: `<manifest>
+ <imports>
+ <import name="private"/>
+ </imports>
+</manifest>
+`,
+ Want: `<manifest>
+ <imports>
+ <import manifest="private" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
+ </imports>
+</manifest>
+`,
+ },
+ {
+ Args: []string{"fuchsia"},
+ Local: `<manifest>
+ <imports>
+ <import name="private"/>
+ <import name="infrastructure"/>
+ <import name="default"/>
+ </imports>
+</manifest>
+`,
+ Want: `<manifest>
+ <imports>
+ <import manifest="private" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
+ <import manifest="infrastructure" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
+ <import manifest="manifest/fuchsia" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
+ </imports>
+</manifest>
+`,
+ },
+ {
+ Args: []string{"fuchsia"},
+ Local: `<manifest>
+ <imports>
+ <import name="default"/>
+ <import name="infrastructure"/>
+ <import name="private"/>
+ </imports>
+</manifest>
+`,
+ Want: `<manifest>
+ <imports>
+ <import manifest="manifest/fuchsia" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
+ <import manifest="infrastructure" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
+ <import manifest="private" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
+ </imports>
+</manifest>
+`,
+ },
+ }
+ opts := gosh.Opts{Fatalf: t.Fatalf, Logf: t.Logf}
+ sh := gosh.NewShell(opts)
+ defer sh.Cleanup()
+ jiriTool := sh.BuildGoPkg("v.io/jiri")
+ for _, test := range tests {
+ if err := testUpgrade(opts, jiriTool, test); err != nil {
+ t.Errorf("%v: %v", test.Args, err)
+ }
+ }
+}
+
+func testUpgrade(opts gosh.Opts, jiriTool string, test upgradeTestCase) error {
+ opts.PropagateChildOutput = true
+ sh := gosh.NewShell(opts)
+ defer sh.Cleanup()
+ jiriRoot := sh.MakeTempDir()
+ sh.Pushd(jiriRoot)
+ // Set up an existing file or local_manifest, if they were specified
+ if test.Exist {
+ if err := ioutil.WriteFile(".jiri_manifest", []byte("<manifest/>"), 0644); err != nil {
+ return err
+ }
+ }
+ if test.Local != "" {
+ if err := ioutil.WriteFile(".local_manifest", []byte(test.Local), 0644); err != nil {
+ return err
+ }
+ }
+ // Run upgrade and check the error.
+ sh.Vars[jiri.RootEnv] = jiriRoot
+ cmd := sh.Cmd(jiriTool, append([]string{"upgrade"}, test.Args...)...)
+ if test.Stderr != "" {
+ cmd.ExitErrorIsOk = true
+ }
+ _, stderr := cmd.StdoutStderr()
+ if got, want := stderr, test.Stderr; !strings.Contains(got, want) || (got != "" && want == "") {
+ return fmt.Errorf("stderr got %q, want substr %q", got, want)
+ }
+ // Make sure the right file is generated.
+ if test.Want != "" {
+ data, err := ioutil.ReadFile(".jiri_manifest")
+ if err != nil {
+ return err
+ }
+ if got, want := string(data), test.Want; got != want {
+ return fmt.Errorf("GOT\n%s\nWANT\n%s", got, want)
+ }
+ }
+ // Make sure the .local_manifest file is backed up.
+ if test.Local != "" && test.Stderr == "" {
+ data, err := ioutil.ReadFile(".local_manifest.BACKUP")
+ if err != nil {
+ return fmt.Errorf("local manifest backup got error: %v", err)
+ }
+ if got, want := string(data), test.Local; got != want {
+ return fmt.Errorf("local manifest backup GOT\n%s\nWANT\n%s", got, want)
+ }
+ }
+ return nil
+}
+
+func TestUpgradeRevert(t *testing.T) {
+ sh := gosh.NewShell(gosh.Opts{Fatalf: t.Fatalf, Logf: t.Logf})
+ defer sh.Cleanup()
+ jiriRoot := sh.MakeTempDir()
+ sh.Pushd(jiriRoot)
+ jiriTool := sh.BuildGoPkg("v.io/jiri")
+ localData := `<manifest/>`
+ jiriData := `<manifest>
+ <imports>
+ <import manifest="public" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
+ </imports>
+</manifest>
+`
+ // Set up an existing local_manifest.
+ if err := ioutil.WriteFile(".local_manifest", []byte(localData), 0644); err != nil {
+ t.Errorf("couldn't write local manifest: %v", err)
+ }
+ // Run a regular upgrade first, and make sure files are as expected.
+ sh.Vars[jiri.RootEnv] = jiriRoot
+ sh.Cmd(jiriTool, "upgrade", "v23").Run()
+ gotJiri, err := ioutil.ReadFile(".jiri_manifest")
+ if err != nil {
+ t.Errorf("couldn't read jiri manifest: %v", err)
+ }
+ if got, want := string(gotJiri), jiriData; got != want {
+ t.Errorf("jiri manifest GOT\n%s\nWANT\n%s", got, want)
+ }
+ gotBackup, err := ioutil.ReadFile(".local_manifest.BACKUP")
+ if err != nil {
+ t.Errorf("couldn't read local manifest backup: %v", err)
+ }
+ if got, want := string(gotBackup), localData; got != want {
+ t.Errorf("local manifest backup GOT\n%s\nWANT\n%s", got, want)
+ }
+ // Now run a revert, and make sure files are as expected.
+ sh.Cmd(jiriTool, "upgrade", "-revert").Run()
+ if _, err := os.Stat(".jiri_manifest"); !os.IsNotExist(err) {
+ t.Errorf(".jiri_manifest still exists after revert: %v", err)
+ }
+ if _, err := os.Stat(".local_manifest.BACKUP"); !os.IsNotExist(err) {
+ t.Errorf(".local_manifest.BACKUP still exists after revert: %v", err)
+ }
+ gotLocal, err := ioutil.ReadFile(".local_manifest")
+ if err != nil {
+ t.Errorf("couldn't read local manifest: %v", err)
+ }
+ if got, want := string(gotLocal), localData; got != want {
+ t.Errorf("local manifest GOT\n%s\nWANT\n%s", got, want)
+ }
+}
diff --git a/cmd/jiri/which.go b/cmd/jiri/which.go
new file mode 100644
index 0000000..9dee05c
--- /dev/null
+++ b/cmd/jiri/which.go
@@ -0,0 +1,54 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "os"
+ "os/exec"
+ "path/filepath"
+
+ "v.io/x/lib/cmdline"
+)
+
+var cmdWhich = &cmdline.Command{
+ Runner: cmdline.RunnerFunc(runWhich),
+ Name: "which",
+ Short: "Show path to the jiri tool",
+ Long: `
+Which behaves similarly to the unix commandline tool. It is useful in
+determining whether the jiri binary is being run directly, or run via the jiri
+shim script.
+
+If the binary is being run directly, the output looks like this:
+
+ # binary
+ /path/to/binary/jiri
+
+If the script is being run, the output looks like this:
+
+ # script
+ /path/to/script/jiri
+`,
+}
+
+func runWhich(env *cmdline.Env, args []string) error {
+ if len(args) == 0 {
+ fmt.Fprintln(env.Stdout, "# binary")
+ path, err := exec.LookPath(os.Args[0])
+ if err != nil {
+ return err
+ }
+ abs, err := filepath.Abs(path)
+ if err != nil {
+ return err
+ }
+ fmt.Fprintln(env.Stdout, abs)
+ return nil
+ }
+ // TODO(toddw): Look up the path to each argument. This will only be helpful
+ // after the profiles are moved back into the main jiri tool.
+ return fmt.Errorf("unexpected arguments")
+}
diff --git a/cmd/jiri/which_test.go b/cmd/jiri/which_test.go
new file mode 100644
index 0000000..dbe46f1
--- /dev/null
+++ b/cmd/jiri/which_test.go
@@ -0,0 +1,45 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "path/filepath"
+ "testing"
+
+ "v.io/x/lib/gosh"
+)
+
+func TestWhich(t *testing.T) {
+ sh := gosh.NewShell(gosh.Opts{Fatalf: t.Fatalf, Logf: t.Logf, PropagateChildOutput: true})
+ defer sh.Cleanup()
+
+ jiriBinary := sh.BuildGoPkg("v.io/jiri")
+ stdout, stderr := sh.Cmd(jiriBinary, []string{"which"}...).StdoutStderr()
+ if got, want := stdout, fmt.Sprintf("# binary\n%s\n", jiriBinary); got != want {
+ t.Errorf("stdout got %q, want %q", got, want)
+ }
+ if got, want := stderr, ""; got != want {
+ t.Errorf("stderr got %q, want %q", got, want)
+ }
+}
+
+// TestWhichScript tests the behavior of "jiri which" for the shim script.
+func TestWhichScript(t *testing.T) {
+ sh := gosh.NewShell(gosh.Opts{Fatalf: t.Fatalf, Logf: t.Logf, PropagateChildOutput: true})
+ defer sh.Cleanup()
+
+ jiriScript, err := filepath.Abs("./scripts/jiri")
+ if err != nil {
+ t.Fatalf("couldn't determine absolute path to jiri script")
+ }
+ stdout, stderr := sh.Cmd(jiriScript, "which").StdoutStderr()
+ if got, want := stdout, fmt.Sprintf("# script\n%s\n", jiriScript); got != want {
+ t.Errorf("stdout got %q, want %q", got, want)
+ }
+ if got, want := stderr, ""; got != want {
+ t.Errorf("stderr got %q, want %q", got, want)
+ }
+}
