Merge "TBR: Revert "TBR: Revert "jiri: The jiri script must put $JIRI_ROOT/.jiri_root/bin in PATH before invoking the jiri binary."""
diff --git a/bootstrap_jiri_test.go b/bootstrap_jiri_test.go
deleted file mode 100644
index 3bdca29..0000000
--- a/bootstrap_jiri_test.go
+++ /dev/null
@@ -1,62 +0,0 @@
-// 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/cl.go b/cl.go
deleted file mode 100644
index b5a8721..0000000
--- a/cl.go
+++ /dev/null
@@ -1,1120 +0,0 @@
-// 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/cl_test.go b/cl_test.go
deleted file mode 100644
index e92f35b..0000000
--- a/cl_test.go
+++ /dev/null
@@ -1,1033 +0,0 @@
-// 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.go b/cmd.go
deleted file mode 100644
index 0d4d2ee..0000000
--- a/cmd.go
+++ /dev/null
@@ -1,158 +0,0 @@
-// 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/import_test.go b/cmd/jiri/import_test.go
index 7b13b97..6dd60c6 100644
--- a/cmd/jiri/import_test.go
+++ b/cmd/jiri/import_test.go
@@ -138,7 +138,7 @@
opts := gosh.Opts{Fatalf: t.Fatalf, Logf: t.Logf}
sh := gosh.NewShell(opts)
defer sh.Cleanup()
- jiriTool := sh.BuildGoPkg("v.io/jiri")
+ jiriTool := sh.BuildGoPkg("v.io/jiri/cmd/jiri")
for _, test := range tests {
if err := testImport(opts, jiriTool, test); err != nil {
t.Errorf("%v: %v", test.Args, err)
diff --git a/cmd/jiri/scripts/bootstrap_jiri b/cmd/jiri/scripts/bootstrap_jiri
index 8f00a2f..3cf0f2c 100755
--- a/cmd/jiri/scripts/bootstrap_jiri
+++ b/cmd/jiri/scripts/bootstrap_jiri
@@ -65,9 +65,9 @@
# 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"
+GOPATH="${tmp_dir}" go get -d v.io/jiri/cmd/jiri
+GOPATH="${tmp_dir}" go build -o "${bin_dir}/jiri" v.io/jiri/cmd/jiri
+cp "${tmp_dir}/src/v.io/jiri/cmd/jiri/scripts/jiri" "${scripts_dir}/jiri"
# Clean up the tmp_dir.
rm -rf "${tmp_dir}"
diff --git a/cmd/jiri/snapshot.go b/cmd/jiri/snapshot.go
index 437cd81..21d572d 100644
--- a/cmd/jiri/snapshot.go
+++ b/cmd/jiri/snapshot.go
@@ -266,19 +266,18 @@
}
// Check that all labels exist.
- failed := false
+ var notexist []string
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)
+ switch _, err := jirix.NewSeq().Stat(labelDir); {
+ case runutil.IsNotExist(err):
+ notexist = append(notexist, label)
+ case err != nil:
+ return err
}
}
- if failed {
- return cmdline.ErrExitCode(2)
+ if len(notexist) > 0 {
+ return fmt.Errorf("snapshot labels %v not found", notexist)
}
// Print snapshots for all labels.
diff --git a/cmd/jiri/upgrade_test.go b/cmd/jiri/upgrade_test.go
index a7c5eab..d8913ed 100644
--- a/cmd/jiri/upgrade_test.go
+++ b/cmd/jiri/upgrade_test.go
@@ -201,7 +201,7 @@
opts := gosh.Opts{Fatalf: t.Fatalf, Logf: t.Logf}
sh := gosh.NewShell(opts)
defer sh.Cleanup()
- jiriTool := sh.BuildGoPkg("v.io/jiri")
+ jiriTool := sh.BuildGoPkg("v.io/jiri/cmd/jiri")
for _, test := range tests {
if err := testUpgrade(opts, jiriTool, test); err != nil {
t.Errorf("%v: %v", test.Args, err)
@@ -264,7 +264,7 @@
defer sh.Cleanup()
jiriRoot := sh.MakeTempDir()
sh.Pushd(jiriRoot)
- jiriTool := sh.BuildGoPkg("v.io/jiri")
+ jiriTool := sh.BuildGoPkg("v.io/jiri/cmd/jiri")
localData := `<manifest/>`
jiriData := `<manifest>
<imports>
diff --git a/cmd/jiri/which_test.go b/cmd/jiri/which_test.go
index dbe46f1..a60655a 100644
--- a/cmd/jiri/which_test.go
+++ b/cmd/jiri/which_test.go
@@ -16,7 +16,7 @@
sh := gosh.NewShell(gosh.Opts{Fatalf: t.Fatalf, Logf: t.Logf, PropagateChildOutput: true})
defer sh.Cleanup()
- jiriBinary := sh.BuildGoPkg("v.io/jiri")
+ jiriBinary := sh.BuildGoPkg("v.io/jiri/cmd/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)
diff --git a/contrib.go b/contrib.go
deleted file mode 100644
index 1fb31e6..0000000
--- a/contrib.go
+++ /dev/null
@@ -1,223 +0,0 @@
-// 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/doc.go b/doc.go
deleted file mode 100644
index a6a93a5..0000000
--- a/doc.go
+++ /dev/null
@@ -1,907 +0,0 @@
-// 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.
- -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.
- -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.
- -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.
- -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.
- -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.
- -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.
- -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.
- -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.
-
-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.
-
-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.
- -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.
-
-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.
-
-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.
-
-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.
-
-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.
- -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.
- -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.
- -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.
- -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.
- -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.
- -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.
- -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.
- -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.
- -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.
- -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.
- -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.
- -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.
- -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/gitutil/git.go b/gitutil/git.go
index c6a6675..985017f 100644
--- a/gitutil/git.go
+++ b/gitutil/git.go
@@ -212,7 +212,7 @@
// Committers returns a list of committers for the current repository
// along with the number of their commits.
func (g *Git) Committers() ([]string, error) {
- out, err := g.runOutputNoDryRun("shortlog", "-s", "-n", "-e")
+ out, err := g.runOutput("shortlog", "-s", "-n", "-e")
if err != nil {
return nil, err
}
@@ -227,7 +227,7 @@
args = append(args, "^"+base)
}
args = append(args, "--")
- out, err := g.runOutputNoDryRun(args...)
+ out, err := g.runOutput(args...)
if err != nil {
return 0, err
}
@@ -260,7 +260,7 @@
// CurrentBranchName returns the name of the current branch.
func (g *Git) CurrentBranchName() (string, error) {
- out, err := g.runOutputNoDryRun("rev-parse", "--abbrev-ref", "HEAD")
+ out, err := g.runOutput("rev-parse", "--abbrev-ref", "HEAD")
if err != nil {
return "", err
}
@@ -277,7 +277,7 @@
// CurrentRevisionOfBranch returns the current revision of the given branch.
func (g *Git) CurrentRevisionOfBranch(branch string) (string, error) {
- out, err := g.runOutputNoDryRun("rev-parse", branch)
+ out, err := g.runOutput("rev-parse", branch)
if err != nil {
return "", err
}
@@ -336,7 +336,7 @@
// (e.g. --merged).
func (g *Git) GetBranches(args ...string) ([]string, string, error) {
args = append([]string{"branch"}, args...)
- out, err := g.runOutputNoDryRun(args...)
+ out, err := g.runOutput(args...)
if err != nil {
return nil, "", err
}
@@ -555,7 +555,7 @@
// RemoteUrl gets the url of the remote with the given name.
func (g *Git) RemoteUrl(name string) (string, error) {
configKey := fmt.Sprintf("remote.%s.url", name)
- out, err := g.runOutputNoDryRun("config", "--get", configKey)
+ out, err := g.runOutput("config", "--get", configKey)
if err != nil {
return "", err
}
@@ -630,7 +630,7 @@
// TopLevel returns the top level path of the current repository.
func (g *Git) TopLevel() (string, error) {
// TODO(sadovsky): If g.rootDir is set, perhaps simply return that?
- out, err := g.runOutputNoDryRun("rev-parse", "--show-toplevel")
+ out, err := g.runOutput("rev-parse", "--show-toplevel")
if err != nil {
return "", err
}
@@ -657,7 +657,7 @@
// Version returns the major and minor git version.
func (g *Git) Version() (int, int, error) {
- out, err := g.runOutputNoDryRun("version")
+ out, err := g.runOutput("version")
if err != nil {
return 0, 0, err
}
@@ -709,21 +709,6 @@
return trimOutput(stdout.String()), nil
}
-func (g *Git) runOutputNoDryRun(args ...string) ([]string, error) {
- var stdout, stderr bytes.Buffer
- fn := func(s runutil.Sequence) runutil.Sequence {
- dryrun, _ := s.RunOpts()
- if dryrun {
- return s.DryRun(false).Verbose(true).Capture(&stdout, &stderr)
- }
- return s.Capture(&stdout, &stderr)
- }
- if err := g.runWithFn(fn, args...); err != nil {
- return nil, Error(stdout.String(), stderr.String(), args...)
- }
- return trimOutput(stdout.String()), nil
-}
-
func (g *Git) runInteractive(args ...string) error {
var stderr bytes.Buffer
// In order for the editing to work correctly with
diff --git a/import.go b/import.go
deleted file mode 100644
index 7636f13..0000000
--- a/import.go
+++ /dev/null
@@ -1,101 +0,0 @@
-// 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/import_test.go b/import_test.go
deleted file mode 100644
index 7b13b97..0000000
--- a/import_test.go
+++ /dev/null
@@ -1,199 +0,0 @@
-// 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/profile.go b/profile.go
deleted file mode 100644
index aa78d3f..0000000
--- a/profile.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// 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, true, "", jiri.ProfilesDBDir, jiri.ProfilesRootDir)
-}
diff --git a/profiles/profilescmdline/internal/i1/doc.go b/profiles/profilescmdline/internal/i1/doc.go
new file mode 100644
index 0000000..07f6370
--- /dev/null
+++ b/profiles/profilescmdline/internal/i1/doc.go
@@ -0,0 +1,239 @@
+// 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
+
+/*
+Profiles are used to manage external sofware dependencies and offer a balance
+between providing no support at all and a full blown package manager. Profiles
+can be built natively as well as being cross compiled. A profile is a named
+collection of software required for a given system component or application.
+Current example profiles include 'syncbase' which consists of the leveldb and
+snappy libraries or 'android' which consists of all of the android components
+and downloads needed to build android applications. Profiles are built for
+specific targets.
+
+Targets
+
+Profiles generally refer to uncompiled source code that needs to be compiled for
+a specific "target". Targets hence represent compiled code and consist of:
+
+1. An 'architecture' that refers to the CPU to be generate code for
+
+2. An 'operating system' that refers to the operating system to generate code
+for
+
+3. A lexicographically orderd set of supported versions, one of which is
+designated as the default.
+
+4. An 'environment' which is a set of environment variables to use when
+compiling the profile
+
+Targets thus provide the basic support needed for cross compilation.
+
+Targets are versioned and multiple versions may be installed and used
+simultaneously. Versions are ordered lexicographically and each target specifies
+a 'default' version to be used when a specific version is not explicitly
+requested. A request to 'upgrade' the profile will result in the installation of
+the default version of the targets currently installed if that default version
+is not already installed.
+
+The Supported Commands
+
+Profiles, or more correctly, targets for specific profiles may be installed or
+removed. When doing so, the name of the profile is required, but the other
+components of the target are optional and will default to the values of the
+system that the commands are run on (so-called native builds) and the default
+version for that target. Once a profile is installed it may be referred to by
+its tag for subsequent removals.
+
+The are also update and cleanup commands. Update installs the default version of
+the requested profile or for all profiles for the already installed targets.
+Cleanup will uninstall targets whose version is older than the default.
+
+Finally, there are commands to list the available and installed profiles and to
+access the environment variables specified and stored in each profile
+installation and a command (recreate) to generate a list of commands that can be
+run to recreate the currently installed profiles.
+
+The Profiles Database
+
+The profiles packages manages a database that tracks the installed profiles and
+their configurations. Other command line tools and packages are expected to read
+information about the currently installed profiles from this database via the
+profiles package. The profile command line tools support displaying the database
+(via the list command) or for specifying an alternate version of the file (via
+the -profiles-db flag) which is generally useful for debugging.
+
+Adding Profiles
+
+Profiles are intended to be provided as go packages that register themselves
+with the profile command line tools via the *v.io/jiri/profiles* package. They
+must implement the interfaces defined by that package and be imported (e.g.
+import _ "myprofile") by the command line tools that are to use them.
+
+Usage:
+ jiri profile-i1 [flags] <command>
+
+The jiri profile-i1 commands are:
+ 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
+ help Display help for commands or topics
+
+The jiri profile-i1 flags are:
+ -color=true
+ Use color to format output.
+ -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 profile-i1 install - Install the given profiles
+
+Install the given profiles.
+
+Usage:
+ jiri profile-i1 install [flags] <profiles>
+
+<profiles> is a list of profiles to install.
+
+The jiri profile-i1 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.
+ -v=false
+ Print verbose output.
+
+Jiri profile-i1 uninstall - Uninstall the given profiles
+
+Uninstall the given profiles.
+
+Usage:
+ jiri profile-i1 uninstall [flags] <profiles>
+
+<profiles> is a list of profiles to uninstall.
+
+The jiri profile-i1 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.
+
+Jiri profile-i1 update - Install the latest default version of the given profiles
+
+Install the latest default version of the given profiles.
+
+Usage:
+ jiri profile-i1 update [flags] <profiles>
+
+<profiles> is a list of profiles to update, if omitted all profiles are updated.
+
+The jiri profile-i1 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.
+
+Jiri profile-i1 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-i1 cleanup [flags] <profiles>
+
+<profiles> is a list of profiles to cleanup, if omitted all profiles are
+cleaned.
+
+The jiri profile-i1 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.
+
+Jiri profile-i1 available - List the available profiles
+
+List the available profiles.
+
+Usage:
+ jiri profile-i1 available [flags]
+
+The jiri profile-i1 available flags are:
+ -v=false
+ print more detailed information
+
+ -color=true
+ Use color to format output.
+
+Jiri profile-i1 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 profile-i1 help [flags] [command/topic ...]
+
+[command/topic ...] optionally identifies a specific sub-command or help topic.
+
+The jiri profile-i1 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.
+*/
+package main
diff --git a/profiles/profilescmdline/internal/i2/doc.go b/profiles/profilescmdline/internal/i2/doc.go
new file mode 100644
index 0000000..b202251
--- /dev/null
+++ b/profiles/profilescmdline/internal/i2/doc.go
@@ -0,0 +1,239 @@
+// 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
+
+/*
+Profiles are used to manage external sofware dependencies and offer a balance
+between providing no support at all and a full blown package manager. Profiles
+can be built natively as well as being cross compiled. A profile is a named
+collection of software required for a given system component or application.
+Current example profiles include 'syncbase' which consists of the leveldb and
+snappy libraries or 'android' which consists of all of the android components
+and downloads needed to build android applications. Profiles are built for
+specific targets.
+
+Targets
+
+Profiles generally refer to uncompiled source code that needs to be compiled for
+a specific "target". Targets hence represent compiled code and consist of:
+
+1. An 'architecture' that refers to the CPU to be generate code for
+
+2. An 'operating system' that refers to the operating system to generate code
+for
+
+3. A lexicographically orderd set of supported versions, one of which is
+designated as the default.
+
+4. An 'environment' which is a set of environment variables to use when
+compiling the profile
+
+Targets thus provide the basic support needed for cross compilation.
+
+Targets are versioned and multiple versions may be installed and used
+simultaneously. Versions are ordered lexicographically and each target specifies
+a 'default' version to be used when a specific version is not explicitly
+requested. A request to 'upgrade' the profile will result in the installation of
+the default version of the targets currently installed if that default version
+is not already installed.
+
+The Supported Commands
+
+Profiles, or more correctly, targets for specific profiles may be installed or
+removed. When doing so, the name of the profile is required, but the other
+components of the target are optional and will default to the values of the
+system that the commands are run on (so-called native builds) and the default
+version for that target. Once a profile is installed it may be referred to by
+its tag for subsequent removals.
+
+The are also update and cleanup commands. Update installs the default version of
+the requested profile or for all profiles for the already installed targets.
+Cleanup will uninstall targets whose version is older than the default.
+
+Finally, there are commands to list the available and installed profiles and to
+access the environment variables specified and stored in each profile
+installation and a command (recreate) to generate a list of commands that can be
+run to recreate the currently installed profiles.
+
+The Profiles Database
+
+The profiles packages manages a database that tracks the installed profiles and
+their configurations. Other command line tools and packages are expected to read
+information about the currently installed profiles from this database via the
+profiles package. The profile command line tools support displaying the database
+(via the list command) or for specifying an alternate version of the file (via
+the -profiles-db flag) which is generally useful for debugging.
+
+Adding Profiles
+
+Profiles are intended to be provided as go packages that register themselves
+with the profile command line tools via the *v.io/jiri/profiles* package. They
+must implement the interfaces defined by that package and be imported (e.g.
+import _ "myprofile") by the command line tools that are to use them.
+
+Usage:
+ jiri profile-i2 [flags] <command>
+
+The jiri profile-i2 commands are:
+ 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
+ help Display help for commands or topics
+
+The jiri profile-i2 flags are:
+ -color=true
+ Use color to format output.
+ -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 profile-i2 install - Install the given profiles
+
+Install the given profiles.
+
+Usage:
+ jiri profile-i2 install [flags] <profiles>
+
+<profiles> is a list of profiles to install.
+
+The jiri profile-i2 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.
+ -v=false
+ Print verbose output.
+
+Jiri profile-i2 uninstall - Uninstall the given profiles
+
+Uninstall the given profiles.
+
+Usage:
+ jiri profile-i2 uninstall [flags] <profiles>
+
+<profiles> is a list of profiles to uninstall.
+
+The jiri profile-i2 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.
+
+Jiri profile-i2 update - Install the latest default version of the given profiles
+
+Install the latest default version of the given profiles.
+
+Usage:
+ jiri profile-i2 update [flags] <profiles>
+
+<profiles> is a list of profiles to update, if omitted all profiles are updated.
+
+The jiri profile-i2 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.
+
+Jiri profile-i2 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-i2 cleanup [flags] <profiles>
+
+<profiles> is a list of profiles to cleanup, if omitted all profiles are
+cleaned.
+
+The jiri profile-i2 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.
+
+Jiri profile-i2 available - List the available profiles
+
+List the available profiles.
+
+Usage:
+ jiri profile-i2 available [flags]
+
+The jiri profile-i2 available flags are:
+ -v=false
+ print more detailed information
+
+ -color=true
+ Use color to format output.
+
+Jiri profile-i2 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 profile-i2 help [flags] [command/topic ...]
+
+[command/topic ...] optionally identifies a specific sub-command or help topic.
+
+The jiri profile-i2 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.
+*/
+package main
diff --git a/profiles/profilescmdline/manager_test.go b/profiles/profilescmdline/manager_test.go
index 38cd5d7..b00eccc 100644
--- a/profiles/profilescmdline/manager_test.go
+++ b/profiles/profilescmdline/manager_test.go
@@ -76,7 +76,7 @@
buildInstallersOnce.Do(func() {
sh := newShell(t)
prefix := "v.io/jiri/profiles/profilescmdline/internal/"
- sh.BuildGoPkg("v.io/jiri", "-o", "jiri")
+ sh.BuildGoPkg("v.io/jiri/cmd/jiri", "-o", "jiri")
sh.BuildGoPkg(prefix+"i1", "-o", "jiri-profile-i1")
sh.BuildGoPkg(prefix+"i2", "-o", "jiri-profile-i2")
buildInstallersBindir = sh.Opts.BinDir
@@ -87,7 +87,7 @@
func buildJiri(t *testing.T) string {
buildJiriOnce.Do(func() {
sh := newShell(t)
- sh.BuildGoPkg("v.io/jiri", "-o", "jiri")
+ sh.BuildGoPkg("v.io/jiri/cmd/jiri", "-o", "jiri")
buildJiriBindir = sh.Opts.BinDir
})
return buildJiriBindir
diff --git a/project.go b/project.go
deleted file mode 100644
index ea94798..0000000
--- a/project.go
+++ /dev/null
@@ -1,252 +0,0 @@
-// 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/rebuild.go b/rebuild.go
deleted file mode 100644
index dbf30bc..0000000
--- a/rebuild.go
+++ /dev/null
@@ -1,56 +0,0 @@
-// 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/runutil/.api b/runutil/.api
index e24cb58..4f9083e 100644
--- a/runutil/.api
+++ b/runutil/.api
@@ -20,7 +20,6 @@
pkg runutil, method (Sequence) Create(string) (*os.File, error)
pkg runutil, method (Sequence) Dir(string) Sequence
pkg runutil, method (Sequence) Done() error
-pkg runutil, method (Sequence) DryRun(bool) Sequence
pkg runutil, method (Sequence) Env(map[string]string) Sequence
pkg runutil, method (Sequence) Error() error
pkg runutil, method (Sequence) Fprintf(io.Writer, string, ...interface{}) Sequence
diff --git a/runutil/executor.go b/runutil/executor.go
index 69fd5a9..c8cebce 100644
--- a/runutil/executor.go
+++ b/runutil/executor.go
@@ -25,7 +25,6 @@
type opts struct {
color bool
dir string
- dryRun bool
env map[string]string
stdin io.Reader
stdout io.Writer
@@ -38,7 +37,7 @@
opts opts
}
-func newExecutor(env map[string]string, stdin io.Reader, stdout, stderr io.Writer, color, dryRun, verbose bool) *executor {
+func newExecutor(env map[string]string, stdin io.Reader, stdout, stderr io.Writer, color, verbose bool) *executor {
if color {
term := os.Getenv("TERM")
switch term {
@@ -50,7 +49,6 @@
indent: 0,
opts: opts{
color: color,
- dryRun: dryRun,
env: env,
stdin: stdin,
stdout: stdout,
@@ -115,28 +113,8 @@
}
// call executes the given Go standard library function,
-// encapsulated as a closure, respecting the "dry run" option.
+// encapsulated as a closure.
func (e *executor) call(fn func() error, format string, args ...interface{}) error {
- if opts := e.opts; opts.dryRun {
- opts.verbose = true
- return e.function(opts, func() error { return nil }, format, args...)
- }
- return e.function(e.opts, fn, format, args...)
-}
-
-// alwaysRun executes the given Go standard library function, encapsulated as a
-// closure, but translating "dry run" into "verbose" for this particular
-// command so that the command can execute and thus allow subsequent
-// commands to complete. It is generally used for testing/making files/directories
-// that affect subsequent behaviour.
-func (e *executor) alwaysRun(fn func() error, format string, args ...interface{}) error {
- if opts := e.opts; opts.dryRun {
- // Disable the dry run option as this function has no effect and
- // doing so results in more informative "dry run" output.
- opts.dryRun = false
- opts.verbose = true
- return e.function(opts, fn, format, args...)
- }
return e.function(e.opts, fn, format, args...)
}
@@ -168,7 +146,7 @@
command.Stdout = opts.stdout
command.Stderr = opts.stderr
command.Env = envvar.MapToSlice(opts.env)
- if opts.verbose || opts.dryRun {
+ if opts.verbose {
args := []string{}
for _, arg := range command.Args {
// Quote any arguments that contain '"', ''', '|', or ' '.
@@ -180,10 +158,6 @@
}
e.printf(e.opts.stdout, strings.Replace(strings.Join(args, " "), "%", "%%", -1))
}
- if opts.dryRun {
- e.printf(e.opts.stdout, "OK")
- return nil, nil
- }
if wait {
if timeout == 0 {
diff --git a/runutil/executor_test.go b/runutil/executor_test.go
index c02ca43..634a647 100644
--- a/runutil/executor_test.go
+++ b/runutil/executor_test.go
@@ -40,7 +40,7 @@
func TestCommandOK(t *testing.T) {
var out bytes.Buffer
- e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, false, true)
+ e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, true)
if err := e.run(forever, e.opts, "go", "run", "./testdata/ok_hello.go"); err != nil {
t.Fatalf(`Command("go run ./testdata/ok_hello.go") failed: %v`, err)
}
@@ -51,7 +51,7 @@
func TestCommandFail(t *testing.T) {
var out bytes.Buffer
- e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, false, true)
+ e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, true)
if err := e.run(forever, e.opts, "go", "run", "./testdata/fail_hello.go"); err == nil {
t.Fatalf(`Command("go run ./testdata/fail_hello.go") did not fail when it should`)
}
@@ -62,7 +62,7 @@
func TestCommandWithOptsOK(t *testing.T) {
var cmdOut, runOut bytes.Buffer
- e := newExecutor(nil, os.Stdin, &runOut, ioutil.Discard, false, false, true)
+ e := newExecutor(nil, os.Stdin, &runOut, ioutil.Discard, false, true)
opts := e.opts
opts.stdout = &cmdOut
if err := e.run(forever, opts, "go", "run", "./testdata/ok_hello.go"); err != nil {
@@ -78,7 +78,7 @@
func TestCommandWithOptsFail(t *testing.T) {
var cmdOut, runOut bytes.Buffer
- e := newExecutor(nil, os.Stdin, &runOut, ioutil.Discard, false, false, true)
+ e := newExecutor(nil, os.Stdin, &runOut, ioutil.Discard, false, true)
opts := e.opts
opts.stdout = &cmdOut
if err := e.run(forever, opts, "go", "run", "./testdata/fail_hello.go"); err == nil {
@@ -94,7 +94,7 @@
func TestTimedCommandOK(t *testing.T) {
var out bytes.Buffer
- e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, false, true)
+ e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, true)
if err := e.run(10*time.Second, e.opts, "go", "run", "./testdata/fast_hello.go"); err != nil {
t.Fatalf(`TimedCommand("go run ./testdata/fast_hello.go") failed: %v`, err)
}
@@ -105,7 +105,7 @@
func TestTimedCommandFail(t *testing.T) {
var out bytes.Buffer
- e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, false, true)
+ e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, true)
bin, err := buildTestProgram(e, "slow_hello")
if bin != "" {
defer os.RemoveAll(filepath.Dir(bin))
@@ -125,7 +125,7 @@
func TestTimedCommandWithOptsOK(t *testing.T) {
var cmdOut, runOut bytes.Buffer
- e := newExecutor(nil, os.Stdin, &runOut, ioutil.Discard, false, false, true)
+ e := newExecutor(nil, os.Stdin, &runOut, ioutil.Discard, false, true)
opts := e.opts
opts.stdout = &cmdOut
if err := e.run(10*time.Second, opts, "go", "run", "./testdata/fast_hello.go"); err != nil {
@@ -141,7 +141,7 @@
func TestTimedCommandWithOptsFail(t *testing.T) {
var cmdOut, runOut bytes.Buffer
- e := newExecutor(nil, os.Stdin, &runOut, ioutil.Discard, false, false, true)
+ e := newExecutor(nil, os.Stdin, &runOut, ioutil.Discard, false, true)
bin, err := buildTestProgram(e, "slow_hello")
if bin != "" {
defer os.RemoveAll(filepath.Dir(bin))
@@ -166,7 +166,7 @@
func TestFunctionOK(t *testing.T) {
var out bytes.Buffer
- e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, false, true)
+ e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, true)
fn := func() error {
cmd := exec.Command("go", "run", "./testdata/ok_hello.go")
cmd.Stdout = &out
@@ -182,7 +182,7 @@
func TestFunctionFail(t *testing.T) {
var out bytes.Buffer
- e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, false, true)
+ e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, true)
fn := func() error {
cmd := exec.Command("go", "run", "./testdata/fail_hello.go")
cmd.Stdout = &out
@@ -201,7 +201,7 @@
func TestFunctionWithOptsOK(t *testing.T) {
var out bytes.Buffer
- e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, false, false)
+ e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, false)
opts := e.opts
opts.verbose = true
fn := func() error {
@@ -222,7 +222,7 @@
func TestFunctionWithOptsFail(t *testing.T) {
var out bytes.Buffer
- e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, false, false)
+ e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, false)
opts := e.opts
opts.verbose = true
fn := func() error {
@@ -243,7 +243,7 @@
func TestOutput(t *testing.T) {
var out bytes.Buffer
- e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, false, true)
+ e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, true)
e.output(e.opts, []string{"hello", "world"})
if got, want := removeTimestamps(t, &out), ">> hello\n>> world\n"; got != want {
t.Fatalf("unexpected output:\ngot\n%v\nwant\n%v", got, want)
@@ -252,7 +252,7 @@
func TestOutputWithOpts(t *testing.T) {
var out bytes.Buffer
- e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, false, false)
+ e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, false)
opts := e.opts
opts.verbose = true
e.output(opts, []string{"hello", "world"})
@@ -263,7 +263,7 @@
func TestNested(t *testing.T) {
var out bytes.Buffer
- e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, false, true)
+ e := newExecutor(nil, os.Stdin, &out, ioutil.Discard, false, true)
fn := func() error {
e.output(e.opts, []string{"hello", "world"})
return nil
diff --git a/runutil/sequence.go b/runutil/sequence.go
index 12d5014..3a930ae 100644
--- a/runutil/sequence.go
+++ b/runutil/sequence.go
@@ -94,7 +94,6 @@
defaultStdout, defaultStderr io.Writer
dirs []string
verbosity *bool
- dryRun *bool
cmdDir string
timeout time.Duration
serializedWriterLock sync.Mutex
@@ -110,7 +109,7 @@
}
s := Sequence{
&sequence{
- r: newExecutor(env, stdin, stdout, stderr, color, dryRun, verbose),
+ r: newExecutor(env, stdin, stdout, stderr, color, verbose),
defaultStdin: stdin,
},
}
@@ -122,7 +121,7 @@
// create this sequence.
func (s Sequence) RunOpts() (dryRun bool, verbose bool) {
opts := s.getOpts()
- return opts.dryRun, opts.verbose
+ return false, opts.verbose
}
// Capture arranges for the next call to Run or Last to write its stdout and
@@ -202,17 +201,6 @@
return s
}
-// DryRun arranges for the next call to Run, Call, Start or Last to use the
-// specified dry run value. This will be cleared and not used for any calls
-// to Run, Call or Last beyond the next one.
-func (s Sequence) DryRun(dryRun bool) Sequence {
- if s.err != nil {
- return s
- }
- s.dryRun = &dryRun
- return s
-}
-
// internal getOpts that doesn't override stdin, stdout, stderr
func (s Sequence) getOpts() opts {
var opts opts
@@ -334,7 +322,7 @@
// reset all state except s.err
func (s Sequence) reset() {
s.stdin, s.stdout, s.stderr, s.env = nil, nil, nil, nil
- s.opts, s.verbosity, s.dryRun = nil, nil, nil
+ s.opts, s.verbosity = nil, nil
s.cmdDir = ""
s.reading = false
s.timeout = 0
@@ -421,9 +409,6 @@
if s.verbosity != nil {
opts.verbose = *s.verbosity
}
- if s.dryRun != nil {
- opts.dryRun = *s.dryRun
- }
opts.dir = s.cmdDir
s.setOpts(opts)
if h != nil {
@@ -485,9 +470,6 @@
if s.verbosity != nil {
opts.verbose = *s.verbosity
}
- if s.dryRun != nil {
- opts.dryRun = *s.dryRun
- }
opts.dir = s.cmdDir
s.setOpts(opts)
if h != nil {
@@ -640,7 +622,7 @@
if len(s.dirs) > 0 {
cwd := s.dirs[0]
s.dirs = nil
- err := s.r.alwaysRun(func() error {
+ err := s.r.call(func() error {
return os.Chdir(cwd)
}, fmt.Sprintf("sequence done popd %q", cwd))
if err != nil {
@@ -668,7 +650,7 @@
return s
}
s.dirs = append(s.dirs, cwd)
- err = s.r.alwaysRun(func() error {
+ err = s.r.call(func() error {
return os.Chdir(dir)
}, fmt.Sprintf("pushd %q", dir))
s.setError(err, "Pushd("+dir+")")
@@ -688,7 +670,7 @@
}
last := s.dirs[len(s.dirs)-1]
s.dirs = s.dirs[:len(s.dirs)-1]
- err := s.r.alwaysRun(func() error {
+ err := s.r.call(func() error {
return os.Chdir(last)
}, fmt.Sprintf("popd %q", last))
s.setError(err, "Popd() -> "+last)
@@ -696,12 +678,12 @@
}
// Chdir is a wrapper around os.Chdir that handles options such as
-// "verbose" or "dry run".
+// "verbose".
func (s Sequence) Chdir(dir string) Sequence {
if s.err != nil {
return s
}
- err := s.r.alwaysRun(func() error {
+ err := s.r.call(func() error {
return os.Chdir(dir)
}, fmt.Sprintf("cd %q", dir))
s.setError(err, "Chdir("+dir+")")
@@ -710,7 +692,7 @@
}
// Chmod is a wrapper around os.Chmod that handles options such as
-// "verbose" or "dry run".
+// "verbose".
func (s Sequence) Chmod(dir string, mode os.FileMode) Sequence {
if s.err != nil {
return s
@@ -722,7 +704,7 @@
}
// MkdirAll is a wrapper around os.MkdirAll that handles options such
-// as "verbose" or "dry run".
+// as "verbose".
func (s Sequence) MkdirAll(dir string, mode os.FileMode) Sequence {
if s.err != nil {
return s
@@ -733,7 +715,7 @@
}
// RemoveAll is a wrapper around os.RemoveAll that handles options
-// such as "verbose" or "dry run".
+// such as "verbose".
func (s Sequence) RemoveAll(dir string) Sequence {
if s.err != nil {
return s
@@ -744,7 +726,7 @@
}
// Remove is a wrapper around os.Remove that handles options
-// such as "verbose" or "dry run".
+// such as "verbose".
func (s Sequence) Remove(file string) Sequence {
if s.err != nil {
return s
@@ -755,7 +737,7 @@
}
// Rename is a wrapper around os.Rename that handles options such as
-// "verbose" or "dry run".
+// "verbose".
func (s Sequence) Rename(src, dst string) Sequence {
if s.err != nil {
return s
@@ -785,7 +767,7 @@
}
// Symlink is a wrapper around os.Symlink that handles options such as
-// "verbose" or "dry run".
+// "verbose".
func (s Sequence) Symlink(src, dst string) Sequence {
if s.err != nil {
return s
@@ -796,7 +778,7 @@
}
// Open is a wrapper around os.Open that handles options such as
-// "verbose" or "dry run". Open is a terminating function.
+// "verbose". Open is a terminating function.
func (s Sequence) Open(name string) (f *os.File, err error) {
if s.err != nil {
return nil, s.Done()
@@ -811,7 +793,7 @@
}
// OpenFile is a wrapper around os.OpenFile that handles options such as
-// "verbose" or "dry run". OpenFile is a terminating function.
+// "verbose". OpenFile is a terminating function.
func (s Sequence) OpenFile(name string, flag int, perm os.FileMode) (f *os.File, err error) {
if s.err != nil {
return nil, s.Done()
@@ -826,7 +808,7 @@
}
// Create is a wrapper around os.Create that handles options such as "verbose"
-// or "dry run". Create is a terminating function.
+//. Create is a terminating function.
func (s Sequence) Create(name string) (f *os.File, err error) {
if s.err != nil {
return nil, s.Done()
@@ -842,12 +824,12 @@
}
// ReadDir is a wrapper around ioutil.ReadDir that handles options
-// such as "verbose" or "dry run". ReadDir is a terminating function.
+// such as "verbose". ReadDir is a terminating function.
func (s Sequence) ReadDir(dirname string) (fi []os.FileInfo, err error) {
if s.err != nil {
return nil, s.Done()
}
- s.r.alwaysRun(func() error {
+ s.r.call(func() error {
fi, err = ioutil.ReadDir(dirname)
return err
}, fmt.Sprintf("ls %q", dirname))
@@ -857,13 +839,13 @@
}
// ReadFile is a wrapper around ioutil.ReadFile that handles options
-// such as "verbose" or "dry run". ReadFile is a terminating function.
+// such as "verbose". ReadFile is a terminating function.
func (s Sequence) ReadFile(filename string) (bytes []byte, err error) {
if s.err != nil {
return nil, s.Done()
}
- s.r.alwaysRun(func() error {
+ s.r.call(func() error {
bytes, err = ioutil.ReadFile(filename)
return err
}, fmt.Sprintf("read %q", filename))
@@ -873,7 +855,7 @@
}
// WriteFile is a wrapper around ioutil.WriteFile that handles options
-// such as "verbose" or "dry run".
+// such as "verbose".
func (s Sequence) WriteFile(filename string, data []byte, perm os.FileMode) Sequence {
if s.err != nil {
return s
@@ -901,12 +883,12 @@
}
// Stat is a wrapper around os.Stat that handles options such as
-// "verbose" or "dry run". Stat is a terminating function.
+// "verbose". Stat is a terminating function.
func (s Sequence) Stat(name string) (fi os.FileInfo, err error) {
if s.err != nil {
return nil, s.Done()
}
- s.r.alwaysRun(func() error {
+ s.r.call(func() error {
fi, err = os.Stat(name)
return err
}, fmt.Sprintf("stat %q", name))
@@ -916,12 +898,12 @@
}
// Lstat is a wrapper around os.Lstat that handles options such as
-// "verbose" or "dry run". Lstat is a terminating function.
+// "verbose". Lstat is a terminating function.
func (s Sequence) Lstat(name string) (fi os.FileInfo, err error) {
if s.err != nil {
return nil, s.Done()
}
- s.r.alwaysRun(func() error {
+ s.r.call(func() error {
fi, err = os.Lstat(name)
return err
}, fmt.Sprintf("lstat %q", name))
@@ -931,12 +913,12 @@
}
// Readlink is a wrapper around os.Readlink that handles options such as
-// "verbose" or "dry run". Lstat is a terminating function.
+// "verbose". Lstat is a terminating function.
func (s Sequence) Readlink(name string) (link string, err error) {
if s.err != nil {
return "", s.Done()
}
- s.r.alwaysRun(func() error {
+ s.r.call(func() error {
link, err = os.Readlink(name)
return err
}, fmt.Sprintf("readlink %q", name))
@@ -946,7 +928,7 @@
}
// TempDir is a wrapper around ioutil.TempDir that handles options
-// such as "verbose" or "dry run". TempDir is a terminating function.
+// such as "verbose". TempDir is a terminating function.
func (s Sequence) TempDir(dir, prefix string) (tmpDir string, err error) {
if s.err != nil {
return "", s.Done()
@@ -965,7 +947,7 @@
}
// TempFile is a wrapper around ioutil.TempFile that handles options
-// such as "verbose" or "dry run".
+// such as "verbose".
func (s Sequence) TempFile(dir, prefix string) (f *os.File, err error) {
if s.err != nil {
return nil, s.Done()
@@ -991,7 +973,7 @@
}
var fileInfo os.FileInfo
var err error
- err = s.r.alwaysRun(func() error {
+ err = s.r.call(func() error {
fileInfo, err = os.Stat(dirname)
return err
}, fmt.Sprintf("isdir %q", dirname))
@@ -1014,7 +996,7 @@
}
var fileInfo os.FileInfo
var err error
- err = s.r.alwaysRun(func() error {
+ err = s.r.call(func() error {
fileInfo, err = os.Stat(file)
return err
}, fmt.Sprintf("isfile %q", file))
diff --git a/runutil/sequence_test.go b/runutil/sequence_test.go
index 806f3c7..3bb7421 100644
--- a/runutil/sequence_test.go
+++ b/runutil/sequence_test.go
@@ -358,24 +358,6 @@
}
stdout.Reset()
}
- for _, dryRun := range []bool{false, true} {
- err := seq.DryRun(dryRun).Last("sh", "-c", "echo hello")
- if err != nil {
- t.Fatal(err)
- }
- out := sanitizeTimestampsAndPaths(stdout.String())
- want := `[hh:mm:ss.xx] >> sh -c "echo hello"
-[hh:mm:ss.xx] >> OK
-`
- if !dryRun {
- want += `hello
-`
- }
- if got, want := out, want; got != want {
- t.Errorf("dryRun: %t, got %v, want %v", dryRun, got, want)
- }
- stdout.Reset()
- }
}
func TestSequenceOutputOnError(t *testing.T) {
diff --git a/snapshot.go b/snapshot.go
deleted file mode 100644
index 21d572d..0000000
--- a/snapshot.go
+++ /dev/null
@@ -1,299 +0,0 @@
-// 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.
- var notexist []string
- for _, label := range args {
- labelDir := filepath.Join(snapshotDir, "labels", label)
- switch _, err := jirix.NewSeq().Stat(labelDir); {
- case runutil.IsNotExist(err):
- notexist = append(notexist, label)
- case err != nil:
- return err
- }
- }
- if len(notexist) > 0 {
- return fmt.Errorf("snapshot labels %v not found", notexist)
- }
-
- // 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/snapshot_test.go b/snapshot_test.go
deleted file mode 100644
index d24b5a6..0000000
--- a/snapshot_test.go
+++ /dev/null
@@ -1,341 +0,0 @@
-// 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/update.go b/update.go
deleted file mode 100644
index 9dccf97..0000000
--- a/update.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// 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/upgrade.go b/upgrade.go
deleted file mode 100644
index da6947f..0000000
--- a/upgrade.go
+++ /dev/null
@@ -1,150 +0,0 @@
-// 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/upgrade_test.go b/upgrade_test.go
deleted file mode 100644
index a7c5eab..0000000
--- a/upgrade_test.go
+++ /dev/null
@@ -1,311 +0,0 @@
-// 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/which.go b/which.go
deleted file mode 100644
index 9dee05c..0000000
--- a/which.go
+++ /dev/null
@@ -1,54 +0,0 @@
-// 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/which_test.go b/which_test.go
deleted file mode 100644
index dbe46f1..0000000
--- a/which_test.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// 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)
- }
-}
