// runCLMail is a wrapper that sets up and runs a review instance across
// multiple projects.
func runCLMail(jirix *jiri.X, _ []string) error {
mp, err := initForMultiPart(jirix)
if err != nil {
return err
}
if mp.clean {
if err := mp.cleanMultiPartMetadata(jirix); err != nil {
return err
}
return nil
}
if mp.current {
return runCLMailCurrent(jirix, []string{})
}
// multipart mode
if err := mp.writeMultiPartMetadata(jirix); err != nil {
mp.cleanMultiPartMetadata(jirix)
return err
}
if err := runCLMailCurrent(jirix, []string{}); err != nil {
return err
}
git := gitutil.New(jirix.NewSeq())
branch, err := git.CurrentBranchName()
if err != nil {
return err
}
initialMessage, err := strippedGerritCommitMessage(jirix, branch)
if err != nil {
return err
}
s := jirix.NewSeq()
tmp, err := s.TempFile("", branch+"-")
if err != nil {
return err
}
defer func() {
tmp.Close()
os.Remove(tmp.Name())
}()
if _, err := io.WriteString(tmp, initialMessage); err != nil {
return err
}
// Use Capture to make sure that all output from the subcommands is
// sent to stdout/stderr.
flags := clMailMultiFlags()
flags = append(flags, "--commit-message-body-file="+tmp.Name())
return s.Capture(jirix.Stdout(), jirix.Stderr()).Last("jiri", mp.commandline(mp.currentKey, flags)...)
}
func (sc *subcommand) packageCmds(jirix *jiri.X, cl *packagesFlagValues, root jiri.RelPath) ([][]string, error) {
cmd := []string{"profile-" + sc.installer, "os-packages"}
cmd = append(cmd, cl.args()...)
cmd = append(cmd, sc.qname)
var out bytes.Buffer
if err := jirix.NewSeq().Capture(&out, jirix.Stderr()).Last("jiri", cmd...); err != nil {
return nil, err
}
scanner := bufio.NewScanner(&out)
cmds := make([][]string, 0, 5)
for scanner.Scan() {
cmds = append(cmds, strings.Split(scanner.Text(), " "))
}
return cmds, nil
}
// installedProfileManagers creates a profileManager for all installed
// profiles, whether in this process or in a sub command.
func installedProfileManagers(jirix *jiri.X, dbpath string, args []string) ([]profileManager, *profiles.DB, error) {
db := profiles.NewDB()
if err := db.Read(jirix, dbpath); err != nil {
fmt.Fprintf(jirix.Stderr(), "Failed to read profiles database %q: %v\n", dbpath, err)
return nil, nil, err
}
mgrs := []profileManager{}
names := args
if len(names) == 0 {
names = db.Names()
}
for _, name := range names {
mgrs = append(mgrs, newProfileManager(name, db))
}
return mgrs, db, nil
}
func parseCookieFile(jirix *jiri.X, bytes []byte) (cookies []*http.Cookie) {
lines := strings.Split(string(bytes), "\n")
for _, line := range lines {
if strings.TrimSpace(line) == "" || line[0] == '#' {
continue
}
cookie, err := parseCookie(line)
if err != nil {
fmt.Fprintf(jirix.Stderr(), "error parsing cookie in .gitcookies: %v\n", err)
} else {
cookies = append(cookies, cookie)
}
}
return
}
func cleanupGC(jirix *jiri.X, db *profiles.DB, root jiri.RelPath, verbose bool, name string) error {
mgr := profilesmanager.LookupManager(name)
if mgr == nil {
fmt.Fprintf(jirix.Stderr(), "%s is not linked into this binary\n", name)
return nil
}
vi := mgr.VersionInfo()
installer, profileName := profiles.SplitProfileName(name)
profile := db.LookupProfile(installer, profileName)
for _, target := range profile.Targets() {
if vi.IsTargetOlderThanDefault(target.Version()) {
err := mgr.Uninstall(jirix, db, root, *target)
logResult(jirix, "Cleanup: -gc", mgr, *target, err)
if err != nil {
return err
}
}
}
return nil
}
func allAvailableManagers(jirix *jiri.X) ([]string, error) {
names := profilesmanager.Managers()
if profileInstaller != "" {
return names, nil
}
subcommands := findProfileSubcommands(jirix)
s := jirix.NewSeq()
for _, sc := range subcommands {
var out bytes.Buffer
args := []string{"available"}
if err := s.Capture(&out, nil).Last(sc, args...); err != nil {
fmt.Fprintf(jirix.Stderr(), "failed to run %s %s: %v", sc, strings.Join(args, " "), err)
return nil, err
}
mgrs := out.String()
for _, m := range strings.Split(mgrs, ",") {
names = append(names, strings.TrimSpace(m))
}
}
return names, nil
}
func runProjectClean(jirix *jiri.X, args []string) (e error) {
localProjects, err := project.LocalProjects(jirix, project.FullScan)
if err != nil {
return err
}
var projects project.Projects
if len(args) > 0 {
for _, arg := range args {
p, err := localProjects.FindUnique(arg)
if err != nil {
fmt.Fprintf(jirix.Stderr(), "Error finding local project %q: %v.\n", p.Name, err)
} else {
projects[p.Key()] = p
}
}
} else {
projects = localProjects
}
if err := project.CleanupProjects(jirix, projects, cleanupBranchesFlag); err != nil {
return err
}
return nil
}
func runp(jirix *jiri.X, cmd *cmdline.Command, args []string) error {
hasUntrackedSet := profilescmdline.IsFlagSet(cmd.ParsedFlags, "has-untracked")
hasUncommitedSet := profilescmdline.IsFlagSet(cmd.ParsedFlags, "has-uncommitted")
hasGerritSet := profilescmdline.IsFlagSet(cmd.ParsedFlags, "has-gerrit-message")
if runpFlags.interactive {
runpFlags.collateOutput = false
}
var keysRE, branchRE *regexp.Regexp
var err error
if profilescmdline.IsFlagSet(cmd.ParsedFlags, "projects") {
re := ""
for _, pre := range strings.Split(runpFlags.projectKeys, ",") {
re += pre + "|"
}
re = strings.TrimRight(re, "|")
keysRE, err = regexp.Compile(re)
if err != nil {
return fmt.Errorf("failed to compile projects regexp: %q: %v", runpFlags.projectKeys, err)
}
}
if profilescmdline.IsFlagSet(cmd.ParsedFlags, "has-branch") {
branchRE, err = regexp.Compile(runpFlags.hasBranch)
if err != nil {
return fmt.Errorf("failed to compile has-branch regexp: %q: %v", runpFlags.hasBranch, err)
}
}
for _, f := range []string{"show-key-prefix", "show-name-prefix"} {
if profilescmdline.IsFlagSet(cmd.ParsedFlags, f) {
if runpFlags.interactive && profilescmdline.IsFlagSet(cmd.ParsedFlags, "interactive") {
fmt.Fprintf(jirix.Stderr(), "WARNING: interactive mode being disabled because %s was set\n", f)
}
runpFlags.interactive = false
runpFlags.collateOutput = true
break
}
}
git := gitutil.New(jirix.NewSeq())
homeBranch, err := git.CurrentBranchName()
if err != nil {
// jiri was run from outside of a project. Let's assume we'll
// use all projects if none have been specified via the projects flag.
if keysRE == nil {
keysRE = regexp.MustCompile(".*")
}
}
dirty := false
if hasUntrackedSet || hasUncommitedSet {
dirty = true
}
states, err := project.GetProjectStates(jirix, dirty)
if err != nil {
return err
}
mapInputs := map[project.ProjectKey]*mapInput{}
var keys project.ProjectKeys
for key, state := range states {
if keysRE != nil {
if !keysRE.MatchString(string(key)) {
continue
}
} else {
if state.CurrentBranch != homeBranch {
continue
}
}
if branchRE != nil {
found := false
for _, br := range state.Branches {
if branchRE.MatchString(br.Name) {
found = true
break
}
}
if !found {
continue
}
}
if hasUntrackedSet && (state.HasUntracked != runpFlags.hasUntracked) {
continue
}
if hasUncommitedSet && (state.HasUncommitted != runpFlags.hasUncommitted) {
continue
}
if hasGerritSet {
hasMsg := false
for _, br := range state.Branches {
if (state.CurrentBranch == br.Name) && br.HasGerritMessage {
hasMsg = true
break
}
}
if hasMsg != runpFlags.hasGerritMessage {
continue
}
}
mapInputs[key] = &mapInput{
ProjectState: state,
jirix: jirix,
key: key,
}
keys = append(keys, key)
}
total := len(mapInputs)
index := 1
for _, mi := range mapInputs {
mi.index = index
mi.total = total
index++
}
if runpFlags.verbose {
fmt.Fprintf(jirix.Stdout(), "Project Names: %s\n", strings.Join(stateNames(mapInputs), " "))
fmt.Fprintf(jirix.Stdout(), "Project Keys: %s\n", strings.Join(stateKeys(mapInputs), " "))
}
reader, err := profilesreader.NewReader(jirix, runpFlags.ProfilesMode, runpFlags.DBFilename)
runner := &runner{
reader: reader,
args: args,
}
mr := simplemr.MR{}
if runpFlags.interactive {
// Run one mapper at a time.
mr.NumMappers = 1
sort.Sort(keys)
}
in, out := make(chan *simplemr.Record, len(mapInputs)), make(chan *simplemr.Record, len(mapInputs))
sigch := make(chan os.Signal)
signal.Notify(sigch, os.Interrupt)
go func() { <-sigch; mr.Cancel() }()
go mr.Run(in, out, runner, runner)
for _, key := range keys {
in <- &simplemr.Record{string(key), []interface{}{mapInputs[key]}}
}
close(in)
<-out
return mr.Error()
}
func (sc *subcommand) run(jirix *jiri.X, verb string, args []string) error {
cl := []string{"profile-" + sc.installer, verb}
cl = append(cl, args...)
cl = append(cl, sc.qname)
return jirix.NewSeq().Capture(jirix.Stdout(), jirix.Stderr()).Last("jiri", cl...)
}