Merge "v.io/jiir/runutil: more cleanup"
diff --git a/cl.go b/cl.go
index c360baa..241d146 100644
--- a/cl.go
+++ b/cl.go
@@ -14,6 +14,7 @@
"v.io/jiri/collect"
"v.io/jiri/gerrit"
"v.io/jiri/gitutil"
+ "v.io/jiri/jiri"
"v.io/jiri/project"
"v.io/jiri/tool"
"v.io/x/lib/cmdline"
@@ -75,28 +76,28 @@
cmdCLSync.Flags.StringVar(&remoteBranchFlag, "remote-branch", "master", "Name of the remote branch the CL pertains to.")
}
-func getCommitMessageFileName(ctx *tool.Context, branch string) (string, error) {
- topLevel, err := ctx.Git().TopLevel()
+func getCommitMessageFileName(jirix *jiri.X, branch string) (string, error) {
+ topLevel, err := jirix.Git().TopLevel()
if err != nil {
return "", err
}
return filepath.Join(topLevel, project.MetadataDirName(), branch, commitMessageFileName), nil
}
-func getDependencyPathFileName(ctx *tool.Context, branch string) (string, error) {
- topLevel, err := ctx.Git().TopLevel()
+func getDependencyPathFileName(jirix *jiri.X, branch string) (string, error) {
+ topLevel, err := jirix.Git().TopLevel()
if err != nil {
return "", err
}
return filepath.Join(topLevel, project.MetadataDirName(), branch, dependencyPathFileName), nil
}
-func getDependentCLs(ctx *tool.Context, branch string) ([]string, error) {
- file, err := getDependencyPathFileName(ctx, branch)
+func getDependentCLs(jirix *jiri.X, branch string) ([]string, error) {
+ file, err := getDependencyPathFileName(jirix, branch)
if err != nil {
return nil, err
}
- data, err := ctx.Run().ReadFile(file)
+ data, err := jirix.Run().ReadFile(file)
var branches []string
if err != nil {
if !os.IsNotExist(err) {
@@ -124,7 +125,7 @@
// 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: cmdline.RunnerFunc(runCLCleanup),
+ Runner: jiri.RunnerFunc(runCLCleanup),
Name: "cleanup",
Short: "Clean up changelists that have been merged",
Long: `
@@ -137,34 +138,34 @@
ArgsLong: "<branches> is a list of branches to cleanup.",
}
-func cleanupCL(ctx *tool.Context, branches []string) (e error) {
- originalBranch, err := ctx.Git().CurrentBranchName()
+func cleanupCL(jirix *jiri.X, branches []string) (e error) {
+ originalBranch, err := jirix.Git().CurrentBranchName()
if err != nil {
return err
}
- stashed, err := ctx.Git().Stash()
+ stashed, err := jirix.Git().Stash()
if err != nil {
return err
}
if stashed {
- defer collect.Error(func() error { return ctx.Git().StashPop() }, &e)
+ defer collect.Error(func() error { return jirix.Git().StashPop() }, &e)
}
- if err := ctx.Git().CheckoutBranch(remoteBranchFlag); err != nil {
+ if err := jirix.Git().CheckoutBranch(remoteBranchFlag); err != nil {
return err
}
checkoutOriginalBranch := true
defer collect.Error(func() error {
if checkoutOriginalBranch {
- return ctx.Git().CheckoutBranch(originalBranch)
+ return jirix.Git().CheckoutBranch(originalBranch)
}
return nil
}, &e)
- if err := ctx.Git().FetchRefspec("origin", remoteBranchFlag); err != nil {
+ if err := jirix.Git().FetchRefspec("origin", remoteBranchFlag); err != nil {
return err
}
for _, branch := range branches {
- cleanupFn := func() error { return cleanupBranch(ctx, branch) }
- if err := ctx.Run().Function(cleanupFn, "Cleaning up branch %q", branch); err != nil {
+ cleanupFn := func() error { return cleanupBranch(jirix, branch) }
+ if err := jirix.Run().Function(cleanupFn, "Cleaning up branch %q", branch); err != nil {
return err
}
if branch == originalBranch {
@@ -174,16 +175,16 @@
return nil
}
-func cleanupBranch(ctx *tool.Context, branch string) error {
- if err := ctx.Git().CheckoutBranch(branch); err != nil {
+func cleanupBranch(jirix *jiri.X, branch string) error {
+ if err := jirix.Git().CheckoutBranch(branch); err != nil {
return err
}
if !forceFlag {
trackingBranch := "origin/" + remoteBranchFlag
- if err := ctx.Git().Merge(trackingBranch); err != nil {
+ if err := jirix.Git().Merge(trackingBranch); err != nil {
return err
}
- files, err := ctx.Git().ModifiedFiles(trackingBranch, branch)
+ files, err := jirix.Git().ModifiedFiles(trackingBranch, branch)
if err != nil {
return err
}
@@ -191,29 +192,29 @@
return fmt.Errorf("unmerged changes in\n%s", strings.Join(files, "\n"))
}
}
- if err := ctx.Git().CheckoutBranch(remoteBranchFlag); err != nil {
+ if err := jirix.Git().CheckoutBranch(remoteBranchFlag); err != nil {
return err
}
- if err := ctx.Git().DeleteBranch(branch, gitutil.ForceOpt(true)); err != nil {
+ if err := jirix.Git().DeleteBranch(branch, gitutil.ForceOpt(true)); err != nil {
return err
}
reviewBranch := branch + "-REVIEW"
- if ctx.Git().BranchExists(reviewBranch) {
- if err := ctx.Git().DeleteBranch(reviewBranch, gitutil.ForceOpt(true)); err != nil {
+ if jirix.Git().BranchExists(reviewBranch) {
+ if err := jirix.Git().DeleteBranch(reviewBranch, gitutil.ForceOpt(true)); err != nil {
return err
}
}
// Delete branch metadata.
- topLevel, err := ctx.Git().TopLevel()
+ topLevel, err := jirix.Git().TopLevel()
if err != nil {
return err
}
metadataDir := filepath.Join(topLevel, project.MetadataDirName())
- if err := ctx.Run().RemoveAll(filepath.Join(metadataDir, branch)); err != nil {
+ if err := jirix.Run().RemoveAll(filepath.Join(metadataDir, branch)); err != nil {
return err
}
// Remove the branch from all dependency paths.
- fileInfos, err := ctx.Run().ReadDir(metadataDir)
+ fileInfos, err := jirix.Run().ReadDir(metadataDir)
if err != nil {
return err
}
@@ -221,11 +222,11 @@
if !fileInfo.IsDir() {
continue
}
- file, err := getDependencyPathFileName(ctx, fileInfo.Name())
+ file, err := getDependencyPathFileName(jirix, fileInfo.Name())
if err != nil {
return err
}
- data, err := ctx.Run().ReadFile(file)
+ data, err := jirix.Run().ReadFile(file)
if err != nil {
if !os.IsNotExist(err) {
return err
@@ -236,7 +237,7 @@
for i, tmpBranch := range branches {
if branch == tmpBranch {
data := []byte(strings.Join(append(branches[:i], branches[i+1:]...), "\n"))
- if err := ctx.Run().WriteFile(file, data, os.FileMode(0644)); err != nil {
+ if err := jirix.Run().WriteFile(file, data, os.FileMode(0644)); err != nil {
return err
}
break
@@ -246,17 +247,16 @@
return nil
}
-func runCLCleanup(env *cmdline.Env, args []string) error {
+func runCLCleanup(jirix *jiri.X, args []string) error {
if len(args) == 0 {
- return env.UsageErrorf("cleanup requires at least one argument")
+ return jirix.UsageErrorf("cleanup requires at least one argument")
}
- ctx := tool.NewContextFromEnv(env)
- return cleanupCL(ctx, args)
+ return cleanupCL(jirix, args)
}
// cmdCLMail represents the "jiri cl mail" command.
var cmdCLMail = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runCLMail),
+ Runner: jiri.RunnerFunc(runCLMail),
Name: "mail",
Short: "Mail a changelist for review",
Long: `
@@ -331,26 +331,24 @@
`
// runCLMail is a wrapper that sets up and runs a review instance.
-func runCLMail(env *cmdline.Env, _ []string) error {
- ctx := tool.NewContextFromEnv(env)
-
+func runCLMail(jirix *jiri.X, _ []string) error {
// Sanity checks for the <presubmitFlag> flag.
if !checkPresubmitFlag() {
- return env.UsageErrorf("invalid value for the -presubmit flag. Valid values: %s.",
+ return jirix.UsageErrorf("invalid value for the -presubmit flag. Valid values: %s.",
strings.Join(gerrit.PresubmitTestTypes(), ","))
}
host := hostFlag
if host == "" {
var err error
- if host, err = project.GerritHost(ctx); err != nil {
+ if host, err = project.GerritHost(jirix); err != nil {
return err
}
}
// Create and run the review.
- review, err := newReview(ctx, gerrit.CLOpts{
+ review, err := newReview(jirix, gerrit.CLOpts{
Autosubmit: autosubmitFlag,
Ccs: parseEmails(ccsFlag),
Draft: draftFlag,
@@ -394,21 +392,21 @@
// 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(ctx *tool.Context) (e error) {
- originalBranch, err := ctx.Git().CurrentBranchName()
+func checkDependents(jirix *jiri.X) (e error) {
+ originalBranch, err := jirix.Git().CurrentBranchName()
if err != nil {
return err
}
- branches, err := getDependentCLs(ctx, originalBranch)
+ branches, err := getDependentCLs(jirix, originalBranch)
if err != nil {
return err
}
for i := 1; i < len(branches); i++ {
- file, err := getCommitMessageFileName(ctx, branches[i])
+ file, err := getCommitMessageFileName(jirix, branches[i])
if err != nil {
return err
}
- if _, err := ctx.Run().Stat(file); err != nil {
+ if _, err := jirix.Run().Stat(file); err != nil {
if !os.IsNotExist(err) {
return err
}
@@ -426,15 +424,15 @@
}
type review struct {
- ctx *tool.Context
+ jirix *jiri.X
reviewBranch string
gerrit.CLOpts
}
-func newReview(ctx *tool.Context, opts gerrit.CLOpts) (*review, error) {
+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(ctx); err != nil {
+ if err := syncCL(jirix); err != nil {
return nil, err
}
@@ -444,11 +442,11 @@
//
// NOTE: The alternative here is to prompt the user for multiple
// commit messages, which seems less user friendly.
- if err := checkDependents(ctx); err != nil {
+ if err := checkDependents(jirix); err != nil {
return nil, err
}
- branch, err := ctx.Git().CurrentBranchName()
+ branch, err := jirix.Git().CurrentBranchName()
if err != nil {
return nil, err
}
@@ -463,7 +461,7 @@
opts.RemoteBranch = "master" // use master as the default
}
return &review{
- ctx: ctx,
+ jirix: jirix,
reviewBranch: branch + "-REVIEW",
CLOpts: opts,
}, nil
@@ -481,11 +479,11 @@
// confirmFlagChanges asks users to confirm if any of the
// presubmit and autosubmit flags changes.
func (review *review) confirmFlagChanges() (bool, error) {
- file, err := getCommitMessageFileName(review.ctx, review.CLOpts.Branch)
+ file, err := getCommitMessageFileName(review.jirix, review.CLOpts.Branch)
if err != nil {
return false, err
}
- bytes, err := review.ctx.Run().ReadFile(file)
+ bytes, err := review.jirix.Run().ReadFile(file)
if err != nil {
if os.IsNotExist(err) {
return true, nil
@@ -525,16 +523,16 @@
// cleanup cleans up after the review.
func (review *review) cleanup(stashed bool) error {
- if err := review.ctx.Git().CheckoutBranch(review.CLOpts.Branch); err != nil {
+ if err := review.jirix.Git().CheckoutBranch(review.CLOpts.Branch); err != nil {
return err
}
- if review.ctx.Git().BranchExists(review.reviewBranch) {
- if err := review.ctx.Git().DeleteBranch(review.reviewBranch, gitutil.ForceOpt(true)); err != nil {
+ if review.jirix.Git().BranchExists(review.reviewBranch) {
+ if err := review.jirix.Git().DeleteBranch(review.reviewBranch, gitutil.ForceOpt(true)); err != nil {
return err
}
}
if stashed {
- if err := review.ctx.Git().StashPop(); err != nil {
+ if err := review.jirix.Git().StashPop(); err != nil {
return err
}
}
@@ -550,35 +548,35 @@
// the commit message for the last commit.
func (review *review) createReviewBranch(message string) (e error) {
// Create the review branch.
- if err := review.ctx.Git().FetchRefspec("origin", review.CLOpts.RemoteBranch); err != nil {
+ if err := review.jirix.Git().FetchRefspec("origin", review.CLOpts.RemoteBranch); err != nil {
return err
}
- if review.ctx.Git().BranchExists(review.reviewBranch) {
- if err := review.ctx.Git().DeleteBranch(review.reviewBranch, gitutil.ForceOpt(true)); err != nil {
+ if review.jirix.Git().BranchExists(review.reviewBranch) {
+ if err := review.jirix.Git().DeleteBranch(review.reviewBranch, gitutil.ForceOpt(true)); err != nil {
return err
}
}
upstream := "origin/" + review.CLOpts.RemoteBranch
- if err := review.ctx.Git().CreateBranchWithUpstream(review.reviewBranch, upstream); err != nil {
+ if err := review.jirix.Git().CreateBranchWithUpstream(review.reviewBranch, upstream); err != nil {
return err
}
- if err := review.ctx.Git().CheckoutBranch(review.reviewBranch); err != nil {
+ if err := review.jirix.Git().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 review.ctx.Git().CheckoutBranch(review.CLOpts.Branch)
+ return review.jirix.Git().CheckoutBranch(review.CLOpts.Branch)
}
- review.ctx.Git().CheckoutBranch(review.CLOpts.Branch, gitutil.ForceOpt(true))
- review.ctx.Git().DeleteBranch(review.reviewBranch, gitutil.ForceOpt(true))
+ review.jirix.Git().CheckoutBranch(review.CLOpts.Branch, gitutil.ForceOpt(true))
+ review.jirix.Git().DeleteBranch(review.reviewBranch, gitutil.ForceOpt(true))
return nil
}, &e)
// Report an error if the CL is empty.
- if !review.ctx.DryRun() {
- hasDiff, err := review.ctx.Git().BranchesDiffer(review.CLOpts.Branch, review.reviewBranch)
+ if !review.jirix.DryRun() {
+ hasDiff, err := review.jirix.Git().BranchesDiffer(review.CLOpts.Branch, review.reviewBranch)
if err != nil {
return err
}
@@ -599,7 +597,7 @@
// 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.ctx, review.CLOpts.Branch)
+ branches, err := getDependentCLs(review.jirix, review.CLOpts.Branch)
if err != nil {
return err
}
@@ -627,7 +625,7 @@
// here is based on:
//
// http://stackoverflow.com/questions/173919/is-there-a-theirs-version-of-git-merge-s-ours
- if err := review.ctx.Git().Merge(branches[i], gitutil.SquashOpt(true), gitutil.StrategyOpt("ours")); err != nil {
+ if err := review.jirix.Git().Merge(branches[i], gitutil.SquashOpt(true), gitutil.StrategyOpt("ours")); err != nil {
return changeConflictError{
localBranch: branches[i],
remoteBranch: review.CLOpts.RemoteBranch,
@@ -641,7 +639,7 @@
// 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 := review.ctx.Git().Log(branches[i], branches[i]+"^", "%ad%n%cd")
+ output, err := review.jirix.Git().Log(branches[i], branches[i]+"^", "%ad%n%cd")
if err != nil {
return err
}
@@ -651,37 +649,37 @@
authorDate := tool.AuthorDateOpt(output[0][0])
committerDate := tool.CommitterDateOpt(output[0][1])
if i < len(branches)-1 {
- file, err := getCommitMessageFileName(review.ctx, branches[i])
+ file, err := getCommitMessageFileName(review.jirix, branches[i])
if err != nil {
return err
}
- message, err := review.ctx.Run().ReadFile(file)
+ message, err := review.jirix.Run().ReadFile(file)
if err != nil {
return err
}
- if err := review.ctx.Git(authorDate, committerDate).CommitWithMessage(string(message)); err != nil {
+ if err := review.jirix.Git(authorDate, committerDate).CommitWithMessage(string(message)); err != nil {
return err
}
} else {
- committer := review.ctx.Git(authorDate, committerDate).NewCommitter(review.CLOpts.Edit)
+ committer := review.jirix.Git(authorDate, committerDate).NewCommitter(review.CLOpts.Edit)
if err := committer.Commit(message); err != nil {
return err
}
}
tmpBranch := review.reviewBranch + "-" + branches[i] + "-TMP"
- if err := review.ctx.Git().CreateBranch(tmpBranch); err != nil {
+ if err := review.jirix.Git().CreateBranch(tmpBranch); err != nil {
return err
}
defer collect.Error(func() error {
- return review.ctx.Git().DeleteBranch(tmpBranch, gitutil.ForceOpt(true))
+ return review.jirix.Git().DeleteBranch(tmpBranch, gitutil.ForceOpt(true))
}, &e)
- if err := review.ctx.Git().Reset(branches[i]); err != nil {
+ if err := review.jirix.Git().Reset(branches[i]); err != nil {
return err
}
- if err := review.ctx.Git().Reset(tmpBranch, gitutil.ModeOpt("soft")); err != nil {
+ if err := review.jirix.Git().Reset(tmpBranch, gitutil.ModeOpt("soft")); err != nil {
return err
}
- if err := review.ctx.Git(authorDate, committerDate).CommitAmend(); err != nil {
+ if err := review.jirix.Git(authorDate, committerDate).CommitAmend(); err != nil {
return err
}
}
@@ -691,7 +689,7 @@
// defaultCommitMessage creates the default commit message from the
// list of commits on the branch.
func (review *review) defaultCommitMessage() (string, error) {
- commitMessages, err := review.ctx.Git().CommitMessages(review.CLOpts.Branch, review.reviewBranch)
+ commitMessages, err := review.jirix.Git().CommitMessages(review.CLOpts.Branch, review.reviewBranch)
if err != nil {
return "", err
}
@@ -706,7 +704,7 @@
// 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 := review.ctx.Git().LatestCommitMessage()
+ latestCommitMessage, err := review.jirix.Git().LatestCommitMessage()
if err != nil {
return err
}
@@ -746,7 +744,7 @@
// and then mails it to Gerrit.
func (review *review) run() (e error) {
if uncommittedFlag {
- changes, err := review.ctx.Git().FilesWithUncommittedChanges()
+ changes, err := review.jirix.Git().FilesWithUncommittedChanges()
if err != nil {
return err
}
@@ -757,7 +755,7 @@
if review.CLOpts.Branch == remoteBranchFlag {
return fmt.Errorf("cannot do a review from the %q branch.", remoteBranchFlag)
}
- stashed, err := review.ctx.Git().Stash()
+ stashed, err := review.jirix.Git().Stash()
if err != nil {
return err
}
@@ -765,23 +763,23 @@
if err != nil {
return fmt.Errorf("Getwd() failed: %v", err)
}
- defer collect.Error(func() error { return review.ctx.Run().Chdir(wd) }, &e)
- topLevel, err := review.ctx.Git().TopLevel()
+ defer collect.Error(func() error { return review.jirix.Run().Chdir(wd) }, &e)
+ topLevel, err := review.jirix.Git().TopLevel()
if err != nil {
return err
}
- if err := review.ctx.Run().Chdir(topLevel); err != nil {
+ if err := review.jirix.Run().Chdir(topLevel); err != nil {
return err
}
defer collect.Error(func() error { return review.cleanup(stashed) }, &e)
- file, err := getCommitMessageFileName(review.ctx, review.CLOpts.Branch)
+ 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 := review.ctx.Run().ReadFile(file)
+ data, err := review.jirix.Run().ReadFile(file)
if err != nil {
if !os.IsNotExist(err) {
return err
@@ -820,12 +818,12 @@
// send mails the current branch out for review.
func (review *review) send() error {
- if !review.ctx.DryRun() {
+ if !review.jirix.DryRun() {
if err := review.ensureChangeID(); err != nil {
return err
}
}
- if err := gerrit.Push(review.ctx.Run(), review.CLOpts); err != nil {
+ if err := gerrit.Push(review.jirix.Run(), review.CLOpts); err != nil {
return gerritError(err.Error())
}
return nil
@@ -833,11 +831,11 @@
// getChangeID reads the commit message and extracts the change-Id.
func (review *review) getChangeID() (string, error) {
- file, err := getCommitMessageFileName(review.ctx, review.CLOpts.Branch)
+ file, err := getCommitMessageFileName(review.jirix, review.CLOpts.Branch)
if err != nil {
return "", err
}
- bytes, err := review.ctx.Run().ReadFile(file)
+ bytes, err := review.jirix.Run().ReadFile(file)
if err != nil {
return "", err
}
@@ -855,7 +853,7 @@
if err != nil {
return err
}
- if err := review.ctx.Gerrit(review.CLOpts.Host).SetTopic(changeID, review.CLOpts); err != nil {
+ if err := review.jirix.Gerrit(review.CLOpts.Host).SetTopic(changeID, review.CLOpts); err != nil {
return err
}
return nil
@@ -863,10 +861,10 @@
// updateReviewMessage writes the commit message to the given file.
func (review *review) updateReviewMessage(file string) error {
- if err := review.ctx.Git().CheckoutBranch(review.reviewBranch); err != nil {
+ if err := review.jirix.Git().CheckoutBranch(review.reviewBranch); err != nil {
return err
}
- newMessage, err := review.ctx.Git().LatestCommitMessage()
+ newMessage, err := review.jirix.Git().LatestCommitMessage()
if err != nil {
return err
}
@@ -875,25 +873,25 @@
//
// This behavior is consistent with how Change-ID is added for the
// initial commit so we don't confuse users.
- if _, err := review.ctx.Run().Stat(file); err != nil {
+ if _, err := review.jirix.Run().Stat(file); err != nil {
if os.IsNotExist(err) {
newMessage = review.processLabels(newMessage)
- if err := review.ctx.Git().CommitAmendWithMessage(newMessage); err != nil {
+ if err := review.jirix.Git().CommitAmendWithMessage(newMessage); err != nil {
return err
}
} else {
return err
}
}
- topLevel, err := review.ctx.Git().TopLevel()
+ topLevel, err := review.jirix.Git().TopLevel()
if err != nil {
return err
}
newMetadataDir := filepath.Join(topLevel, project.MetadataDirName(), review.CLOpts.Branch)
- if err := review.ctx.Run().MkdirAll(newMetadataDir, os.FileMode(0755)); err != nil {
+ if err := review.jirix.Run().MkdirAll(newMetadataDir, os.FileMode(0755)); err != nil {
return err
}
- if err := review.ctx.Run().WriteFile(file, []byte(newMessage), 0644); err != nil {
+ if err := review.jirix.Run().WriteFile(file, []byte(newMessage), 0644); err != nil {
return err
}
return nil
@@ -901,7 +899,7 @@
// cmdCLNew represents the "jiri cl new" command.
var cmdCLNew = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runCLNew),
+ Runner: jiri.RunnerFunc(runCLNew),
Name: "new",
Short: "Create a new local branch for a changelist",
Long: fmt.Sprintf(`
@@ -916,27 +914,26 @@
ArgsLong: "<name> is the changelist name.",
}
-func runCLNew(env *cmdline.Env, args []string) error {
+func runCLNew(jirix *jiri.X, args []string) error {
if got, want := len(args), 1; got != want {
- return env.UsageErrorf("unexpected number of arguments: got %v, want %v", got, want)
+ return jirix.UsageErrorf("unexpected number of arguments: got %v, want %v", got, want)
}
- ctx := tool.NewContextFromEnv(env)
- return newCL(ctx, args)
+ return newCL(jirix, args)
}
-func newCL(ctx *tool.Context, args []string) error {
- topLevel, err := ctx.Git().TopLevel()
+func newCL(jirix *jiri.X, args []string) error {
+ topLevel, err := jirix.Git().TopLevel()
if err != nil {
return err
}
- originalBranch, err := ctx.Git().CurrentBranchName()
+ originalBranch, err := jirix.Git().CurrentBranchName()
if err != nil {
return err
}
// Create a new branch using the current branch.
newBranch := args[0]
- if err := ctx.Git().CreateAndCheckoutBranch(newBranch); err != nil {
+ if err := jirix.Git().CreateAndCheckoutBranch(newBranch); err != nil {
return err
}
@@ -944,28 +941,28 @@
cleanup := true
defer func() {
if cleanup {
- ctx.Git().CheckoutBranch(originalBranch, gitutil.ForceOpt(true))
- ctx.Git().DeleteBranch(newBranch, gitutil.ForceOpt(true))
+ jirix.Git().CheckoutBranch(originalBranch, gitutil.ForceOpt(true))
+ jirix.Git().DeleteBranch(newBranch, gitutil.ForceOpt(true))
}
}()
// 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(ctx, originalBranch)
+ branches, err := getDependentCLs(jirix, originalBranch)
if err != nil {
return err
}
branches = append(branches, originalBranch)
newMetadataDir := filepath.Join(topLevel, project.MetadataDirName(), newBranch)
- if err := ctx.Run().MkdirAll(newMetadataDir, os.FileMode(0755)); err != nil {
+ if err := jirix.Run().MkdirAll(newMetadataDir, os.FileMode(0755)); err != nil {
return err
}
- file, err := getDependencyPathFileName(ctx, newBranch)
+ file, err := getDependencyPathFileName(jirix, newBranch)
if err != nil {
return err
}
- if err := ctx.Run().WriteFile(file, []byte(strings.Join(branches, "\n")), os.FileMode(0644)); err != nil {
+ if err := jirix.Run().WriteFile(file, []byte(strings.Join(branches, "\n")), os.FileMode(0644)); err != nil {
return err
}
@@ -975,7 +972,7 @@
// cmdCLSync represents the "jiri cl sync" command.
var cmdCLSync = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runCLSync),
+ Runner: jiri.RunnerFunc(runCLSync),
Name: "sync",
Short: "Bring a changelist up to date",
Long: fmt.Sprintf(`
@@ -995,23 +992,22 @@
`, project.MetadataDirName()),
}
-func runCLSync(env *cmdline.Env, _ []string) error {
- ctx := tool.NewContextFromEnv(env)
- return syncCL(ctx)
+func runCLSync(jirix *jiri.X, _ []string) error {
+ return syncCL(jirix)
}
-func syncCL(ctx *tool.Context) (e error) {
- stashed, err := ctx.Git().Stash()
+func syncCL(jirix *jiri.X) (e error) {
+ stashed, err := jirix.Git().Stash()
if err != nil {
return err
}
if stashed {
- defer collect.Error(func() error { return ctx.Git().StashPop() }, &e)
+ defer collect.Error(func() error { return jirix.Git().StashPop() }, &e)
}
// Register a cleanup handler in case of subsequent errors.
forceOriginalBranch := true
- originalBranch, err := ctx.Git().CurrentBranchName()
+ originalBranch, err := jirix.Git().CurrentBranchName()
if err != nil {
return err
}
@@ -1022,43 +1018,43 @@
defer func() {
if forceOriginalBranch {
- ctx.Git().CheckoutBranch(originalBranch, gitutil.ForceOpt(true))
+ jirix.Git().CheckoutBranch(originalBranch, gitutil.ForceOpt(true))
}
- ctx.Run().Chdir(originalWd)
+ jirix.Run().Chdir(originalWd)
}()
// Switch to an existing directory in master so we can run commands.
- topLevel, err := ctx.Git().TopLevel()
+ topLevel, err := jirix.Git().TopLevel()
if err != nil {
return err
}
- if err := ctx.Run().Chdir(topLevel); err != nil {
+ if err := jirix.Run().Chdir(topLevel); err != nil {
return err
}
// Identify the dependents CLs leading to (and including) the
// current branch.
- branches, err := getDependentCLs(ctx, originalBranch)
+ branches, err := getDependentCLs(jirix, originalBranch)
if err != nil {
return err
}
branches = append(branches, originalBranch)
// Sync from upstream.
- if err := ctx.Git().CheckoutBranch(branches[0]); err != nil {
+ if err := jirix.Git().CheckoutBranch(branches[0]); err != nil {
return err
}
- if err := ctx.Git().Pull("origin", branches[0]); err != nil {
+ if err := jirix.Git().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 := ctx.Git().CheckoutBranch(branches[i]); err != nil {
+ if err := jirix.Git().CheckoutBranch(branches[i]); err != nil {
return err
}
- if err := ctx.Git().Merge(branches[i-1]); err != nil {
+ if err := jirix.Git().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
diff --git a/cl_test.go b/cl_test.go
index 9e998b6..586aef3 100644
--- a/cl_test.go
+++ b/cl_test.go
@@ -15,14 +15,14 @@
"v.io/jiri/gerrit"
"v.io/jiri/gitutil"
+ "v.io/jiri/jiri"
"v.io/jiri/project"
- "v.io/jiri/tool"
)
// assertCommitCount asserts that the commit count between two
// branches matches the expectedCount.
-func assertCommitCount(t *testing.T, ctx *tool.Context, branch, baseBranch string, expectedCount int) {
- got, err := ctx.Git().CountCommits(branch, baseBranch)
+func assertCommitCount(t *testing.T, jirix *jiri.X, branch, baseBranch string, expectedCount int) {
+ got, err := jirix.Git().CountCommits(branch, baseBranch)
if err != nil {
t.Fatalf("%v", err)
}
@@ -33,8 +33,8 @@
// assertFileContent asserts that the content of the given file
// matches the expected content.
-func assertFileContent(t *testing.T, ctx *tool.Context, file, want string) {
- got, err := ctx.Run().ReadFile(file)
+func assertFileContent(t *testing.T, jirix *jiri.X, file, want string) {
+ got, err := jirix.Run().ReadFile(file)
if err != nil {
t.Fatalf("%v\n", err)
}
@@ -44,9 +44,9 @@
}
// assertFilesExist asserts that the files exist.
-func assertFilesExist(t *testing.T, ctx *tool.Context, files []string) {
+func assertFilesExist(t *testing.T, jirix *jiri.X, files []string) {
for _, file := range files {
- if _, err := ctx.Run().Stat(file); err != nil {
+ if _, err := jirix.Run().Stat(file); err != nil {
if os.IsNotExist(err) {
t.Fatalf("expected file %v to exist but it did not", file)
}
@@ -56,9 +56,9 @@
}
// assertFilesDoNotExist asserts that the files do not exist.
-func assertFilesDoNotExist(t *testing.T, ctx *tool.Context, files []string) {
+func assertFilesDoNotExist(t *testing.T, jirix *jiri.X, files []string) {
for _, file := range files {
- if _, err := ctx.Run().Stat(file); err != nil && !os.IsNotExist(err) {
+ if _, err := jirix.Run().Stat(file); err != nil && !os.IsNotExist(err) {
t.Fatalf("%v", err)
} else if err == nil {
t.Fatalf("expected file %v to not exist but it did", file)
@@ -68,10 +68,10 @@
// assertFilesCommitted asserts that the files exist and are committed
// in the current branch.
-func assertFilesCommitted(t *testing.T, ctx *tool.Context, files []string) {
- assertFilesExist(t, ctx, files)
+func assertFilesCommitted(t *testing.T, jirix *jiri.X, files []string) {
+ assertFilesExist(t, jirix, files)
for _, file := range files {
- if !ctx.Git().IsFileCommitted(file) {
+ if !jirix.Git().IsFileCommitted(file) {
t.Fatalf("expected file %v to be committed but it is not", file)
}
}
@@ -79,10 +79,10 @@
// assertFilesNotCommitted asserts that the files exist and are *not*
// committed in the current branch.
-func assertFilesNotCommitted(t *testing.T, ctx *tool.Context, files []string) {
- assertFilesExist(t, ctx, files)
+func assertFilesNotCommitted(t *testing.T, jirix *jiri.X, files []string) {
+ assertFilesExist(t, jirix, files)
for _, file := range files {
- if ctx.Git().IsFileCommitted(file) {
+ if jirix.Git().IsFileCommitted(file) {
t.Fatalf("expected file %v not to be committed but it is", file)
}
}
@@ -90,20 +90,20 @@
// assertFilesPushedToRef asserts that the given files have been
// pushed to the given remote repository reference.
-func assertFilesPushedToRef(t *testing.T, ctx *tool.Context, repoPath, gerritPath, pushedRef string, files []string) {
- chdir(t, ctx, gerritPath)
- assertCommitCount(t, ctx, pushedRef, "master", 1)
- if err := ctx.Git().CheckoutBranch(pushedRef); err != nil {
+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 := jirix.Git().CheckoutBranch(pushedRef); err != nil {
t.Fatalf("%v", err)
}
- assertFilesCommitted(t, ctx, files)
- chdir(t, ctx, repoPath)
+ assertFilesCommitted(t, jirix, files)
+ chdir(t, jirix, repoPath)
}
// assertStashSize asserts that the stash size matches the expected
// size.
-func assertStashSize(t *testing.T, ctx *tool.Context, want int) {
- got, err := ctx.Git().StashSize()
+func assertStashSize(t *testing.T, jirix *jiri.X, want int) {
+ got, err := jirix.Git().StashSize()
if err != nil {
t.Fatalf("%v", err)
}
@@ -113,38 +113,38 @@
}
// commitFile commits a file with the specified content into a branch
-func commitFile(t *testing.T, ctx *tool.Context, filename string, content string) {
- if err := ctx.Run().WriteFile(filename, []byte(content), 0644); err != nil {
+func commitFile(t *testing.T, jirix *jiri.X, filename string, content string) {
+ if err := jirix.Run().WriteFile(filename, []byte(content), 0644); err != nil {
t.Fatalf("%v", err)
}
commitMessage := "Commit " + filename
- if err := ctx.Git().CommitFile(filename, commitMessage); err != nil {
+ if err := jirix.Git().CommitFile(filename, commitMessage); err != nil {
t.Fatalf("%v", err)
}
}
// commitFiles commits the given files into to current branch.
-func commitFiles(t *testing.T, ctx *tool.Context, filenames []string) {
+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, ctx, filename, content)
+ commitFile(t, jirix, filename, content)
}
}
// createRepo creates a new repository in the given working directory.
-func createRepo(t *testing.T, ctx *tool.Context, workingDir, prefix string) string {
- repoPath, err := ctx.Run().TempDir(workingDir, "repo-"+prefix)
+func createRepo(t *testing.T, jirix *jiri.X, workingDir, prefix string) string {
+ repoPath, err := jirix.Run().TempDir(workingDir, "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 := ctx.Git().Init(repoPath); err != nil {
+ if err := jirix.Git().Init(repoPath); err != nil {
t.Fatalf("%v", err)
}
- if err := ctx.Run().MkdirAll(filepath.Join(repoPath, project.MetadataDirName()), os.FileMode(0755)); err != nil {
+ if err := jirix.Run().MkdirAll(filepath.Join(repoPath, project.MetadataDirName()), os.FileMode(0755)); err != nil {
t.Fatalf("%v", err)
}
return repoPath
@@ -157,29 +157,29 @@
`
// installCommitMsgHook links the gerrit commit-msg hook into a different repo.
-func installCommitMsgHook(t *testing.T, ctx *tool.Context, repoPath string) {
+func installCommitMsgHook(t *testing.T, jirix *jiri.X, repoPath string) {
hookLocation := path.Join(repoPath, ".git/hooks/commit-msg")
- if err := ctx.Run().WriteFile(hookLocation, []byte(commitMsgHook), 0755); err != nil {
+ if err := jirix.Run().WriteFile(hookLocation, []byte(commitMsgHook), 0755); 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, ctx *tool.Context, path string) {
- if err := ctx.Run().Chdir(path); err != nil {
+func chdir(t *testing.T, jirix *jiri.X, path string) {
+ if err := jirix.Run().Chdir(path); 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, ctx *tool.Context, workingDir string, subpath string, originPath string) string {
- repoPath := createRepo(t, ctx, workingDir, subpath)
- chdir(t, ctx, repoPath)
- if err := ctx.Git().AddRemote("origin", originPath); err != nil {
+func createRepoFromOrigin(t *testing.T, jirix *jiri.X, workingDir string, subpath string, originPath string) string {
+ repoPath := createRepo(t, jirix, workingDir, subpath)
+ chdir(t, jirix, repoPath)
+ if err := jirix.Git().AddRemote("origin", originPath); err != nil {
t.Fatalf("%v", err)
}
- if err := ctx.Git().Pull("origin", "master"); err != nil {
+ if err := jirix.Git().Pull("origin", "master"); err != nil {
t.Fatalf("%v", err)
}
return repoPath
@@ -188,94 +188,92 @@
// 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, ctx *tool.Context, workingDir string) (string, string, string) {
+func createTestRepos(t *testing.T, jirix *jiri.X, workingDir string) (string, string, string) {
// Create origin.
- originPath := createRepo(t, ctx, workingDir, "origin")
- chdir(t, ctx, originPath)
- if err := ctx.Git().CommitWithMessage("initial commit"); err != nil {
+ originPath := createRepo(t, jirix, workingDir, "origin")
+ chdir(t, jirix, originPath)
+ if err := jirix.Git().CommitWithMessage("initial commit"); err != nil {
t.Fatalf("%v", err)
}
// Create test repo.
- repoPath := createRepoFromOrigin(t, ctx, workingDir, "test", originPath)
+ repoPath := createRepoFromOrigin(t, jirix, workingDir, "test", originPath)
// Add Gerrit remote.
- gerritPath := createRepoFromOrigin(t, ctx, workingDir, "gerrit", originPath)
+ gerritPath := createRepoFromOrigin(t, jirix, workingDir, "gerrit", originPath)
// Switch back to test repo.
- chdir(t, ctx, repoPath)
+ 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, ctx *tool.Context, originPath string, gerritPath string, review *review) {
+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, ctx, originPath)
+ chdir(t, jirix, originPath)
expectedRef := gerrit.Reference(review.CLOpts)
- if err := ctx.Git().Pull(gerritPath, expectedRef); err != nil {
+ if err := jirix.Git().Pull(gerritPath, expectedRef); err != nil {
t.Fatalf("Pull gerrit to origin failed: %v", err)
}
- chdir(t, ctx, cwd)
+ chdir(t, jirix, cwd)
}
// setupTest creates a setup for testing the review tool.
-func setupTest(t *testing.T, installHook bool) (ctx *tool.Context, cwd string, root *project.FakeJiriRoot, repoPath, originPath, gerritPath string) {
- ctx = tool.NewDefaultContext()
- cwd, err := os.Getwd()
- if err != nil {
+func setupTest(t *testing.T, installHook bool) (cwd string, root *project.FakeJiriRoot, repoPath, originPath, gerritPath string) {
+ var err error
+ if cwd, err = os.Getwd(); err != nil {
t.Fatalf("Getwd() failed: %v", err)
}
- root, err = project.NewFakeJiriRoot(ctx)
- if err != nil {
+ if root, err = project.NewFakeJiriRoot(); err != nil {
t.Fatalf("%v", err)
}
- repoPath, originPath, gerritPath = createTestRepos(t, ctx, root.Dir)
+ repoPath, originPath, gerritPath = createTestRepos(t, root.X, root.Dir)
if installHook == true {
for _, path := range []string{repoPath, originPath, gerritPath} {
- installCommitMsgHook(t, ctx, path)
+ installCommitMsgHook(t, root.X, path)
}
}
- chdir(t, ctx, repoPath)
+ chdir(t, root.X, repoPath)
return
}
// teardownTest cleans up the setup for testing the review tool.
-func teardownTest(t *testing.T, ctx *tool.Context, oldWorkDir string, root *project.FakeJiriRoot) {
- chdir(t, ctx, oldWorkDir)
- if err := root.Cleanup(ctx); err != nil {
+func teardownTest(t *testing.T, oldWorkDir string, root *project.FakeJiriRoot) {
+ chdir(t, root.X, oldWorkDir)
+ if err := root.Cleanup(); err != nil {
t.Fatalf("%v", err)
}
}
-func createCLWithFiles(t *testing.T, ctx *tool.Context, branch string, files ...string) {
- if err := newCL(ctx, []string{branch}); err != nil {
+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, ctx, files)
+ 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) {
- ctx, cwd, root, repoPath, originPath, _ := setupTest(t, true)
- defer teardownTest(t, ctx, cwd, root)
+ cwd, root, repoPath, originPath, _ := setupTest(t, true)
+ defer teardownTest(t, cwd, root)
branch := "my-branch"
- if err := ctx.Git().CreateAndCheckoutBranch(branch); err != nil {
+ if err := root.X.Git().CreateAndCheckoutBranch(branch); err != nil {
t.Fatalf("%v", err)
}
- commitFiles(t, ctx, []string{"file1", "file2"})
- if err := ctx.Git().CheckoutBranch("master"); err != nil {
+ commitFiles(t, root.X, []string{"file1", "file2"})
+ if err := root.X.Git().CheckoutBranch("master"); err != nil {
t.Fatalf("%v", err)
}
- chdir(t, ctx, originPath)
- commitFiles(t, ctx, []string{"file1", "file2"})
- chdir(t, ctx, repoPath)
- if err := cleanupCL(ctx, []string{branch}); err != nil {
+ chdir(t, root.X, originPath)
+ commitFiles(t, root.X, []string{"file1", "file2"})
+ chdir(t, root.X, repoPath)
+ if err := cleanupCL(root.X, []string{branch}); err != nil {
t.Fatalf("cleanup() failed: %v", err)
}
- if ctx.Git().BranchExists(branch) {
+ if root.X.Git().BranchExists(branch) {
t.Fatalf("cleanup failed to remove the feature branch")
}
}
@@ -283,38 +281,38 @@
// TestCleanupDirty checks that cleanup is a no-op if the branch to be
// cleaned up has unmerged changes.
func TestCleanupDirty(t *testing.T) {
- ctx, cwd, root, _, _, _ := setupTest(t, true)
- defer teardownTest(t, ctx, cwd, root)
+ cwd, root, _, _, _ := setupTest(t, true)
+ defer teardownTest(t, cwd, root)
branch := "my-branch"
- if err := ctx.Git().CreateAndCheckoutBranch(branch); err != nil {
+ if err := root.X.Git().CreateAndCheckoutBranch(branch); err != nil {
t.Fatalf("%v", err)
}
files := []string{"file1", "file2"}
- commitFiles(t, ctx, files)
- if err := ctx.Git().CheckoutBranch("master"); err != nil {
+ commitFiles(t, root.X, files)
+ if err := root.X.Git().CheckoutBranch("master"); err != nil {
t.Fatalf("%v", err)
}
- if err := cleanupCL(ctx, []string{branch}); err == nil {
+ if err := cleanupCL(root.X, []string{branch}); err == nil {
t.Fatalf("cleanup did not fail when it should")
}
- if err := ctx.Git().CheckoutBranch(branch); err != nil {
+ if err := root.X.Git().CheckoutBranch(branch); err != nil {
t.Fatalf("%v", err)
}
- assertFilesCommitted(t, ctx, files)
+ assertFilesCommitted(t, root.X, files)
}
// TestCreateReviewBranch checks that the temporary review branch is
// created correctly.
func TestCreateReviewBranch(t *testing.T) {
- ctx, cwd, root, _, _, _ := setupTest(t, true)
- defer teardownTest(t, ctx, cwd, root)
+ cwd, root, _, _, _ := setupTest(t, true)
+ defer teardownTest(t, cwd, root)
branch := "my-branch"
- if err := ctx.Git().CreateAndCheckoutBranch(branch); err != nil {
+ if err := root.X.Git().CreateAndCheckoutBranch(branch); err != nil {
t.Fatalf("%v", err)
}
files := []string{"file1", "file2", "file3"}
- commitFiles(t, ctx, files)
- review, err := newReview(ctx, gerrit.CLOpts{})
+ commitFiles(t, root.X, files)
+ review, err := newReview(root.X, gerrit.CLOpts{})
if err != nil {
t.Fatalf("%v", err)
}
@@ -326,27 +324,27 @@
t.Fatalf("%v", err)
}
// Verify that the branch exists.
- if !ctx.Git().BranchExists(review.reviewBranch) {
+ if !root.X.Git().BranchExists(review.reviewBranch) {
t.Fatalf("review branch not found")
}
- if err := ctx.Git().CheckoutBranch(review.reviewBranch); err != nil {
+ if err := root.X.Git().CheckoutBranch(review.reviewBranch); err != nil {
t.Fatalf("%v", err)
}
- assertCommitCount(t, ctx, review.reviewBranch, "master", 1)
- assertFilesCommitted(t, ctx, files)
+ assertCommitCount(t, root.X, review.reviewBranch, "master", 1)
+ assertFilesCommitted(t, root.X, files)
}
// TestCreateReviewBranchWithEmptyChange checks that running
// createReviewBranch() on a branch with no changes will result in an
// EmptyChangeError.
func TestCreateReviewBranchWithEmptyChange(t *testing.T) {
- ctx, cwd, root, _, _, _ := setupTest(t, true)
- defer teardownTest(t, ctx, cwd, root)
+ cwd, root, _, _, _ := setupTest(t, true)
+ defer teardownTest(t, cwd, root)
branch := "my-branch"
- if err := ctx.Git().CreateAndCheckoutBranch(branch); err != nil {
+ if err := root.X.Git().CreateAndCheckoutBranch(branch); err != nil {
t.Fatalf("%v", err)
}
- review, err := newReview(ctx, gerrit.CLOpts{Remote: branch})
+ review, err := newReview(root.X, gerrit.CLOpts{Remote: branch})
if err != nil {
t.Fatalf("%v", err)
}
@@ -362,17 +360,17 @@
// TestSendReview checks the various options for sending a review.
func TestSendReview(t *testing.T) {
- ctx, cwd, root, repoPath, _, gerritPath := setupTest(t, true)
- defer teardownTest(t, ctx, cwd, root)
+ cwd, root, repoPath, _, gerritPath := setupTest(t, true)
+ defer teardownTest(t, cwd, root)
branch := "my-branch"
- if err := ctx.Git().CreateAndCheckoutBranch(branch); err != nil {
+ if err := root.X.Git().CreateAndCheckoutBranch(branch); err != nil {
t.Fatalf("%v", err)
}
files := []string{"file1"}
- commitFiles(t, ctx, files)
+ commitFiles(t, root.X, files)
{
// Test with draft = false, no reviewiers, and no ccs.
- review, err := newReview(ctx, gerrit.CLOpts{Remote: gerritPath})
+ review, err := newReview(root.X, gerrit.CLOpts{Remote: gerritPath})
if err != nil {
t.Fatalf("%v", err)
}
@@ -380,11 +378,11 @@
t.Fatalf("failed to send a review: %v", err)
}
expectedRef := gerrit.Reference(review.CLOpts)
- assertFilesPushedToRef(t, ctx, repoPath, gerritPath, expectedRef, files)
+ assertFilesPushedToRef(t, root.X, repoPath, gerritPath, expectedRef, files)
}
{
// Test with draft = true, no reviewers, and no ccs.
- review, err := newReview(ctx, gerrit.CLOpts{
+ review, err := newReview(root.X, gerrit.CLOpts{
Draft: true,
Remote: gerritPath,
})
@@ -395,11 +393,11 @@
t.Fatalf("failed to send a review: %v", err)
}
expectedRef := gerrit.Reference(review.CLOpts)
- assertFilesPushedToRef(t, ctx, repoPath, gerritPath, expectedRef, files)
+ assertFilesPushedToRef(t, root.X, repoPath, gerritPath, expectedRef, files)
}
{
// Test with draft = false, reviewers, and no ccs.
- review, err := newReview(ctx, gerrit.CLOpts{
+ review, err := newReview(root.X, gerrit.CLOpts{
Remote: gerritPath,
Reviewers: parseEmails("reviewer1,reviewer2@example.org"),
})
@@ -410,11 +408,11 @@
t.Fatalf("failed to send a review: %v", err)
}
expectedRef := gerrit.Reference(review.CLOpts)
- assertFilesPushedToRef(t, ctx, repoPath, gerritPath, expectedRef, files)
+ assertFilesPushedToRef(t, root.X, repoPath, gerritPath, expectedRef, files)
}
{
// Test with draft = true, reviewers, and ccs.
- review, err := newReview(ctx, gerrit.CLOpts{
+ review, err := newReview(root.X, gerrit.CLOpts{
Ccs: parseEmails("cc1@example.org,cc2"),
Draft: true,
Remote: gerritPath,
@@ -427,7 +425,7 @@
t.Fatalf("failed to send a review: %v", err)
}
expectedRef := gerrit.Reference(review.CLOpts)
- assertFilesPushedToRef(t, ctx, repoPath, gerritPath, expectedRef, files)
+ assertFilesPushedToRef(t, root.X, repoPath, gerritPath, expectedRef, files)
}
}
@@ -435,14 +433,14 @@
// 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.
- ctx, cwd, root, _, _, gerritPath := setupTest(t, false)
- defer teardownTest(t, ctx, cwd, root)
+ cwd, root, _, _, gerritPath := setupTest(t, false)
+ defer teardownTest(t, cwd, root)
branch := "my-branch"
- if err := ctx.Git().CreateAndCheckoutBranch(branch); err != nil {
+ if err := root.X.Git().CreateAndCheckoutBranch(branch); err != nil {
t.Fatalf("%v", err)
}
- commitFiles(t, ctx, []string{"file1"})
- review, err := newReview(ctx, gerrit.CLOpts{Remote: gerritPath})
+ commitFiles(t, root.X, []string{"file1"})
+ review, err := newReview(root.X, gerrit.CLOpts{Remote: gerritPath})
if err != nil {
t.Fatalf("%v", err)
}
@@ -457,15 +455,15 @@
// TestEndToEnd checks the end-to-end functionality of the review tool.
func TestEndToEnd(t *testing.T) {
- ctx, cwd, root, repoPath, _, gerritPath := setupTest(t, true)
- defer teardownTest(t, ctx, cwd, root)
+ cwd, root, repoPath, _, gerritPath := setupTest(t, true)
+ defer teardownTest(t, cwd, root)
branch := "my-branch"
- if err := ctx.Git().CreateAndCheckoutBranch(branch); err != nil {
+ if err := root.X.Git().CreateAndCheckoutBranch(branch); err != nil {
t.Fatalf("%v", err)
}
files := []string{"file1", "file2", "file3"}
- commitFiles(t, ctx, files)
- review, err := newReview(ctx, gerrit.CLOpts{Remote: gerritPath})
+ commitFiles(t, root.X, files)
+ review, err := newReview(root.X, gerrit.CLOpts{Remote: gerritPath})
if err != nil {
t.Fatalf("%v", err)
}
@@ -474,7 +472,7 @@
t.Fatalf("run() failed: %v", err)
}
expectedRef := gerrit.Reference(review.CLOpts)
- assertFilesPushedToRef(t, ctx, repoPath, gerritPath, expectedRef, files)
+ assertFilesPushedToRef(t, root.X, repoPath, gerritPath, expectedRef, files)
}
// TestLabelsInCommitMessage checks the labels are correctly processed
@@ -492,17 +490,17 @@
// fact that the reference name is a function of the reviewers and
// uses different reviewers for different review runs.
func TestLabelsInCommitMessage(t *testing.T) {
- ctx, cwd, root, repoPath, _, gerritPath := setupTest(t, true)
- defer teardownTest(t, ctx, cwd, root)
+ cwd, root, repoPath, _, gerritPath := setupTest(t, true)
+ defer teardownTest(t, cwd, root)
branch := "my-branch"
- if err := ctx.Git().CreateAndCheckoutBranch(branch); err != nil {
+ if err := root.X.Git().CreateAndCheckoutBranch(branch); err != nil {
t.Fatalf("%v", err)
}
// Test setting -presubmit=none and autosubmit.
files := []string{"file1", "file2", "file3"}
- commitFiles(t, ctx, files)
- review, err := newReview(ctx, gerrit.CLOpts{
+ commitFiles(t, root.X, files)
+ review, err := newReview(root.X, gerrit.CLOpts{
Autosubmit: true,
Presubmit: gerrit.PresubmitTestTypeNone,
Remote: gerritPath,
@@ -516,16 +514,16 @@
t.Fatalf("%v", err)
}
expectedRef := gerrit.Reference(review.CLOpts)
- assertFilesPushedToRef(t, ctx, repoPath, gerritPath, expectedRef, files)
+ assertFilesPushedToRef(t, root.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.ctx, review.CLOpts.Branch)
+ file, err := getCommitMessageFileName(review.jirix, review.CLOpts.Branch)
if err != nil {
t.Fatalf("%v", err)
}
- bytes, err := ctx.Run().ReadFile(file)
+ bytes, err := root.X.Run().ReadFile(file)
if err != nil {
t.Fatalf("%v\n", err)
}
@@ -545,7 +543,7 @@
}
// Test setting -presubmit=all but keep autosubmit=true.
- review, err = newReview(ctx, gerrit.CLOpts{
+ review, err = newReview(root.X, gerrit.CLOpts{
Autosubmit: true,
Remote: gerritPath,
Reviewers: parseEmails("run2"),
@@ -557,8 +555,8 @@
t.Fatalf("%v", err)
}
expectedRef = gerrit.Reference(review.CLOpts)
- assertFilesPushedToRef(t, ctx, repoPath, gerritPath, expectedRef, files)
- bytes, err = ctx.Run().ReadFile(file)
+ assertFilesPushedToRef(t, root.X, repoPath, gerritPath, expectedRef, files)
+ bytes, err = root.X.Run().ReadFile(file)
if err != nil {
t.Fatalf("%v\n", err)
}
@@ -574,7 +572,7 @@
}
// Test setting autosubmit=false.
- review, err = newReview(ctx, gerrit.CLOpts{
+ review, err = newReview(root.X, gerrit.CLOpts{
Remote: gerritPath,
Reviewers: parseEmails("run3"),
})
@@ -585,8 +583,8 @@
t.Fatalf("%v", err)
}
expectedRef = gerrit.Reference(review.CLOpts)
- assertFilesPushedToRef(t, ctx, repoPath, gerritPath, expectedRef, files)
- bytes, err = ctx.Run().ReadFile(file)
+ assertFilesPushedToRef(t, root.X, repoPath, gerritPath, expectedRef, files)
+ bytes, err = root.X.Run().ReadFile(file)
if err != nil {
t.Fatalf("%v\n", err)
}
@@ -601,42 +599,42 @@
// TestDirtyBranch checks that the tool correctly handles unstaged and
// untracked changes in a working branch with stashed changes.
func TestDirtyBranch(t *testing.T) {
- ctx, cwd, root, _, _, gerritPath := setupTest(t, true)
- defer teardownTest(t, ctx, cwd, root)
+ cwd, root, _, _, gerritPath := setupTest(t, true)
+ defer teardownTest(t, cwd, root)
branch := "my-branch"
- if err := ctx.Git().CreateAndCheckoutBranch(branch); err != nil {
+ if err := root.X.Git().CreateAndCheckoutBranch(branch); err != nil {
t.Fatalf("%v", err)
}
files := []string{"file1", "file2"}
- commitFiles(t, ctx, files)
- assertStashSize(t, ctx, 0)
+ commitFiles(t, root.X, files)
+ assertStashSize(t, root.X, 0)
stashedFile, stashedFileContent := "stashed-file", "stashed-file content"
- if err := ctx.Run().WriteFile(stashedFile, []byte(stashedFileContent), 0644); err != nil {
+ if err := root.X.Run().WriteFile(stashedFile, []byte(stashedFileContent), 0644); err != nil {
t.Fatalf("WriteFile(%v, %v) failed: %v", stashedFile, stashedFileContent, err)
}
- if err := ctx.Git().Add(stashedFile); err != nil {
+ if err := root.X.Git().Add(stashedFile); err != nil {
t.Fatalf("%v", err)
}
- if _, err := ctx.Git().Stash(); err != nil {
+ if _, err := root.X.Git().Stash(); err != nil {
t.Fatalf("%v", err)
}
- assertStashSize(t, ctx, 1)
+ assertStashSize(t, root.X, 1)
modifiedFile, modifiedFileContent := "file1", "modified-file content"
- if err := ctx.Run().WriteFile(modifiedFile, []byte(modifiedFileContent), 0644); err != nil {
+ if err := root.X.Run().WriteFile(modifiedFile, []byte(modifiedFileContent), 0644); err != nil {
t.Fatalf("WriteFile(%v, %v) failed: %v", modifiedFile, modifiedFileContent, err)
}
stagedFile, stagedFileContent := "file2", "staged-file content"
- if err := ctx.Run().WriteFile(stagedFile, []byte(stagedFileContent), 0644); err != nil {
+ if err := root.X.Run().WriteFile(stagedFile, []byte(stagedFileContent), 0644); err != nil {
t.Fatalf("WriteFile(%v, %v) failed: %v", stagedFile, stagedFileContent, err)
}
- if err := ctx.Git().Add(stagedFile); err != nil {
+ if err := root.X.Git().Add(stagedFile); err != nil {
t.Fatalf("%v", err)
}
untrackedFile, untrackedFileContent := "file3", "untracked-file content"
- if err := ctx.Run().WriteFile(untrackedFile, []byte(untrackedFileContent), 0644); err != nil {
+ if err := root.X.Run().WriteFile(untrackedFile, []byte(untrackedFileContent), 0644); err != nil {
t.Fatalf("WriteFile(%v, %v) failed: %v", untrackedFile, untrackedFileContent, err)
}
- review, err := newReview(ctx, gerrit.CLOpts{Remote: gerritPath})
+ review, err := newReview(root.X, gerrit.CLOpts{Remote: gerritPath})
if err != nil {
t.Fatalf("%v", err)
}
@@ -644,44 +642,44 @@
if err := review.run(); err == nil {
t.Fatalf("run() didn't fail when it should")
}
- assertFilesNotCommitted(t, ctx, []string{stagedFile})
- assertFilesNotCommitted(t, ctx, []string{untrackedFile})
- assertFileContent(t, ctx, modifiedFile, modifiedFileContent)
- assertFileContent(t, ctx, stagedFile, stagedFileContent)
- assertFileContent(t, ctx, untrackedFile, untrackedFileContent)
+ assertFilesNotCommitted(t, root.X, []string{stagedFile})
+ assertFilesNotCommitted(t, root.X, []string{untrackedFile})
+ assertFileContent(t, root.X, modifiedFile, modifiedFileContent)
+ assertFileContent(t, root.X, stagedFile, stagedFileContent)
+ assertFileContent(t, root.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 := ctx.Git().Commit(); err != nil {
+ if err := root.X.Git().Commit(); err != nil {
t.Fatalf("%v", err)
}
- assertStashSize(t, ctx, 1)
- if err := ctx.Git().StashPop(); err != nil {
+ assertStashSize(t, root.X, 1)
+ if err := root.X.Git().StashPop(); err != nil {
t.Fatalf("%v", err)
}
- assertStashSize(t, ctx, 0)
- assertFilesNotCommitted(t, ctx, []string{stashedFile})
- assertFileContent(t, ctx, stashedFile, stashedFileContent)
+ assertStashSize(t, root.X, 0)
+ assertFilesNotCommitted(t, root.X, []string{stashedFile})
+ assertFileContent(t, root.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) {
- ctx, cwd, root, repoPath, _, gerritPath := setupTest(t, true)
- defer teardownTest(t, ctx, cwd, root)
+ cwd, root, repoPath, _, gerritPath := setupTest(t, true)
+ defer teardownTest(t, cwd, root)
branch := "my-branch"
- if err := ctx.Git().CreateAndCheckoutBranch(branch); err != nil {
+ if err := root.X.Git().CreateAndCheckoutBranch(branch); err != nil {
t.Fatalf("%v", err)
}
subdir := "sub/directory"
subdirPerms := os.FileMode(0744)
- if err := ctx.Run().MkdirAll(subdir, subdirPerms); err != nil {
+ if err := root.X.Run().MkdirAll(subdir, subdirPerms); err != nil {
t.Fatalf("MkdirAll(%v, %v) failed: %v", subdir, subdirPerms, err)
}
files := []string{path.Join(subdir, "file1")}
- commitFiles(t, ctx, files)
- chdir(t, ctx, subdir)
- review, err := newReview(ctx, gerrit.CLOpts{Remote: gerritPath})
+ commitFiles(t, root.X, files)
+ chdir(t, root.X, subdir)
+ review, err := newReview(root.X, gerrit.CLOpts{Remote: gerritPath})
if err != nil {
t.Fatalf("%v", err)
}
@@ -706,13 +704,13 @@
t.Fatalf("unexpected working directory: got %v, want %v", got, want)
}
expectedRef := gerrit.Reference(review.CLOpts)
- assertFilesPushedToRef(t, ctx, repoPath, gerritPath, expectedRef, files)
+ assertFilesPushedToRef(t, root.X, repoPath, gerritPath, expectedRef, files)
}
// TestProcessLabels checks that the processLabels function works as expected.
func TestProcessLabels(t *testing.T) {
- ctx, cwd, root, _, _, _ := setupTest(t, true)
- defer teardownTest(t, ctx, cwd, root)
+ cwd, root, _, _, _ := setupTest(t, true)
+ defer teardownTest(t, cwd, root)
testCases := []struct {
autosubmit bool
presubmitType gerrit.PresubmitTestType
@@ -784,7 +782,7 @@
},
}
for _, test := range testCases {
- review, err := newReview(ctx, gerrit.CLOpts{
+ review, err := newReview(root.X, gerrit.CLOpts{
Autosubmit: test.autosubmit,
Presubmit: test.presubmitType,
})
@@ -799,14 +797,14 @@
// TestCLNew checks the operation of the "jiri cl new" command.
func TestCLNew(t *testing.T) {
- ctx, cwd, root, _, _, _ := setupTest(t, true)
- defer teardownTest(t, ctx, cwd, root)
+ cwd, root, _, _, _ := setupTest(t, true)
+ defer teardownTest(t, cwd, root)
// Create some dependent CLs.
- if err := newCL(ctx, []string{"feature1"}); err != nil {
+ if err := newCL(root.X, []string{"feature1"}); err != nil {
t.Fatalf("%v", err)
}
- if err := newCL(ctx, []string{"feature2"}); err != nil {
+ if err := newCL(root.X, []string{"feature2"}); err != nil {
t.Fatalf("%v", err)
}
@@ -825,11 +823,11 @@
},
}
for _, testCase := range testCases {
- file, err := getDependencyPathFileName(ctx, testCase.branch)
+ file, err := getDependencyPathFileName(root.X, testCase.branch)
if err != nil {
t.Fatalf("%v", err)
}
- data, err := ctx.Run().ReadFile(file)
+ data, err := root.X.Run().ReadFile(file)
if err != nil {
t.Fatalf("%v", err)
}
@@ -843,28 +841,28 @@
// 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) {
- ctx, cwd, root, repoPath, originPath, gerritPath := setupTest(t, true)
- defer teardownTest(t, ctx, cwd, root)
- chdir(t, ctx, originPath)
- commitFiles(t, ctx, []string{"A", "B"})
+ cwd, root, repoPath, originPath, gerritPath := setupTest(t, true)
+ defer teardownTest(t, cwd, root)
+ chdir(t, root.X, originPath)
+ commitFiles(t, root.X, []string{"A", "B"})
- chdir(t, ctx, repoPath)
- if err := syncCL(ctx); err != nil {
+ chdir(t, root.X, repoPath)
+ if err := syncCL(root.X); err != nil {
t.Fatalf("%v", err)
}
- assertFilesExist(t, ctx, []string{"A", "B"})
+ assertFilesExist(t, root.X, []string{"A", "B"})
- createCLWithFiles(t, ctx, "editme", "C")
- if err := ctx.Run().WriteFile("B", []byte("Will I dream?"), 0644); err != nil {
+ createCLWithFiles(t, root.X, "editme", "C")
+ if err := root.X.Run().WriteFile("B", []byte("Will I dream?"), 0644); err != nil {
t.Fatalf("%v", err)
}
- if err := ctx.Git().Add("B"); err != nil {
+ if err := root.X.Git().Add("B"); err != nil {
t.Fatalf("%v", err)
}
- if err := ctx.Git().CommitWithMessage("editing stuff"); err != nil {
+ if err := root.X.Git().CommitWithMessage("editing stuff"); err != nil {
t.Fatalf("git commit failed: %v", err)
}
- review, err := newReview(ctx, gerrit.CLOpts{
+ review, err := newReview(root.X, gerrit.CLOpts{
Remote: gerritPath,
Reviewers: parseEmails("run1"), // See hack note about TestLabelsInCommitMessage
})
@@ -876,16 +874,16 @@
t.Fatalf("run() failed: %v", err)
}
- if err := newCL(ctx, []string{"deleteme"}); err != nil {
+ if err := newCL(root.X, []string{"deleteme"}); err != nil {
t.Fatalf("%v", err)
}
- if err := ctx.Git().Remove("B", "C"); err != nil {
+ if err := root.X.Git().Remove("B", "C"); err != nil {
t.Fatalf("git rm B C failed: %v", err)
}
- if err := ctx.Git().CommitWithMessage("deleting stuff"); err != nil {
+ if err := root.X.Git().CommitWithMessage("deleting stuff"); err != nil {
t.Fatalf("git commit failed: %v", err)
}
- review, err = newReview(ctx, gerrit.CLOpts{
+ review, err = newReview(root.X, gerrit.CLOpts{
Remote: gerritPath,
Reviewers: parseEmails("run2"),
})
@@ -896,35 +894,35 @@
t.Fatalf("run() failed: %v", err)
}
- chdir(t, ctx, gerritPath)
+ chdir(t, root.X, gerritPath)
expectedRef := gerrit.Reference(review.CLOpts)
- if err := ctx.Git().CheckoutBranch(expectedRef); err != nil {
+ if err := root.X.Git().CheckoutBranch(expectedRef); err != nil {
t.Fatalf("%v", err)
}
- assertFilesExist(t, ctx, []string{"A"})
- assertFilesDoNotExist(t, ctx, []string{"B", "C"})
+ assertFilesExist(t, root.X, []string{"A"})
+ assertFilesDoNotExist(t, root.X, []string{"B", "C"})
}
// TestParallelDev checks "jiri cl mail" behavior when parallel development has
// been submitted upstream.
func TestParallelDev(t *testing.T) {
- ctx, cwd, root, repoPath, originPath, gerritAPath := setupTest(t, true)
- gerritBPath := createRepoFromOrigin(t, ctx, root.Dir, "gerritB", originPath)
- chdir(t, ctx, repoPath)
- defer teardownTest(t, ctx, cwd, root)
+ cwd, root, repoPath, originPath, gerritAPath := setupTest(t, true)
+ gerritBPath := createRepoFromOrigin(t, root.X, root.Dir, "gerritB", originPath)
+ chdir(t, root.X, repoPath)
+ defer teardownTest(t, cwd, root)
// Create parallel branches with:
// * non-conflicting changes in different files
// * conflicting changes in a file
- createCLWithFiles(t, ctx, "feature1-A", "A")
+ createCLWithFiles(t, root.X, "feature1-A", "A")
- if err := ctx.Git().CheckoutBranch("master"); err != nil {
+ if err := root.X.Git().CheckoutBranch("master"); err != nil {
t.Fatalf("%v", err)
}
- createCLWithFiles(t, ctx, "feature1-B", "B")
- commitFile(t, ctx, "A", "Don't tread on me.")
+ createCLWithFiles(t, root.X, "feature1-B", "B")
+ commitFile(t, root.X, "A", "Don't tread on me.")
- reviewB, err := newReview(ctx, gerrit.CLOpts{Remote: gerritBPath})
+ reviewB, err := newReview(root.X, gerrit.CLOpts{Remote: gerritBPath})
if err != nil {
t.Fatalf("%v", err)
}
@@ -934,48 +932,48 @@
}
// Submit B and verify A doesn't revert it.
- submit(t, ctx, originPath, gerritBPath, reviewB)
+ submit(t, root.X, originPath, gerritBPath, reviewB)
// Assert files pushed to origin.
- chdir(t, ctx, originPath)
- assertFilesExist(t, ctx, []string{"A", "B"})
- chdir(t, ctx, repoPath)
+ chdir(t, root.X, originPath)
+ assertFilesExist(t, root.X, []string{"A", "B"})
+ chdir(t, root.X, repoPath)
- if err := ctx.Git().CheckoutBranch("feature1-A"); err != nil {
+ if err := root.X.Git().CheckoutBranch("feature1-A"); err != nil {
t.Fatalf("%v", err)
}
- reviewA, err := newReview(ctx, gerrit.CLOpts{Remote: gerritAPath})
+ reviewA, err := newReview(root.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, ctx, "A", "This is file A")
- assertFilesDoNotExist(t, ctx, []string{"B"})
+ assertFileContent(t, root.X, "A", "This is file A")
+ assertFilesDoNotExist(t, root.X, []string{"B"})
// Manual conflict resolution.
- if err := ctx.Git().Merge("master", gitutil.ResetOnFailureOpt(false)); err == nil {
+ if err := root.X.Git().Merge("master", gitutil.ResetOnFailureOpt(false)); err == nil {
t.Fatalf("merge applied cleanly when it shouldn't")
}
- assertFilesNotCommitted(t, ctx, []string{"A", "B"})
- assertFileContent(t, ctx, "B", "This is file B")
+ assertFilesNotCommitted(t, root.X, []string{"A", "B"})
+ assertFileContent(t, root.X, "B", "This is file B")
- if err := ctx.Run().WriteFile("A", []byte("This is file A. Don't tread on me."), 0644); err != nil {
+ if err := root.X.Run().WriteFile("A", []byte("This is file A. Don't tread on me."), 0644); err != nil {
t.Fatalf("%v", err)
}
- if err := ctx.Git().Add("A"); err != nil {
+ if err := root.X.Git().Add("A"); err != nil {
t.Fatalf("%v", err)
}
- if err := ctx.Git().Add("B"); err != nil {
+ if err := root.X.Git().Add("B"); err != nil {
t.Fatalf("%v", err)
}
- if err := ctx.Git().CommitWithMessage("Conflict resolution"); err != nil {
+ if err := root.X.Git().CommitWithMessage("Conflict resolution"); err != nil {
t.Fatalf("%v", err)
}
// Retry review.
- reviewA, err = newReview(ctx, gerrit.CLOpts{Remote: gerritAPath})
+ reviewA, err = newReview(root.X, gerrit.CLOpts{Remote: gerritAPath})
if err != nil {
t.Fatalf("review failed: %v", err)
}
@@ -984,46 +982,46 @@
t.Fatalf("run() failed: %v", err)
}
- chdir(t, ctx, gerritAPath)
+ chdir(t, root.X, gerritAPath)
expectedRef := gerrit.Reference(reviewA.CLOpts)
- if err := ctx.Git().CheckoutBranch(expectedRef); err != nil {
+ if err := root.X.Git().CheckoutBranch(expectedRef); err != nil {
t.Fatalf("%v", err)
}
- assertFilesExist(t, ctx, []string{"B"})
+ assertFilesExist(t, root.X, []string{"B"})
}
// TestCLSync checks the operation of the "jiri cl sync" command.
func TestCLSync(t *testing.T) {
- ctx, cwd, root, _, _, _ := setupTest(t, true)
- defer teardownTest(t, ctx, cwd, root)
+ cwd, root, _, _, _ := setupTest(t, true)
+ defer teardownTest(t, cwd, root)
// Create some dependent CLs.
- if err := newCL(ctx, []string{"feature1"}); err != nil {
+ if err := newCL(root.X, []string{"feature1"}); err != nil {
t.Fatalf("%v", err)
}
- if err := newCL(ctx, []string{"feature2"}); err != nil {
+ if err := newCL(root.X, []string{"feature2"}); err != nil {
t.Fatalf("%v", err)
}
// Add the "test" file to the master.
- if err := ctx.Git().CheckoutBranch("master"); err != nil {
+ if err := root.X.Git().CheckoutBranch("master"); err != nil {
t.Fatalf("%v", err)
}
- commitFiles(t, ctx, []string{"test"})
+ commitFiles(t, root.X, []string{"test"})
// Sync the dependent CLs.
- if err := ctx.Git().CheckoutBranch("feature2"); err != nil {
+ if err := root.X.Git().CheckoutBranch("feature2"); err != nil {
t.Fatalf("%v", err)
}
- if err := syncCL(ctx); err != nil {
+ if err := syncCL(root.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 := ctx.Git().CheckoutBranch(branch); err != nil {
+ if err := root.X.Git().CheckoutBranch(branch); err != nil {
t.Fatalf("%v", err)
}
- assertFilesExist(t, ctx, []string{"test"})
+ assertFilesExist(t, root.X, []string{"test"})
}
}
diff --git a/cmd.go b/cmd.go
index a3f6e93..0090f3b 100644
--- a/cmd.go
+++ b/cmd.go
@@ -8,7 +8,6 @@
package main
import (
- "fmt"
"runtime"
"v.io/jiri/tool"
@@ -40,26 +39,12 @@
cmdRebuild,
cmdSnapshot,
cmdUpdate,
- cmdVersion,
},
Topics: []cmdline.Topic{
topicManifest,
},
}
-// cmdVersion represents the "jiri version" command.
-var cmdVersion = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runVersion),
- Name: "version",
- Short: "Print version",
- Long: "Print version of the jiri tool.",
-}
-
-func runVersion(env *cmdline.Env, _ []string) error {
- fmt.Fprintf(env.Stdout, "jiri tool version %v\n", tool.Version)
- return nil
-}
-
var topicManifest = cmdline.Topic{
Name: "manifest",
Short: "Description of manifest files",
diff --git a/contrib.go b/contrib.go
index 8210f33..066850a 100644
--- a/contrib.go
+++ b/contrib.go
@@ -14,6 +14,7 @@
"strings"
"v.io/jiri/collect"
+ "v.io/jiri/jiri"
"v.io/jiri/project"
"v.io/jiri/tool"
"v.io/x/lib/cmdline"
@@ -36,7 +37,7 @@
// cmdContributors represents the "jiri contributors" command.
var cmdContributors = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runContributors),
+ Runner: jiri.RunnerFunc(runContributors),
Name: "contributors",
Short: "List project contributors",
Long: `
@@ -90,16 +91,16 @@
return canonicalEmail, canonicalName
}
-func loadAliases(ctx *tool.Context) (*aliasMaps, error) {
+func loadAliases(jirix *jiri.X) (*aliasMaps, error) {
aliasesFile := aliasesFlag
if aliasesFile == "" {
- dataDir, err := project.DataDirPath(ctx, tool.Name)
+ dataDir, err := project.DataDirPath(jirix, tool.Name)
if err != nil {
return nil, err
}
aliasesFile = filepath.Join(dataDir, aliasesFileName)
}
- bytes, err := ctx.Run().ReadFile(aliasesFile)
+ bytes, err := jirix.Run().ReadFile(aliasesFile)
if err != nil {
return nil, err
}
@@ -124,10 +125,8 @@
return aliases, nil
}
-func runContributors(env *cmdline.Env, args []string) error {
- ctx := tool.NewContextFromEnv(env)
-
- projects, err := project.LocalProjects(ctx, project.FastScan)
+func runContributors(jirix *jiri.X, args []string) error {
+ projects, err := project.LocalProjects(jirix, project.FastScan)
if err != nil {
return err
}
@@ -140,7 +139,7 @@
}
}
- aliases, err := loadAliases(ctx)
+ aliases, err := loadAliases(jirix)
if err != nil {
return err
}
@@ -150,12 +149,12 @@
if !ok {
continue
}
- if err := ctx.Run().Chdir(project.Path); err != nil {
+ if err := jirix.Run().Chdir(project.Path); err != nil {
return err
}
switch project.Protocol {
case "git":
- lines, err := listCommitters(ctx)
+ lines, err := listCommitters(jirix)
if err != nil {
return err
}
@@ -193,28 +192,28 @@
for _, name := range names {
c := contributors[name]
if countFlag {
- fmt.Fprintf(env.Stdout, "%4d ", c.count)
+ fmt.Fprintf(jirix.Stdout(), "%4d ", c.count)
}
- fmt.Fprintf(env.Stdout, "%v <%v>\n", c.name, c.email)
+ fmt.Fprintf(jirix.Stdout(), "%v <%v>\n", c.name, c.email)
}
return nil
}
-func listCommitters(ctx *tool.Context) (_ []string, e error) {
- branch, err := ctx.Git().CurrentBranchName()
+func listCommitters(jirix *jiri.X) (_ []string, e error) {
+ branch, err := jirix.Git().CurrentBranchName()
if err != nil {
return nil, err
}
- stashed, err := ctx.Git().Stash()
+ stashed, err := jirix.Git().Stash()
if err != nil {
return nil, err
}
if stashed {
- defer collect.Error(func() error { return ctx.Git().StashPop() }, &e)
+ defer collect.Error(func() error { return jirix.Git().StashPop() }, &e)
}
- if err := ctx.Git().CheckoutBranch("master"); err != nil {
+ if err := jirix.Git().CheckoutBranch("master"); err != nil {
return nil, err
}
- defer collect.Error(func() error { return ctx.Git().CheckoutBranch(branch) }, &e)
- return ctx.Git().Committers()
+ defer collect.Error(func() error { return jirix.Git().CheckoutBranch(branch) }, &e)
+ return jirix.Git().Committers()
}
diff --git a/doc.go b/doc.go
index 3940c48..b41ea96 100644
--- a/doc.go
+++ b/doc.go
@@ -18,7 +18,6 @@
rebuild Rebuild all jiri tools
snapshot Manage project snapshots
update Update all jiri tools and projects
- version Print version
help Display help for commands or topics
The jiri additional help topics are:
@@ -339,13 +338,6 @@
-manifest=
Name of the project manifest.
-Jiri version - Print version
-
-Print version of the jiri tool.
-
-Usage:
- jiri version
-
Jiri help - Display help for commands or topics
Help with no args displays the usage of the parent command.
diff --git a/jiri/jiritest/x.go b/jiri/jiritest/x.go
new file mode 100644
index 0000000..3f680b6
--- /dev/null
+++ b/jiri/jiritest/x.go
@@ -0,0 +1,32 @@
+// 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 jiritest provides utilities for testing jiri functionality.
+package jiritest
+
+import (
+ "os"
+ "testing"
+
+ "v.io/jiri/jiri"
+ "v.io/jiri/tool"
+)
+
+// NewX is similar to jiri.NewX, but is meant for usage in a testing environment.
+func NewX(t *testing.T) (*jiri.X, func()) {
+ ctx := tool.NewDefaultContext()
+ root, err := ctx.NewSeq().TempDir("", "")
+ if err != nil {
+ t.Fatalf("TempDir() failed: %v", err)
+ }
+ oldEnv := os.Getenv("JIRI_ROOT")
+ if err := os.Setenv("JIRI_ROOT", root); err != nil {
+ t.Fatalf("Setenv(JIRI_ROOT) failed: %v", err)
+ }
+ cleanup := func() {
+ os.Setenv("JIRI_ROOT", oldEnv)
+ ctx.NewSeq().RemoveAll(root).Done()
+ }
+ return &jiri.X{Context: ctx, Root: root}, cleanup
+}
diff --git a/jiri/x.go b/jiri/x.go
new file mode 100644
index 0000000..5b5e0c9
--- /dev/null
+++ b/jiri/x.go
@@ -0,0 +1,104 @@
+// 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 jiri provides utilities used by the jiri tool and related tools.
+package jiri
+
+// TODO(toddw): Rename this package to v.io/jiri, and rename the tool itself to
+// v.io/jiri/cmd/jiri
+
+import (
+ "fmt"
+ "os"
+ "path/filepath"
+
+ "v.io/jiri/tool"
+ "v.io/x/lib/cmdline"
+)
+
+const (
+ rootEnv = "JIRI_ROOT"
+)
+
+// X holds the execution environment for the jiri tool and related tools. This
+// includes the jiri filesystem root directory.
+//
+// TODO(toddw): The Root is not currently used; we still use project.JiriRoot
+// everywhere. Transition those uses gradually over to use this instead.
+//
+// TODO(toddw): Other jiri state should be transitioned to this struct,
+// including the manifest and related operations.
+type X struct {
+ *tool.Context
+ Root string
+ Usage func(format string, args ...interface{}) error
+}
+
+// NewX returns a new execution environment, given a cmdline env.
+func NewX(env *cmdline.Env) (*X, error) {
+ ctx := tool.NewContextFromEnv(env)
+ root, err := findJiriRoot(ctx)
+ if err != nil {
+ return nil, err
+ }
+ return &X{
+ Context: ctx,
+ Root: root,
+ Usage: env.UsageErrorf,
+ }, nil
+}
+
+func findJiriRoot(ctx *tool.Context) (string, error) {
+ ctx.TimerPush("find JIRI_ROOT")
+ defer ctx.TimerPop()
+ if root := os.Getenv(rootEnv); root != "" {
+ // Always use JIRI_ROOT if it's set.
+ result, err := filepath.EvalSymlinks(root)
+ if err != nil {
+ return "", fmt.Errorf("%v EvalSymlinks(%v) failed: %v", rootEnv, root, err)
+ }
+ if !filepath.IsAbs(result) {
+ return "", fmt.Errorf("%v isn't an absolute path: %v", rootEnv, result)
+ }
+ return filepath.Clean(result), nil
+ }
+ // TODO(toddw): Try to find the root by walking up the filesystem.
+ return "", fmt.Errorf("%v is not set", rootEnv)
+}
+
+// Clone returns a clone of the environment.
+func (x *X) Clone(opts tool.ContextOpts) *X {
+ return &X{
+ Context: x.Context.Clone(opts),
+ Root: x.Root,
+ Usage: x.Usage,
+ }
+}
+
+// UsageErrorf prints the error message represented by the printf-style format
+// and args, followed by the usage output. The implementation typically calls
+// cmdline.Env.UsageErrorf.
+func (x *X) UsageErrorf(format string, args ...interface{}) error {
+ if x.Usage != nil {
+ return x.Usage(format, args...)
+ }
+ return nil
+}
+
+// RunnerFunc is an adapter that turns regular functions into cmdline.Runner.
+// This is similar to cmdline.RunnerFunc, but the first function argument is
+// jiri.X, rather than cmdline.Env.
+func RunnerFunc(run func(*X, []string) error) cmdline.Runner {
+ return runner(run)
+}
+
+type runner func(*X, []string) error
+
+func (r runner) Run(env *cmdline.Env, args []string) error {
+ x, err := NewX(env)
+ if err != nil {
+ return err
+ }
+ return r(x, args)
+}
diff --git a/profiles/commandline/driver.go b/profiles/commandline/driver.go
index 6fa89ef..44f2c87 100644
--- a/profiles/commandline/driver.go
+++ b/profiles/commandline/driver.go
@@ -16,6 +16,7 @@
"strings"
"text/template"
+ "v.io/jiri/jiri"
"v.io/jiri/profiles"
"v.io/jiri/project"
"v.io/jiri/tool"
@@ -45,7 +46,7 @@
// cmdInstall represents the "profile install" command.
var cmdInstall = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runInstall),
+ Runner: jiri.RunnerFunc(runInstall),
Name: "install",
Short: "Install the given profiles",
Long: "Install the given profiles.",
@@ -55,7 +56,7 @@
// cmdList represents the "profile list" command.
var cmdList = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runList),
+ Runner: jiri.RunnerFunc(runList),
Name: "list",
Short: "List available or installed profiles",
Long: "List available or installed profiles.",
@@ -65,7 +66,7 @@
// cmdEnv represents the "profile env" command.
var cmdEnv = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runEnv),
+ Runner: jiri.RunnerFunc(runEnv),
Name: "env",
Short: "Display profile environment variables",
Long: `
@@ -83,7 +84,7 @@
// cmdUpdate represents the "profile update" command.
var cmdUpdate = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runUpdate),
+ Runner: jiri.RunnerFunc(runUpdate),
Name: "update",
Short: "Install the latest default version of the given profiles",
Long: "Install the latest default version of the given profiles.",
@@ -93,7 +94,7 @@
// cmdCleanup represents the "profile Cleanup" command.
var cmdCleanup = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runCleanup),
+ Runner: jiri.RunnerFunc(runCleanup),
Name: "cleanup",
Short: "Cleanup the locally installed profiles",
Long: "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.",
@@ -103,7 +104,7 @@
// cmdUninstall represents the "profile uninstall" command.
var cmdUninstall = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runUninstall),
+ Runner: jiri.RunnerFunc(runUninstall),
Name: "uninstall",
Short: "Uninstall the given profiles",
Long: "Uninstall the given profiles.",
@@ -201,33 +202,32 @@
cmdCleanup.Flags.BoolVar(&rewriteManifestFlag, "rewrite-profiles-manifest", false, "rewrite the profiles manifest file to use the latest schema version")
}
-func runList(env *cmdline.Env, args []string) error {
- ctx := tool.NewContextFromEnv(env)
+func runList(jirix *jiri.X, args []string) error {
if showManifestFlag {
- data, err := ctx.Run().ReadFile(manifestFlag)
+ data, err := jirix.Run().ReadFile(manifestFlag)
if err != nil {
return err
}
- fmt.Fprintln(ctx.Stdout(), string(data))
+ fmt.Fprintln(jirix.Stdout(), string(data))
return nil
}
if verboseFlag {
- fmt.Fprintf(ctx.Stdout(), "Manifest: %s\n", manifestFlag)
+ fmt.Fprintf(jirix.Stdout(), "Manifest: %s\n", manifestFlag)
}
if availableFlag {
if verboseFlag {
- fmt.Fprintf(ctx.Stdout(), "Available Profiles:\n")
+ fmt.Fprintf(jirix.Stdout(), "Available Profiles:\n")
for _, name := range profiles.Managers() {
mgr := profiles.LookupManager(name)
vi := mgr.VersionInfo()
- fmt.Fprintf(ctx.Stdout(), "%s: versions: %s\n", name, vi)
+ fmt.Fprintf(jirix.Stdout(), "%s: versions: %s\n", name, vi)
}
} else {
- fmt.Fprintf(ctx.Stdout(), "%s\n", strings.Join(profiles.Managers(), ", "))
+ fmt.Fprintf(jirix.Stdout(), "%s\n", strings.Join(profiles.Managers(), ", "))
}
}
- if err := profiles.Read(ctx, manifestFlag); err != nil {
- fmt.Fprintf(ctx.Stderr(), "Failed to read manifest: %v", err)
+ if err := profiles.Read(jirix, manifestFlag); err != nil {
+ fmt.Fprintf(jirix.Stderr(), "Failed to read manifest: %v", err)
return err
}
profileNames := args
@@ -241,13 +241,13 @@
}
}
if verboseFlag {
- fmt.Fprintf(ctx.Stdout(), "Installed Profiles: ")
- fmt.Fprintf(ctx.Stdout(), "%s\n", strings.Join(profiles.Profiles(), ", "))
+ fmt.Fprintf(jirix.Stdout(), "Installed Profiles: ")
+ fmt.Fprintf(jirix.Stdout(), "%s\n", strings.Join(profiles.Profiles(), ", "))
for _, name := range availableNames {
profile := profiles.LookupProfile(name)
- fmt.Fprintf(ctx.Stdout(), "Profile: %s @ %s\n", profile.Name, profile.Root)
+ fmt.Fprintf(jirix.Stdout(), "Profile: %s @ %s\n", profile.Name, profile.Root)
for _, target := range profile.Targets() {
- fmt.Fprintf(ctx.Stdout(), "\t%s\n", target.DebugString())
+ fmt.Fprintf(jirix.Stdout(), "\t%s\n", target.DebugString())
}
}
} else {
@@ -267,7 +267,7 @@
out.WriteString(fmtHeader(name, target))
out.WriteString(" ")
}
- r, err := fmtInfo(ctx, mgr, profile, target)
+ r, err := fmtInfo(jirix, mgr, profile, target)
if err != nil {
return err
}
@@ -276,7 +276,7 @@
out.WriteString("\n")
}
}
- fmt.Fprint(ctx.Stdout(), out.String())
+ fmt.Fprint(jirix.Stdout(), out.String())
}
}
return nil
@@ -322,7 +322,7 @@
Note: if no profiles are specified then the requested field will be displayed for all profiles.`
}
-func fmtOutput(ctx *tool.Context, o string) string {
+func fmtOutput(jirix *jiri.X, o string) string {
_, width, err := textutil.TerminalSize()
if err != nil {
width = 80
@@ -345,7 +345,7 @@
return root.RootJoin(s).Expand()
}
-func fmtInfo(ctx *tool.Context, mgr profiles.Manager, profile *profiles.Profile, target *profiles.Target) (string, error) {
+func fmtInfo(jirix *jiri.X, mgr profiles.Manager, profile *profiles.Profile, target *profiles.Target) (string, error) {
if len(infoFlag) > 0 {
// Populate an instance listInfo
info := &listInfo{}
@@ -353,7 +353,7 @@
if mgr != nil {
// Format the description on its own, without any preceeding
// text so that the line breaks work correctly.
- info.Profile.Description = "\n" + fmtOutput(ctx, mgr.Info()) + "\n"
+ info.Profile.Description = "\n" + fmtOutput(jirix, mgr.Info()) + "\n"
vi := mgr.VersionInfo()
if supported := vi.Supported(); len(supported) > 0 {
info.Profile.Versions = supported
@@ -391,12 +391,11 @@
return "", nil
}
-func runEnv(env *cmdline.Env, args []string) error {
+func runEnv(jirix *jiri.X, args []string) error {
if len(profilesFlag) == 0 {
return fmt.Errorf("no profiles were specified using --profiles")
}
- ctx := tool.NewContextFromEnv(env)
- ch, err := profiles.NewConfigHelper(ctx, profiles.UseProfiles, manifestFlag)
+ ch, err := profiles.NewConfigHelper(jirix, profiles.UseProfiles, manifestFlag)
if err != nil {
return err
}
@@ -407,7 +406,7 @@
ch.MergeEnvFromProfiles(mergePoliciesFlag, targetFlag, profileNames...)
out := fmtVars(ch.ToMap(), args)
if len(out) > 0 {
- fmt.Fprintln(ctx.Stdout(), out)
+ fmt.Fprintln(jirix.Stdout(), out)
}
return nil
}
@@ -439,7 +438,7 @@
return strings.TrimSuffix(buf.String(), " ")
}
-func initCommand(ctx *tool.Context, args []string) error {
+func initCommand(jirix *jiri.X, args []string) error {
if len(args) == 0 {
return fmt.Errorf("no profiles specified")
}
@@ -448,19 +447,18 @@
return fmt.Errorf("profile %v is not available, use \"list --available\" to see the list of available profiles", n)
}
}
- if err := profiles.Read(ctx, manifestFlag); err != nil {
- fmt.Fprintf(ctx.Stderr(), "Failed to read manifest: %v", err)
+ if err := profiles.Read(jirix, manifestFlag); err != nil {
+ fmt.Fprintf(jirix.Stderr(), "Failed to read manifest: %v", err)
return err
}
return nil
}
-func runUpdate(env *cmdline.Env, args []string) error {
- ctx := tool.NewContextFromEnv(env)
+func runUpdate(jirix *jiri.X, args []string) error {
if len(args) == 0 {
args = profiles.Managers()
}
- if err := initCommand(ctx, args); err != nil {
+ if err := initCommand(jirix, args); err != nil {
return err
}
for _, n := range args {
@@ -473,34 +471,34 @@
for _, target := range profile.Targets() {
if vi.IsTargetOlderThanDefault(target.Version()) {
if verboseFlag {
- fmt.Fprintf(ctx.Stdout(), "Updating %s %s from %q to %s\n", n, target, target.Version(), vi)
+ fmt.Fprintf(jirix.Stdout(), "Updating %s %s from %q to %s\n", n, target, target.Version(), vi)
}
target.SetVersion(vi.Default())
- err := mgr.Install(ctx, rootPath, *target)
- logResult(ctx, "Update", mgr, *target, err)
+ err := mgr.Install(jirix, rootPath, *target)
+ logResult(jirix, "Update", mgr, *target, err)
if err != nil {
return err
}
} else {
if verboseFlag {
- fmt.Fprintf(ctx.Stdout(), "%s %s at %q is up to date(%s)\n", n, target, target.Version(), vi)
+ fmt.Fprintf(jirix.Stdout(), "%s %s at %q is up to date(%s)\n", n, target, target.Version(), vi)
}
}
}
}
- return profiles.Write(ctx, manifestFlag)
+ return profiles.Write(jirix, manifestFlag)
}
-func runGC(ctx *tool.Context, args []string) error {
+func runGC(jirix *jiri.X, args []string) error {
for _, n := range args {
mgr := profiles.LookupManager(n)
vi := mgr.VersionInfo()
profile := profiles.LookupProfile(n)
for _, target := range profile.Targets() {
if vi.IsTargetOlderThanDefault(target.Version()) {
- err := mgr.Uninstall(ctx, rootPath, *target)
- logResult(ctx, "gc", mgr, *target, err)
+ err := mgr.Uninstall(jirix, rootPath, *target)
+ logResult(jirix, "gc", mgr, *target, err)
if err != nil {
return err
}
@@ -510,12 +508,12 @@
return nil
}
-func runEnsureVersionsAreSet(ctx *tool.Context, args []string) error {
+func runEnsureVersionsAreSet(jirix *jiri.X, args []string) error {
for _, name := range args {
profile := profiles.LookupProfile(name)
mgr := profiles.LookupManager(name)
if mgr == nil {
- fmt.Fprintf(ctx.Stderr(), "%s is not linked into this binary", name)
+ fmt.Fprintf(jirix.Stderr(), "%s is not linked into this binary", name)
continue
}
for _, target := range profile.Targets() {
@@ -531,7 +529,7 @@
return err
}
if verboseFlag {
- fmt.Fprintf(ctx.Stdout(), "%s %s had no version, now set to: %s\n", name, prior, target)
+ fmt.Fprintf(jirix.Stdout(), "%s %s had no version, now set to: %s\n", name, prior, target)
}
}
}
@@ -539,8 +537,8 @@
return nil
}
-func runRmAll(ctx *tool.Context) error {
- s := ctx.NewSeq()
+func runRmAll(jirix *jiri.X) error {
+ s := jirix.NewSeq()
if exists, err := s.FileExists(manifestFlag); err != nil || exists {
if err := s.Remove(manifestFlag).Done(); err != nil {
return err
@@ -556,10 +554,9 @@
return nil
}
-func runCleanup(env *cmdline.Env, args []string) error {
- ctx := tool.NewContextFromEnv(env)
- if err := profiles.Read(ctx, manifestFlag); err != nil {
- fmt.Fprintf(ctx.Stderr(), "Failed to read manifest: %v", err)
+func runCleanup(jirix *jiri.X, args []string) error {
+ if err := profiles.Read(jirix, manifestFlag); err != nil {
+ fmt.Fprintf(jirix.Stderr(), "Failed to read manifest: %v", err)
return err
}
if len(args) == 0 {
@@ -568,27 +565,27 @@
dirty := false
if specificVersionsFlag {
if verboseFlag {
- fmt.Fprintf(ctx.Stdout(), "Ensuring that all targets have a specific version set for %s\n", args)
+ fmt.Fprintf(jirix.Stdout(), "Ensuring that all targets have a specific version set for %s\n", args)
}
- if err := runEnsureVersionsAreSet(ctx, args); err != nil {
+ if err := runEnsureVersionsAreSet(jirix, args); err != nil {
return fmt.Errorf("ensure-specific-versions-are-set: %v", err)
}
dirty = true
}
if cleanupFlag {
if verboseFlag {
- fmt.Fprintf(ctx.Stdout(), "Removing targets older than the default version for %s\n", args)
+ fmt.Fprintf(jirix.Stdout(), "Removing targets older than the default version for %s\n", args)
}
- if err := runGC(ctx, args); err != nil {
+ if err := runGC(jirix, args); err != nil {
return fmt.Errorf("gc: %v", err)
}
dirty = true
}
if rmAllFlag {
if verboseFlag {
- fmt.Fprintf(ctx.Stdout(), "Removing profile manifest and all profile output files\n")
+ fmt.Fprintf(jirix.Stdout(), "Removing profile manifest and all profile output files\n")
}
- if err := runRmAll(ctx); err != nil {
+ if err := runRmAll(jirix); err != nil {
return err
}
// Don't write out the profiles manifest file again.
@@ -600,19 +597,19 @@
if !dirty {
return fmt.Errorf("at least one option must be specified")
}
- return profiles.Write(ctx, manifestFlag)
+ return profiles.Write(jirix, manifestFlag)
}
-func logResult(ctx *tool.Context, action string, mgr profiles.Manager, target profiles.Target, err error) {
- fmt.Fprintf(ctx.Stdout(), "%s: %s %s: ", action, mgr.Name(), target)
+func logResult(jirix *jiri.X, action string, mgr profiles.Manager, target profiles.Target, err error) {
+ fmt.Fprintf(jirix.Stdout(), "%s: %s %s: ", action, mgr.Name(), target)
if err == nil {
- fmt.Fprintf(ctx.Stdout(), "success\n")
+ fmt.Fprintf(jirix.Stdout(), "success\n")
} else {
- fmt.Fprintf(ctx.Stdout(), "%v\n", err)
+ fmt.Fprintf(jirix.Stdout(), "%v\n", err)
}
}
-func applyCommand(names []string, env *cmdline.Env, ctx *tool.Context, target profiles.Target, fn func(profiles.Manager, *tool.Context, profiles.Target) error) error {
+func applyCommand(names []string, jirix *jiri.X, target profiles.Target, fn func(profiles.Manager, *jiri.X, profiles.Target) error) error {
for _, n := range names {
mgr := profiles.LookupManager(n)
version, err := mgr.VersionInfo().Select(target.Version())
@@ -620,16 +617,15 @@
return err
}
target.SetVersion(version)
- if err := fn(mgr, ctx, target); err != nil {
+ if err := fn(mgr, jirix, target); err != nil {
return err
}
}
return nil
}
-func runInstall(env *cmdline.Env, args []string) error {
- ctx := tool.NewContextFromEnv(env)
- if err := initCommand(ctx, args); err != nil {
+func runInstall(jirix *jiri.X, args []string) error {
+ if err := initCommand(jirix, args); err != nil {
return err
}
names := []string{}
@@ -641,29 +637,28 @@
targetFlag.UseCommandLineEnv()
for _, name := range args {
if p := profiles.LookupProfileTarget(name, targetFlag); p != nil {
- fmt.Fprintf(ctx.Stdout(), "%v %v is already installed as %v\n", name, targetFlag, p)
+ fmt.Fprintf(jirix.Stdout(), "%v %v is already installed as %v\n", name, targetFlag, p)
continue
}
names = append(names, name)
}
- if err := applyCommand(names, env, ctx, targetFlag,
- func(mgr profiles.Manager, ctx *tool.Context, target profiles.Target) error {
- err := mgr.Install(ctx, rootPath, target)
- logResult(ctx, "Install:", mgr, target, err)
+ if err := applyCommand(names, jirix, targetFlag,
+ func(mgr profiles.Manager, jirix *jiri.X, target profiles.Target) error {
+ err := mgr.Install(jirix, rootPath, target)
+ logResult(jirix, "Install:", mgr, target, err)
return err
}); err != nil {
return err
}
- return profiles.Write(ctx, manifestFlag)
+ return profiles.Write(jirix, manifestFlag)
}
-func runUninstall(env *cmdline.Env, args []string) error {
- ctx := tool.NewContextFromEnv(env)
- if err := initCommand(ctx, args); err != nil {
+func runUninstall(jirix *jiri.X, args []string) error {
+ if err := initCommand(jirix, args); err != nil {
return err
}
if allFlag && targetFlag.IsSet() {
- fmt.Fprintf(ctx.Stdout(), "ignore target (%v) when used in conjunction with --all-targets\n", targetFlag)
+ fmt.Fprintf(jirix.Stdout(), "ignore target (%v) when used in conjunction with --all-targets\n", targetFlag)
}
if allFlag {
for _, name := range args {
@@ -673,20 +668,20 @@
continue
}
for _, target := range profile.Targets() {
- if err := mgr.Uninstall(ctx, rootPath, *target); err != nil {
- logResult(ctx, "Uninstall", mgr, *target, err)
+ if err := mgr.Uninstall(jirix, rootPath, *target); err != nil {
+ logResult(jirix, "Uninstall", mgr, *target, err)
return err
}
- logResult(ctx, "Uninstall", mgr, *target, nil)
+ logResult(jirix, "Uninstall", mgr, *target, nil)
}
}
} else {
- applyCommand(args, env, ctx, targetFlag,
- func(mgr profiles.Manager, ctx *tool.Context, target profiles.Target) error {
- err := mgr.Uninstall(ctx, rootPath, target)
- logResult(ctx, "Uninstall", mgr, target, err)
+ applyCommand(args, jirix, targetFlag,
+ func(mgr profiles.Manager, jirix *jiri.X, target profiles.Target) error {
+ err := mgr.Uninstall(jirix, rootPath, target)
+ logResult(jirix, "Uninstall", mgr, target, err)
return err
})
}
- return profiles.Write(ctx, manifestFlag)
+ return profiles.Write(jirix, manifestFlag)
}
diff --git a/profiles/env.go b/profiles/env.go
index 752d7b6..4f34cf8 100644
--- a/profiles/env.go
+++ b/profiles/env.go
@@ -13,8 +13,8 @@
"strconv"
"strings"
+ "v.io/jiri/jiri"
"v.io/jiri/project"
- "v.io/jiri/tool"
"v.io/jiri/util"
"v.io/x/lib/envvar"
)
@@ -100,7 +100,7 @@
*envvar.Vars
profilesMode bool
root string
- ctx *tool.Context
+ jirix *jiri.X
config *util.Config
projects project.Projects
tools project.Tools
@@ -110,26 +110,26 @@
// length then that file will be read as a profiles manifest file, if not, the
// existing, if any, in-memory profiles information will be used. If SkipProfiles
// is specified for profilesMode, then no profiles are used.
-func NewConfigHelper(ctx *tool.Context, profilesMode ProfilesMode, filename string) (*ConfigHelper, error) {
+func NewConfigHelper(jirix *jiri.X, profilesMode ProfilesMode, filename string) (*ConfigHelper, error) {
root, err := project.JiriRoot()
if err != nil {
return nil, err
}
- config, err := util.LoadConfig(ctx)
+ config, err := util.LoadConfig(jirix)
if err != nil {
return nil, err
}
- projects, tools, err := project.ReadManifest(ctx)
+ projects, tools, err := project.ReadManifest(jirix)
if err != nil {
return nil, err
}
if profilesMode == UseProfiles && len(filename) > 0 {
- if err := Read(ctx, filename); err != nil {
+ if err := Read(jirix, filename); err != nil {
return nil, err
}
}
ch := &ConfigHelper{
- ctx: ctx,
+ jirix: jirix,
root: root,
config: config,
projects: projects,
@@ -223,19 +223,19 @@
// GoPath computes and returns the GOPATH environment variable based on the
// current jiri configuration.
func (ch *ConfigHelper) GoPath() string {
- path := pathHelper(ch.ctx, ch.root, ch.projects, ch.config.GoWorkspaces(), "")
+ path := pathHelper(ch.jirix, ch.root, ch.projects, ch.config.GoWorkspaces(), "")
return "GOPATH=" + envvar.JoinTokens(path, ":")
}
// VDLPath computes and returns the VDLPATH environment variable based on the
// current jiri configuration.
func (ch *ConfigHelper) VDLPath() string {
- path := pathHelper(ch.ctx, ch.root, ch.projects, ch.config.VDLWorkspaces(), "src")
+ path := pathHelper(ch.jirix, ch.root, ch.projects, ch.config.VDLWorkspaces(), "src")
return "VDLPATH=" + envvar.JoinTokens(path, ":")
}
// pathHelper is a utility function for determining paths for project workspaces.
-func pathHelper(ctx *tool.Context, root string, projects project.Projects, workspaces []string, suffix string) []string {
+func pathHelper(jirix *jiri.X, root string, projects project.Projects, workspaces []string, suffix string) []string {
path := []string{}
for _, workspace := range workspaces {
absWorkspace := filepath.Join(root, workspace, suffix)
@@ -250,7 +250,7 @@
// account for Go workspaces that span multiple jiri projects,
// such as: $JIRI_ROOT/release/go.
if strings.HasPrefix(absWorkspace, project.Path) || strings.HasPrefix(project.Path, absWorkspace) {
- if _, err := ctx.Run().Stat(filepath.Join(absWorkspace)); err == nil {
+ if _, err := jirix.Run().Stat(filepath.Join(absWorkspace)); err == nil {
path = append(path, absWorkspace)
break
}
diff --git a/profiles/env_test.go b/profiles/env_test.go
index f057c3c..e0c3423 100644
--- a/profiles/env_test.go
+++ b/profiles/env_test.go
@@ -13,6 +13,7 @@
"sort"
"testing"
+ "v.io/jiri/jiri"
"v.io/jiri/profiles"
"v.io/jiri/project"
"v.io/jiri/tool"
@@ -21,12 +22,12 @@
)
func TestConfigHelper(t *testing.T) {
- ctx := tool.NewDefaultContext()
root, err := project.JiriRoot()
if err != nil {
t.Fatal(err)
}
- ch, err := profiles.NewConfigHelper(ctx, profiles.UseProfiles, filepath.Join(root, "release/go/src/v.io/jiri/profiles/testdata/m2.xml"))
+ jirix := &jiri.X{Context: tool.NewDefaultContext(), Root: root}
+ ch, err := profiles.NewConfigHelper(jirix, profiles.UseProfiles, filepath.Join(root, "release/go/src/v.io/jiri/profiles/testdata/m2.xml"))
if err != nil {
t.Fatal(err)
}
@@ -44,8 +45,11 @@
func TestEnvFromTarget(t *testing.T) {
profiles.Clear()
- root, _ := project.JiriRoot()
- ctx := tool.NewDefaultContext()
+ root, err := project.JiriRoot()
+ if err != nil {
+ t.Fatal(err)
+ }
+ jirix := &jiri.X{Context: tool.NewDefaultContext(), Root: root}
profiles.InstallProfile("a", "root")
profiles.InstallProfile("b", "root")
t1, t2 := &profiles.Target{}, &profiles.Target{}
@@ -60,11 +64,11 @@
t.Fatal(err)
}
filename := filepath.Join(root, "release", "go", "src", "v.io", "jiri", "profiles", tmpdir, "manifest")
- if err := profiles.Write(ctx, filename); err != nil {
+ if err := profiles.Write(jirix, filename); err != nil {
t.Fatal(err)
}
defer os.RemoveAll(tmpdir)
- ch, err := profiles.NewConfigHelper(ctx, profiles.UseProfiles, filename)
+ ch, err := profiles.NewConfigHelper(jirix, profiles.UseProfiles, filename)
if err != nil {
t.Fatal(err)
}
@@ -145,31 +149,29 @@
func testSetPathHelper(t *testing.T, name string) {
profiles.Clear()
- ctx := tool.NewDefaultContext()
-
// Setup a fake JIRI_ROOT.
- root, err := project.NewFakeJiriRoot(ctx)
+ root, err := project.NewFakeJiriRoot()
if err != nil {
t.Fatalf("%v", err)
}
defer func() {
- if err := root.Cleanup(ctx); err != nil {
+ if err := root.Cleanup(); err != nil {
t.Fatalf("%v", err)
}
}()
// Create a test project and identify it as a Go workspace.
- if err := root.CreateRemoteProject(ctx, "test"); err != nil {
+ if err := root.CreateRemoteProject("test"); err != nil {
t.Fatalf("%v", err)
}
- if err := root.AddProject(ctx, project.Project{
+ if err := root.AddProject(project.Project{
Name: "test",
Path: "test",
Remote: root.Projects["test"],
}); err != nil {
t.Fatalf("%v", err)
}
- if err := root.UpdateUniverse(ctx, false); err != nil {
+ if err := root.UpdateUniverse(false); err != nil {
t.Fatalf("%v", err)
}
var config *util.Config
@@ -186,11 +188,11 @@
}
defer os.Setenv("JIRI_ROOT", oldRoot)
- if err := profiles.Write(ctx, filepath.Join(root.Dir, "profiles-manifest")); err != nil {
+ if err := profiles.Write(root.X, filepath.Join(root.Dir, "profiles-manifest")); err != nil {
t.Fatal(err)
}
- if err := util.SaveConfig(ctx, config); err != nil {
+ if err := util.SaveConfig(root.X, config); err != nil {
t.Fatalf("%v", err)
}
@@ -200,7 +202,7 @@
t.Fatalf("%v", err)
}
- ch, err := profiles.NewConfigHelper(ctx, profiles.UseProfiles, filepath.Join(jiriRoot, "profiles-manifest"))
+ ch, err := profiles.NewConfigHelper(root.X, profiles.UseProfiles, filepath.Join(jiriRoot, "profiles-manifest"))
if err != nil {
t.Fatal(err)
}
@@ -213,7 +215,7 @@
case "VDLPATH":
// Make a fake src directory.
want = filepath.Join(jiriRoot, "test", "src")
- if err := ctx.Run().MkdirAll(want, 0755); err != nil {
+ if err := root.X.Run().MkdirAll(want, 0755); err != nil {
t.Fatalf("%v", err)
}
want = "VDLPATH=" + want
diff --git a/profiles/manager.go b/profiles/manager.go
index 4f60cfb..65635ed 100644
--- a/profiles/manager.go
+++ b/profiles/manager.go
@@ -41,7 +41,7 @@
"strings"
"sync"
- "v.io/jiri/tool"
+ "v.io/jiri/jiri"
"v.io/x/lib/envvar"
)
@@ -177,9 +177,9 @@
// is its name and version.
String() string
// Install installs the profile for the specified build target.
- Install(ctx *tool.Context, root RelativePath, target Target) error
+ Install(jirix *jiri.X, root RelativePath, target Target) error
// Uninstall uninstalls the profile for the specified build target. When
// the last target for any given profile is uninstalled, then the profile
// itself (i.e. the source code) will be uninstalled.
- Uninstall(ctx *tool.Context, root RelativePath, target Target) error
+ Uninstall(jirix *jiri.X, root RelativePath, target Target) error
}
diff --git a/profiles/manager_test.go b/profiles/manager_test.go
index 5e83747..b613330 100644
--- a/profiles/manager_test.go
+++ b/profiles/manager_test.go
@@ -11,6 +11,7 @@
"path/filepath"
"testing"
+ "v.io/jiri/jiri"
"v.io/jiri/profiles"
"v.io/jiri/tool"
)
@@ -81,13 +82,13 @@
func (p *myNewProfile) AddFlags(*flag.FlagSet, profiles.Action) {
}
-func (p *myNewProfile) Install(ctx *tool.Context, root profiles.RelativePath, target profiles.Target) error {
+func (p *myNewProfile) Install(jirix *jiri.X, root profiles.RelativePath, target profiles.Target) error {
p.status = "installed"
profiles.AddProfileTarget(p.name, target)
return nil
}
-func (p *myNewProfile) Uninstall(ctx *tool.Context, root profiles.RelativePath, target profiles.Target) error {
+func (p *myNewProfile) Uninstall(jirix *jiri.X, root profiles.RelativePath, target profiles.Target) error {
profiles.RemoveProfileTarget(p.name, target)
if profiles.LookupProfile(p.name) == nil {
p.status = "uninstalled"
@@ -113,9 +114,9 @@
panic("manager not found for: " + myProfile)
}
- ctx := tool.NewDefaultContext()
+ jirix := &jiri.X{Context: tool.NewDefaultContext()}
// Install myNewProfile for target.
- if err := mgr.Install(ctx, rootPath, target); err != nil {
+ if err := mgr.Install(jirix, rootPath, target); err != nil {
panic("failed to find manager for: " + myProfile)
}
@@ -124,7 +125,7 @@
filename := tmpFile()
defer os.RemoveAll(filepath.Dir(filename))
- if err := profiles.Write(ctx, filename); err != nil {
+ if err := profiles.Write(jirix, filename); err != nil {
panic(err)
}
@@ -133,7 +134,7 @@
profiles.Clear()
// Read the profile manifest.
- profiles.Read(ctx, filename)
+ profiles.Read(jirix, filename)
mgr = profiles.LookupManager(myProfile)
if mgr == nil {
@@ -141,7 +142,7 @@
}
fmt.Println(mgr.String())
- mgr.Uninstall(ctx, rootPath, target)
+ mgr.Uninstall(jirix, rootPath, target)
fmt.Println(mgr.String())
fmt.Println(mgr.VersionInfo().Supported())
fmt.Println(mgr.VersionInfo().Default())
diff --git a/profiles/manifest.go b/profiles/manifest.go
index cb1c505..02395ab 100644
--- a/profiles/manifest.go
+++ b/profiles/manifest.go
@@ -12,7 +12,7 @@
"sync"
"time"
- "v.io/jiri/tool"
+ "v.io/jiri/jiri"
)
const (
@@ -145,14 +145,14 @@
// Read reads the specified manifest file to obtain the current set of
// installed profiles.
-func Read(ctx *tool.Context, filename string) error {
- return db.read(ctx, filename)
+func Read(jirix *jiri.X, filename string) error {
+ return db.read(jirix, filename)
}
// Write writes the current set of installed profiles to the specified manifest
// file.
-func Write(ctx *tool.Context, filename string) error {
- return db.write(ctx, filename)
+func Write(jirix *jiri.X, filename string) error {
+ return db.write(jirix, filename)
}
func (pdb *profileDB) installProfile(name, root string) {
@@ -237,15 +237,15 @@
return pdb.db[name]
}
-func (pdb *profileDB) read(ctx *tool.Context, filename string) error {
+func (pdb *profileDB) read(jirix *jiri.X, filename string) error {
pdb.Lock()
defer pdb.Unlock()
pdb.db = make(map[string]*Profile)
- data, err := ctx.Run().ReadFile(filename)
+ data, err := jirix.Run().ReadFile(filename)
if err != nil {
if os.IsNotExist(err) {
- fmt.Fprintf(ctx.Stderr(), "WARNING: %v doesn't exist\n", filename)
+ fmt.Fprintf(jirix.Stderr(), "WARNING: %v doesn't exist\n", filename)
return nil
}
return err
@@ -278,7 +278,7 @@
return nil
}
-func (pdb *profileDB) write(ctx *tool.Context, filename string) error {
+func (pdb *profileDB) write(jirix *jiri.X, filename string) error {
pdb.Lock()
defer pdb.Unlock()
@@ -318,17 +318,17 @@
oldName := filename + ".prev"
newName := filename + fmt.Sprintf(".%d", time.Now().UnixNano())
- if err := ctx.Run().WriteFile(newName, data, defaultFileMode); err != nil {
+ if err := jirix.Run().WriteFile(newName, data, defaultFileMode); err != nil {
return err
}
- if ctx.Run().FileExists(filename) {
- if err := ctx.Run().Rename(filename, oldName); err != nil {
+ if jirix.Run().FileExists(filename) {
+ if err := jirix.Run().Rename(filename, oldName); err != nil {
return err
}
}
- if err := ctx.Run().Rename(newName, filename); err != nil {
+ if err := jirix.Run().Rename(newName, filename); err != nil {
return err
}
diff --git a/profiles/manifest_test.go b/profiles/manifest_test.go
index aa6ef33..99a2a86 100644
--- a/profiles/manifest_test.go
+++ b/profiles/manifest_test.go
@@ -15,6 +15,7 @@
"strings"
"testing"
+ "v.io/jiri/jiri"
"v.io/jiri/profiles"
"v.io/jiri/project"
"v.io/jiri/tool"
@@ -55,21 +56,21 @@
profiles.Clear()
filename := tmpFile()
defer os.RemoveAll(filepath.Dir(filename))
- ctx := tool.NewDefaultContext()
+ jirix := &jiri.X{Context: tool.NewDefaultContext()}
// test for no version being set.
t1, _ := profiles.NewTargetWithEnv("cpu1-os1", "A=B,C=D")
if err := profiles.AddProfileTarget("b", t1); err != nil {
t.Fatal(err)
}
- if err := profiles.Write(ctx, filename); err == nil || !strings.HasPrefix(err.Error(), "missing version for profile") {
+ if err := profiles.Write(jirix, filename); err == nil || !strings.HasPrefix(err.Error(), "missing version for profile") {
t.Fatalf("was expecing a missing version error, but got %v", err)
}
profiles.RemoveProfileTarget("b", t1)
addProfileAndTargets(t, "b")
addProfileAndTargets(t, "a")
- if err := profiles.Write(ctx, filename); err != nil {
+ if err := profiles.Write(jirix, filename); err != nil {
t.Fatal(err)
}
@@ -82,8 +83,8 @@
func TestRead(t *testing.T) {
profiles.Clear()
- ctx := tool.NewDefaultContext()
- if err := profiles.Read(ctx, "./testdata/m1.xml"); err != nil {
+ jirix := &jiri.X{Context: tool.NewDefaultContext()}
+ if err := profiles.Read(jirix, "./testdata/m1.xml"); err != nil {
t.Fatal(err)
}
@@ -135,8 +136,8 @@
return db
}
- ctx := tool.NewDefaultContext()
- if err := profiles.Read(ctx, "./testdata/legacy.xml"); err != nil {
+ jirix := &jiri.X{Context: tool.NewDefaultContext()}
+ if err := profiles.Read(jirix, "./testdata/legacy.xml"); err != nil {
t.Fatal(err)
}
@@ -155,11 +156,11 @@
t1.Set("cpu-os@1")
profiles.AddProfileTarget("__first", t1)
- if err := profiles.Write(ctx, filename); err != nil {
+ if err := profiles.Write(jirix, filename); err != nil {
t.Fatal(err)
}
- if err := profiles.Read(ctx, filename); err != nil {
+ if err := profiles.Read(jirix, filename); err != nil {
t.Fatal(err)
}
@@ -191,11 +192,11 @@
}
func TestReadingV3AndV4(t *testing.T) {
- ctx := tool.NewDefaultContext()
root, err := project.JiriRoot()
if err != nil {
t.Fatal(err)
}
+ jirix := &jiri.X{Context: tool.NewDefaultContext(), Root: root}
for i, c := range []struct {
filename, prefix, variable string
version profiles.Version
@@ -203,7 +204,7 @@
{"v3.xml", "", "", profiles.V3},
{"v4.xml", root, "${JIRI_ROOT}", profiles.V4},
} {
- ch, err := profiles.NewConfigHelper(ctx, profiles.UseProfiles, filepath.Join("testdata", c.filename))
+ ch, err := profiles.NewConfigHelper(jirix, profiles.UseProfiles, filepath.Join("testdata", c.filename))
if err != nil {
t.Fatal(err)
}
diff --git a/profiles/util.go b/profiles/util.go
index f12d3c1..170f897 100644
--- a/profiles/util.go
+++ b/profiles/util.go
@@ -16,6 +16,7 @@
"runtime"
"strings"
+ "v.io/jiri/jiri"
"v.io/jiri/project"
"v.io/jiri/runutil"
"v.io/jiri/tool"
@@ -95,10 +96,10 @@
// are not successfully logged therein after deleting the entire contents of the
// dir parameter. Consequently it does not make sense to apply AtomicAction to
// the same directory in sequence.
-func AtomicAction(ctx *tool.Context, installFn func() error, dir, message string) error {
+func AtomicAction(jirix *jiri.X, installFn func() error, dir, message string) error {
atomicFn := func() error {
completionLogPath := filepath.Join(dir, ".complete")
- s := ctx.NewSeq()
+ s := jirix.NewSeq()
if dir != "" {
if exists, _ := s.DirectoryExists(dir); exists {
// If the dir exists but the completionLogPath doesn't, then it
@@ -107,8 +108,8 @@
if exists, _ := s.FileExists(completionLogPath); !exists {
s.RemoveAll(dir).Done()
} else {
- if ctx.Verbose() {
- fmt.Fprintf(ctx.Stdout(), "AtomicAction: %s already completed in %s\n", message, dir)
+ if jirix.Verbose() {
+ fmt.Fprintf(jirix.Stdout(), "AtomicAction: %s already completed in %s\n", message, dir)
}
return nil
}
@@ -122,14 +123,14 @@
}
return s.WriteFile(completionLogPath, []byte("completed"), DefaultFilePerm).Done()
}
- return ctx.NewSeq().Call(atomicFn, message).Done()
+ return jirix.NewSeq().Call(atomicFn, message).Done()
}
-func brewList(ctx *tool.Context) (map[string]bool, error) {
+func brewList(jirix *jiri.X) (map[string]bool, error) {
var out bytes.Buffer
- err := ctx.NewSeq().Capture(&out, &out).Last("brew", "list")
+ err := jirix.NewSeq().Capture(&out, &out).Last("brew", "list")
if err != nil || tool.VerboseFlag {
- fmt.Fprintf(ctx.Stdout(), "%s", out.String())
+ fmt.Fprintf(jirix.Stdout(), "%s", out.String())
}
scanner := bufio.NewScanner(&out)
pkgs := map[string]bool{}
@@ -141,14 +142,14 @@
// InstallPackages identifies the packages that need to be installed
// and installs them using the OS-specific package manager.
-func InstallPackages(ctx *tool.Context, pkgs []string) error {
+func InstallPackages(jirix *jiri.X, pkgs []string) error {
installDepsFn := func() error {
- s := ctx.NewSeq()
+ s := jirix.NewSeq()
switch runtime.GOOS {
case "linux":
if runutil.IsFNLHost() {
- fmt.Fprintf(ctx.Stdout(), "skipping installation of %v on FNL host", pkgs)
- fmt.Fprintf(ctx.Stdout(), "success\n")
+ fmt.Fprintf(jirix.Stdout(), "skipping installation of %v on FNL host", pkgs)
+ fmt.Fprintf(jirix.Stdout(), "success\n")
break
}
installPkgs := []string{}
@@ -159,16 +160,16 @@
}
if len(installPkgs) > 0 {
args := append([]string{"apt-get", "install", "-y"}, installPkgs...)
- fmt.Fprintf(ctx.Stdout(), "Running: sudo %s: ", strings.Join(args, " "))
+ fmt.Fprintf(jirix.Stdout(), "Running: sudo %s: ", strings.Join(args, " "))
if err := s.Last("sudo", args...); err != nil {
- fmt.Fprintf(ctx.Stdout(), "%v\n", err)
+ fmt.Fprintf(jirix.Stdout(), "%v\n", err)
return err
}
- fmt.Fprintf(ctx.Stdout(), "success\n")
+ fmt.Fprintf(jirix.Stdout(), "success\n")
}
case "darwin":
installPkgs := []string{}
- installedPkgs, err := brewList(ctx)
+ installedPkgs, err := brewList(jirix)
if err != nil {
return err
}
@@ -179,22 +180,22 @@
}
if len(installPkgs) > 0 {
args := append([]string{"install"}, installPkgs...)
- fmt.Fprintf(ctx.Stdout(), "Running: brew %s: ", strings.Join(args, " "))
+ fmt.Fprintf(jirix.Stdout(), "Running: brew %s: ", strings.Join(args, " "))
if err := s.Last("brew", args...); err != nil {
- fmt.Fprintf(ctx.Stdout(), "%v\n", err)
+ fmt.Fprintf(jirix.Stdout(), "%v\n", err)
return err
}
- fmt.Fprintf(ctx.Stdout(), "success\n")
+ fmt.Fprintf(jirix.Stdout(), "success\n")
}
}
return nil
}
- return ctx.NewSeq().Call(installDepsFn, "Install dependencies").Done()
+ return jirix.NewSeq().Call(installDepsFn, "Install dependencies").Done()
}
// ensureAction ensures that the requested profile and target
// is installed/uninstalled, installing/uninstalling it if only if necessary.
-func ensureAction(ctx *tool.Context, action Action, profile string, root RelativePath, target Target) error {
+func ensureAction(jirix *jiri.X, action Action, profile string, root RelativePath, target Target) error {
verb := ""
switch action {
case Install:
@@ -205,8 +206,8 @@
return fmt.Errorf("unrecognised action %v", action)
}
if t := LookupProfileTarget(profile, target); t != nil {
- if ctx.Verbose() {
- fmt.Fprintf(ctx.Stdout(), "%v %v is already %sed as %v\n", profile, target, verb, t)
+ if jirix.Verbose() {
+ fmt.Fprintf(jirix.Stdout(), "%v %v is already %sed as %v\n", profile, target, verb, t)
}
return nil
}
@@ -219,32 +220,32 @@
return err
}
target.SetVersion(version)
- if ctx.Verbose() || ctx.DryRun() {
- fmt.Fprintf(ctx.Stdout(), "%s %s %s\n", verb, profile, target.DebugString())
+ if jirix.Verbose() || jirix.DryRun() {
+ fmt.Fprintf(jirix.Stdout(), "%s %s %s\n", verb, profile, target.DebugString())
}
if action == Install {
- return mgr.Install(ctx, root, target)
+ return mgr.Install(jirix, root, target)
}
- return mgr.Uninstall(ctx, root, target)
+ return mgr.Uninstall(jirix, root, target)
}
// EnsureProfileTargetIsInstalled ensures that the requested profile and target
// is installed, installing it if only if necessary.
-func EnsureProfileTargetIsInstalled(ctx *tool.Context, profile string, root RelativePath, target Target) error {
- return ensureAction(ctx, Install, profile, root, target)
+func EnsureProfileTargetIsInstalled(jirix *jiri.X, profile string, root RelativePath, target Target) error {
+ return ensureAction(jirix, Install, profile, root, target)
}
// EnsureProfileTargetIsUninstalled ensures that the requested profile and target
// are no longer installed.
-func EnsureProfileTargetIsUninstalled(ctx *tool.Context, profile string, root RelativePath, target Target) error {
- return ensureAction(ctx, Uninstall, profile, root, target)
+func EnsureProfileTargetIsUninstalled(jirix *jiri.X, profile string, root RelativePath, target Target) error {
+ return ensureAction(jirix, Uninstall, profile, root, target)
}
// Fetch downloads the specified url and saves it to dst.
// TODO(nlacasse, cnicoloau): Move this to a package for profile-implementors
// so it does not pollute the profile package namespace.
-func Fetch(ctx *tool.Context, dst, url string) error {
- s := ctx.NewSeq()
+func Fetch(jirix *jiri.X, dst, url string) error {
+ s := jirix.NewSeq()
s.Output([]string{"fetching " + url})
resp, err := http.Get(url)
if err != nil {
@@ -265,7 +266,7 @@
// Unzip unzips the file in srcFile and puts resulting files in directory dstDir.
// TODO(nlacasse, cnicoloau): Move this to a package for profile-implementors
// so it does not pollute the profile package namespace.
-func Unzip(ctx *tool.Context, srcFile, dstDir string) error {
+func Unzip(jirix *jiri.X, srcFile, dstDir string) error {
r, err := zip.OpenReader(srcFile)
if err != nil {
return err
@@ -279,7 +280,7 @@
}
defer rc.Close()
- s := ctx.NewSeq()
+ s := jirix.NewSeq()
fileDst := filepath.Join(dstDir, zFile.Name)
if zFile.FileInfo().IsDir() {
return s.MkdirAll(fileDst, zFile.Mode()).Done()
@@ -299,7 +300,7 @@
_, err = s.Copy(file, rc)
return err
}
- s := ctx.NewSeq()
+ s := jirix.NewSeq()
s.Output([]string{"unzipping " + srcFile})
for _, zFile := range r.File {
s.Output([]string{"extracting " + zFile.Name})
diff --git a/project.go b/project.go
index ac11219..f59871a 100644
--- a/project.go
+++ b/project.go
@@ -12,6 +12,7 @@
"sort"
"strings"
+ "v.io/jiri/jiri"
"v.io/jiri/project"
"v.io/jiri/tool"
"v.io/jiri/util"
@@ -48,7 +49,7 @@
// cmdProjectClean represents the "jiri project clean" command.
var cmdProjectClean = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runProjectClean),
+ 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.",
@@ -56,9 +57,8 @@
ArgsLong: "<project ...> is a list of projects to clean up.",
}
-func runProjectClean(env *cmdline.Env, args []string) (e error) {
- ctx := tool.NewContextFromEnv(env)
- localProjects, err := project.LocalProjects(ctx, project.FullScan)
+func runProjectClean(jirix *jiri.X, args []string) (e error) {
+ localProjects, err := project.LocalProjects(jirix, project.FullScan)
if err != nil {
return err
}
@@ -68,13 +68,13 @@
if p, ok := localProjects[arg]; ok {
projects[p.Name] = p
} else {
- fmt.Fprintf(ctx.Stderr(), "Local project %q not found.\n", p.Name)
+ fmt.Fprintf(jirix.Stderr(), "Local project %q not found.\n", p.Name)
}
}
} else {
projects = localProjects
}
- if err := project.CleanupProjects(ctx, projects, cleanupBranchesFlag); err != nil {
+ if err := project.CleanupProjects(jirix, projects, cleanupBranchesFlag); err != nil {
return err
}
return nil
@@ -82,16 +82,15 @@
// cmdProjectList represents the "jiri project list" command.
var cmdProjectList = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runProjectList),
+ 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(env *cmdline.Env, _ []string) error {
- ctx := tool.NewContextFromEnv(env)
- states, err := project.GetProjectStates(ctx, noPristineFlag)
+func runProjectList(jirix *jiri.X, _ []string) error {
+ states, err := project.GetProjectStates(jirix, noPristineFlag)
if err != nil {
return err
}
@@ -109,7 +108,7 @@
continue
}
}
- fmt.Fprintf(ctx.Stdout(), "project=%q path=%q\n", path.Base(name), state.Project.Path)
+ fmt.Fprintf(jirix.Stdout(), "project=%q path=%q\n", path.Base(name), state.Project.Path)
if branchesFlag {
for _, branch := range state.Branches {
s := " "
@@ -120,7 +119,7 @@
if branch.HasGerritMessage {
s += " (exported to gerrit)"
}
- fmt.Fprintf(ctx.Stdout(), "%v\n", s)
+ fmt.Fprintf(jirix.Stdout(), "%v\n", s)
}
}
}
@@ -129,7 +128,7 @@
// cmdProjectShellPrompt represents the "jiri project shell-prompt" command.
var cmdProjectShellPrompt = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runProjectShellPrompt),
+ Runner: jiri.RunnerFunc(runProjectShellPrompt),
Name: "shell-prompt",
Short: "Print a succinct status of projects suitable for shell prompts",
Long: `
@@ -140,10 +139,8 @@
`,
}
-func runProjectShellPrompt(env *cmdline.Env, args []string) error {
- ctx := tool.NewContextFromEnv(env)
-
- states, err := project.GetProjectStates(ctx, checkDirtyFlag)
+func runProjectShellPrompt(jirix *jiri.X, args []string) error {
+ states, err := project.GetProjectStates(jirix, checkDirtyFlag)
if err != nil {
return err
}
@@ -154,7 +151,7 @@
sort.Strings(names)
// Get the name of the current project.
- currentProjectName, err := project.CurrentProjectName(ctx)
+ currentProjectName, err := project.CurrentProjectName(jirix)
if err != nil {
return err
}
@@ -194,7 +191,7 @@
// cmdProjectPoll represents the "jiri project poll" command.
var cmdProjectPoll = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runProjectPoll),
+ Runner: jiri.RunnerFunc(runProjectPoll),
Name: "poll",
Short: "Poll existing jiri projects",
Long: `
@@ -208,11 +205,10 @@
// runProjectPoll generates a description of changes that exist
// remotely but do not exist locally.
-func runProjectPoll(env *cmdline.Env, args []string) error {
- ctx := tool.NewContextFromEnv(env)
+func runProjectPoll(jirix *jiri.X, args []string) error {
projectSet := map[string]struct{}{}
if len(args) > 0 {
- config, err := util.LoadConfig(ctx)
+ config, err := util.LoadConfig(jirix)
if err != nil {
return err
}
@@ -232,7 +228,7 @@
set.String.Union(projectSet, set.String.FromSlice(projects))
}
}
- update, err := project.PollProjects(ctx, projectSet)
+ update, err := project.PollProjects(jirix, projectSet)
if err != nil {
return err
}
@@ -250,7 +246,7 @@
if err != nil {
return fmt.Errorf("MarshalIndent() failed: %v", err)
}
- fmt.Fprintf(env.Stdout, "%s\n", bytes)
+ fmt.Fprintf(jirix.Stdout(), "%s\n", bytes)
}
return nil
}
diff --git a/project/fake.go b/project/fake.go
index 5e1e125..fcbf5c7 100644
--- a/project/fake.go
+++ b/project/fake.go
@@ -11,10 +11,12 @@
"path/filepath"
"v.io/jiri/collect"
+ "v.io/jiri/jiri"
"v.io/jiri/tool"
)
type FakeJiriRoot struct {
+ X *jiri.X
Dir string
Projects map[string]string
remote string
@@ -29,47 +31,48 @@
)
// NewFakeJiriRoot is the FakeJiriRoot factory.
-func NewFakeJiriRoot(ctx *tool.Context) (*FakeJiriRoot, error) {
+func NewFakeJiriRoot() (*FakeJiriRoot, error) {
+ // Create a fake JIRI_ROOT.
+ ctx := tool.NewDefaultContext()
+ rootDir, err := ctx.Run().TempDir("", "")
+ if err != nil {
+ return nil, err
+ }
+ jirix := &jiri.X{Context: ctx, Root: rootDir}
root := &FakeJiriRoot{
+ X: jirix,
+ Dir: rootDir,
Projects: map[string]string{},
}
// Create fake remote manifest and tools projects.
- remoteDir, err := ctx.Run().TempDir("", "")
+ remoteDir, err := jirix.Run().TempDir("", "")
if err != nil {
return nil, err
}
doCleanup := true
defer func() {
if doCleanup {
- root.Cleanup(ctx)
+ root.Cleanup()
}
}()
-
root.remote = remoteDir
- if err := root.CreateRemoteProject(ctx, manifestProject); err != nil {
+ if err := root.CreateRemoteProject(manifestProject); err != nil {
return nil, err
}
- if err := root.CreateRemoteProject(ctx, toolsProject); err != nil {
+ if err := root.CreateRemoteProject(toolsProject); err != nil {
return nil, err
}
// Create a fake manifest.
manifestDir := filepath.Join(remoteDir, manifestProject, manifestVersion)
- if err := ctx.Run().MkdirAll(manifestDir, os.FileMode(0700)); err != nil {
+ if err := jirix.Run().MkdirAll(manifestDir, os.FileMode(0700)); err != nil {
return nil, err
}
- if err := root.WriteRemoteManifest(ctx, &Manifest{}); err != nil {
+ if err := root.WriteRemoteManifest(&Manifest{}); err != nil {
return nil, err
}
-
- // Create a fake JIRI_ROOT.
- rootDir, err := ctx.Run().TempDir("", "")
- if err != nil {
- return nil, err
- }
- root.Dir = rootDir
- if err := ctx.Git().Clone(root.Projects[manifestProject], filepath.Join(root.Dir, manifestProject)); err != nil {
+ if err := jirix.Git().Clone(root.Projects[manifestProject], filepath.Join(root.Dir, manifestProject)); err != nil {
return nil, err
}
@@ -77,14 +80,14 @@
// manifests. This is necessary to make sure that the commonly
// invoked DataDirPath() function, which uses the "jiri" tool
// configuration for its default, works.
- if err := root.AddProject(ctx, Project{
+ if err := root.AddProject(Project{
Name: toolsProject,
Path: toolsProject,
Remote: root.Projects[toolsProject],
}); err != nil {
return nil, err
}
- if err := root.AddTool(ctx, Tool{
+ if err := root.AddTool(Tool{
Name: "jiri",
Data: defaultDataDir,
Project: toolsProject,
@@ -94,13 +97,13 @@
// Add "gerrit" and "git" hosts to the manifest, as required by the "jiri"
// tool.
- if err := root.AddHost(ctx, Host{
+ if err := root.AddHost(Host{
Name: "gerrit",
Location: "git://example.com/gerrit",
}); err != nil {
return nil, err
}
- if err := root.AddHost(ctx, Host{
+ if err := root.AddHost(Host{
Name: "git",
Location: "git://example.com/git",
}); err != nil {
@@ -109,7 +112,7 @@
// Update the contents of the fake JIRI_ROOT instance based on
// the information recorded in the remote manifest.
- if err := root.UpdateUniverse(ctx, false); err != nil {
+ if err := root.UpdateUniverse(false); err != nil {
return nil, err
}
@@ -118,15 +121,15 @@
}
// Cleanup cleans up the given Vanadium root fake.
-func (root FakeJiriRoot) Cleanup(ctx *tool.Context) error {
+func (root FakeJiriRoot) Cleanup() error {
var errs []error
collect.Errors(func() error {
if root.Dir == "" {
return nil
}
- return ctx.Run().RemoveAll(root.Dir)
+ return root.X.Run().RemoveAll(root.Dir)
}, &errs)
- collect.Errors(func() error { return ctx.Run().RemoveAll(root.remote) }, &errs)
+ collect.Errors(func() error { return root.X.Run().RemoveAll(root.remote) }, &errs)
if len(errs) != 0 {
return fmt.Errorf("Cleanup() failed: %v", errs)
}
@@ -134,39 +137,39 @@
}
// AddHost adds the given host to a remote manifest.
-func (root FakeJiriRoot) AddHost(ctx *tool.Context, host Host) error {
- manifest, err := root.ReadRemoteManifest(ctx)
+func (root FakeJiriRoot) AddHost(host Host) error {
+ manifest, err := root.ReadRemoteManifest()
if err != nil {
return err
}
manifest.Hosts = append(manifest.Hosts, host)
- if err := root.WriteRemoteManifest(ctx, manifest); err != nil {
+ if err := root.WriteRemoteManifest(manifest); err != nil {
return err
}
return nil
}
// AddProject adds the given project to a remote manifest.
-func (root FakeJiriRoot) AddProject(ctx *tool.Context, project Project) error {
- manifest, err := root.ReadRemoteManifest(ctx)
+func (root FakeJiriRoot) AddProject(project Project) error {
+ manifest, err := root.ReadRemoteManifest()
if err != nil {
return err
}
manifest.Projects = append(manifest.Projects, project)
- if err := root.WriteRemoteManifest(ctx, manifest); err != nil {
+ if err := root.WriteRemoteManifest(manifest); err != nil {
return err
}
return nil
}
// AddTool adds the given tool to a remote manifest.
-func (root FakeJiriRoot) AddTool(ctx *tool.Context, tool Tool) error {
- manifest, err := root.ReadRemoteManifest(ctx)
+func (root FakeJiriRoot) AddTool(tool Tool) error {
+ manifest, err := root.ReadRemoteManifest()
if err != nil {
return err
}
manifest.Tools = append(manifest.Tools, tool)
- if err := root.WriteRemoteManifest(ctx, manifest); err != nil {
+ if err := root.WriteRemoteManifest(manifest); err != nil {
return err
}
return nil
@@ -174,9 +177,9 @@
// DisableRemoteManifestPush disables pushes to the remote manifest
// repository.
-func (root FakeJiriRoot) DisableRemoteManifestPush(ctx *tool.Context) error {
+func (root FakeJiriRoot) DisableRemoteManifestPush() error {
dir := tool.RootDirOpt(filepath.Join(root.remote, manifestProject))
- if err := ctx.Git(dir).CheckoutBranch("master"); err != nil {
+ if err := root.X.Git(dir).CheckoutBranch("master"); err != nil {
return err
}
return nil
@@ -184,37 +187,37 @@
// EnableRemoteManifestPush enables pushes to the remote manifest
// repository.
-func (root FakeJiriRoot) EnableRemoteManifestPush(ctx *tool.Context) error {
+func (root FakeJiriRoot) EnableRemoteManifestPush() error {
dir := tool.RootDirOpt(filepath.Join(root.remote, manifestProject))
- if !ctx.Git(dir).BranchExists("non-master") {
- if err := ctx.Git(dir).CreateBranch("non-master"); err != nil {
+ if !root.X.Git(dir).BranchExists("non-master") {
+ if err := root.X.Git(dir).CreateBranch("non-master"); err != nil {
return err
}
}
- if err := ctx.Git(dir).CheckoutBranch("non-master"); err != nil {
+ if err := root.X.Git(dir).CheckoutBranch("non-master"); err != nil {
return err
}
return nil
}
// CreateRemoteProject creates a new remote project.
-func (root FakeJiriRoot) CreateRemoteProject(ctx *tool.Context, name string) error {
+func (root FakeJiriRoot) CreateRemoteProject(name string) error {
projectDir := filepath.Join(root.remote, name)
- if err := ctx.Run().MkdirAll(projectDir, os.FileMode(0700)); err != nil {
+ if err := root.X.Run().MkdirAll(projectDir, os.FileMode(0700)); err != nil {
return err
}
- if err := ctx.Git().Init(projectDir); err != nil {
+ if err := root.X.Git().Init(projectDir); err != nil {
return err
}
- if err := ctx.Git(tool.RootDirOpt(projectDir)).CommitWithMessage("initial commit"); err != nil {
+ if err := root.X.Git(tool.RootDirOpt(projectDir)).CommitWithMessage("initial commit"); err != nil {
return err
}
root.Projects[name] = projectDir
return nil
}
-func getManifest(ctx *tool.Context) string {
- manifest := ctx.Manifest()
+func getManifest(jirix *jiri.X) string {
+ manifest := jirix.Manifest()
if manifest != "" {
return manifest
}
@@ -222,19 +225,19 @@
}
// ReadLocalManifest read a manifest from the local manifest project.
-func (root FakeJiriRoot) ReadLocalManifest(ctx *tool.Context) (*Manifest, error) {
- path := filepath.Join(root.Dir, manifestProject, manifestVersion, getManifest(ctx))
- return root.readManifest(ctx, path)
+func (root FakeJiriRoot) ReadLocalManifest() (*Manifest, error) {
+ path := filepath.Join(root.Dir, manifestProject, manifestVersion, getManifest(root.X))
+ return root.readManifest(path)
}
// ReadRemoteManifest read a manifest from the remote manifest project.
-func (root FakeJiriRoot) ReadRemoteManifest(ctx *tool.Context) (*Manifest, error) {
- path := filepath.Join(root.remote, manifestProject, manifestVersion, getManifest(ctx))
- return root.readManifest(ctx, path)
+func (root FakeJiriRoot) ReadRemoteManifest() (*Manifest, error) {
+ path := filepath.Join(root.remote, manifestProject, manifestVersion, getManifest(root.X))
+ return root.readManifest(path)
}
-func (root FakeJiriRoot) readManifest(ctx *tool.Context, path string) (*Manifest, error) {
- bytes, err := ctx.Run().ReadFile(path)
+func (root FakeJiriRoot) readManifest(path string) (*Manifest, error) {
+ bytes, err := root.X.Run().ReadFile(path)
if err != nil {
return nil, err
}
@@ -247,13 +250,13 @@
// UpdateUniverse synchronizes the content of the Vanadium root based
// on the content of the remote manifest.
-func (root FakeJiriRoot) UpdateUniverse(ctx *tool.Context, gc bool) error {
+func (root FakeJiriRoot) UpdateUniverse(gc bool) error {
oldRoot := os.Getenv("JIRI_ROOT")
if err := os.Setenv("JIRI_ROOT", root.Dir); err != nil {
return fmt.Errorf("Setenv() failed: %v", err)
}
defer os.Setenv("JIRI_ROOT", oldRoot)
- if err := UpdateUniverse(ctx, gc); err != nil {
+ if err := UpdateUniverse(root.X, gc); err != nil {
return err
}
return nil
@@ -261,32 +264,32 @@
// WriteLocalManifest writes the given manifest to the local
// manifest project.
-func (root FakeJiriRoot) WriteLocalManifest(ctx *tool.Context, manifest *Manifest) error {
+func (root FakeJiriRoot) WriteLocalManifest(manifest *Manifest) error {
dir := filepath.Join(root.Dir, manifestProject)
- path := filepath.Join(dir, manifestVersion, getManifest(ctx))
- return root.writeManifest(ctx, manifest, dir, path)
+ path := filepath.Join(dir, manifestVersion, getManifest(root.X))
+ return root.writeManifest(manifest, dir, path)
}
// WriteRemoteManifest writes the given manifest to the remote
// manifest project.
-func (root FakeJiriRoot) WriteRemoteManifest(ctx *tool.Context, manifest *Manifest) error {
+func (root FakeJiriRoot) WriteRemoteManifest(manifest *Manifest) error {
dir := filepath.Join(root.remote, manifestProject)
- path := filepath.Join(dir, manifestVersion, getManifest(ctx))
- return root.writeManifest(ctx, manifest, dir, path)
+ path := filepath.Join(dir, manifestVersion, getManifest(root.X))
+ return root.writeManifest(manifest, dir, path)
}
-func (root FakeJiriRoot) writeManifest(ctx *tool.Context, manifest *Manifest, dir, path string) error {
+func (root FakeJiriRoot) writeManifest(manifest *Manifest, dir, path string) error {
bytes, err := xml.Marshal(manifest)
if err != nil {
return fmt.Errorf("Marshal(%v) failed: %v", manifest, err)
}
- if err := ctx.Run().WriteFile(path, bytes, os.FileMode(0600)); err != nil {
+ if err := root.X.Run().WriteFile(path, bytes, os.FileMode(0600)); err != nil {
return err
}
- if err := ctx.Git(tool.RootDirOpt(dir)).Add(path); err != nil {
+ if err := root.X.Git(tool.RootDirOpt(dir)).Add(path); err != nil {
return err
}
- if err := ctx.Git(tool.RootDirOpt(dir)).Commit(); err != nil {
+ if err := root.X.Git(tool.RootDirOpt(dir)).Commit(); err != nil {
return err
}
return nil
diff --git a/project/paths.go b/project/paths.go
index 45d874a..6586fe3 100644
--- a/project/paths.go
+++ b/project/paths.go
@@ -9,7 +9,7 @@
"os"
"path/filepath"
- "v.io/jiri/tool"
+ "v.io/jiri/jiri"
)
const (
@@ -25,8 +25,8 @@
// uses DataDirPath, and the default tool name is "jiri", so nothing actually
// breaks. We should revisit the whole data directory thing, and in particular
// see if we can get rid of tools having to know their own names.
-func DataDirPath(ctx *tool.Context, toolName string) (string, error) {
- _, projects, tools, _, err := readManifest(ctx, false)
+func DataDirPath(jirix *jiri.X, toolName string) (string, error) {
+ _, projects, tools, _, err := readManifest(jirix, false)
if err != nil {
return "", err
}
@@ -121,8 +121,8 @@
return path, nil
}
-func getHost(ctx *tool.Context, name string) (string, error) {
- hosts, _, _, _, err := readManifest(ctx, false)
+func getHost(jirix *jiri.X, name string) (string, error) {
+ hosts, _, _, _, err := readManifest(jirix, false)
if err != nil {
return "", err
}
@@ -134,13 +134,13 @@
}
// GerritHost returns the URL that hosts the Gerrit code review system.
-func GerritHost(ctx *tool.Context) (string, error) {
- return getHost(ctx, "gerrit")
+func GerritHost(jirix *jiri.X) (string, error) {
+ return getHost(jirix, "gerrit")
}
// GitHost returns the URL that hosts the git repositories.
-func GitHost(ctx *tool.Context) (string, error) {
- return getHost(ctx, "git")
+func GitHost(jirix *jiri.X) (string, error) {
+ return getHost(jirix, "git")
}
// JiriRoot returns the root of the jiri universe.
diff --git a/project/project.go b/project/project.go
index ade8eb8..5fb7b6e 100644
--- a/project/project.go
+++ b/project/project.go
@@ -17,6 +17,7 @@
"v.io/jiri/collect"
"v.io/jiri/gitutil"
"v.io/jiri/googlesource"
+ "v.io/jiri/jiri"
"v.io/jiri/runutil"
"v.io/jiri/tool"
"v.io/x/lib/cmdline"
@@ -183,14 +184,14 @@
// CreateSnapshot creates a manifest that encodes the current state of
// master branches of all projects and writes this snapshot out to the
// given file.
-func CreateSnapshot(ctx *tool.Context, path string) error {
- ctx.TimerPush("create snapshot")
- defer ctx.TimerPop()
+func CreateSnapshot(jirix *jiri.X, path string) error {
+ jirix.TimerPush("create snapshot")
+ defer jirix.TimerPop()
manifest := Manifest{}
// Add all local projects to manifest.
- localProjects, err := LocalProjects(ctx, FullScan)
+ localProjects, err := LocalProjects(jirix, FullScan)
if err != nil {
return err
}
@@ -205,7 +206,7 @@
// Add all hosts, tools, and hooks from the current manifest to the
// snapshot manifest.
- hosts, _, tools, hooks, err := readManifest(ctx, true)
+ hosts, _, tools, hooks, err := readManifest(jirix, true)
if err != nil {
return err
}
@@ -220,7 +221,7 @@
}
perm := os.FileMode(0755)
- if err := ctx.Run().MkdirAll(filepath.Dir(path), perm); err != nil {
+ if err := jirix.Run().MkdirAll(filepath.Dir(path), perm); err != nil {
return err
}
data, err := xml.MarshalIndent(manifest, "", " ")
@@ -228,7 +229,7 @@
return fmt.Errorf("MarshalIndent(%v) failed: %v", manifest, err)
}
perm = os.FileMode(0644)
- if err := ctx.Run().WriteFile(path, data, perm); err != nil {
+ if err := jirix.Run().WriteFile(path, data, perm); err != nil {
return err
}
return nil
@@ -238,15 +239,15 @@
// CurrentManifest returns a manifest that identifies the result of
// the most recent "jiri update" invocation.
-func CurrentManifest(ctx *tool.Context) (*Manifest, error) {
+func CurrentManifest(jirix *jiri.X) (*Manifest, error) {
currentManifestPath, err := ToAbs(currentManifestFileName)
if err != nil {
return nil, err
}
- bytes, err := ctx.Run().ReadFile(currentManifestPath)
+ bytes, err := jirix.Run().ReadFile(currentManifestPath)
if err != nil {
if os.IsNotExist(err) {
- fmt.Fprintf(ctx.Stderr(), `WARNING: Could not find %s.
+ fmt.Fprintf(jirix.Stderr(), `WARNING: Could not find %s.
The contents of this file are stored as metadata in binaries the jiri
tool builds. To fix this problem, please run "jiri update".
`, currentManifestPath)
@@ -263,7 +264,7 @@
// writeCurrentManifest writes the given manifest to a file that
// stores the result of the most recent "jiri update" invocation.
-func writeCurrentManifest(ctx *tool.Context, manifest *Manifest) error {
+func writeCurrentManifest(jirix *jiri.X, manifest *Manifest) error {
currentManifestPath, err := ToAbs(currentManifestFileName)
if err != nil {
return err
@@ -272,7 +273,7 @@
if err != nil {
return fmt.Errorf("MarshalIndent(%v) failed: %v", manifest, err)
}
- if err := ctx.Run().WriteFile(currentManifestPath, bytes, os.FileMode(0644)); err != nil {
+ if err := jirix.Run().WriteFile(currentManifestPath, bytes, os.FileMode(0644)); err != nil {
return err
}
return nil
@@ -281,15 +282,15 @@
// CurrentProjectName gets the name of the current project from the
// current directory by reading the jiri project metadata located in a
// directory at the root of the current repository.
-func CurrentProjectName(ctx *tool.Context) (string, error) {
- topLevel, err := ctx.Git().TopLevel()
+func CurrentProjectName(jirix *jiri.X) (string, error) {
+ topLevel, err := jirix.Git().TopLevel()
if err != nil {
return "", nil
}
metadataDir := filepath.Join(topLevel, metadataDirName)
- if _, err := ctx.Run().Stat(metadataDir); err == nil {
+ if _, err := jirix.Run().Stat(metadataDir); err == nil {
metadataFile := filepath.Join(metadataDir, metadataFileName)
- bytes, err := ctx.Run().ReadFile(metadataFile)
+ bytes, err := jirix.Run().ReadFile(metadataFile)
if err != nil {
return "", err
}
@@ -304,20 +305,20 @@
// setProjectRevisions sets the current project revision from the master for
// each project as found on the filesystem
-func setProjectRevisions(ctx *tool.Context, projects Projects) (_ Projects, e error) {
+func setProjectRevisions(jirix *jiri.X, projects Projects) (_ Projects, e error) {
cwd, err := os.Getwd()
if err != nil {
return nil, err
}
- defer collect.Error(func() error { return ctx.Run().Chdir(cwd) }, &e)
+ defer collect.Error(func() error { return jirix.Run().Chdir(cwd) }, &e)
for name, project := range projects {
switch project.Protocol {
case "git":
- if err := ctx.Run().Chdir(project.Path); err != nil {
+ if err := jirix.Run().Chdir(project.Path); err != nil {
return nil, err
}
- revision, err := ctx.Git().CurrentRevisionOfBranch("master")
+ revision, err := jirix.Git().CurrentRevisionOfBranch("master")
if err != nil {
return nil, err
}
@@ -335,25 +336,25 @@
// projects in the manifest that exist locally will be returned. Otherwise, a
// full scan of the filesystem will take place, and all found projects will be
// returned.
-func LocalProjects(ctx *tool.Context, scanMode ScanMode) (Projects, error) {
- ctx.TimerPush("local projects")
- defer ctx.TimerPop()
+func LocalProjects(jirix *jiri.X, scanMode ScanMode) (Projects, error) {
+ jirix.TimerPush("local projects")
+ defer jirix.TimerPop()
projects := Projects{}
if scanMode == FastScan {
// Fast path: Full scan was not requested, and all projects in
// manifest exist on local filesystem. We just use the projects
// directly from the manifest.
- manifestProjects, _, err := ReadManifest(ctx)
+ manifestProjects, _, err := ReadManifest(jirix)
if err != nil {
return nil, err
}
- projectsExist, err := projectsExistLocally(ctx, manifestProjects)
+ projectsExist, err := projectsExistLocally(jirix, manifestProjects)
if err != nil {
return nil, err
}
if projectsExist {
- return setProjectRevisions(ctx, manifestProjects)
+ return setProjectRevisions(jirix, manifestProjects)
}
}
@@ -367,24 +368,24 @@
// Initial call to findLocalProjects -- it will recursively search all the
// directories under JiriRoot.
- ctx.TimerPush("scan fs")
- err = findLocalProjects(ctx, root, projects)
- ctx.TimerPop()
+ jirix.TimerPush("scan fs")
+ err = findLocalProjects(jirix, root, projects)
+ jirix.TimerPop()
if err != nil {
return nil, err
}
- return setProjectRevisions(ctx, projects)
+ return setProjectRevisions(jirix, projects)
}
// projectsExistLocally returns true iff all the given projects exist on the
// local filesystem.
// Note that this may return true even if there are projects on the local
// filesystem not included in the provided projects argument.
-func projectsExistLocally(ctx *tool.Context, projects Projects) (bool, error) {
- ctx.TimerPush("match manifest")
- defer ctx.TimerPop()
+func projectsExistLocally(jirix *jiri.X, projects Projects) (bool, error) {
+ jirix.TimerPush("match manifest")
+ defer jirix.TimerPop()
for _, p := range projects {
- isLocal, err := isLocalProject(ctx, p.Path)
+ isLocal, err := isLocalProject(jirix, p.Path)
if err != nil {
return false, err
}
@@ -398,23 +399,23 @@
// PollProjects returns the set of changelists that exist remotely but not
// locally. Changes are grouped by projects and contain author identification
// and a description of their content.
-func PollProjects(ctx *tool.Context, projectSet map[string]struct{}) (_ Update, e error) {
- ctx.TimerPush("poll projects")
- defer ctx.TimerPop()
+func PollProjects(jirix *jiri.X, projectSet map[string]struct{}) (_ Update, e error) {
+ jirix.TimerPush("poll projects")
+ defer jirix.TimerPop()
// Switch back to current working directory when we're done.
cwd, err := os.Getwd()
if err != nil {
return nil, err
}
- defer collect.Error(func() error { return ctx.Run().Chdir(cwd) }, &e)
+ defer collect.Error(func() error { return jirix.Run().Chdir(cwd) }, &e)
// Gather local & remote project data.
- localProjects, err := LocalProjects(ctx, FastScan)
+ localProjects, err := LocalProjects(jirix, FastScan)
if err != nil {
return nil, err
}
- _, remoteProjects, _, _, err := readManifest(ctx, false)
+ _, remoteProjects, _, _, err := readManifest(jirix, false)
if err != nil {
return nil, err
}
@@ -443,17 +444,17 @@
case "git":
// Enter project directory - this assumes absolute paths.
- if err := ctx.Run().Chdir(updateOp.destination); err != nil {
+ if err := jirix.Run().Chdir(updateOp.destination); err != nil {
return nil, err
}
// Fetch the latest from origin.
- if err := ctx.Git().FetchRefspec("origin", updateOp.project.RemoteBranch); err != nil {
+ if err := jirix.Git().FetchRefspec("origin", updateOp.project.RemoteBranch); err != nil {
return nil, err
}
// Collect commits visible from FETCH_HEAD that aren't visible from master.
- commitsText, err := ctx.Git().Log("FETCH_HEAD", "master", "%an%n%ae%n%B")
+ commitsText, err := jirix.Git().Log("FETCH_HEAD", "master", "%an%n%ae%n%B")
if err != nil {
return nil, err
}
@@ -480,8 +481,8 @@
// ReadManifest retrieves and parses the manifest that determines what
// projects and tools are part of the jiri universe.
-func ReadManifest(ctx *tool.Context) (Projects, Tools, error) {
- _, p, t, _, e := readManifest(ctx, false)
+func ReadManifest(jirix *jiri.X) (Projects, Tools, error) {
+ _, p, t, _, e := readManifest(jirix, false)
return p, t, e
}
@@ -490,11 +491,11 @@
// TODO(nlacasse,toddw): Once the manifest project is specified in the
// manifest, we should get the remote directly from the manifest, and not from
// the filesystem.
-func getManifestRemote(ctx *tool.Context, manifestPath string) (string, error) {
+func getManifestRemote(jirix *jiri.X, manifestPath string) (string, error) {
var remote string
- return remote, ctx.NewSeq().Pushd(manifestPath).Call(
+ return remote, jirix.NewSeq().Pushd(manifestPath).Call(
func() (e error) {
- remote, e = ctx.Git().RemoteUrl("origin")
+ remote, e = jirix.Git().RemoteUrl("origin")
return
}, "get manifest origin").Done()
}
@@ -502,15 +503,15 @@
// readManifest implements the ReadManifest logic and provides an
// optional flag that can be used to fetch the latest manifest updates
// from the manifest repository.
-func readManifest(ctx *tool.Context, update bool) (Hosts, Projects, Tools, Hooks, error) {
- ctx.TimerPush("read manifest")
- defer ctx.TimerPop()
+func readManifest(jirix *jiri.X, update bool) (Hosts, Projects, Tools, Hooks, error) {
+ jirix.TimerPush("read manifest")
+ defer jirix.TimerPop()
if update {
manifestPath, err := ToAbs(".manifest")
if err != nil {
return nil, nil, nil, nil, err
}
- manifestRemote, err := getManifestRemote(ctx, manifestPath)
+ manifestRemote, err := getManifestRemote(jirix, manifestPath)
if err != nil {
return nil, nil, nil, nil, err
}
@@ -521,16 +522,16 @@
Revision: "HEAD",
RemoteBranch: "master",
}
- if err := resetProject(ctx, project); err != nil {
+ if err := resetProject(jirix, project); err != nil {
return nil, nil, nil, nil, err
}
}
- path, err := ResolveManifestPath(ctx.Manifest())
+ path, err := ResolveManifestPath(jirix.Manifest())
if err != nil {
return nil, nil, nil, nil, err
}
hosts, projects, tools, hooks, stack := Hosts{}, Projects{}, Tools{}, Hooks{}, map[string]struct{}{}
- if err := loadManifest(ctx, path, hosts, projects, tools, hooks, stack); err != nil {
+ if err := loadManifest(jirix, path, hosts, projects, tools, hooks, stack); err != nil {
return nil, nil, nil, nil, err
}
return hosts, projects, tools, hooks, nil
@@ -540,74 +541,74 @@
// remote counterparts identified by the given manifest. Optionally,
// the 'gc' flag can be used to indicate that local projects that no
// longer exist remotely should be removed.
-func UpdateUniverse(ctx *tool.Context, gc bool) (e error) {
- ctx.TimerPush("update universe")
- defer ctx.TimerPop()
- _, remoteProjects, remoteTools, remoteHooks, err := readManifest(ctx, true)
+func UpdateUniverse(jirix *jiri.X, gc bool) (e error) {
+ jirix.TimerPush("update universe")
+ defer jirix.TimerPop()
+ _, remoteProjects, remoteTools, remoteHooks, err := readManifest(jirix, true)
if err != nil {
return err
}
// 1. Update all local projects to match their remote counterparts.
- if err := updateProjects(ctx, remoteProjects, gc); err != nil {
+ if err := updateProjects(jirix, remoteProjects, gc); err != nil {
return err
}
// 2. Build all tools in a temporary directory.
- tmpDir, err := ctx.Run().TempDir("", "tmp-jiri-tools-build")
+ tmpDir, err := jirix.Run().TempDir("", "tmp-jiri-tools-build")
if err != nil {
return fmt.Errorf("TempDir() failed: %v", err)
}
- defer collect.Error(func() error { return ctx.Run().RemoveAll(tmpDir) }, &e)
- if err := buildToolsFromMaster(ctx, remoteTools, tmpDir); err != nil {
+ defer collect.Error(func() error { return jirix.Run().RemoveAll(tmpDir) }, &e)
+ if err := buildToolsFromMaster(jirix, remoteTools, tmpDir); err != nil {
return err
}
// 3. Install the tools into $JIRI_ROOT/devtools/bin.
- if err := InstallTools(ctx, tmpDir); err != nil {
+ if err := InstallTools(jirix, tmpDir); err != nil {
return err
}
// 4. Run all specified hooks
- return runHooks(ctx, remoteHooks)
+ return runHooks(jirix, remoteHooks)
}
// ApplyToLocalMaster applies an operation expressed as the given function to
// the local master branch of the given projects.
-func ApplyToLocalMaster(ctx *tool.Context, projects Projects, fn func() error) (e error) {
+func ApplyToLocalMaster(jirix *jiri.X, projects Projects, fn func() error) (e error) {
cwd, err := os.Getwd()
if err != nil {
return err
}
- defer collect.Error(func() error { return ctx.Run().Chdir(cwd) }, &e)
+ defer collect.Error(func() error { return jirix.Run().Chdir(cwd) }, &e)
// Loop through all projects, checking out master and stashing any unstaged
// changes.
for _, project := range projects {
p := project
- if err := ctx.Run().Chdir(p.Path); err != nil {
+ if err := jirix.Run().Chdir(p.Path); err != nil {
return err
}
switch p.Protocol {
case "git":
- branch, err := ctx.Git().CurrentBranchName()
+ branch, err := jirix.Git().CurrentBranchName()
if err != nil {
return err
}
- stashed, err := ctx.Git().Stash()
+ stashed, err := jirix.Git().Stash()
if err != nil {
return err
}
- if err := ctx.Git().CheckoutBranch("master"); err != nil {
+ if err := jirix.Git().CheckoutBranch("master"); err != nil {
return err
}
// After running the function, return to this project's directory,
// checkout the original branch, and stash pop if necessary.
defer collect.Error(func() error {
- if err := ctx.Run().Chdir(p.Path); err != nil {
+ if err := jirix.Run().Chdir(p.Path); err != nil {
return err
}
- if err := ctx.Git().CheckoutBranch(branch); err != nil {
+ if err := jirix.Git().CheckoutBranch(branch); err != nil {
return err
}
if stashed {
- return ctx.Git().StashPop()
+ return jirix.Git().StashPop()
}
return nil
}, &e)
@@ -620,14 +621,14 @@
// BuildTools builds the given tools and places the resulting binaries into the
// given directory.
-func BuildTools(ctx *tool.Context, tools Tools, outputDir string) error {
- ctx.TimerPush("build tools")
- defer ctx.TimerPop()
+func BuildTools(jirix *jiri.X, tools Tools, outputDir string) error {
+ jirix.TimerPush("build tools")
+ defer jirix.TimerPop()
if len(tools) == 0 {
// Nothing to do here...
return nil
}
- projects, err := LocalProjects(ctx, FastScan)
+ projects, err := LocalProjects(jirix, FastScan)
if err != nil {
return err
}
@@ -664,7 +665,7 @@
workspaces = append(workspaces, strings.Split(envGoPath, string(filepath.ListSeparator))...)
}
var stderr bytes.Buffer
- opts := ctx.Run().Opts()
+ opts := jirix.Run().Opts()
// We unset GOARCH and GOOS because jiri update should always build for the
// native architecture and OS. Also, as of go1.5, setting GOBIN is not
// compatible with GOARCH or GOOS.
@@ -677,7 +678,7 @@
opts.Stdout = ioutil.Discard
opts.Stderr = &stderr
args := append([]string{"install"}, toolPkgs...)
- if err := ctx.Run().CommandWithOpts(opts, "go", args...); err != nil {
+ if err := jirix.Run().CommandWithOpts(opts, "go", args...); err != nil {
return fmt.Errorf("tool build failed\n%v", stderr.String())
}
return nil
@@ -687,8 +688,8 @@
// available in the local master branch of the tools repository. Notably, this
// function does not perform any version control operation on the master
// branch.
-func buildToolsFromMaster(ctx *tool.Context, tools Tools, outputDir string) error {
- localProjects, err := LocalProjects(ctx, FastScan)
+func buildToolsFromMaster(jirix *jiri.X, tools Tools, outputDir string) error {
+ localProjects, err := LocalProjects(jirix, FastScan)
if err != nil {
return err
}
@@ -714,16 +715,16 @@
}
updateFn := func() error {
- return ApplyToLocalMaster(ctx, toolProjects, func() error {
- return BuildTools(ctx, toolsToBuild, outputDir)
+ return ApplyToLocalMaster(jirix, toolProjects, func() error {
+ return BuildTools(jirix, toolsToBuild, outputDir)
})
}
// Always log the output of updateFn, irrespective of
// the value of the verbose flag.
opts := runutil.Opts{Verbose: true}
- if err := ctx.Run().FunctionWithOpts(opts, updateFn, "build tools: %v", strings.Join(toolNames, " ")); err != nil {
- fmt.Fprintf(ctx.Stderr(), "%v\n", err)
+ if err := jirix.Run().FunctionWithOpts(opts, updateFn, "build tools: %v", strings.Join(toolNames, " ")); err != nil {
+ fmt.Fprintf(jirix.Stderr(), "%v\n", err)
failed = true
}
if failed {
@@ -735,18 +736,18 @@
// CleanupProjects restores the given jiri projects back to their master
// branches and gets rid of all the local changes. If "cleanupBranches" is
// true, it will also delete all the non-master branches.
-func CleanupProjects(ctx *tool.Context, projects Projects, cleanupBranches bool) (e error) {
+func CleanupProjects(jirix *jiri.X, projects Projects, cleanupBranches bool) (e error) {
wd, err := os.Getwd()
if err != nil {
return fmt.Errorf("Getwd() failed: %v", err)
}
- defer collect.Error(func() error { return ctx.Run().Chdir(wd) }, &e)
+ defer collect.Error(func() error { return jirix.Run().Chdir(wd) }, &e)
for _, project := range projects {
localProjectDir := project.Path
- if err := ctx.Run().Chdir(localProjectDir); err != nil {
+ if err := jirix.Run().Chdir(localProjectDir); err != nil {
return err
}
- if err := resetLocalProject(ctx, cleanupBranches, project.RemoteBranch); err != nil {
+ if err := resetLocalProject(jirix, cleanupBranches, project.RemoteBranch); err != nil {
return err
}
}
@@ -755,31 +756,31 @@
// resetLocalProject checks out the master branch, cleans up untracked files
// and uncommitted changes, and optionally deletes all the other branches.
-func resetLocalProject(ctx *tool.Context, cleanupBranches bool, remoteBranch string) error {
+func resetLocalProject(jirix *jiri.X, cleanupBranches bool, remoteBranch string) error {
// Check out master and clean up changes.
- curBranchName, err := ctx.Git().CurrentBranchName()
+ curBranchName, err := jirix.Git().CurrentBranchName()
if err != nil {
return err
}
if curBranchName != "master" {
- if err := ctx.Git().CheckoutBranch("master", gitutil.ForceOpt(true)); err != nil {
+ if err := jirix.Git().CheckoutBranch("master", gitutil.ForceOpt(true)); err != nil {
return err
}
}
- if err := ctx.Git().RemoveUntrackedFiles(); err != nil {
+ if err := jirix.Git().RemoveUntrackedFiles(); err != nil {
return err
}
// Discard any uncommitted changes.
if remoteBranch == "" {
remoteBranch = "master"
}
- if err := ctx.Git().Reset("origin/" + remoteBranch); err != nil {
+ if err := jirix.Git().Reset("origin/" + remoteBranch); err != nil {
return err
}
// Delete all the other branches.
// At this point we should be at the master branch.
- branches, _, err := ctx.Git().GetBranches()
+ branches, _, err := jirix.Git().GetBranches()
if err != nil {
return err
}
@@ -788,7 +789,7 @@
continue
}
if cleanupBranches {
- if err := ctx.Git().DeleteBranch(branch, gitutil.ForceOpt(true)); err != nil {
+ if err := jirix.Git().DeleteBranch(branch, gitutil.ForceOpt(true)); err != nil {
return nil
}
}
@@ -798,7 +799,7 @@
}
// isLocalProject returns true if there is a project at the given path.
-func isLocalProject(ctx *tool.Context, path string) (bool, error) {
+func isLocalProject(jirix *jiri.X, path string) (bool, error) {
absPath, err := ToAbs(path)
if err != nil {
return false, err
@@ -806,7 +807,7 @@
// Existence of a metadata directory is how we know we've found a
// Jiri-maintained project.
metadataDir := filepath.Join(absPath, metadataDirName)
- _, err = ctx.Run().Stat(metadataDir)
+ _, err = jirix.Run().Stat(metadataDir)
if err != nil {
if os.IsNotExist(err) {
return false, nil
@@ -818,14 +819,14 @@
// projectAtPath returns a Project struct corresponding to the project at the
// path in the filesystem.
-func projectAtPath(ctx *tool.Context, path string) (Project, error) {
+func projectAtPath(jirix *jiri.X, path string) (Project, error) {
var project Project
absPath, err := ToAbs(path)
if err != nil {
return project, err
}
metadataFile := filepath.Join(absPath, metadataDirName, metadataFileName)
- bytes, err := ctx.Run().ReadFile(metadataFile)
+ bytes, err := jirix.Run().ReadFile(metadataFile)
if err != nil {
return project, err
}
@@ -842,17 +843,17 @@
// findLocalProjects scans the filesystem for all projects. Note that project
// directories can be nested recursively.
-func findLocalProjects(ctx *tool.Context, path string, projects Projects) error {
+func findLocalProjects(jirix *jiri.X, path string, projects Projects) error {
absPath, err := ToAbs(path)
if err != nil {
return err
}
- isLocal, err := isLocalProject(ctx, absPath)
+ isLocal, err := isLocalProject(jirix, absPath)
if err != nil {
return err
}
if isLocal {
- project, err := projectAtPath(ctx, absPath)
+ project, err := projectAtPath(jirix, absPath)
if err != nil {
return err
}
@@ -866,13 +867,13 @@
}
// Recurse into all the sub directories.
- fileInfos, err := ctx.Run().ReadDir(path)
+ fileInfos, err := jirix.Run().ReadDir(path)
if err != nil {
return err
}
for _, fileInfo := range fileInfos {
if fileInfo.IsDir() && !strings.HasPrefix(fileInfo.Name(), ".") {
- if err := findLocalProjects(ctx, filepath.Join(path, fileInfo.Name()), projects); err != nil {
+ if err := findLocalProjects(jirix, filepath.Join(path, fileInfo.Name()), projects); err != nil {
return err
}
}
@@ -882,10 +883,10 @@
// InstallTools installs the tools from the given directory into
// $JIRI_ROOT/devtools/bin.
-func InstallTools(ctx *tool.Context, dir string) error {
- ctx.TimerPush("install tools")
- defer ctx.TimerPop()
- if ctx.DryRun() {
+func InstallTools(jirix *jiri.X, dir string) error {
+ jirix.TimerPush("install tools")
+ defer jirix.TimerPop()
+ if jirix.DryRun() {
// In "dry run" mode, no binaries are built.
return nil
}
@@ -902,14 +903,14 @@
installFn := func() error {
src := filepath.Join(dir, fi.Name())
dst := filepath.Join(binDir, fi.Name())
- if err := ctx.Run().Rename(src, dst); err != nil {
+ if err := jirix.Run().Rename(src, dst); err != nil {
return err
}
return nil
}
opts := runutil.Opts{Verbose: true}
- if err := ctx.Run().FunctionWithOpts(opts, installFn, "install tool %q", fi.Name()); err != nil {
- fmt.Fprintf(ctx.Stderr(), "%v\n", err)
+ if err := jirix.Run().FunctionWithOpts(opts, installFn, "install tool %q", fi.Name()); err != nil {
+ fmt.Fprintf(jirix.Stderr(), "%v\n", err)
failed = true
}
}
@@ -924,7 +925,7 @@
}
for _, subCmd := range v23SubCmds {
subCmdPath := filepath.Join(binDir, subCmd)
- if err := ctx.Run().RemoveAll(subCmdPath); err != nil {
+ if err := jirix.Run().RemoveAll(subCmdPath); err != nil {
return err
}
}
@@ -933,9 +934,9 @@
}
// runHooks runs the specified hooks
-func runHooks(ctx *tool.Context, hooks Hooks) error {
- ctx.TimerPush("run hooks")
- defer ctx.TimerPop()
+func runHooks(jirix *jiri.X, hooks Hooks) error {
+ jirix.TimerPush("run hooks")
+ defer jirix.TimerPop()
for _, hook := range hooks {
command := hook.Path
args := []string{}
@@ -946,7 +947,7 @@
for _, arg := range hook.Args {
args = append(args, arg.Arg)
}
- if err := ctx.Run().Command(command, args...); err != nil {
+ if err := jirix.Run().Command(command, args...); err != nil {
return fmt.Errorf("Hook %v failed: %v command: %v args: %v", hook.Name, err, command, args)
}
}
@@ -955,24 +956,24 @@
// resetProject advances the local master branch of the given
// project, which is expected to exist locally at project.Path.
-func resetProject(ctx *tool.Context, project Project) error {
+func resetProject(jirix *jiri.X, project Project) error {
fn := func() error {
switch project.Protocol {
case "git":
if project.Remote == "" {
return fmt.Errorf("project %v does not have a remote", project.Name)
}
- if err := ctx.Git().SetRemoteUrl("origin", project.Remote); err != nil {
+ if err := jirix.Git().SetRemoteUrl("origin", project.Remote); err != nil {
return err
}
- if err := ctx.Git().Fetch("origin"); err != nil {
+ if err := jirix.Git().Fetch("origin"); err != nil {
return err
}
// Having a specific revision trumps everything else - once fetched,
// always reset to that revision.
if project.Revision != "" && project.Revision != "HEAD" {
- return ctx.Git().Reset(project.Revision)
+ return jirix.Git().Reset(project.Revision)
}
// If no revision, reset to the configured remote branch, or master
@@ -981,18 +982,18 @@
if remoteBranch == "" {
remoteBranch = "master"
}
- return ctx.Git().Reset("origin/" + remoteBranch)
+ return jirix.Git().Reset("origin/" + remoteBranch)
default:
return UnsupportedProtocolErr(project.Protocol)
}
}
- return ApplyToLocalMaster(ctx, Projects{project.Name: project}, fn)
+ return ApplyToLocalMaster(jirix, Projects{project.Name: project}, fn)
}
// loadManifest loads the given manifest, processing all of its
// imports, projects and tools settings.
-func loadManifest(ctx *tool.Context, path string, hosts Hosts, projects Projects, tools Tools, hooks Hooks, stack map[string]struct{}) error {
- data, err := ctx.Run().ReadFile(path)
+func loadManifest(jirix *jiri.X, path string, hosts Hosts, projects Projects, tools Tools, hooks Hooks, stack map[string]struct{}) error {
+ data, err := jirix.Run().ReadFile(path)
if err != nil {
return err
}
@@ -1010,7 +1011,7 @@
return err
}
stack[manifest.Name] = struct{}{}
- if err := loadManifest(ctx, path, hosts, projects, tools, hooks, stack); err != nil {
+ if err := loadManifest(jirix, path, hosts, projects, tools, hooks, stack); err != nil {
return err
}
delete(stack, manifest.Name)
@@ -1101,18 +1102,18 @@
// reportNonMaster checks if the given project is on master branch and
// if not, reports this fact along with information on how to update it.
-func reportNonMaster(ctx *tool.Context, project Project) (e error) {
+func reportNonMaster(jirix *jiri.X, project Project) (e error) {
cwd, err := os.Getwd()
if err != nil {
return err
}
- defer collect.Error(func() error { return ctx.Run().Chdir(cwd) }, &e)
- if err := ctx.Run().Chdir(project.Path); err != nil {
+ defer collect.Error(func() error { return jirix.Run().Chdir(cwd) }, &e)
+ if err := jirix.Run().Chdir(project.Path); err != nil {
return err
}
switch project.Protocol {
case "git":
- current, err := ctx.Git().CurrentBranchName()
+ current, err := jirix.Git().CurrentBranchName()
if err != nil {
return err
}
@@ -1120,7 +1121,7 @@
line1 := fmt.Sprintf(`NOTE: "jiri update" only updates the "master" branch and the current branch is %q`, current)
line2 := fmt.Sprintf(`to update the %q branch once the master branch is updated, run "git merge master"`, current)
opts := runutil.Opts{Verbose: true}
- ctx.Run().OutputWithOpts(opts, []string{line1, line2})
+ jirix.Run().OutputWithOpts(opts, []string{line1, line2})
}
return nil
default:
@@ -1130,7 +1131,7 @@
// getRemoteHeadRevisions attempts to get the repo statuses from remote for HEAD
// projects so we can detect when a local project is already up-to-date.
-func getRemoteHeadRevisions(ctx *tool.Context, remoteProjects Projects) {
+func getRemoteHeadRevisions(jirix *jiri.X, remoteProjects Projects) {
someAtHead := false
for _, rp := range remoteProjects {
if rp.Revision == "HEAD" {
@@ -1141,14 +1142,14 @@
if !someAtHead {
return
}
- gitHost, gitHostErr := GitHost(ctx)
+ gitHost, gitHostErr := GitHost(jirix)
if gitHostErr != nil || !googlesource.IsGoogleSourceHost(gitHost) {
return
}
- repoStatuses, err := googlesource.GetRepoStatuses(ctx, gitHost)
+ repoStatuses, err := googlesource.GetRepoStatuses(jirix.Context, gitHost)
if err != nil {
// Log the error but don't fail.
- fmt.Fprintf(ctx.Stderr(), "Error fetching repo statuses from remote: %v\n", err)
+ fmt.Fprintf(jirix.Stderr(), "Error fetching repo statuses from remote: %v\n", err)
return
}
for name, rp := range remoteProjects {
@@ -1168,45 +1169,45 @@
}
}
-func updateProjects(ctx *tool.Context, remoteProjects Projects, gc bool) error {
- ctx.TimerPush("update projects")
- defer ctx.TimerPop()
+func updateProjects(jirix *jiri.X, remoteProjects Projects, gc bool) error {
+ jirix.TimerPush("update projects")
+ defer jirix.TimerPop()
scanMode := FastScan
if gc {
scanMode = FullScan
}
- localProjects, err := LocalProjects(ctx, scanMode)
+ localProjects, err := LocalProjects(jirix, scanMode)
if err != nil {
return err
}
- getRemoteHeadRevisions(ctx, remoteProjects)
+ getRemoteHeadRevisions(jirix, remoteProjects)
ops, err := computeOperations(localProjects, remoteProjects, gc)
if err != nil {
return err
}
for _, op := range ops {
- if err := op.Test(ctx); err != nil {
+ if err := op.Test(jirix); err != nil {
return err
}
}
failed := false
- manifest := &Manifest{Label: ctx.Manifest()}
+ manifest := &Manifest{Label: jirix.Manifest()}
for _, op := range ops {
- updateFn := func() error { return op.Run(ctx, manifest) }
+ updateFn := func() error { return op.Run(jirix, manifest) }
// Always log the output of updateFn, irrespective of
// the value of the verbose flag.
opts := runutil.Opts{Verbose: true}
- if err := ctx.Run().FunctionWithOpts(opts, updateFn, "%v", op); err != nil {
- fmt.Fprintf(ctx.Stderr(), "%v\n", err)
+ if err := jirix.Run().FunctionWithOpts(opts, updateFn, "%v", op); err != nil {
+ fmt.Fprintf(jirix.Stderr(), "%v\n", err)
failed = true
}
}
if failed {
return cmdline.ErrExitCode(2)
}
- if err := writeCurrentManifest(ctx, manifest); err != nil {
+ if err := writeCurrentManifest(jirix, manifest); err != nil {
return err
}
return nil
@@ -1214,17 +1215,17 @@
// writeMetadata stores the given project metadata in the directory
// identified by the given path.
-func writeMetadata(ctx *tool.Context, project Project, dir string) (e error) {
+func writeMetadata(jirix *jiri.X, project Project, dir string) (e error) {
metadataDir := filepath.Join(dir, metadataDirName)
cwd, err := os.Getwd()
if err != nil {
return err
}
- defer collect.Error(func() error { return ctx.Run().Chdir(cwd) }, &e)
- if err := ctx.Run().MkdirAll(metadataDir, os.FileMode(0755)); err != nil {
+ defer collect.Error(func() error { return jirix.Run().Chdir(cwd) }, &e)
+ if err := jirix.Run().MkdirAll(metadataDir, os.FileMode(0755)); err != nil {
return err
}
- if err := ctx.Run().Chdir(metadataDir); err != nil {
+ if err := jirix.Run().Chdir(metadataDir); err != nil {
return err
}
// Replace absolute project paths with relative paths to make it
@@ -1240,10 +1241,10 @@
}
metadataFile := filepath.Join(metadataDir, metadataFileName)
tmpMetadataFile := metadataFile + ".tmp"
- if err := ctx.Run().WriteFile(tmpMetadataFile, bytes, os.FileMode(0644)); err != nil {
+ if err := jirix.Run().WriteFile(tmpMetadataFile, bytes, os.FileMode(0644)); err != nil {
return err
}
- if err := ctx.Run().Rename(tmpMetadataFile, metadataFile); err != nil {
+ if err := jirix.Run().Rename(tmpMetadataFile, metadataFile); err != nil {
return err
}
return nil
@@ -1256,12 +1257,12 @@
//
// NOTE: The function assumes that the the given project is on a
// master branch.
-func addProjectToManifest(ctx *tool.Context, manifest *Manifest, project Project) error {
+func addProjectToManifest(jirix *jiri.X, manifest *Manifest, project Project) error {
// If the project uses relative revision, replace it with an absolute one.
switch project.Protocol {
case "git":
if project.Revision == "HEAD" {
- revision, err := ctx.Git(tool.RootDirOpt(project.Path)).CurrentRevision()
+ revision, err := jirix.Git(tool.RootDirOpt(project.Path)).CurrentRevision()
if err != nil {
return err
}
@@ -1283,11 +1284,11 @@
// Project identifies the project this operation pertains to.
Project() Project
// Run executes the operation.
- Run(ctx *tool.Context, manifest *Manifest) error
+ Run(jirix *jiri.X, manifest *Manifest) error
// String returns a string representation of the operation.
String() string
// Test checks whether the operation would fail.
- Test(ctx *tool.Context) error
+ Test(jirix *jiri.X) error
}
// commonOperation represents a project operation.
@@ -1311,28 +1312,28 @@
commonOperation
}
-func (op createOperation) Run(ctx *tool.Context, manifest *Manifest) (e error) {
- hosts, _, _, _, err := readManifest(ctx, false)
+func (op createOperation) Run(jirix *jiri.X, manifest *Manifest) (e error) {
+ hosts, _, _, _, err := readManifest(jirix, false)
if err != nil {
return err
}
path, perm := filepath.Dir(op.destination), os.FileMode(0755)
- if err := ctx.Run().MkdirAll(path, perm); err != nil {
+ if err := jirix.Run().MkdirAll(path, perm); err != nil {
return err
}
// Create a temporary directory for the initial setup of the
// project to prevent an untimely termination from leaving the
// $JIRI_ROOT directory in an inconsistent state.
tmpDirPrefix := strings.Replace(op.Project().Name, "/", ".", -1) + "-"
- tmpDir, err := ctx.Run().TempDir(path, tmpDirPrefix)
+ tmpDir, err := jirix.Run().TempDir(path, tmpDirPrefix)
if err != nil {
return err
}
- defer collect.Error(func() error { return ctx.Run().RemoveAll(tmpDir) }, &e)
+ defer collect.Error(func() error { return jirix.Run().RemoveAll(tmpDir) }, &e)
switch op.project.Protocol {
case "git":
- if err := ctx.Git().Clone(op.project.Remote, tmpDir); err != nil {
+ if err := jirix.Git().Clone(op.project.Remote, tmpDir); err != nil {
return err
}
@@ -1348,12 +1349,12 @@
if err != nil {
return err
}
- src, err := ctx.Run().ReadFile(filepath.Join(mdir, githook.Path))
+ src, err := jirix.Run().ReadFile(filepath.Join(mdir, githook.Path))
if err != nil {
return err
}
dst := filepath.Join(gitHookDir, githook.Name)
- if err := ctx.Run().WriteFile(dst, src, perm); err != nil {
+ if err := jirix.Run().WriteFile(dst, src, perm); err != nil {
return err
}
}
@@ -1363,11 +1364,11 @@
// write to .git/info/exclude
excludeString := "/.jiri/\n"
excludeDir := filepath.Join(tmpDir, ".git", "info")
- if err := ctx.Run().MkdirAll(excludeDir, os.FileMode(0750)); err != nil {
+ if err := jirix.Run().MkdirAll(excludeDir, os.FileMode(0750)); err != nil {
return err
}
excludeFile := filepath.Join(excludeDir, "exclude")
- if err := ctx.Run().WriteFile(excludeFile, []byte(excludeString), perm); err != nil {
+ if err := jirix.Run().WriteFile(excludeFile, []byte(excludeString), perm); err != nil {
return err
}
@@ -1375,38 +1376,38 @@
if err != nil {
return err
}
- defer collect.Error(func() error { return ctx.Run().Chdir(cwd) }, &e)
- if err := ctx.Run().Chdir(tmpDir); err != nil {
+ defer collect.Error(func() error { return jirix.Run().Chdir(cwd) }, &e)
+ if err := jirix.Run().Chdir(tmpDir); err != nil {
return err
}
- if err := ctx.Git().Reset(op.project.Revision); err != nil {
+ if err := jirix.Git().Reset(op.project.Revision); err != nil {
return err
}
default:
return UnsupportedProtocolErr(op.project.Protocol)
}
- if err := writeMetadata(ctx, op.project, tmpDir); err != nil {
+ if err := writeMetadata(jirix, op.project, tmpDir); err != nil {
return err
}
- if err := ctx.Run().Chmod(tmpDir, os.FileMode(0755)); err != nil {
+ if err := jirix.Run().Chmod(tmpDir, os.FileMode(0755)); err != nil {
return err
}
- if err := ctx.Run().Rename(tmpDir, op.destination); err != nil {
+ if err := jirix.Run().Rename(tmpDir, op.destination); err != nil {
return err
}
- if err := resetProject(ctx, op.project); err != nil {
+ if err := resetProject(jirix, op.project); err != nil {
return err
}
- return addProjectToManifest(ctx, manifest, op.project)
+ return addProjectToManifest(jirix, manifest, op.project)
}
func (op createOperation) String() string {
return fmt.Sprintf("create project %q in %q and advance it to %q", op.project.Name, op.destination, fmtRevision(op.project.Revision))
}
-func (op createOperation) Test(ctx *tool.Context) error {
+func (op createOperation) Test(jirix *jiri.X) error {
// Check the local file system.
- if _, err := ctx.Run().Stat(op.destination); err != nil {
+ if _, err := jirix.Run().Stat(op.destination); err != nil {
if !os.IsNotExist(err) {
return err
}
@@ -1424,7 +1425,7 @@
gc bool
}
-func (op deleteOperation) Run(ctx *tool.Context, _ *Manifest) error {
+func (op deleteOperation) Run(jirix *jiri.X, _ *Manifest) error {
if op.gc {
// Never delete the <JiriProject>.
if op.project.Name == JiriProject {
@@ -1434,12 +1435,12 @@
"development tools and will thus not be deleted",
}
opts := runutil.Opts{Verbose: true}
- ctx.Run().OutputWithOpts(opts, lines)
+ jirix.Run().OutputWithOpts(opts, lines)
return nil
}
// Never delete projects with non-master branches, uncommitted
// work, or untracked content.
- git := ctx.Git(tool.RootDirOpt(op.project.Path))
+ git := jirix.Git(tool.RootDirOpt(op.project.Path))
branches, _, err := git.GetBranches()
if err != nil {
return err
@@ -1459,10 +1460,10 @@
"work, or untracked files and will thus not be deleted",
}
opts := runutil.Opts{Verbose: true}
- ctx.Run().OutputWithOpts(opts, lines)
+ jirix.Run().OutputWithOpts(opts, lines)
return nil
}
- return ctx.Run().RemoveAll(op.source)
+ return jirix.Run().RemoveAll(op.source)
}
lines := []string{
fmt.Sprintf("NOTE: project %v was not found in the project manifest", op.project.Name),
@@ -1471,7 +1472,7 @@
`or invoke "jiri update -gc" to remove all such local projects`,
}
opts := runutil.Opts{Verbose: true}
- ctx.Run().OutputWithOpts(opts, lines)
+ jirix.Run().OutputWithOpts(opts, lines)
return nil
}
@@ -1479,8 +1480,8 @@
return fmt.Sprintf("delete project %q from %q", op.project.Name, op.source)
}
-func (op deleteOperation) Test(ctx *tool.Context) error {
- if _, err := ctx.Run().Stat(op.source); err != nil {
+func (op deleteOperation) Test(jirix *jiri.X) error {
+ if _, err := jirix.Run().Stat(op.source); err != nil {
if os.IsNotExist(err) {
return fmt.Errorf("cannot delete %q as it does not exist", op.source)
}
@@ -1494,38 +1495,38 @@
commonOperation
}
-func (op moveOperation) Run(ctx *tool.Context, manifest *Manifest) error {
+func (op moveOperation) Run(jirix *jiri.X, manifest *Manifest) error {
path, perm := filepath.Dir(op.destination), os.FileMode(0755)
- if err := ctx.Run().MkdirAll(path, perm); err != nil {
+ if err := jirix.Run().MkdirAll(path, perm); err != nil {
return err
}
- if err := ctx.Run().Rename(op.source, op.destination); err != nil {
+ if err := jirix.Run().Rename(op.source, op.destination); err != nil {
return err
}
- if err := reportNonMaster(ctx, op.project); err != nil {
+ if err := reportNonMaster(jirix, op.project); err != nil {
return err
}
- if err := resetProject(ctx, op.project); err != nil {
+ if err := resetProject(jirix, op.project); err != nil {
return err
}
- if err := writeMetadata(ctx, op.project, op.project.Path); err != nil {
+ if err := writeMetadata(jirix, op.project, op.project.Path); err != nil {
return err
}
- return addProjectToManifest(ctx, manifest, op.project)
+ return addProjectToManifest(jirix, manifest, op.project)
}
func (op moveOperation) String() string {
return fmt.Sprintf("move project %q located in %q to %q and advance it to %q", op.project.Name, op.source, op.destination, fmtRevision(op.project.Revision))
}
-func (op moveOperation) Test(ctx *tool.Context) error {
- if _, err := ctx.Run().Stat(op.source); err != nil {
+func (op moveOperation) Test(jirix *jiri.X) error {
+ if _, err := jirix.Run().Stat(op.source); err != nil {
if os.IsNotExist(err) {
return fmt.Errorf("cannot move %q to %q as the source does not exist", op.source, op.destination)
}
return err
}
- if _, err := ctx.Run().Stat(op.destination); err != nil {
+ if _, err := jirix.Run().Stat(op.destination); err != nil {
if !os.IsNotExist(err) {
return err
}
@@ -1540,24 +1541,24 @@
commonOperation
}
-func (op updateOperation) Run(ctx *tool.Context, manifest *Manifest) error {
- if err := reportNonMaster(ctx, op.project); err != nil {
+func (op updateOperation) Run(jirix *jiri.X, manifest *Manifest) error {
+ if err := reportNonMaster(jirix, op.project); err != nil {
return err
}
- if err := resetProject(ctx, op.project); err != nil {
+ if err := resetProject(jirix, op.project); err != nil {
return err
}
- if err := writeMetadata(ctx, op.project, op.project.Path); err != nil {
+ if err := writeMetadata(jirix, op.project, op.project.Path); err != nil {
return err
}
- return addProjectToManifest(ctx, manifest, op.project)
+ return addProjectToManifest(jirix, manifest, op.project)
}
func (op updateOperation) String() string {
return fmt.Sprintf("advance project %q located in %q to %q", op.project.Name, op.source, fmtRevision(op.project.Revision))
}
-func (op updateOperation) Test(ctx *tool.Context) error {
+func (op updateOperation) Test(jirix *jiri.X) error {
return nil
}
@@ -1567,15 +1568,15 @@
commonOperation
}
-func (op nullOperation) Run(ctx *tool.Context, manifest *Manifest) error {
- return addProjectToManifest(ctx, manifest, op.project)
+func (op nullOperation) Run(jirix *jiri.X, manifest *Manifest) error {
+ return addProjectToManifest(jirix, manifest, op.project)
}
func (op nullOperation) String() string {
return fmt.Sprintf("project %q located in %q at revision %q is up-to-date", op.project.Name, op.source, fmtRevision(op.project.Revision))
}
-func (op nullOperation) Test(ctx *tool.Context) error {
+func (op nullOperation) Test(jirix *jiri.X) error {
return nil
}
@@ -1696,8 +1697,8 @@
// ParseNames identifies the set of projects that a jiri command should
// be applied to.
-func ParseNames(ctx *tool.Context, args []string, defaultProjects map[string]struct{}) (map[string]Project, error) {
- projects, _, err := ReadManifest(ctx)
+func ParseNames(jirix *jiri.X, args []string, defaultProjects map[string]struct{}) (map[string]Project, error) {
+ projects, _, err := ReadManifest(jirix)
if err != nil {
return nil, err
}
@@ -1712,7 +1713,7 @@
} else {
// Issue a warning if the target project does not exist in the
// project manifest.
- fmt.Fprintf(ctx.Stderr(), "WARNING: project %q does not exist in the project manifest and will be skipped\n", name)
+ fmt.Fprintf(jirix.Stderr(), "WARNING: project %q does not exist in the project manifest and will be skipped\n", name)
}
}
return result, nil
diff --git a/project/project_test.go b/project/project_test.go
index 3355850..b15b445 100644
--- a/project/project_test.go
+++ b/project/project_test.go
@@ -18,25 +18,26 @@
"strings"
"testing"
- "v.io/jiri/tool"
+ "v.io/jiri/jiri"
+ "v.io/jiri/jiri/jiritest"
)
-func addRemote(t *testing.T, ctx *tool.Context, localProject, name, remoteProject string) {
+func addRemote(t *testing.T, jirix *jiri.X, localProject, name, remoteProject string) {
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("%v", err)
}
- defer ctx.Run().Chdir(cwd)
- if err := ctx.Run().Chdir(localProject); err != nil {
+ defer jirix.Run().Chdir(cwd)
+ if err := jirix.Run().Chdir(localProject); err != nil {
t.Fatalf("%v", err)
}
- if err := ctx.Git().AddRemote(name, remoteProject); err != nil {
+ if err := jirix.Git().AddRemote(name, remoteProject); err != nil {
t.Fatalf("%v", err)
}
}
-func checkReadme(t *testing.T, ctx *tool.Context, project, message string) {
- if _, err := ctx.Run().Stat(project); err != nil {
+func checkReadme(t *testing.T, jirix *jiri.X, project, message string) {
+ if _, err := jirix.Run().Stat(project); err != nil {
t.Fatalf("%v", err)
}
readmeFile := filepath.Join(project, "README")
@@ -50,8 +51,8 @@
}
// Checks that /.jiri/ is ignored in a local project checkout
-func checkGitIgnore(t *testing.T, ctx *tool.Context, project string) {
- if _, err := ctx.Run().Stat(project); err != nil {
+func checkGitIgnore(t *testing.T, jirix *jiri.X, project string) {
+ if _, err := jirix.Run().Stat(project); err != nil {
t.Fatalf("%v", err)
}
gitInfoExcludeFile := filepath.Join(project, ".git", "info", "exclude")
@@ -65,7 +66,7 @@
}
}
-func createLocalManifestCopy(t *testing.T, ctx *tool.Context, dir, manifestDir string) {
+func createLocalManifestCopy(t *testing.T, jirix *jiri.X, dir, manifestDir string) {
// Load the remote manifest.
manifestFile := filepath.Join(manifestDir, "v2", "default")
data, err := ioutil.ReadFile(manifestFile)
@@ -88,7 +89,7 @@
}
}
-func createLocalManifestStub(t *testing.T, ctx *tool.Context, dir string) {
+func createLocalManifestStub(t *testing.T, jirix *jiri.X, dir string) {
// Create a manifest stub.
manifest := Manifest{}
manifest.Imports = append(manifest.Imports, Import{Name: "default"})
@@ -104,9 +105,9 @@
}
}
-func createRemoteManifest(t *testing.T, ctx *tool.Context, dir string, remotes []string) {
+func createRemoteManifest(t *testing.T, jirix *jiri.X, dir string, remotes []string) {
manifestDir, perm := filepath.Join(dir, "v2"), os.FileMode(0755)
- if err := ctx.Run().MkdirAll(manifestDir, perm); err != nil {
+ if err := jirix.Run().MkdirAll(manifestDir, perm); err != nil {
t.Fatalf("%v", err)
}
manifest := Manifest{}
@@ -129,10 +130,10 @@
Location: "git://example.com/git",
},
}
- commitManifest(t, ctx, &manifest, dir)
+ commitManifest(t, jirix, &manifest, dir)
}
-func commitManifest(t *testing.T, ctx *tool.Context, manifest *Manifest, manifestDir string) {
+func commitManifest(t *testing.T, jirix *jiri.X, manifest *Manifest, manifestDir string) {
data, err := xml.Marshal(*manifest)
if err != nil {
t.Fatalf("%v", err)
@@ -145,16 +146,16 @@
if err != nil {
t.Fatalf("%v", err)
}
- defer ctx.Run().Chdir(cwd)
- if err := ctx.Run().Chdir(manifestDir); err != nil {
+ defer jirix.Run().Chdir(cwd)
+ if err := jirix.Run().Chdir(manifestDir); err != nil {
t.Fatalf("%v", err)
}
- if err := ctx.Git().CommitFile(manifestFile, "creating manifest"); err != nil {
+ if err := jirix.Git().CommitFile(manifestFile, "creating manifest"); err != nil {
t.Fatalf("%v", err)
}
}
-func deleteProject(t *testing.T, ctx *tool.Context, manifestDir, project string) {
+func deleteProject(t *testing.T, jirix *jiri.X, manifestDir, project string) {
manifestFile := filepath.Join(manifestDir, "v2", "default")
data, err := ioutil.ReadFile(manifestFile)
if err != nil {
@@ -165,20 +166,20 @@
t.Fatalf("Unmarshal() failed: %v\n%v", err, data)
}
manifest.Projects = append(manifest.Projects, Project{Exclude: true, Name: project})
- commitManifest(t, ctx, &manifest, manifestDir)
+ commitManifest(t, jirix, &manifest, manifestDir)
}
// Identify the current revision for a given project.
-func currentRevision(t *testing.T, ctx *tool.Context, project string) string {
+func currentRevision(t *testing.T, jirix *jiri.X, project string) string {
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("%v", err)
}
- defer ctx.Run().Chdir(cwd)
- if err := ctx.Run().Chdir(project); err != nil {
+ defer jirix.Run().Chdir(cwd)
+ if err := jirix.Run().Chdir(project); err != nil {
t.Fatalf("%v", err)
}
- revision, err := ctx.Git().CurrentRevision()
+ revision, err := jirix.Git().CurrentRevision()
if err != nil {
t.Fatalf("%v", err)
}
@@ -186,7 +187,7 @@
}
// Fix the revision in the manifest file.
-func setRevisionForProject(t *testing.T, ctx *tool.Context, manifestDir, project, revision string) {
+func setRevisionForProject(t *testing.T, jirix *jiri.X, manifestDir, project, revision string) {
manifestFile := filepath.Join(manifestDir, "v2", "default")
data, err := ioutil.ReadFile(manifestFile)
if err != nil {
@@ -208,19 +209,19 @@
if !updated {
t.Fatalf("failed to fix revision for project %v", project)
}
- commitManifest(t, ctx, &manifest, manifestDir)
+ commitManifest(t, jirix, &manifest, manifestDir)
}
-func holdProjectBack(t *testing.T, ctx *tool.Context, manifestDir, project string) {
- revision := currentRevision(t, ctx, project)
- setRevisionForProject(t, ctx, manifestDir, project, revision)
+func holdProjectBack(t *testing.T, jirix *jiri.X, manifestDir, project string) {
+ revision := currentRevision(t, jirix, project)
+ setRevisionForProject(t, jirix, manifestDir, project, revision)
}
func localProjectName(i int) string {
return "test-local-project-" + fmt.Sprintf("%d", i)
}
-func moveProject(t *testing.T, ctx *tool.Context, manifestDir, project, dst string) {
+func moveProject(t *testing.T, jirix *jiri.X, manifestDir, project, dst string) {
manifestFile := filepath.Join(manifestDir, "v2", "default")
data, err := ioutil.ReadFile(manifestFile)
if err != nil {
@@ -242,50 +243,50 @@
if !updated {
t.Fatalf("failed to set path for project %v", project)
}
- commitManifest(t, ctx, &manifest, manifestDir)
+ commitManifest(t, jirix, &manifest, manifestDir)
}
func remoteProjectName(i int) string {
return "test-remote-project-" + fmt.Sprintf("%d", i)
}
-func setupNewProject(t *testing.T, ctx *tool.Context, dir, name string, ignore bool) string {
+func setupNewProject(t *testing.T, jirix *jiri.X, dir, name string, ignore bool) string {
projectDir, perm := filepath.Join(dir, name), os.FileMode(0755)
- if err := ctx.Run().MkdirAll(projectDir, perm); err != nil {
+ if err := jirix.Run().MkdirAll(projectDir, perm); err != nil {
t.Fatalf("%v", err)
}
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("%v", err)
}
- defer ctx.Run().Chdir(cwd)
- if err := ctx.Run().Chdir(projectDir); err != nil {
+ defer jirix.Run().Chdir(cwd)
+ if err := jirix.Run().Chdir(projectDir); err != nil {
t.Fatalf("%v", err)
}
- if err := ctx.Git().Init(projectDir); err != nil {
+ if err := jirix.Git().Init(projectDir); err != nil {
t.Fatalf("%v", err)
}
if ignore {
ignoreFile := filepath.Join(projectDir, ".gitignore")
- if err := ctx.Run().WriteFile(ignoreFile, []byte(metadataDirName), os.FileMode(0644)); err != nil {
+ if err := jirix.Run().WriteFile(ignoreFile, []byte(metadataDirName), os.FileMode(0644)); err != nil {
t.Fatalf("%v", err)
}
- if err := ctx.Git().Add(ignoreFile); err != nil {
+ if err := jirix.Git().Add(ignoreFile); err != nil {
t.Fatalf("%v", err)
}
}
- if err := ctx.Git().Commit(); err != nil {
+ if err := jirix.Git().Commit(); err != nil {
t.Fatalf("%v", err)
}
return projectDir
}
-func writeEmptyMetadata(t *testing.T, ctx *tool.Context, projectDir string) {
- if err := ctx.Run().Chdir(projectDir); err != nil {
+func writeEmptyMetadata(t *testing.T, jirix *jiri.X, projectDir string) {
+ if err := jirix.Run().Chdir(projectDir); err != nil {
t.Fatalf("%v", err)
}
metadataDir := filepath.Join(projectDir, metadataDirName)
- if err := ctx.Run().MkdirAll(metadataDir, os.FileMode(0755)); err != nil {
+ if err := jirix.Run().MkdirAll(metadataDir, os.FileMode(0755)); err != nil {
t.Fatalf("%v", err)
}
bytes, err := xml.Marshal(Project{})
@@ -293,12 +294,12 @@
t.Fatalf("Marshal() failed: %v", err)
}
metadataFile := filepath.Join(metadataDir, metadataFileName)
- if err := ctx.Run().WriteFile(metadataFile, bytes, os.FileMode(0644)); err != nil {
+ if err := jirix.Run().WriteFile(metadataFile, bytes, os.FileMode(0644)); err != nil {
t.Fatalf("%v", err)
}
}
-func writeReadme(t *testing.T, ctx *tool.Context, projectDir, message string) {
+func writeReadme(t *testing.T, jirix *jiri.X, projectDir, message string) {
path, perm := filepath.Join(projectDir, "README"), os.FileMode(0644)
if err := ioutil.WriteFile(path, []byte(message), perm); err != nil {
t.Fatalf("WriteFile(%v, %v) failed: %v", path, perm, err)
@@ -307,39 +308,39 @@
if err != nil {
t.Fatalf("%v", err)
}
- defer ctx.Run().Chdir(cwd)
- if err := ctx.Run().Chdir(projectDir); err != nil {
+ defer jirix.Run().Chdir(cwd)
+ if err := jirix.Run().Chdir(projectDir); err != nil {
t.Fatalf("%v", err)
}
- if err := ctx.Git().CommitFile(path, "creating README"); err != nil {
+ if err := jirix.Git().CommitFile(path, "creating README"); err != nil {
t.Fatalf("%v", err)
}
}
-func createAndCheckoutBranch(t *testing.T, ctx *tool.Context, projectDir, branch string) {
+func createAndCheckoutBranch(t *testing.T, jirix *jiri.X, projectDir, branch string) {
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("%v", err)
}
- defer ctx.Run().Chdir(cwd)
- if err := ctx.Run().Chdir(projectDir); err != nil {
+ defer jirix.Run().Chdir(cwd)
+ if err := jirix.Run().Chdir(projectDir); err != nil {
t.Fatalf("%v", err)
}
- if err := ctx.Git().CreateAndCheckoutBranch(branch); err != nil {
+ if err := jirix.Git().CreateAndCheckoutBranch(branch); err != nil {
t.Fatalf("%v", err)
}
}
-func resetToOriginMaster(t *testing.T, ctx *tool.Context, projectDir string) {
+func resetToOriginMaster(t *testing.T, jirix *jiri.X, projectDir string) {
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("%v", err)
}
- defer ctx.Run().Chdir(cwd)
- if err := ctx.Run().Chdir(projectDir); err != nil {
+ defer jirix.Run().Chdir(cwd)
+ if err := jirix.Run().Chdir(projectDir); err != nil {
t.Fatalf("%v", err)
}
- if err := ctx.Git().Reset("origin/master"); err != nil {
+ if err := jirix.Git().Reset("origin/master"); err != nil {
t.Fatalf("%v", err)
}
}
@@ -359,49 +360,40 @@
// TestLocalProjects tests the behavior of the LocalProjects method with
// different ScanModes.
func TestLocalProjects(t *testing.T) {
- ctx := tool.NewDefaultContext()
- rootDir, err := ctx.Run().TempDir("", "")
- if err != nil {
- t.Fatalf("TempDir() failed: %v", err)
- }
- defer ctx.Run().RemoveAll(rootDir)
- oldRoot := os.Getenv("JIRI_ROOT")
- if err := os.Setenv("JIRI_ROOT", rootDir); err != nil {
- t.Fatalf("%v", err)
- }
- defer os.Setenv("JIRI_ROOT", oldRoot)
+ jirix, cleanup := jiritest.NewX(t)
+ defer cleanup()
- manifestDir := setupNewProject(t, ctx, rootDir, ".manifest", false)
+ manifestDir := setupNewProject(t, jirix, jirix.Root, ".manifest", false)
// Create some projects.
numProjects, projectPaths := 3, []string{}
for i := 0; i < numProjects; i++ {
projectName := localProjectName(i)
- projectPath := setupNewProject(t, ctx, rootDir, projectName, true)
+ projectPath := setupNewProject(t, jirix, jirix.Root, projectName, true)
project := Project{
Path: projectPath,
Name: projectName,
Protocol: "git",
}
- if err := writeMetadata(ctx, project, projectPath); err != nil {
+ if err := writeMetadata(jirix, project, projectPath); err != nil {
t.Fatalf("writeMetadata %v %v) failed: %v\n", project, projectPath, err)
}
projectPaths = append(projectPaths, projectPath)
}
// Create manifest but only tell it about the first project.
- createRemoteManifest(t, ctx, manifestDir, projectPaths[:1])
+ createRemoteManifest(t, jirix, manifestDir, projectPaths[:1])
// LocalProjects with scanMode = FastScan should only find the first
// project.
- foundProjects, err := LocalProjects(ctx, FastScan)
+ foundProjects, err := LocalProjects(jirix, FastScan)
if err != nil {
t.Fatalf("LocalProjects(%v) failed: %v", FastScan, err)
}
checkProjectsMatchPaths(t, foundProjects, projectPaths[:1])
// LocalProjects with scanMode = FullScan should find all projects.
- foundProjects, err = LocalProjects(ctx, FullScan)
+ foundProjects, err = LocalProjects(jirix, FullScan)
if err != nil {
t.Fatalf("LocalProjects(%v) failed: %v", FastScan, err)
}
@@ -409,10 +401,10 @@
// Check that deleting a project forces LocalProjects to run a full scan,
// even if FastScan is specified.
- if err := ctx.Run().RemoveAll(projectPaths[0]); err != nil {
+ if err := jirix.Run().RemoveAll(projectPaths[0]); err != nil {
t.Fatalf("RemoveAll(%v) failed: %v", projectPaths[0])
}
- foundProjects, err = LocalProjects(ctx, FastScan)
+ foundProjects, err = LocalProjects(jirix, FastScan)
if err != nil {
t.Fatalf("LocalProjects(%v) failed: %v", FastScan, err)
}
@@ -427,50 +419,46 @@
// Setup an instance of jiri universe, creating the remote repositories for
// the manifest and projects under the "remote" directory, which is ignored
// from the consideration of LocalProjects().
- ctx := tool.NewDefaultContext()
- rootDir, err := ctx.Run().TempDir("", "")
- if err != nil {
- t.Fatalf("TempDir() failed: %v", err)
- }
- defer ctx.Run().RemoveAll(rootDir)
- localDir := filepath.Join(rootDir, "local")
- remoteDir := filepath.Join(rootDir, "remote")
- localManifest := setupNewProject(t, ctx, localDir, ".manifest", false)
- writeEmptyMetadata(t, ctx, localManifest)
- remoteManifest := setupNewProject(t, ctx, remoteDir, "test-remote-manifest", false)
- addRemote(t, ctx, localManifest, "origin", remoteManifest)
- numProjects, remoteProjects := 5, []string{}
- for i := 0; i < numProjects; i++ {
- remoteProject := setupNewProject(t, ctx, remoteDir, remoteProjectName(i), true)
- remoteProjects = append(remoteProjects, remoteProject)
- }
- createRemoteManifest(t, ctx, remoteManifest, remoteProjects)
- oldRoot := os.Getenv("JIRI_ROOT")
+ jirix, cleanup := jiritest.NewX(t)
+ defer cleanup()
+
+ localDir := filepath.Join(jirix.Root, "local")
+ remoteDir := filepath.Join(jirix.Root, "remote")
if err := os.Setenv("JIRI_ROOT", localDir); err != nil {
t.Fatalf("%v", err)
}
- defer os.Setenv("JIRI_ROOT", oldRoot)
+
+ localManifest := setupNewProject(t, jirix, localDir, ".manifest", false)
+ writeEmptyMetadata(t, jirix, localManifest)
+ remoteManifest := setupNewProject(t, jirix, remoteDir, "test-remote-manifest", false)
+ addRemote(t, jirix, localManifest, "origin", remoteManifest)
+ numProjects, remoteProjects := 5, []string{}
+ for i := 0; i < numProjects; i++ {
+ remoteProject := setupNewProject(t, jirix, remoteDir, remoteProjectName(i), true)
+ remoteProjects = append(remoteProjects, remoteProject)
+ }
+ createRemoteManifest(t, jirix, remoteManifest, remoteProjects)
// Check that calling UpdateUniverse() creates local copies of
// the remote repositories, advancing projects to HEAD or to
// the fixed revision set in the manifest.
for _, remoteProject := range remoteProjects {
- writeReadme(t, ctx, remoteProject, "revision 1")
+ writeReadme(t, jirix, remoteProject, "revision 1")
}
- holdProjectBack(t, ctx, remoteManifest, remoteProjects[0])
+ holdProjectBack(t, jirix, remoteManifest, remoteProjects[0])
for _, remoteProject := range remoteProjects {
- writeReadme(t, ctx, remoteProject, "revision 2")
+ writeReadme(t, jirix, remoteProject, "revision 2")
}
- if err := UpdateUniverse(ctx, false); err != nil {
+ if err := UpdateUniverse(jirix, false); err != nil {
t.Fatalf("%v", err)
}
checkCreateFn := func(i int, revision string) {
localProject := filepath.Join(localDir, localProjectName(i))
- checkGitIgnore(t, ctx, localProject)
+ checkGitIgnore(t, jirix, localProject)
if i == 0 {
- checkReadme(t, ctx, localProject, "revision 1")
+ checkReadme(t, jirix, localProject, "revision 1")
} else {
- checkReadme(t, ctx, localProject, revision)
+ checkReadme(t, jirix, localProject, revision)
}
}
for i, _ := range remoteProjects {
@@ -480,16 +468,16 @@
// Commit more work to the remote repositories and check that
// calling UpdateUniverse() advances project to HEAD or to the
// fixed revision set in the manifest.
- holdProjectBack(t, ctx, remoteManifest, remoteProjects[1])
+ holdProjectBack(t, jirix, remoteManifest, remoteProjects[1])
for _, remoteProject := range remoteProjects {
- writeReadme(t, ctx, remoteProject, "revision 3")
+ writeReadme(t, jirix, remoteProject, "revision 3")
}
- if err := UpdateUniverse(ctx, false); err != nil {
+ if err := UpdateUniverse(jirix, false); err != nil {
t.Fatalf("%v", err)
}
checkUpdateFn := func(i int, revision string) {
if i == 1 {
- checkReadme(t, ctx, filepath.Join(localDir, localProjectName(i)), "revision 2")
+ checkReadme(t, jirix, filepath.Join(localDir, localProjectName(i)), "revision 2")
} else {
checkCreateFn(i, revision)
}
@@ -506,7 +494,7 @@
if err := ioutil.WriteFile(file, want, perm); err != nil {
t.Fatalf("WriteFile(%v, %v) failed: %v", file, err, perm)
}
- if err := UpdateUniverse(ctx, false); err != nil {
+ if err := UpdateUniverse(jirix, false); err != nil {
t.Fatalf("%v", err)
}
got, err := ioutil.ReadFile(file)
@@ -521,13 +509,13 @@
// located and check that UpdateUniverse() moves the local
// copy of the project.
destination := filepath.Join("test", localProjectName(2))
- moveProject(t, ctx, remoteManifest, remoteProjects[2], destination)
- if err := UpdateUniverse(ctx, false); err != nil {
+ moveProject(t, jirix, remoteManifest, remoteProjects[2], destination)
+ if err := UpdateUniverse(jirix, false); err != nil {
t.Fatalf("%v", err)
}
checkMoveFn := func(i int, revision string) {
if i == 2 {
- checkReadme(t, ctx, filepath.Join(localDir, destination), revision)
+ checkReadme(t, jirix, filepath.Join(localDir, destination), revision)
} else {
checkUpdateFn(i, revision)
}
@@ -538,14 +526,14 @@
// Delete a remote project and check that UpdateUniverse()
// deletes the local copy of the project.
- deleteProject(t, ctx, remoteManifest, remoteProjects[3])
- if err := UpdateUniverse(ctx, true); err != nil {
+ deleteProject(t, jirix, remoteManifest, remoteProjects[3])
+ if err := UpdateUniverse(jirix, true); err != nil {
t.Fatalf("%v", err)
}
checkDeleteFn := func(i int, revision string) {
if i == 3 {
localProject := filepath.Join(localDir, localProjectName(i))
- if _, err := ctx.Run().Stat(localProject); err == nil {
+ if _, err := jirix.Run().Stat(localProject); err == nil {
t.Fatalf("project %v has not been deleted", localProject)
} else {
if !os.IsNotExist(err) {
@@ -563,32 +551,32 @@
// Commit to a non-master branch of a remote project and check that
// UpdateUniverse() can update the local project to point to a revision on
// that branch.
- writeReadme(t, ctx, remoteProjects[4], "master commit")
- createAndCheckoutBranch(t, ctx, remoteProjects[4], "non_master")
- writeReadme(t, ctx, remoteProjects[4], "non master commit")
- remoteBranchRevision := currentRevision(t, ctx, remoteProjects[4])
- setRevisionForProject(t, ctx, remoteManifest, remoteProjects[4], remoteBranchRevision)
- if err := UpdateUniverse(ctx, true); err != nil {
+ writeReadme(t, jirix, remoteProjects[4], "master commit")
+ createAndCheckoutBranch(t, jirix, remoteProjects[4], "non_master")
+ writeReadme(t, jirix, remoteProjects[4], "non master commit")
+ remoteBranchRevision := currentRevision(t, jirix, remoteProjects[4])
+ setRevisionForProject(t, jirix, remoteManifest, remoteProjects[4], remoteBranchRevision)
+ if err := UpdateUniverse(jirix, true); err != nil {
t.Fatalf("%v", err)
}
localProject := filepath.Join(localDir, localProjectName(4))
- localBranchRevision := currentRevision(t, ctx, localProject)
+ localBranchRevision := currentRevision(t, jirix, localProject)
if localBranchRevision != remoteBranchRevision {
t.Fatalf("project 4 is at revision %v, expected %v\n", localBranchRevision, remoteBranchRevision)
}
// Reset back to origin/master so the next update without a "revision" works.
- resetToOriginMaster(t, ctx, localProject)
+ resetToOriginMaster(t, jirix, localProject)
// Create a local manifest that imports the remote manifest
// and check that UpdateUniverse() has no effect.
- createLocalManifestStub(t, ctx, localDir)
- if err := UpdateUniverse(ctx, true); err != nil {
+ createLocalManifestStub(t, jirix, localDir)
+ if err := UpdateUniverse(jirix, true); err != nil {
t.Fatalf("%v", err)
}
checkRebaseFn := func(i int, revision string) {
if i == 4 {
- checkReadme(t, ctx, localProject, "non master commit")
+ checkReadme(t, jirix, localProject, "non master commit")
} else {
checkDeleteFn(i, revision)
}
@@ -600,9 +588,9 @@
// Create a local manifest that matches the remote manifest,
// then revert the remote manifest to its initial version and
// check that UpdateUniverse() has no effect.
- createLocalManifestCopy(t, ctx, localDir, remoteManifest)
- createRemoteManifest(t, ctx, remoteManifest, remoteProjects)
- if err := UpdateUniverse(ctx, true); err != nil {
+ createLocalManifestCopy(t, jirix, localDir, remoteManifest)
+ createRemoteManifest(t, jirix, remoteManifest, remoteProjects)
+ if err := UpdateUniverse(jirix, true); err != nil {
t.Fatalf("%v", err)
}
for i, _ := range remoteProjects {
diff --git a/project/state.go b/project/state.go
index eef43b5..2f86aa9 100644
--- a/project/state.go
+++ b/project/state.go
@@ -8,6 +8,7 @@
"os"
"path/filepath"
+ "v.io/jiri/jiri"
"v.io/jiri/tool"
)
@@ -24,11 +25,11 @@
Project Project
}
-func setProjectState(ctx *tool.Context, state *ProjectState, checkDirty bool, ch chan<- error) {
+func setProjectState(jirix *jiri.X, state *ProjectState, checkDirty bool, ch chan<- error) {
var err error
switch state.Project.Protocol {
case "git":
- scm := ctx.Git(tool.RootDirOpt(state.Project.Path))
+ scm := jirix.Git(tool.RootDirOpt(state.Project.Path))
var branches []string
branches, state.CurrentBranch, err = scm.GetBranches()
if err != nil {
@@ -38,7 +39,7 @@
for _, branch := range branches {
file := filepath.Join(state.Project.Path, MetadataDirName(), branch, ".gerrit_commit_message")
hasFile := true
- if _, err := ctx.Run().Stat(file); err != nil {
+ if _, err := jirix.Run().Stat(file); err != nil {
if !os.IsNotExist(err) {
ch <- err
return
@@ -69,8 +70,8 @@
ch <- nil
}
-func GetProjectStates(ctx *tool.Context, checkDirty bool) (map[string]*ProjectState, error) {
- projects, err := LocalProjects(ctx, FastScan)
+func GetProjectStates(jirix *jiri.X, checkDirty bool) (map[string]*ProjectState, error) {
+ projects, err := LocalProjects(jirix, FastScan)
if err != nil {
return nil, err
}
@@ -81,8 +82,8 @@
Project: project,
}
states[name] = state
- // ctx is not threadsafe, so we make a clone for each goroutine.
- go setProjectState(ctx.Clone(tool.ContextOpts{}), state, checkDirty, sem)
+ // jirix is not threadsafe, so we make a clone for each goroutine.
+ go setProjectState(jirix.Clone(tool.ContextOpts{}), state, checkDirty, sem)
}
for _ = range projects {
err := <-sem
diff --git a/rebuild.go b/rebuild.go
index 577c1d8..2ca2de0 100644
--- a/rebuild.go
+++ b/rebuild.go
@@ -8,14 +8,14 @@
"fmt"
"v.io/jiri/collect"
+ "v.io/jiri/jiri"
"v.io/jiri/project"
- "v.io/jiri/tool"
"v.io/x/lib/cmdline"
)
// cmdRebuild represents the "jiri rebuild" command.
var cmdRebuild = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runRebuild),
+ Runner: jiri.RunnerFunc(runRebuild),
Name: "rebuild",
Short: "Rebuild all jiri tools",
Long: `
@@ -28,21 +28,20 @@
`,
}
-func runRebuild(env *cmdline.Env, args []string) (e error) {
- ctx := tool.NewContextFromEnv(env)
- _, tools, err := project.ReadManifest(ctx)
+func runRebuild(jirix *jiri.X, args []string) (e error) {
+ _, tools, err := project.ReadManifest(jirix)
if err != nil {
return err
}
// Create a temporary directory in which tools will be built.
- tmpDir, err := ctx.Run().TempDir("", "tmp-jiri-rebuild")
+ tmpDir, err := jirix.Run().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 ctx.Run().RemoveAll(tmpDir) }, &e)
+ defer collect.Error(func() error { return jirix.Run().RemoveAll(tmpDir) }, &e)
// Paranoid sanity checking.
if _, ok := tools[project.JiriName]; !ok {
@@ -50,8 +49,8 @@
}
// Build and install tools.
- if err := project.BuildTools(ctx, tools, tmpDir); err != nil {
+ if err := project.BuildTools(jirix, tools, tmpDir); err != nil {
return err
}
- return project.InstallTools(ctx, tmpDir)
+ return project.InstallTools(jirix, tmpDir)
}
diff --git a/snapshot.go b/snapshot.go
index f90f81e..0afc338 100644
--- a/snapshot.go
+++ b/snapshot.go
@@ -15,8 +15,8 @@
"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"
)
@@ -47,7 +47,7 @@
// cmdSnapshotCreate represents the "jiri snapshot create" command.
var cmdSnapshotCreate = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runSnapshotCreate),
+ Runner: jiri.RunnerFunc(runSnapshotCreate),
Name: "create",
Short: "Create a new project snapshot",
Long: `
@@ -83,13 +83,12 @@
ArgsLong: "<label> is the snapshot label.",
}
-func runSnapshotCreate(env *cmdline.Env, args []string) error {
+func runSnapshotCreate(jirix *jiri.X, args []string) error {
if len(args) != 1 {
- return env.UsageErrorf("unexpected number of arguments")
+ return jirix.UsageErrorf("unexpected number of arguments")
}
label := args[0]
- ctx := tool.NewContextFromEnv(env)
- if err := checkSnapshotDir(ctx); err != nil {
+ if err := checkSnapshotDir(jirix); err != nil {
return err
}
snapshotDir, err := getSnapshotDir()
@@ -101,14 +100,14 @@
// state and push the changes to the remote repository (if
// applicable), or fail with no effect.
createFn := func() error {
- revision, err := ctx.Git().CurrentRevision()
+ revision, err := jirix.Git().CurrentRevision()
if err != nil {
return err
}
- if err := createSnapshot(ctx, snapshotDir, snapshotFile, label); err != nil {
+ if err := createSnapshot(jirix, snapshotDir, snapshotFile, label); err != nil {
// Clean up on all errors.
- ctx.Git().Reset(revision)
- ctx.Git().RemoveUntrackedFiles()
+ jirix.Git().Reset(revision)
+ jirix.Git().RemoveUntrackedFiles()
return err
}
return nil
@@ -120,7 +119,7 @@
Protocol: "git",
Revision: "HEAD",
}
- if err := project.ApplyToLocalMaster(ctx, project.Projects{p.Name: p}, createFn); err != nil {
+ if err := project.ApplyToLocalMaster(jirix, project.Projects{p.Name: p}, createFn); err != nil {
return err
}
return nil
@@ -128,53 +127,53 @@
// checkSnapshotDir makes sure that he local snapshot directory exists
// and is initialized properly.
-func checkSnapshotDir(ctx *tool.Context) (e error) {
+func checkSnapshotDir(jirix *jiri.X) (e error) {
snapshotDir, err := getSnapshotDir()
if err != nil {
return err
}
- if _, err := ctx.Run().Stat(snapshotDir); err != nil {
+ if _, err := jirix.Run().Stat(snapshotDir); err != nil {
if !os.IsNotExist(err) {
return err
}
if remoteFlag {
- if err := ctx.Run().MkdirAll(snapshotDir, 0755); err != nil {
+ if err := jirix.Run().MkdirAll(snapshotDir, 0755); err != nil {
return err
}
return nil
}
createFn := func() (err error) {
- if err := ctx.Run().MkdirAll(snapshotDir, 0755); err != nil {
+ if err := jirix.Run().MkdirAll(snapshotDir, 0755); err != nil {
return err
}
- if err := ctx.Git().Init(snapshotDir); err != nil {
+ if err := jirix.Git().Init(snapshotDir); err != nil {
return err
}
cwd, err := os.Getwd()
if err != nil {
return err
}
- defer collect.Error(func() error { return ctx.Run().Chdir(cwd) }, &e)
- if err := ctx.Run().Chdir(snapshotDir); err != nil {
+ defer collect.Error(func() error { return jirix.Run().Chdir(cwd) }, &e)
+ if err := jirix.Run().Chdir(snapshotDir); err != nil {
return err
}
- if err := ctx.Git().Commit(); err != nil {
+ if err := jirix.Git().Commit(); err != nil {
return err
}
return nil
}
if err := createFn(); err != nil {
- ctx.Run().RemoveAll(snapshotDir)
+ jirix.Run().RemoveAll(snapshotDir)
return err
}
}
return nil
}
-func createSnapshot(ctx *tool.Context, snapshotDir, snapshotFile, label string) error {
+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(ctx, snapshotFile); err != nil {
+ if err := project.CreateSnapshot(jirix, snapshotFile); err != nil {
return err
}
@@ -182,19 +181,19 @@
// latest snapshot.
symlink := filepath.Join(snapshotDir, label)
newSymlink := symlink + ".new"
- if err := ctx.Run().RemoveAll(newSymlink); err != nil {
+ if err := jirix.Run().RemoveAll(newSymlink); err != nil {
return err
}
relativeSnapshotPath := strings.TrimPrefix(snapshotFile, snapshotDir+string(os.PathSeparator))
- if err := ctx.Run().Symlink(relativeSnapshotPath, newSymlink); err != nil {
+ if err := jirix.Run().Symlink(relativeSnapshotPath, newSymlink); err != nil {
return err
}
- if err := ctx.Run().Rename(newSymlink, symlink); err != nil {
+ if err := jirix.Run().Rename(newSymlink, symlink); err != nil {
return err
}
// Revision the changes.
- if err := revisionChanges(ctx, snapshotDir, snapshotFile, label); err != nil {
+ if err := revisionChanges(jirix, snapshotDir, snapshotFile, label); err != nil {
return err
}
return nil
@@ -220,28 +219,28 @@
// revisionChanges commits changes identified by the given manifest
// file and label to the manifest repository and (if applicable)
// pushes these changes to the remote repository.
-func revisionChanges(ctx *tool.Context, snapshotDir, snapshotFile, label string) (e error) {
+func revisionChanges(jirix *jiri.X, snapshotDir, snapshotFile, label string) (e error) {
cwd, err := os.Getwd()
if err != nil {
return err
}
- defer collect.Error(func() error { return ctx.Run().Chdir(cwd) }, &e)
- if err := ctx.Run().Chdir(snapshotDir); err != nil {
+ defer collect.Error(func() error { return jirix.Run().Chdir(cwd) }, &e)
+ if err := jirix.Run().Chdir(snapshotDir); err != nil {
return err
}
relativeSnapshotPath := strings.TrimPrefix(snapshotFile, snapshotDir+string(os.PathSeparator))
- if err := ctx.Git().Add(relativeSnapshotPath); err != nil {
+ if err := jirix.Git().Add(relativeSnapshotPath); err != nil {
return err
}
- if err := ctx.Git().Add(label); err != nil {
+ if err := jirix.Git().Add(label); err != nil {
return err
}
name := strings.TrimPrefix(snapshotFile, snapshotDir)
- if err := ctx.Git().CommitWithMessage(fmt.Sprintf("adding snapshot %q for label %q", name, label)); err != nil {
+ if err := jirix.Git().CommitWithMessage(fmt.Sprintf("adding snapshot %q for label %q", name, label)); err != nil {
return err
}
if remoteFlag {
- if err := ctx.Git().Push("origin", "master", gitutil.VerifyOpt(false)); err != nil {
+ if err := jirix.Git().Push("origin", "master", gitutil.VerifyOpt(false)); err != nil {
return err
}
}
@@ -250,7 +249,7 @@
// cmdSnapshotList represents the "jiri snapshot list" command.
var cmdSnapshotList = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runSnapshotList),
+ Runner: jiri.RunnerFunc(runSnapshotList),
Name: "list",
Short: "List existing project snapshots",
Long: `
@@ -262,9 +261,8 @@
ArgsLong: "<label ...> is a list of snapshot labels.",
}
-func runSnapshotList(env *cmdline.Env, args []string) error {
- ctx := tool.NewContextFromEnv(env)
- if err := checkSnapshotDir(ctx); err != nil {
+func runSnapshotList(jirix *jiri.X, args []string) error {
+ if err := checkSnapshotDir(jirix); err != nil {
return err
}
@@ -300,12 +298,12 @@
failed := false
for _, label := range args {
labelDir := filepath.Join(snapshotDir, "labels", label)
- if _, err := ctx.Run().Stat(labelDir); err != nil {
+ if _, err := jirix.Run().Stat(labelDir); err != nil {
if !os.IsNotExist(err) {
return err
}
failed = true
- fmt.Fprintf(env.Stderr, "snapshot label %q not found", label)
+ fmt.Fprintf(jirix.Stderr(), "snapshot label %q not found", label)
}
}
if failed {
@@ -322,9 +320,9 @@
if err != nil {
return fmt.Errorf("ReadDir(%v) failed: %v", labelDir, err)
}
- fmt.Fprintf(env.Stdout, "snapshots of label %q:\n", label)
+ fmt.Fprintf(jirix.Stdout(), "snapshots of label %q:\n", label)
for _, fileInfo := range fileInfoList {
- fmt.Fprintf(env.Stdout, " %v\n", fileInfo.Name())
+ fmt.Fprintf(jirix.Stdout(), " %v\n", fileInfo.Name())
}
}
return nil
diff --git a/snapshot_test.go b/snapshot_test.go
index fe54d1d..bb97ed9 100644
--- a/snapshot_test.go
+++ b/snapshot_test.go
@@ -11,14 +11,14 @@
"path/filepath"
"testing"
+ "v.io/jiri/jiri"
"v.io/jiri/project"
"v.io/jiri/tool"
- "v.io/x/lib/cmdline"
)
-func createLabelDir(t *testing.T, ctx *tool.Context, snapshotDir, name string, snapshots []string) {
+func createLabelDir(t *testing.T, jirix *jiri.X, snapshotDir, name string, snapshots []string) {
labelDir, perm := filepath.Join(snapshotDir, "labels", name), os.FileMode(0700)
- if err := ctx.Run().MkdirAll(labelDir, perm); err != nil {
+ if err := jirix.Run().MkdirAll(labelDir, perm); err != nil {
t.Fatalf("MkdirAll(%v, %v) failed: %v", labelDir, perm, err)
}
for i, snapshot := range snapshots {
@@ -29,7 +29,7 @@
}
if i == 0 {
symlinkPath := filepath.Join(snapshotDir, name)
- if err := ctx.Run().Symlink(path, symlinkPath); err != nil {
+ if err := jirix.Run().Symlink(path, symlinkPath); err != nil {
t.Fatalf("Symlink(%v, %v) failed: %v", path, symlinkPath, err)
}
}
@@ -58,15 +58,13 @@
}
func TestList(t *testing.T) {
- ctx := tool.NewDefaultContext()
-
// Setup a fake JIRI_ROOT.
- root, err := project.NewFakeJiriRoot(ctx)
+ root, err := project.NewFakeJiriRoot()
if err != nil {
t.Fatalf("%v", err)
}
defer func() {
- if err := root.Cleanup(ctx); err != nil {
+ if err := root.Cleanup(); err != nil {
t.Fatalf("%v", err)
}
}()
@@ -112,17 +110,14 @@
// Create the snapshots directory and populate it with the
// data specified by the test suite.
for _, label := range labels {
- createLabelDir(t, ctx, test.dir, label.name, label.snapshots)
+ createLabelDir(t, root.X, test.dir, label.name, label.snapshots)
}
// Check that running "jiri snapshot list" with no arguments
// returns the expected output.
var stdout bytes.Buffer
- env := &cmdline.Env{Stdout: &stdout}
- if err != nil {
- t.Fatalf("%v", err)
- }
- if err := runSnapshotList(env, nil); err != nil {
+ root.X.Context = tool.NewContext(tool.ContextOpts{Stdout: &stdout})
+ if err := runSnapshotList(root.X, nil); err != nil {
t.Fatalf("%v", err)
}
got, want := stdout.String(), generateOutput(labels)
@@ -133,7 +128,7 @@
// Check that running "jiri snapshot list" with one argument
// returns the expected output.
stdout.Reset()
- if err := runSnapshotList(env, []string{"stable"}); err != nil {
+ if err := runSnapshotList(root.X, []string{"stable"}); err != nil {
t.Fatalf("%v", err)
}
got, want = stdout.String(), generateOutput(labels[1:])
@@ -144,7 +139,7 @@
// Check that running "jiri snapshot list" with
// multiple arguments returns the expected output.
stdout.Reset()
- if err := runSnapshotList(env, []string{"beta", "stable"}); err != nil {
+ if err := runSnapshotList(root.X, []string{"beta", "stable"}); err != nil {
t.Fatalf("%v", err)
}
got, want = stdout.String(), generateOutput(labels)
@@ -154,12 +149,12 @@
}
}
-func checkReadme(t *testing.T, ctx *tool.Context, project, message string) {
- if _, err := ctx.Run().Stat(project); err != nil {
+func checkReadme(t *testing.T, jirix *jiri.X, project, message string) {
+ if _, err := jirix.Run().Stat(project); err != nil {
t.Fatalf("%v", err)
}
readmeFile := filepath.Join(project, "README")
- data, err := ctx.Run().ReadFile(readmeFile)
+ data, err := jirix.Run().ReadFile(readmeFile)
if err != nil {
t.Fatalf("%v", err)
}
@@ -176,34 +171,32 @@
return "test-remote-project-" + fmt.Sprintf("%d", i+1)
}
-func writeReadme(t *testing.T, ctx *tool.Context, projectDir, message string) {
+func writeReadme(t *testing.T, jirix *jiri.X, projectDir, message string) {
path, perm := filepath.Join(projectDir, "README"), os.FileMode(0644)
- if err := ctx.Run().WriteFile(path, []byte(message), perm); err != nil {
+ if err := jirix.Run().WriteFile(path, []byte(message), perm); err != nil {
t.Fatalf("%v", err)
}
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("%v", err)
}
- defer ctx.Run().Chdir(cwd)
- if err := ctx.Run().Chdir(projectDir); err != nil {
+ defer jirix.Run().Chdir(cwd)
+ if err := jirix.Run().Chdir(projectDir); err != nil {
t.Fatalf("%v", err)
}
- if err := ctx.Git().CommitFile(path, "creating README"); err != nil {
+ if err := jirix.Git().CommitFile(path, "creating README"); err != nil {
t.Fatalf("%v", err)
}
}
func TestCreate(t *testing.T) {
- ctx := tool.NewDefaultContext()
-
// Setup a fake JIRI_ROOT instance.
- root, err := project.NewFakeJiriRoot(ctx)
+ root, err := project.NewFakeJiriRoot()
if err != nil {
t.Fatalf("%v", err)
}
defer func() {
- if err := root.Cleanup(ctx); err != nil {
+ if err := root.Cleanup(); err != nil {
t.Fatalf("%v", err)
}
}()
@@ -211,10 +204,10 @@
// Setup the initial remote and local projects.
numProjects, remoteProjects := 2, []string{}
for i := 0; i < numProjects; i++ {
- if err := root.CreateRemoteProject(ctx, remoteProjectName(i)); err != nil {
+ if err := root.CreateRemoteProject(remoteProjectName(i)); err != nil {
t.Fatalf("%v", err)
}
- if err := root.AddProject(ctx, project.Project{
+ if err := root.AddProject(project.Project{
Name: remoteProjectName(i),
Path: localProjectName(i),
Remote: root.Projects[remoteProjectName(i)],
@@ -233,24 +226,24 @@
// Create initial commits in the remote projects and use
// UpdateUniverse() to mirror them locally.
for i := 0; i < numProjects; i++ {
- writeReadme(t, ctx, root.Projects[remoteProjectName(i)], "revision 1")
+ writeReadme(t, root.X, root.Projects[remoteProjectName(i)], "revision 1")
}
- if err := project.UpdateUniverse(ctx, true); err != nil {
+ if err := project.UpdateUniverse(root.X, true); err != nil {
t.Fatalf("%v", err)
}
// Create a local snapshot.
var stdout bytes.Buffer
- env := &cmdline.Env{Stdout: &stdout}
+ root.X.Context = tool.NewContext(tool.ContextOpts{Stdout: &stdout})
remoteFlag = false
- if err := runSnapshotCreate(env, []string{"test-local"}); err != nil {
+ if err := runSnapshotCreate(root.X, []string{"test-local"}); err != nil {
t.Fatalf("%v", err)
}
// Remove the local project repositories.
for i, _ := range remoteProjects {
localProject := filepath.Join(root.Dir, localProjectName(i))
- if err := ctx.Run().RemoveAll(localProject); err != nil {
+ if err := root.X.Run().RemoveAll(localProject); err != nil {
t.Fatalf("%v", err)
}
}
@@ -262,28 +255,28 @@
t.Fatalf("%v", err)
}
snapshotFile := filepath.Join(snapshotDir, "test-local")
- localCtx := ctx.Clone(tool.ContextOpts{
+ localX := root.X.Clone(tool.ContextOpts{
Manifest: &snapshotFile,
})
- if err := project.UpdateUniverse(localCtx, true); err != nil {
+ if err := project.UpdateUniverse(localX, true); err != nil {
t.Fatalf("%v", err)
}
for i, _ := range remoteProjects {
localProject := filepath.Join(root.Dir, localProjectName(i))
- checkReadme(t, ctx, localProject, "revision 1")
+ checkReadme(t, root.X, localProject, "revision 1")
}
// Create a remote snapshot.
remoteFlag = true
- root.EnableRemoteManifestPush(ctx)
- if err := runSnapshotCreate(env, []string{"test-remote"}); err != nil {
+ root.EnableRemoteManifestPush()
+ if err := runSnapshotCreate(root.X, []string{"test-remote"}); err != nil {
t.Fatalf("%v", err)
}
// Remove the local project repositories.
for i, _ := range remoteProjects {
localProject := filepath.Join(root.Dir, localProjectName(i))
- if err := ctx.Run().RemoveAll(localProject); err != nil {
+ if err := root.X.Run().RemoveAll(localProject); err != nil {
t.Fatalf("%v", err)
}
}
@@ -291,14 +284,14 @@
// Check that invoking the UpdateUniverse() with the remote snapshot
// restores the local repositories.
manifest := "snapshot/test-remote"
- remoteCtx := ctx.Clone(tool.ContextOpts{
+ remoteX := root.X.Clone(tool.ContextOpts{
Manifest: &manifest,
})
- if err := project.UpdateUniverse(remoteCtx, true); err != nil {
+ if err := project.UpdateUniverse(remoteX, true); err != nil {
t.Fatalf("%v", err)
}
for i, _ := range remoteProjects {
localProject := filepath.Join(root.Dir, localProjectName(i))
- checkReadme(t, ctx, localProject, "revision 1")
+ checkReadme(t, root.X, localProject, "revision 1")
}
}
diff --git a/update.go b/update.go
index 5576500..ab1f60d 100644
--- a/update.go
+++ b/update.go
@@ -8,6 +8,7 @@
"path/filepath"
"time"
+ "v.io/jiri/jiri"
"v.io/jiri/project"
"v.io/jiri/retry"
"v.io/jiri/tool"
@@ -28,7 +29,7 @@
// cmdUpdate represents the "jiri update" command.
var cmdUpdate = &cmdline.Command{
- Runner: cmdline.RunnerFunc(runUpdate),
+ Runner: jiri.RunnerFunc(runUpdate),
Name: "update",
Short: "Update all jiri tools and projects",
Long: `
@@ -42,9 +43,7 @@
`,
}
-func runUpdate(env *cmdline.Env, _ []string) error {
- ctx := tool.NewContextFromEnv(env)
-
+func runUpdate(jirix *jiri.X, _ []string) error {
// Create a snapshot of the current state of all projects and
// write it to the $JIRI_ROOT/.update_history folder.
root, err := project.JiriRoot()
@@ -52,14 +51,14 @@
return err
}
snapshotFile := filepath.Join(root, ".update_history", time.Now().Format(time.RFC3339))
- if err := project.CreateSnapshot(ctx, snapshotFile); err != nil {
+ if err := project.CreateSnapshot(jirix, snapshotFile); err != nil {
return err
}
// Update all projects to their latest version.
// Attempt <attemptsFlag> times before failing.
updateFn := func() error {
- return project.UpdateUniverse(ctx, gcFlag)
+ return project.UpdateUniverse(jirix, gcFlag)
}
- return retry.Function(ctx, updateFn, retry.AttemptsOpt(attemptsFlag))
+ return retry.Function(jirix.Context, updateFn, retry.AttemptsOpt(attemptsFlag))
}
diff --git a/util/config.go b/util/config.go
index 84249cd..9268b83 100644
--- a/util/config.go
+++ b/util/config.go
@@ -11,7 +11,7 @@
"path/filepath"
"sort"
- "v.io/jiri/tool"
+ "v.io/jiri/jiri"
"v.io/x/lib/set"
)
@@ -282,16 +282,16 @@
// LoadConfig returns the configuration stored in the tools
// configuration file.
-func LoadConfig(ctx *tool.Context) (*Config, error) {
- configPath, err := ConfigFilePath(ctx)
+func LoadConfig(jirix *jiri.X) (*Config, error) {
+ configPath, err := ConfigFilePath(jirix)
if err != nil {
return nil, err
}
- return loadConfig(ctx, configPath)
+ return loadConfig(jirix, configPath)
}
-func loadConfig(ctx *tool.Context, path string) (*Config, error) {
- configBytes, err := ctx.Run().ReadFile(path)
+func loadConfig(jirix *jiri.X, path string) (*Config, error) {
+ configBytes, err := jirix.Run().ReadFile(path)
if err != nil {
return nil, err
}
@@ -340,15 +340,15 @@
// SaveConfig writes the given configuration to the tools
// configuration file.
-func SaveConfig(ctx *tool.Context, config *Config) error {
- configPath, err := ConfigFilePath(ctx)
+func SaveConfig(jirix *jiri.X, config *Config) error {
+ configPath, err := ConfigFilePath(jirix)
if err != nil {
return err
}
- return saveConfig(ctx, config, configPath)
+ return saveConfig(jirix, config, configPath)
}
-func saveConfig(ctx *tool.Context, config *Config, path string) error {
+func saveConfig(jirix *jiri.X, config *Config, path string) error {
var data configSchema
data.APICheckProjects = set.String.ToSlice(config.apiCheckProjects)
sort.Strings(data.APICheckProjects)
@@ -398,10 +398,10 @@
if err != nil {
return fmt.Errorf("MarshalIndent(%v) failed: %v", data, err)
}
- if err := ctx.Run().MkdirAll(filepath.Dir(path), os.FileMode(0755)); err != nil {
+ if err := jirix.Run().MkdirAll(filepath.Dir(path), os.FileMode(0755)); err != nil {
return err
}
- if err := ctx.Run().WriteFile(path, bytes, os.FileMode(0644)); err != nil {
+ if err := jirix.Run().WriteFile(path, bytes, os.FileMode(0644)); err != nil {
return err
}
return nil
diff --git a/util/config_test.go b/util/config_test.go
index bf99242..87204f5 100644
--- a/util/config_test.go
+++ b/util/config_test.go
@@ -10,7 +10,6 @@
"testing"
"v.io/jiri/project"
- "v.io/jiri/tool"
)
var (
@@ -112,14 +111,12 @@
}
func TestConfigSerialization(t *testing.T) {
- ctx := tool.NewDefaultContext()
-
- root, err := project.NewFakeJiriRoot(ctx)
+ root, err := project.NewFakeJiriRoot()
if err != nil {
t.Fatalf("%v", err)
}
defer func() {
- if err := root.Cleanup(ctx); err != nil {
+ if err := root.Cleanup(); err != nil {
t.Fatalf("%v", err)
}
}()
@@ -141,10 +138,10 @@
VDLWorkspacesOpt(vdlWorkspaces),
)
- if err := SaveConfig(ctx, config); err != nil {
+ if err := SaveConfig(root.X, config); err != nil {
t.Fatalf("%v", err)
}
- gotConfig, err := LoadConfig(ctx)
+ gotConfig, err := LoadConfig(root.X)
if err != nil {
t.Fatalf("%v", err)
}
diff --git a/util/env_test.go b/util/env_test.go
index 47f47cb..5e2d0c4 100644
--- a/util/env_test.go
+++ b/util/env_test.go
@@ -17,14 +17,14 @@
// of the JIRI_ROOT environment variable as a path, evaluates any
// symlinks the path might contain, and returns the result.
func TestJiriRootSymlink(t *testing.T) {
- ctx := tool.NewDefaultContext()
+ jirix := tool.NewDefaultContext()
// Create a temporary directory.
- tmpDir, err := ctx.Run().TempDir("", "")
+ tmpDir, err := jirix.Run().TempDir("", "")
if err != nil {
t.Fatalf("TempDir() failed: %v", err)
}
- defer ctx.Run().RemoveAll(tmpDir)
+ defer jirix.Run().RemoveAll(tmpDir)
// Make sure tmpDir is not a symlink itself.
tmpDir, err = filepath.EvalSymlinks(tmpDir)
@@ -34,11 +34,11 @@
// Create a directory and a symlink to it.
root, perm := filepath.Join(tmpDir, "root"), os.FileMode(0700)
- if err := ctx.Run().MkdirAll(root, perm); err != nil {
+ if err := jirix.Run().MkdirAll(root, perm); err != nil {
t.Fatalf("%v", err)
}
symRoot := filepath.Join(tmpDir, "sym_root")
- if err := ctx.Run().Symlink(root, symRoot); err != nil {
+ if err := jirix.Run().Symlink(root, symRoot); err != nil {
t.Fatalf("%v", err)
}
diff --git a/util/oncall.go b/util/oncall.go
index 643d968..4cab5a9 100644
--- a/util/oncall.go
+++ b/util/oncall.go
@@ -10,7 +10,7 @@
"io/ioutil"
"time"
- "v.io/jiri/tool"
+ "v.io/jiri/jiri"
)
type OncallRotation struct {
@@ -25,8 +25,8 @@
}
// LoadOncallRotation parses the default oncall schedule file.
-func LoadOncallRotation(ctx *tool.Context) (*OncallRotation, error) {
- oncallRotationsFile, err := OncallRotationPath(ctx)
+func LoadOncallRotation(jirix *jiri.X) (*OncallRotation, error) {
+ oncallRotationsFile, err := OncallRotationPath(jirix)
if err != nil {
return nil, err
}
@@ -43,9 +43,9 @@
// Oncall finds the oncall shift at the given time from the
// oncall configuration file by comparing timestamps.
-func Oncall(ctx *tool.Context, targetTime time.Time) (*OncallShift, error) {
+func Oncall(jirix *jiri.X, targetTime time.Time) (*OncallShift, error) {
// Parse oncall configuration file.
- rotation, err := LoadOncallRotation(ctx)
+ rotation, err := LoadOncallRotation(jirix)
if err != nil {
return nil, err
}
diff --git a/util/oncall_test.go b/util/oncall_test.go
index 32536a4..85b0d39 100644
--- a/util/oncall_test.go
+++ b/util/oncall_test.go
@@ -12,11 +12,11 @@
"testing"
"time"
+ "v.io/jiri/jiri"
"v.io/jiri/project"
- "v.io/jiri/tool"
)
-func createOncallFile(t *testing.T, ctx *tool.Context) {
+func createOncallFile(t *testing.T, jirix *jiri.X) {
content := `<?xml version="1.0" ?>
<rotation>
<shift>
@@ -35,13 +35,13 @@
<startDate>Nov 19, 2014 12:00:00 PM</startDate>
</shift>
</rotation>`
- oncallRotationsFile, err := OncallRotationPath(ctx)
+ oncallRotationsFile, err := OncallRotationPath(jirix)
if err != nil {
t.Fatalf("%v", err)
}
dir := filepath.Dir(oncallRotationsFile)
dirMode := os.FileMode(0700)
- if err := ctx.Run().MkdirAll(dir, dirMode); err != nil {
+ if err := jirix.Run().MkdirAll(dir, dirMode); err != nil {
t.Fatalf("MkdirAll(%q, %v) failed: %v", dir, dirMode, err)
}
fileMode := os.FileMode(0644)
@@ -51,13 +51,12 @@
}
func TestOncall(t *testing.T) {
- ctx := tool.NewDefaultContext()
- root, err := project.NewFakeJiriRoot(ctx)
+ root, err := project.NewFakeJiriRoot()
if err != nil {
t.Fatalf("%v", err)
}
defer func() {
- if err := root.Cleanup(ctx); err != nil {
+ if err := root.Cleanup(); err != nil {
t.Fatalf("%v", err)
}
}()
@@ -71,7 +70,7 @@
defer os.Setenv("JIRI_ROOT", oldRoot)
// Create a oncall.v1.xml file.
- createOncallFile(t, ctx)
+ createOncallFile(t, root.X)
type testCase struct {
targetTime time.Time
expectedShift *OncallShift
@@ -107,7 +106,7 @@
},
}
for _, test := range testCases {
- got, err := Oncall(ctx, test.targetTime)
+ got, err := Oncall(root.X, test.targetTime)
if err != nil {
t.Fatalf("want no errors, got: %v", err)
}
diff --git a/util/paths.go b/util/paths.go
index e0f2893..a68d10d 100644
--- a/util/paths.go
+++ b/util/paths.go
@@ -10,14 +10,15 @@
"path/filepath"
"runtime"
+ "v.io/jiri/jiri"
"v.io/jiri/project"
"v.io/jiri/tool"
"v.io/x/lib/host"
)
// ConfigFilePath returns the path to the tools configuration file.
-func ConfigFilePath(ctx *tool.Context) (string, error) {
- dataDir, err := project.DataDirPath(ctx, tool.Name)
+func ConfigFilePath(jirix *jiri.X) (string, error) {
+ dataDir, err := project.DataDirPath(jirix, tool.Name)
if err != nil {
return "", err
}
@@ -25,8 +26,8 @@
}
// OncallRotationPath returns the path to the oncall rotation file.
-func OncallRotationPath(ctx *tool.Context) (string, error) {
- dataDir, err := project.DataDirPath(ctx, tool.Name)
+func OncallRotationPath(jirix *jiri.X) (string, error) {
+ dataDir, err := project.DataDirPath(jirix, tool.Name)
if err != nil {
return "", err
}
