Short: "Manage project snapshots",
Long: `
The "jiri snapshot" command can be used to manage project snapshots.
In particular, it can be used to create new snapshots and to list
existing snapshots.
The command-line flag "-remote" determines whether the command
pertains to "local" snapshots that are only stored locally or "remote"
snapshots the are revisioned in the manifest repository.
`,
Children: []*cmdline.Command{cmdSnapshotCreate, cmdSnapshotList},
}
// cmdSnapshotCreate represents the "jiri snapshot create" command.
var cmdSnapshotCreate = &cmdline.Command{
Runner: cmdline.RunnerFunc(runSnapshotCreate),
Name: "create",
Short: "Create a new project snapshot",
Long: `
The "jiri snapshot create <label>" command captures the current project
state in a manifest and, depending on the value of the -remote flag,
the command either stores the manifest in the local
$JIRI_ROOT/.snapshots directory, or in the manifest repository, pushing
the change to the remote repository and thus making it available
globally.
Internally, snapshots are organized as follows:
<snapshot-dir>/
labels/
<label1>/
Short: "Manage profiles",
Long: helpMsg,
Children: []*cmdline.Command{
cmdInstall,
cmdList,
cmdEnv,
cmdUninstall,
cmdUpdate,
cmdInfo,
cmdRecreate,
},
}
// cmdInstall represents the "profile install" command.
var cmdInstall = &cmdline.Command{
Runner: cmdline.RunnerFunc(runInstall),
Name: "install",
Short: "Install the given profiles",
Long: "Install the given profiles.",
ArgsName: "<profiles>",
ArgsLong: "<profiles> is a list of profiles to install.",
}
// cmdList represents the "profile list" command.
var cmdList = &cmdline.Command{
Runner: cmdline.RunnerFunc(runList),
Name: "list",
Short: "List available or installed profiles",
Long: "List available or installed profiles.",
ArgsName: "[<profiles>]",
ArgsLong: "<profiles> is a list of profiles to list, defaulting to all profiles if none are specifically requested.",
var (
gcFlag bool
attemptsFlag int
)
func init() {
tool.InitializeProjectFlags(&cmdUpdate.Flags)
cmdUpdate.Flags.BoolVar(&gcFlag, "gc", false, "Garbage collect obsolete repositories.")
cmdUpdate.Flags.IntVar(&attemptsFlag, "attempts", 1, "Number of attempts before failing.")
}
// cmdUpdate represents the "jiri update" command.
var cmdUpdate = &cmdline.Command{
Runner: cmdline.RunnerFunc(runUpdate),
Name: "update",
Short: "Update all jiri tools and projects",
Long: `
Updates all projects, builds the latest version of all tools, and installs the
resulting binaries into $JIRI_ROOT/devtools/bin. The sequence in which the
individual updates happen guarantees that we end up with a consistent set of
tools and source code. The set of projects and tools to update is described in
the manifest.
Run "jiri help manifest" for details on manifests.
`,
}
func runUpdate(env *cmdline.Env, _ []string) error {
ctx := tool.NewContextFromEnv(env)
}
// cmdCL represents the "jiri cl" command.
var cmdCL = &cmdline.Command{
Name: "cl",
Short: "Manage project changelists",
Long: "Manage project changelists.",
Children: []*cmdline.Command{cmdCLCleanup, cmdCLMail, cmdCLNew, cmdCLSync},
}
// cmdCLCleanup represents the "jiri cl cleanup" command.
//
// TODO(jsimsa): Replace this with a "submit" command that talks to
// Gerrit to submit the CL and then (optionally) removes it locally.
var cmdCLCleanup = &cmdline.Command{
Runner: cmdline.RunnerFunc(runCLCleanup),
Name: "cleanup",
Short: "Clean up changelists that have been merged",
Long: `
Command "cleanup" checks that the given branches have been merged into
the corresponding remote branch. If a branch differs from the
corresponding remote branch, the command reports the difference and
stops. Otherwise, it deletes the given branches.
`,
ArgsName: "<branches>",
ArgsLong: "<branches> is a list of branches to cleanup.",
}
func cleanupCL(ctx *tool.Context, branches []string) (e error) {
originalBranch, err := ctx.Git().CurrentBranchName()
if err != nil {
aliasesFileName = "aliases.v1.xml"
)
var (
countFlag bool
aliasesFlag string
)
func init() {
cmdContributors.Flags.BoolVar(&countFlag, "n", false, "Show number of contributions.")
cmdContributors.Flags.StringVar(&aliasesFlag, "aliases", "", "Path to the aliases file.")
}
// cmdContributors represents the "jiri contributors" command.
var cmdContributors = &cmdline.Command{
Runner: cmdline.RunnerFunc(runContributors),
Name: "contributors",
Short: "List project contributors",
Long: `
Lists project contributors. Projects to consider can be specified as
an argument. If no projects are specified, all projects in the current
manifest are considered by default.
`,
ArgsName: "<projects>",
ArgsLong: "<projects> is a list of projects to consider.",
}
type contributor struct {
count int
email string
name string
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
"fmt"
"os"
"os/exec"
"path/filepath"
"v.io/x/lib/cmdline"
)
var cmdWhich = &cmdline.Command{
Runner: cmdline.RunnerFunc(runWhich),
Name: "which",
Short: "Show path to the jiri tool",
Long: `
Which behaves similarly to the unix commandline tool. It is useful in
determining whether the jiri binary is being run directly, or run via the jiri
shim script.
If the binary is being run directly, the output looks like this:
# binary
/path/to/binary/jiri
If the script is being run, the output looks like this:
# script
cmdCL,
cmdContributors,
cmdProject,
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",
Long: `
Jiri manifests are revisioned and stored in a "manifest" repository, that is
tool.InitializeProjectFlags(&cmdProjectPoll.Flags)
}
// cmdProject represents the "jiri project" command.
var cmdProject = &cmdline.Command{
Name: "project",
Short: "Manage the jiri projects",
Long: "Manage the jiri projects.",
Children: []*cmdline.Command{cmdProjectClean, cmdProjectList, cmdProjectShellPrompt, cmdProjectPoll},
}
// cmdProjectClean represents the "jiri project clean" command.
var cmdProjectClean = &cmdline.Command{
Runner: cmdline.RunnerFunc(runProjectClean),
Name: "clean",
Short: "Restore jiri projects to their pristine state",
Long: "Restore jiri projects back to their master branches and get rid of all the local branches and changes.",
ArgsName: "<project ...>",
ArgsLong: "<project ...> is a list of projects to clean up.",
}
func runProjectClean(env *cmdline.Env, args []string) (e error) {
ctx := tool.NewContextFromEnv(env)
localProjects, err := project.LocalProjects(ctx, project.FullScan)
if err != nil {
return err
}
projects := map[string]project.Project{}
if len(args) > 0 {
// license that can be found in the LICENSE file.
package main
import (
"fmt"
"v.io/jiri/collect"
"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),
Name: "rebuild",
Short: "Rebuild all jiri tools",
Long: `
Rebuilds all jiri tools and installs the resulting binaries into
$JIRI_ROOT/devtools/bin. This is similar to "jiri update", but does not update
any projects before building the tools. The set of tools to rebuild is described
in the manifest.
Run "jiri help manifest" for details on manifests.
`,
}
func runRebuild(env *cmdline.Env, args []string) (e error) {
ctx := tool.NewContextFromEnv(env)
_, tools, err := project.ReadManifest(ctx)