Permalink
Switch branches/tags
Nothing to show
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
1583 lines (1429 sloc) 43 KB
// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Logic to interact with a Gerrit server. Gerrit has an entire Git-based
// protocol for fetching metadata about CL's, reviewers, patch comments, which
// is used here - we don't use the x/build/gerrit client, which hits the API.
// TODO: write about Gerrit's Git API.
package maintner
import (
"bufio"
"bytes"
"context"
"errors"
"fmt"
"log"
"net/url"
"os"
"os/exec"
"path/filepath"
"regexp"
"sort"
"strconv"
"strings"
"time"
"golang.org/x/build/maintner/maintpb"
)
// Gerrit holds information about a number of Gerrit projects.
type Gerrit struct {
c *Corpus
projects map[string]*GerritProject // keyed by "go.googlesource.com/build"
clsReferencingGithubIssue map[GitHubIssueRef][]*GerritCL
}
func normalizeGerritServer(server string) string {
u, err := url.Parse(server)
if err == nil && u.Host != "" {
server = u.Host
}
if strings.HasSuffix(server, "-review.googlesource.com") {
// special case: the review site is hosted at a different URL than the
// Git checkout URL.
return strings.Replace(server, "-review.googlesource.com", ".googlesource.com", 1)
}
return server
}
// Project returns the specified Gerrit project if it's known, otherwise
// it returns nil. Server is the Gerrit server's hostname, such as
// "go.googlesource.com".
func (g *Gerrit) Project(server, project string) *GerritProject {
server = normalizeGerritServer(server)
return g.projects[server+"/"+project]
}
// c.mu must be held
func (g *Gerrit) getOrCreateProject(gerritProj string) *GerritProject {
proj, ok := g.projects[gerritProj]
if ok {
return proj
}
proj = &GerritProject{
gerrit: g,
proj: gerritProj,
cls: map[int32]*GerritCL{},
remote: map[gerritCLVersion]GitHash{},
ref: map[string]GitHash{},
commit: map[GitHash]*GitCommit{},
need: map[GitHash]bool{},
}
g.projects[gerritProj] = proj
return proj
}
// ForeachProjectUnsorted calls fn for each known Gerrit project.
// Iteration ends if fn returns a non-nil value.
func (g *Gerrit) ForeachProjectUnsorted(fn func(*GerritProject) error) error {
for _, p := range g.projects {
if err := fn(p); err != nil {
return err
}
}
return nil
}
// GerritProject represents a single Gerrit project.
type GerritProject struct {
gerrit *Gerrit
proj string // "go.googlesource.com/net"
cls map[int32]*GerritCL
remote map[gerritCLVersion]GitHash
need map[GitHash]bool
commit map[GitHash]*GitCommit
numLabelChanges int // incremented (too many times) by meta commits with "Label:" updates
dirtyCL map[*GerritCL]struct{}
// ref are the non-change refs with keys like "HEAD",
// "refs/heads/master", "refs/tags/v0.8.0", etc.
//
// Notably, this excludes the "refs/changes/*" refs matched by
// rxChangeRef. Those are in the remote map.
ref map[string]GitHash
}
// Ref returns a non-change ref, such as "HEAD", "refs/heads/master",
// or "refs/tags/v0.8.0",
// Change refs of the form "refs/changes/*" are not supported.
// The returned hash is the zero value (an empty string) if the ref
// does not exist.
func (gp *GerritProject) Ref(ref string) GitHash {
return gp.ref[ref]
}
func (gp *GerritProject) gitDir() string {
return filepath.Join(gp.gerrit.c.getDataDir(), url.PathEscape(gp.proj))
}
// NumLabelChanges is an inaccurate count the number of times vote labels have
// changed in this project. This number is monotonically increasing.
// This is not guaranteed to be accurate; it definitely overcounts, but it
// at least increments when changes are made.
// It will not undercount.
func (gp *GerritProject) NumLabelChanges() int {
// TODO: rename this method.
return gp.numLabelChanges
}
// ServerSlashProject returns the server and project together, such as
// "go.googlesource.com/build".
func (gp *GerritProject) ServerSlashProject() string { return gp.proj }
// Server returns the Gerrit server, such as "go.googlesource.com".
func (gp *GerritProject) Server() string {
if i := strings.IndexByte(gp.proj, '/'); i != -1 {
return gp.proj[:i]
}
return ""
}
// Project returns the Gerrit project on the server, such as "go" or "crypto".
func (gp *GerritProject) Project() string {
if i := strings.IndexByte(gp.proj, '/'); i != -1 {
return gp.proj[i+1:]
}
return ""
}
// ForeachNonChangeRef calls fn for each git ref on the server that is
// not a change (code review) ref. In general, these correspond to
// submitted changes.
// fn is called serially with sorted ref names.
// Iteration stops with the first non-nil error returned by fn.
func (gp *GerritProject) ForeachNonChangeRef(fn func(ref string, hash GitHash) error) error {
refs := make([]string, 0, len(gp.ref))
for ref := range gp.ref {
refs = append(refs, ref)
}
sort.Strings(refs)
for _, ref := range refs {
if err := fn(ref, gp.ref[ref]); err != nil {
return err
}
}
return nil
}
// ForeachOpenCL calls fn for each open CL in the repo.
//
// If fn returns an error, iteration ends and ForeachOpenCL returns
// with that error.
//
// The fn function is called serially, with increasingly numbered
// CLs.
func (gp *GerritProject) ForeachOpenCL(fn func(*GerritCL) error) error {
var s []*GerritCL
for _, cl := range gp.cls {
if !cl.complete() || cl.Status != "new" || cl.Private {
continue
}
s = append(s, cl)
}
sort.Slice(s, func(i, j int) bool { return s[i].Number < s[j].Number })
for _, cl := range s {
if err := fn(cl); err != nil {
return err
}
}
return nil
}
// ForeachCLUnsorted calls fn for each CL in the repo, in any order.
//
// If fn returns an error, iteration ends and ForeachCLUnsorted returns with
// that error.
func (gp *GerritProject) ForeachCLUnsorted(fn func(*GerritCL) error) error {
for _, cl := range gp.cls {
if !cl.complete() {
continue
}
if err := fn(cl); err != nil {
return err
}
}
return nil
}
// CL returns the GerritCL with the given number, or nil if it is not present.
//
// CL numbers are shared across all projects on a Gerrit server, so you can get
// nil unless you have the GerritProject containing that CL.
func (gp *GerritProject) CL(number int32) *GerritCL {
if cl := gp.cls[number]; cl != nil && cl.complete() {
return cl
}
return nil
}
// GitCommit returns the provided git commit, or nil if it's unknown.
func (gp *GerritProject) GitCommit(hash string) *GitCommit {
if len(hash) != 40 {
// TODO: support prefix lookups. build a trie. But
// for now just avoid panicking in gitHashFromHexStr.
return nil
}
var buf [20]byte
_, err := decodeHexStr(buf[:], hash)
if err != nil {
return nil
}
return gp.commit[GitHash(buf[:])]
}
func (gp *GerritProject) logf(format string, args ...interface{}) {
log.Printf("gerrit "+gp.proj+": "+format, args...)
}
// gerritCLVersion is a value type used as a map key to store a CL
// number and a patchset version. Its Version field is overloaded
// to reference the "meta" metadata commit if the Version is 0.
type gerritCLVersion struct {
CLNumber int32
Version int32 // version 0 is used for the "meta" ref.
}
// A GerritCL represents a single change in Gerrit.
type GerritCL struct {
// Project is the project this CL is part of.
Project *GerritProject
// Number is the CL number on the Gerrit server (e.g. 1, 2, 3). Gerrit CL
// numbers are sparse (CL N does not guarantee that CL N-1 exists) and
// Gerrit issues CL's out of order - it may issue CL N, then CL (N - 18),
// then CL (N - 40).
Number int32
// Created is the CL creation time.
Created time.Time
// Version is the number of versions of the patchset for this
// CL seen so far. It starts at 1.
Version int32
// Commit is the git commit of the latest version of this CL.
// Previous versions are available via CommitAtVersion.
// Commit is always non-nil.
Commit *GitCommit
// branch is a cache of the latest "Branch: " value seen from
// MetaCommits' commit message values, stripped of any
// "refs/heads/" prefix. It's usually "master".
branch string
// Meta is the head of the most recent Gerrit "meta" commit
// for this CL. This is guaranteed to be a linear history
// back to a CL-specific root commit for this meta branch.
// Meta will always be non-nil.
Meta *GerritMeta
// Metas contains the history of Meta commits, from the oldest (root)
// to the most recent. The last item in the slice is the same
// value as the GerritCL.Meta field.
// The Metas slice will always contain at least 1 element.
Metas []*GerritMeta
// Status will be "merged", "abandoned", "new", or "draft".
Status string
// Private indicates whether this is a private CL.
// Empirically, it seems that one meta commit of private CLs is
// sometimes visible to everybody, even when the rest of the details
// and later meta commits are not. In general, if you see this
// being set to true, treat this CL as if it doesn't exist.
Private bool
// GitHubIssueRefs are parsed references to GitHub issues.
// Multiple references to the same issue are deduplicated.
GitHubIssueRefs []GitHubIssueRef
// Messages contains all of the messages for this CL, in sorted order.
Messages []*GerritMessage
}
// complete reports whether cl is complete.
// A CL is considered complete if its Meta and Commit fields are non-nil,
// and the Metas slice contains at least 1 element.
func (cl *GerritCL) complete() bool {
return cl.Meta != nil &&
len(cl.Metas) >= 1 &&
cl.Commit != nil
}
// GerritMessage is a Gerrit reply that is attached to the CL as a whole, and
// not to a file or line of a patch set.
//
// Maintner does very little parsing or formatting of a Message body. Messages
// are stored the same way they are stored in the API.
type GerritMessage struct {
// Meta is the commit containing the message.
Meta *GitCommit
// Version is the patch set version this message was sent on.
Version int32
// Message is the raw message contents from Gerrit (a subset
// of the raw git commit message), starting with "Patch Set
// nnnn".
Message string
// Date is when this message was stored (the commit time of
// the git commit).
Date time.Time
// Author returns the author of the commit. This takes the form "Kevin Burke
// <13437@62eb7196-b449-3ce5-99f1-c037f21e1705>", where the number before
// the '@' sign is your Gerrit user ID, and the UUID after the '@' sign
// seems to be the same for all commits for the same Gerrit server, across
// projects.
//
// TODO: Merge the *GitPerson object here and for a person's Git commits
// (which use their real email) via the user ID, so they point to the same
// object.
Author *GitPerson
}
// References reports whether cl includes a commit message reference
// to the provided Github issue ref.
func (cl *GerritCL) References(ref GitHubIssueRef) bool {
for _, eref := range cl.GitHubIssueRefs {
if eref == ref {
return true
}
}
return false
}
// Branch returns the CL's branch, with any "refs/heads/" prefix removed.
func (cl *GerritCL) Branch() string { return cl.branch }
func (cl *GerritCL) updateBranch() {
for i := len(cl.Metas) - 1; i >= 0; i-- {
mc := cl.Metas[i]
branch, _ := lineValue(mc.Commit.Msg, "Branch:")
if branch != "" {
cl.branch = strings.TrimPrefix(branch, "refs/heads/")
return
}
}
}
// lineValue extracts a value from an RFC 822-style "key: value" series of lines.
// If all is,
// foo: bar
// bar: baz
// lineValue(all, "foo:") returns "bar". It trims any whitespace.
// The prefix is case sensitive and must include the colon.
func lineValue(all, prefix string) (value, rest string) {
orig := all
consumed := 0
for {
i := strings.Index(all, prefix)
if i == -1 {
return "", ""
}
if i > 0 && all[i-1] != '\n' && all[i-1] != '\r' {
all = all[i+len(prefix):]
consumed += i + len(prefix)
continue
}
val := all[i+len(prefix):]
consumed += i + len(prefix)
if nl := strings.IndexByte(val, '\n'); nl != -1 {
consumed += nl + 1
val = val[:nl+1]
} else {
consumed = len(orig)
}
return strings.TrimSpace(val), orig[consumed:]
}
}
// WorkInProgress reports whether the CL has its Work-in-progress bit set, per
// https://gerrit-review.googlesource.com/Documentation/intro-user.html#wip
func (cl *GerritCL) WorkInProgress() bool {
var wip bool
for _, m := range cl.Metas {
v, _ := lineValue(m.Commit.Msg, "Work-in-progress:")
switch v {
case "true":
wip = true
case "false":
wip = false
}
}
return wip
}
// ChangeID returns the Gerrit "Change-Id: Ixxxx" line's Ixxxx
// value from the cl.Msg, if any.
func (cl *GerritCL) ChangeID() string {
id := cl.Footer("Change-Id:")
if strings.HasPrefix(id, "I") && len(id) == 41 {
return id
}
return ""
}
// Footer returns the value of a line of the form <key>: value from
// the CL’s commit message. The key is case-sensitive and must end in
// a colon.
// An empty string is returned if there is no value for key.
func (cl *GerritCL) Footer(key string) string {
if len(key) == 0 || key[len(key)-1] != ':' {
panic("Footer key does not end in colon")
}
// TODO: git footers are treated as multimaps. Account for this.
v, _ := lineValue(cl.Commit.Msg, key)
return v
}
// OwnerName returns the name of the CL’s owner or an empty string on error.
func (cl *GerritCL) OwnerName() string {
if !cl.complete() {
return ""
}
return cl.Metas[0].Commit.Author.Name()
}
// OwnerID returns the ID of the CL’s owner. It will return -1 on error.
func (cl *GerritCL) OwnerID() int {
if !cl.complete() {
return -1
}
// Meta commits caused by the owner of a change have an email of the form
// <user id>@<uuid of gerrit server>.
email := cl.Metas[0].Commit.Author.Email()
idx := strings.Index(email, "@")
if idx == -1 {
return -1
}
id, err := strconv.Atoi(email[:idx])
if err != nil {
return -1
}
return id
}
// Owner returns the author of the first commit to the CL. It returns nil on error.
func (cl *GerritCL) Owner() *GitPerson {
// The owner of a change is a numeric ID that can have more than one email
// associated with it, but the email associated with the very first upload is
// designated as the owner of the change by Gerrit.
hash, ok := cl.Project.remote[gerritCLVersion{CLNumber: cl.Number, Version: 1}]
if !ok {
return nil
}
commit, ok := cl.Project.commit[hash]
if !ok {
return nil
}
return commit.Author
}
// Subject returns the first line of the latest commit message.
func (cl *GerritCL) Subject() string {
if cl.Commit == nil {
return ""
}
if i := strings.Index(cl.Commit.Msg, "\n"); i >= 0 {
return cl.Commit.Msg[:i]
}
return cl.Commit.Msg
}
// CommitAtVersion returns the git commit of the specifid version of this CL.
// It returns nil if version is not in the range [1, cl.Version].
func (cl *GerritCL) CommitAtVersion(version int32) *GitCommit {
if version < 1 || version > cl.Version {
return nil
}
hash, ok := cl.Project.remote[gerritCLVersion{CLNumber: cl.Number, Version: version}]
if !ok {
return nil
}
return cl.Project.commit[hash]
}
func (cl *GerritCL) updateGithubIssueRefs() {
gp := cl.Project
gerrit := gp.gerrit
gc := cl.Commit
oldRefs := cl.GitHubIssueRefs
newRefs := gerrit.c.parseGithubRefs(gp.proj, gc.Msg)
cl.GitHubIssueRefs = newRefs
for _, ref := range newRefs {
if !clSliceContains(gerrit.clsReferencingGithubIssue[ref], cl) {
// TODO: make this as small as
// possible? Most will have length
// 1. Care about default capacity of
// 2?
gerrit.clsReferencingGithubIssue[ref] = append(gerrit.clsReferencingGithubIssue[ref], cl)
}
}
for _, ref := range oldRefs {
if !cl.References(ref) {
// TODO: remove ref from gerrit.clsReferencingGithubIssue
// It could be a map of maps I suppose, but not as compact.
// So uses a slice as the second layer, since there will normally
// be one item.
}
}
}
// c.mu must be held
func (c *Corpus) initGerrit() {
if c.gerrit != nil {
return
}
c.gerrit = &Gerrit{
c: c,
projects: map[string]*GerritProject{},
clsReferencingGithubIssue: map[GitHubIssueRef][]*GerritCL{},
}
}
type watchedGerritRepo struct {
project *GerritProject
}
// TrackGerrit registers the Gerrit project with the given project as a project
// to watch and append to the mutation log. Only valid in leader mode.
// The provided string should be of the form "hostname/project", without a scheme
// or trailing slash.
func (c *Corpus) TrackGerrit(gerritProj string) {
if c.mutationLogger == nil {
panic("can't TrackGerrit in non-leader mode")
}
c.mu.Lock()
defer c.mu.Unlock()
if strings.Count(gerritProj, "/") != 1 {
panic(fmt.Sprintf("gerrit project argument %q expected to contain exactly 1 slash", gerritProj))
}
c.initGerrit()
if _, dup := c.gerrit.projects[gerritProj]; dup {
panic("duplicated watched gerrit project " + gerritProj)
}
project := c.gerrit.getOrCreateProject(gerritProj)
if project == nil {
panic("gerrit project not created")
}
c.watchedGerritRepos = append(c.watchedGerritRepos, watchedGerritRepo{
project: project,
})
}
// called with c.mu Locked
func (c *Corpus) processGerritMutation(gm *maintpb.GerritMutation) {
if c.gerrit == nil {
// TODO: option to ignore mutation if user isn't interested.
c.initGerrit()
}
gp, ok := c.gerrit.projects[gm.Project]
if !ok {
// TODO: option to ignore mutation if user isn't interested.
// For now, always process the record.
gp = c.gerrit.getOrCreateProject(gm.Project)
}
gp.processMutation(gm)
}
var statusIndicator = "\nStatus: "
// The Go Gerrit site does not really use the "draft" status much, but if
// you need to test it, create a dummy commit and then run
//
// git push origin HEAD:refs/drafts/master
var statuses = []string{"merged", "abandoned", "draft", "new"}
// getGerritStatus returns a Gerrit status for a commit, or the empty string to
// indicate the commit did not show a status.
//
// getGerritStatus relies on the Gerrit code review convention of amending
// the meta commit to include the current status of the CL. The Gerrit search
// bar allows you to search for changes with the following statuses: "open",
// "reviewed", "closed", "abandoned", "merged", "draft", "pending". The REST API
// returns only "NEW", "DRAFT", "ABANDONED", "MERGED". Gerrit attaches "draft",
// "abandoned", "new", and "merged" statuses to some meta commits; you may have
// to search the current meta commit's parents to find the last good commit.
func getGerritStatus(commit *GitCommit) string {
idx := strings.Index(commit.Msg, statusIndicator)
if idx == -1 {
return ""
}
off := idx + len(statusIndicator)
for _, status := range statuses {
if strings.HasPrefix(commit.Msg[off:], status) {
return status
}
}
return ""
}
var errTooManyParents = errors.New("maintner: too many commit parents")
// foreachCommit walks an entire linear git history, starting at commit itself,
// and iterating over all of its parents. commit must be non-nil.
// f is called for each commit until an error is returned from f, or a commit has no parent.
//
// foreachCommit returns errTooManyParents (and stops processing) if a commit
// has more than one parent.
// An error is returned if a commit has a parent that cannot be found.
//
// Corpus.mu must be held.
func (gp *GerritProject) foreachCommit(commit *GitCommit, f func(*GitCommit) error) error {
c := gp.gerrit.c
for {
if err := f(commit); err != nil {
return err
}
if len(commit.Parents) == 0 {
// No parents, we're at the end of the linear history.
return nil
}
if len(commit.Parents) > 1 {
return errTooManyParents
}
parentHash := commit.Parents[0].Hash // meta tree has no merge commits
commit = c.gitCommit[parentHash]
if commit == nil {
return fmt.Errorf("parent commit %v not found", parentHash)
}
}
}
// getGerritMessage parses a Gerrit comment from the given commit or returns nil
// if there wasn't one.
//
// Corpus.mu must be held.
func (gp *GerritProject) getGerritMessage(commit *GitCommit) *GerritMessage {
const existVerPhrase = "\nPatch Set "
const newVerPhrase = "\nUploaded patch set "
startExist := strings.Index(commit.Msg, existVerPhrase)
startNew := strings.Index(commit.Msg, newVerPhrase)
var start int
var phrase string
switch {
case startExist == -1 && startNew == -1:
return nil
case startExist == -1 || (startNew != -1 && startNew < startExist):
phrase = newVerPhrase
start = startNew
case startNew == -1 || (startExist != -1 && startExist < startNew):
phrase = existVerPhrase
start = startExist
}
numStart := start + len(phrase)
colon := strings.IndexByte(commit.Msg[numStart:], ':')
if colon == -1 {
return nil
}
num := commit.Msg[numStart : numStart+colon]
if strings.Contains(num, "\n") || strings.Contains(num, ".") {
// Spanned lines. Didn't match expected comment form
// we care about (comments with vote changes), like:
//
// Uploaded patch set 5: Some-Vote=+2
//
// For now, treat such meta updates (new uploads only)
// as not comments.
return nil
}
version, err := strconv.ParseInt(num, 10, 32)
if err != nil {
gp.logf("for phrase %q at %d, unexpected patch set number in %s; err: %v, message: %s", phrase, start, commit.Hash, err, commit.Msg)
return nil
}
start++
v := commit.Msg[start:]
l := 0
for {
i := strings.IndexByte(v, '\n')
if i < 0 {
return nil
}
if strings.HasPrefix(v[:i], "Patch-set:") {
// two newlines before the Patch-set message
v = commit.Msg[start : start+l-2]
break
}
v = v[i+1:]
l = l + i + 1
}
return &GerritMessage{
Meta: commit,
Author: commit.Author,
Date: commit.CommitTime,
Message: v,
Version: int32(version),
}
}
func reverseGerritMessages(ss []*GerritMessage) {
for i := len(ss)/2 - 1; i >= 0; i-- {
opp := len(ss) - 1 - i
ss[i], ss[opp] = ss[opp], ss[i]
}
}
func reverseGerritMetas(ss []*GerritMeta) {
for i := len(ss)/2 - 1; i >= 0; i-- {
opp := len(ss) - 1 - i
ss[i], ss[opp] = ss[opp], ss[i]
}
}
// called with c.mu Locked
func (gp *GerritProject) processMutation(gm *maintpb.GerritMutation) {
c := gp.gerrit.c
for _, commitp := range gm.Commits {
gc, err := c.processGitCommit(commitp)
if err != nil {
gp.logf("error processing commit %q: %v", commitp.Sha1, err)
continue
}
gp.commit[gc.Hash] = gc
delete(gp.need, gc.Hash)
for _, p := range gc.Parents {
gp.markNeededCommit(p.Hash)
}
}
for _, refp := range gm.Refs {
refName := refp.Ref
hash := c.gitHashFromHexStr(refp.Sha1)
m := rxChangeRef.FindStringSubmatch(refName)
if m == nil {
if strings.HasPrefix(refName, "refs/meta/") {
// Some of these slipped in to the data
// before we started ignoring them. So ignore them here.
continue
}
// Misc ref, not a change ref.
if _, ok := c.gitCommit[hash]; !ok {
gp.logf("ERROR: non-change ref %v references unknown hash %v; ignoring", refp, hash)
continue
}
gp.ref[refName] = hash
continue
}
clNum64, err := strconv.ParseInt(m[1], 10, 32)
version, ok := gerritVersionNumber(m[2])
if !ok || err != nil {
continue
}
gc, ok := c.gitCommit[hash]
if !ok {
gp.logf("ERROR: ref %v references unknown hash %v; ignoring", refp, hash)
continue
}
clv := gerritCLVersion{int32(clNum64), version}
gp.remote[clv] = hash
cl := gp.getOrCreateCL(clv.CLNumber)
if clv.Version == 0 { // is a meta commit
cl.Meta = newGerritMeta(gc, cl)
gp.noteDirtyCL(cl) // needs processing at end of sync
} else {
cl.Commit = gc
cl.Version = clv.Version
cl.updateGithubIssueRefs()
}
if c.didInit {
gp.logf("Ref %+v => %v", clv, hash)
}
}
}
// noteDirtyCL notes a CL that needs further processing before the corpus
// is returned to the user.
// cl.Meta must be non-nil.
//
// called with Corpus.mu Locked
func (gp *GerritProject) noteDirtyCL(cl *GerritCL) {
if cl.Meta == nil {
panic("noteDirtyCL given a GerritCL with a nil Meta field")
}
if gp.dirtyCL == nil {
gp.dirtyCL = make(map[*GerritCL]struct{})
}
gp.dirtyCL[cl] = struct{}{}
}
// called with Corpus.mu Locked
func (gp *GerritProject) finishProcessing() {
for cl := range gp.dirtyCL {
// All dirty CLs have non-nil Meta, so it's safe to call finishProcessingCL.
gp.finishProcessingCL(cl)
}
gp.dirtyCL = nil
}
// finishProcessingCL fixes up invariants before the cl can be returned back to the user.
// cl.Meta must be non-nil.
//
// called with Corpus.mu Locked
func (gp *GerritProject) finishProcessingCL(cl *GerritCL) {
c := gp.gerrit.c
mostRecentMetaCommit, ok := c.gitCommit[cl.Meta.Commit.Hash]
if !ok {
log.Printf("WARNING: GerritProject(%q).finishProcessingCL failed to find CL %v hash %s",
gp.ServerSlashProject(), cl.Number, cl.Meta.Commit.Hash)
return
}
foundStatus := ""
// Walk from the newest meta commit backwards, so we store the messages
// in reverse order and then flip the array before setting on the
// GerritCL object.
var backwardMessages []*GerritMessage
var backwardMetas []*GerritMeta
err := gp.foreachCommit(mostRecentMetaCommit, func(gc *GitCommit) error {
if strings.Contains(gc.Msg, "\nLabel: ") {
gp.numLabelChanges++
}
if strings.Contains(gc.Msg, "\nPrivate: true\n") {
cl.Private = true
}
if gc.GerritMeta == nil {
gc.GerritMeta = newGerritMeta(gc, cl)
}
if foundStatus == "" {
foundStatus = getGerritStatus(gc)
}
backwardMetas = append(backwardMetas, gc.GerritMeta)
if message := gp.getGerritMessage(gc); message != nil {
backwardMessages = append(backwardMessages, message)
}
return nil
})
if err != nil {
log.Printf("WARNING: GerritProject(%q).finishProcessingCL failed to walk CL %v meta history: %v",
gp.ServerSlashProject(), cl.Number, err)
return
}
if foundStatus != "" {
cl.Status = foundStatus
} else if cl.Status == "" {
cl.Status = "new"
}
reverseGerritMessages(backwardMessages)
cl.Messages = backwardMessages
reverseGerritMetas(backwardMetas)
cl.Metas = backwardMetas
cl.Created = cl.Metas[0].Commit.CommitTime
cl.updateBranch()
}
// clSliceContains reports whether cls contains cl.
func clSliceContains(cls []*GerritCL, cl *GerritCL) bool {
for _, v := range cls {
if v == cl {
return true
}
}
return false
}
// c.mu must be held
func (gp *GerritProject) markNeededCommit(hash GitHash) {
if _, ok := gp.commit[hash]; ok {
// Already have it.
return
}
gp.need[hash] = true
}
// c.mu must be held
func (gp *GerritProject) getOrCreateCL(num int32) *GerritCL {
cl, ok := gp.cls[num]
if ok {
return cl
}
cl = &GerritCL{
Project: gp,
Number: num,
}
gp.cls[num] = cl
return cl
}
func gerritVersionNumber(s string) (version int32, ok bool) {
if s == "meta" {
return 0, true
}
v, err := strconv.ParseInt(s, 10, 32)
if err != nil {
return 0, false
}
return int32(v), true
}
// rxRemoteRef matches "git ls-remote" lines.
//
// sample row:
// fd1e71f1594ce64941a85428ddef2fbb0ad1023e refs/changes/99/30599/3
//
// Capture values:
// $0: whole match
// $1: "fd1e71f1594ce64941a85428ddef2fbb0ad1023e"
// $2: "30599" (CL number)
// $3: "1", "2" (patchset number) or "meta" (a/ special commit
// holding the comments for a commit)
//
// The "99" in the middle covers all CL's that end in "99", so
// refs/changes/99/99/1, refs/changes/99/199/meta.
var rxRemoteRef = regexp.MustCompile(`^([0-9a-f]{40,})\s+refs/changes/[0-9a-f]{2}/([0-9]+)/(.+)$`)
// $1: change num
// $2: version or "meta"
var rxChangeRef = regexp.MustCompile(`^refs/changes/[0-9a-f]{2}/([0-9]+)/(meta|(?:\d+))`)
func (gp *GerritProject) sync(ctx context.Context, loop bool) error {
if err := gp.init(ctx); err != nil {
gp.logf("init: %v", err)
return err
}
activityCh := gp.gerrit.c.activityChan("gerrit:" + gp.proj)
for {
if err := gp.syncOnce(ctx); err != nil {
if ee, ok := err.(*exec.ExitError); ok {
err = fmt.Errorf("%v; stderr=%q", err, ee.Stderr)
}
gp.logf("sync: %v", err)
return err
}
if !loop {
return nil
}
timer := time.NewTimer(5 * time.Minute)
select {
case <-ctx.Done():
timer.Stop()
return ctx.Err()
case <-activityCh:
timer.Stop()
case <-timer.C:
}
}
}
// syncMissingCommits is a cleanup step to fix a previous maintner bug where
// refs were updated without all their reachable commits being indexed and
// recorded in the log. This should only ever run once, and only in Go's history.
// If we restarted the log from the beginning this wouldn't be necessary.
func (gp *GerritProject) syncMissingCommits(ctx context.Context) error {
c := gp.gerrit.c
var hashes []GitHash
c.mu.Lock()
for hash := range gp.need {
hashes = append(hashes, hash)
}
c.mu.Unlock()
if len(hashes) == 0 {
return nil
}
gp.logf("fixing indexing of %d missing commits", len(hashes))
if err := gp.fetchHashes(ctx, hashes); err != nil {
return err
}
n, err := gp.syncCommits(ctx)
if err != nil {
return err
}
gp.logf("%d missing commits indexed", n)
return nil
}
func (gp *GerritProject) syncOnce(ctx context.Context) error {
if err := gp.syncMissingCommits(ctx); err != nil {
return err
}
c := gp.gerrit.c
gitDir := gp.gitDir()
fetchCtx, cancel := context.WithTimeout(ctx, time.Minute)
cmd := exec.CommandContext(fetchCtx, "git", "fetch", "origin")
cmd.Dir = gitDir
out, err := cmd.CombinedOutput()
cancel()
if err != nil {
return fmt.Errorf("git fetch origin: %v, %s", err, out)
}
cmd = exec.CommandContext(ctx, "git", "ls-remote")
cmd.Dir = gitDir
out, err = cmd.CombinedOutput()
if err != nil {
return fmt.Errorf("git ls-remote in %s: %v, %s", gitDir, err, out)
}
var changedRefs []*maintpb.GitRef
var toFetch []GitHash
bs := bufio.NewScanner(bytes.NewReader(out))
// Take the lock here to access gp.remote and call c.gitHashFromHex.
// It's acceptable to take such a coarse-looking lock because
// it's not actually around I/O: all the input from ls-remote has
// already been slurped into memory.
c.mu.Lock()
for bs.Scan() {
line := bs.Bytes()
tab := bytes.IndexByte(line, '\t')
if tab == -1 {
if !strings.HasPrefix(bs.Text(), "From ") {
gp.logf("bogus ls-remote line: %q", line)
}
continue
}
sha1 := string(line[:tab])
refName := strings.TrimSpace(string(line[tab+1:]))
hash := c.gitHashFromHexStr(sha1)
var needFetch bool
m := rxRemoteRef.FindSubmatch(line)
if m != nil {
clNum, err := strconv.ParseInt(string(m[2]), 10, 32)
version, ok := gerritVersionNumber(string(m[3]))
if err != nil || !ok {
continue
}
curHash := gp.remote[gerritCLVersion{int32(clNum), version}]
needFetch = curHash != hash
} else if trackGerritRef(refName) && gp.ref[refName] != hash {
needFetch = true
gp.logf("gerrit ref %q = %q", refName, sha1)
}
if needFetch {
toFetch = append(toFetch, hash)
changedRefs = append(changedRefs, &maintpb.GitRef{
Ref: refName,
Sha1: string(sha1),
})
}
}
c.mu.Unlock()
if err := bs.Err(); err != nil {
return err
}
if len(changedRefs) == 0 {
return nil
}
gp.logf("%d new refs", len(changedRefs))
const batchSize = 250
for len(toFetch) > 0 {
batch := toFetch
if len(batch) > batchSize {
batch = batch[:batchSize]
}
if err := gp.fetchHashes(ctx, batch); err != nil {
return err
}
c.mu.Lock()
for _, hash := range batch {
gp.markNeededCommit(hash)
}
c.mu.Unlock()
n, err := gp.syncCommits(ctx)
if err != nil {
return err
}
toFetch = toFetch[len(batch):]
gp.logf("synced %v commits for %d new hashes, %d hashes remain", n, len(batch), len(toFetch))
c.addMutation(&maintpb.Mutation{
Gerrit: &maintpb.GerritMutation{
Project: gp.proj,
Refs: changedRefs[:len(batch)],
}})
changedRefs = changedRefs[len(batch):]
}
return nil
}
func (gp *GerritProject) syncCommits(ctx context.Context) (n int, err error) {
c := gp.gerrit.c
lastLog := time.Now()
for {
hash := gp.commitToIndex()
if hash == "" {
return n, nil
}
now := time.Now()
if lastLog.Before(now.Add(-1 * time.Second)) {
lastLog = now
gp.logf("parsing commits (%v done)", n)
}
commit, err := parseCommitFromGit(gp.gitDir(), hash)
if err != nil {
return n, err
}
c.addMutation(&maintpb.Mutation{
Gerrit: &maintpb.GerritMutation{
Project: gp.proj,
Commits: []*maintpb.GitCommit{commit},
},
})
n++
}
}
func (gp *GerritProject) commitToIndex() GitHash {
c := gp.gerrit.c
c.mu.RLock()
defer c.mu.RUnlock()
for hash := range gp.need {
return hash
}
return ""
}
var (
statusSpace = []byte("Status: ")
)
func (gp *GerritProject) fetchHashes(ctx context.Context, hashes []GitHash) error {
args := []string{"fetch", "--quiet", "origin"}
for _, hash := range hashes {
args = append(args, hash.String())
}
gp.logf("fetching %v hashes...", len(hashes))
cmd := exec.CommandContext(ctx, "git", args...)
cmd.Dir = gp.gitDir()
if out, err := cmd.CombinedOutput(); err != nil {
log.Printf("error fetching %d hashes from gerrit project %s: %s", len(hashes), gp.proj, out)
return err
}
gp.logf("fetched %v hashes.", len(hashes))
return nil
}
func formatExecError(err error) string {
if ee, ok := err.(*exec.ExitError); ok {
return fmt.Sprintf("%v; stderr=%q", err, ee.Stderr)
}
return fmt.Sprint(err)
}
func (gp *GerritProject) init(ctx context.Context) error {
gitDir := gp.gitDir()
if err := os.MkdirAll(gitDir, 0755); err != nil {
return err
}
// try to short circuit a git init error, since the init error matching is
// brittle
if _, err := exec.LookPath("git"); err != nil {
return fmt.Errorf("looking for git binary: %v", err)
}
if _, err := os.Stat(filepath.Join(gitDir, ".git", "config")); err == nil {
cmd := exec.CommandContext(ctx, "git", "remote", "-v")
cmd.Dir = gitDir
remoteBytes, err := cmd.Output()
if err != nil {
return fmt.Errorf("running git remote -v in %v: %v", gitDir, formatExecError(err))
}
if !strings.Contains(string(remoteBytes), "origin") && !strings.Contains(string(remoteBytes), "https://"+gp.proj) {
return fmt.Errorf("didn't find origin & gp.url in remote output %s", string(remoteBytes))
}
gp.logf("git directory exists.")
return nil
}
cmd := exec.CommandContext(ctx, "git", "init")
buf := new(bytes.Buffer)
cmd.Stdout = buf
cmd.Stderr = buf
cmd.Dir = gitDir
if err := cmd.Run(); err != nil {
log.Printf(`Error running "git init": %s`, buf.String())
return err
}
buf.Reset()
cmd = exec.CommandContext(ctx, "git", "remote", "add", "origin", "https://"+gp.proj)
cmd.Stdout = buf
cmd.Stderr = buf
cmd.Dir = gitDir
if err := cmd.Run(); err != nil {
log.Printf(`Error running "git remote add origin": %s`, buf.String())
return err
}
return nil
}
// trackGerritRef reports whether we care to record changes about the
// given ref.
func trackGerritRef(ref string) bool {
if strings.HasPrefix(ref, "refs/users/") {
return false
}
if strings.HasPrefix(ref, "refs/meta/") {
return false
}
if strings.HasPrefix(ref, "refs/cache-automerge/") {
return false
}
return true
}
func (g *Gerrit) check() error {
for key, gp := range g.projects {
if err := gp.check(); err != nil {
return fmt.Errorf("%s: %v", key, err)
}
}
return nil
}
// called with its Corpus.mu locked. (called by
// Corpus.finishProcessing; read comment there)
func (g *Gerrit) finishProcessing() {
if g == nil {
return
}
for _, gp := range g.projects {
gp.finishProcessing()
}
}
func (gp *GerritProject) check() error {
if len(gp.need) != 0 {
return fmt.Errorf("%d missing commits", len(gp.need))
}
for hash, gc := range gp.commit {
if gc.Committer == placeholderCommitter {
return fmt.Errorf("git commit for key %q was placeholder", hash)
}
if gc.Hash != hash {
return fmt.Errorf("git commit for key %q had GitCommit.Hash %q", hash, gc.Hash)
}
for _, pc := range gc.Parents {
if _, ok := gp.commit[pc.Hash]; !ok {
return fmt.Errorf("git commit %q exists but its parent %q does not", gc.Hash, pc.Hash)
}
}
}
return nil
}
// GerritMeta represents a Git commit in the Gerrit NoteDb meta
// format.
type GerritMeta struct {
// Commit points up to the git commit for this Gerrit NoteDB meta commit.
Commit *GitCommit
// CL is the Gerrit CL this metadata is for.
CL *GerritCL
flags gerritMetaFlags
}
type gerritMetaFlags uint8
const (
// metaFlagHashtagEdit indicates that the meta commit edits the hashtags on the commit.
metaFlagHashtagEdit gerritMetaFlags = 1 << iota
)
func newGerritMeta(gc *GitCommit, cl *GerritCL) *GerritMeta {
m := &GerritMeta{Commit: gc, CL: cl}
if msg := m.Commit.Msg; strings.Contains(msg, "autogenerated:gerrit:setHashtag") && m.ActionTag() == "autogenerated:gerrit:setHashtag" {
m.flags |= metaFlagHashtagEdit
}
return m
}
// Footer returns the "key: value" lines at the base of the commit.
func (m *GerritMeta) Footer() string {
i := strings.LastIndex(m.Commit.Msg, "\n\n")
if i == -1 {
return ""
}
return m.Commit.Msg[i+2:]
}
// Hashtags returns the current set of hashtags.
func (m *GerritMeta) Hashtags() GerritHashtags {
tags, _ := lineValue(m.Footer(), "Hashtags: ")
return GerritHashtags(tags)
}
// ActionTag returns the Gerrit "Tag" value from the meta commit.
// These are of the form "autogenerated:gerrit:setHashtag".
func (m *GerritMeta) ActionTag() string {
v, _ := lineValue(m.Footer(), "Tag: ")
return v
}
// HashtagEdits returns the hashtags added and removed by this meta commit,
// and whether this meta commit actually modified hashtags.
func (m *GerritMeta) HashtagEdits() (added, removed GerritHashtags, ok bool) {
// Return early for the majority of meta commits that don't edit hashtags.
if m.flags&metaFlagHashtagEdit == 0 {
return
}
msg := m.Commit.Msg
// Parse lines of form:
//
// Hashtag removed: bar
// Hashtags removed: foo, bar
// Hashtag added: bar
// Hashtags added: foo, bar
for len(msg) > 0 {
value, rest := lineValue(msg, "Hash")
msg = rest
colon := strings.IndexByte(value, ':')
if colon != -1 {
action := value[:colon]
value := GerritHashtags(strings.TrimSpace(value[colon+1:]))
switch action {
case "tag added", "tags added":
added = value
case "tag removed", "tags removed":
removed = value
}
}
}
ok = added != "" || removed != ""
return
}
// HashtagsAdded returns the hashtags added by this meta commit, if any.
func (m *GerritMeta) HashtagsAdded() GerritHashtags {
added, _, _ := m.HashtagEdits()
return added
}
// HashtagsRemoved returns the hashtags removed by this meta commit, if any.
func (m *GerritMeta) HashtagsRemoved() GerritHashtags {
_, removed, _ := m.HashtagEdits()
return removed
}
// LabelVotes returns a map from label name to voter email to their vote.
//
// This is relatively expensive to call compared to other methods in maintner.
// It is not currently cached.
func (m *GerritMeta) LabelVotes() map[string]map[string]int8 {
if m == nil {
panic("nil *GerritMeta")
}
if m.CL == nil {
panic("GerritMeta has nil CL field")
}
// To calculate votes as the time of the 'm' meta commit,
// we need to consider the meta commits before it.
// Let's see which number in the (linear) meta history
// we are.
ourIndex := -1
for i, mc := range m.CL.Metas {
if mc == m {
ourIndex = i
break
}
}
if ourIndex == -1 {
panic("LabelVotes called on GerritMeta not in its m.CL.Metas slice")
}
labels := map[string]map[string]int8{}
history := m.CL.Metas[:ourIndex+1]
var lastCommit string
for _, mc := range history {
log.Printf("For CL %v, mc %v", m.CL.Number, mc)
footer := mc.Footer()
isNew := strings.Contains(footer, "\nTag: autogenerated:gerrit:newPatchSet\n")
email := mc.Commit.Author.Email()
if isNew {
commit, _ := lineValue(footer, "Commit: ")
if commit != "" {
// TODO: implement Gerrit's vote copying. For example,
// label.Label-Name.copyAllScoresIfNoChange defaults to true (as it is with Go's server)
// https://gerrit-review.googlesource.com/Documentation/config-labels.html#label_copyAllScoresIfNoChange
// We don't have the information in Maintner to do this, though.
// One approximation is:
if lastCommit != "" {
oldCommit := m.CL.Project.GitCommit(lastCommit)
newCommit := m.CL.Project.GitCommit(commit)
if !oldCommit.SameDiffStat(newCommit) {
// TODO: this should really use
// the Gerrit server's project
// config, including the
// All-Projects config, but
// that's not in Maintner
// either.
delete(labels, "Run-TryBot")
delete(labels, "TryBot-Result")
}
}
lastCommit = commit
}
}
remain := footer
for len(remain) > 0 {
var labelEqVal string
labelEqVal, remain = lineValue(remain, "Label: ")
if labelEqVal != "" {
label, value, whose := parseGerritLabelValue(labelEqVal)
if label != "" {
if whose == "" {
whose = email
}
if label[0] == '-' {
label = label[1:]
if m := labels[label]; m != nil {
delete(m, whose)
}
} else {
m := labels[label]
if m == nil {
m = make(map[string]int8)
labels[label] = m
}
m[whose] = value
}
}
}
}
}
return labels
}
// parseGerritLabelValue parses a Gerrit NoteDb "Label: ..." value.
// It can take forms and return values such as:
//
// "Run-TryBot=+1" => ("Run-TryBot", 1, "")
// "-Run-TryBot" => ("-Run-TryBot", 0, "")
// "-Run-TryBot " => ("-Run-TryBot", 0, "")
// "Run-TryBot=+1 Brad Fitzpatrick <5065@62eb7196-b449-3ce5-99f1-c037f21e1705>" =>
// ("Run-TryBot", 1, "5065@62eb7196-b449-3ce5-99f1-c037f21e1705")
// "-TryBot-Result Gobot Gobot <5976@62eb7196-b449-3ce5-99f1-c037f21e1705>" =>
// ("-TryBot-Result", 0, "5976@62eb7196-b449-3ce5-99f1-c037f21e1705")
func parseGerritLabelValue(v string) (label string, value int8, whose string) {
space := strings.IndexByte(v, ' ')
if space != -1 {
v, whose = v[:space], v[space+1:]
if i := strings.IndexByte(whose, '<'); i == -1 {
whose = ""
} else {
whose = whose[i+1:]
if i := strings.IndexByte(whose, '>'); i == -1 {
whose = ""
} else {
whose = whose[:i]
}
}
}
v = strings.TrimSpace(v)
if eq := strings.IndexByte(v, '='); eq == -1 {
label = v
} else {
label = v[:eq]
if n, err := strconv.ParseInt(v[eq+1:], 10, 8); err == nil {
value = int8(n)
}
}
return
}
// GerritHashtags represents a set of "hashtags" on a Gerrit CL.
//
// The representation is a comma-separated string, to match Gerrit's
// internal representation in the meta commits. To support both
// forms of Gerrit's internal representation, whitespace is optional
// around the commas.
type GerritHashtags string
// Contains reports whether the hashtag t is in the set of tags s.
func (s GerritHashtags) Contains(t string) bool {
for len(s) > 0 {
comma := strings.IndexByte(string(s), ',')
if comma == -1 {
return strings.TrimSpace(string(s)) == t
}
if strings.TrimSpace(string(s[:comma])) == t {
return true
}
s = s[comma+1:]
}
return false
}
// Foreach calls fn for each tag in the set s.
func (s GerritHashtags) Foreach(fn func(string)) {
for len(s) > 0 {
comma := strings.IndexByte(string(s), ',')
if comma == -1 {
fn(strings.TrimSpace(string(s)))
return
}
fn(strings.TrimSpace(string(s[:comma])))
s = s[comma+1:]
}
}
// Match reports whether fn returns true for any tag in the set s.
// If fn returns true, iteration stops and Match returns true.
func (s GerritHashtags) Match(fn func(string) bool) bool {
for len(s) > 0 {
comma := strings.IndexByte(string(s), ',')
if comma == -1 {
return fn(strings.TrimSpace(string(s)))
}
if fn(strings.TrimSpace(string(s[:comma]))) {
return true
}
s = s[comma+1:]
}
return false
}
// Len returns the number of tags in the set s.
func (s GerritHashtags) Len() int {
if s == "" {
return 0
}
return strings.Count(string(s), ",") + 1
}