// Munge is the workhorse the will actually make updates to the PR
func (LGTMAfterCommitMunger) Munge(obj *github.MungeObject) {
if !obj.IsPR() {
return
}
if !obj.HasLabel(lgtmLabel) {
return
}
lastModified := obj.LastModifiedTime()
lgtmTime := obj.LabelTime(lgtmLabel)
if lastModified == nil || lgtmTime == nil {
glog.Errorf("PR %d unable to determine lastModified or lgtmTime", *obj.Issue.Number)
return
}
if lastModified.After(*lgtmTime) {
glog.Infof("PR: %d lgtm:%s lastModified:%s", *obj.Issue.Number, lgtmTime.String(), lastModified.String())
body := fmt.Sprintf(lgtmRemovedBody, mungerutil.GetIssueUsers(obj.Issue).AllUsers().Mention().Join())
if err := obj.WriteComment(body); err != nil {
return
}
obj.RemoveLabel(lgtmLabel)
}
}
func (h *ApprovalHandler) updateNotification(obj *github.MungeObject, ownersMap map[string]sets.String) error {
notificationMatcher := c.MungerNotificationName(approvalNotificationName)
comments, err := obj.ListComments()
if err != nil {
glog.Error("Could not list the comments for PR%v", obj.Issue.Number)
return err
}
notifications := c.FilterComments(comments, notificationMatcher)
latestNotification := notifications.GetLast()
if latestNotification == nil {
return h.createMessage(obj, ownersMap)
}
latestApprove := c.FilterComments(comments, c.CommandName(approveCommand)).GetLast()
if latestApprove == nil || latestApprove.CreatedAt == nil {
// there was already a bot notification and nothing has changed since
// or we wouldn't tell when the latestApproval occurred
return nil
}
if latestApprove.CreatedAt.After(*latestNotification.CreatedAt) {
// if we can't tell when latestApprove happened, we should make a new one
obj.DeleteComment(latestNotification)
return h.createMessage(obj, ownersMap)
}
lastModified := obj.LastModifiedTime()
if latestNotification.CreatedAt.Before(*lastModified) {
obj.DeleteComment(latestNotification)
return h.createMessage(obj, ownersMap)
}
return nil
}
// Munge is the workhorse the will actually make updates to the PR
func (LGTMAfterCommitMunger) Munge(obj *github.MungeObject) {
if !obj.IsPR() {
return
}
if !obj.HasLabel("lgtm") {
return
}
lastModified := obj.LastModifiedTime()
lgtmTime := obj.LabelTime("lgtm")
if lastModified == nil || lgtmTime == nil {
glog.Errorf("PR %d unable to determine lastModified or lgtmTime", *obj.Issue.Number)
return
}
if lastModified.After(*lgtmTime) {
glog.Infof("PR: %d lgtm:%s lastModified:%s", *obj.Issue.Number, lgtmTime.String(), lastModified.String())
lgtmRemovedBody := "PR changed after LGTM, removing LGTM."
if err := obj.WriteComment(lgtmRemovedBody); err != nil {
return
}
obj.RemoveLabel("lgtm")
}
}
func getCommentsAfterLastModified(obj *github.MungeObject) ([]*githubapi.IssueComment, error) {
afterLastModified := func(opt *githubapi.IssueListCommentsOptions) *githubapi.IssueListCommentsOptions {
// Only comments updated at or after this time are returned.
// One possible case is that reviewer might "/lgtm" first, contributor updated PR, and reviewer updated "/lgtm".
// This is still valid. We don't recommend user to update it.
lastModified := *obj.LastModifiedTime()
opt.Since = lastModified
return opt
}
return obj.ListComments(afterLastModified)
}
// assigneeActionNeeded returns true if we are waiting on an action from the reviewer.
func isReviewerActionNeeded(obj *github.MungeObject) (bool, error) {
comments, err := obj.ListComments()
if err != nil {
return false, err
}
lastAuthorCommentTime := comment.LastComment(comments, comment.Author(*obj.Issue.User), nil)
lastReviewerCommentTime := getLastReviewerComment(obj, comments)
if lastReviewerCommentTime == nil {
// this implies that no reviewer has commented on the PR yet.
return true, nil
}
if obj.LastModifiedTime().After(*lastReviewerCommentTime) {
return true, nil
}
if lastAuthorCommentTime == nil {
return false, nil
}
return lastReviewerCommentTime.Before(*lastAuthorCommentTime), nil
}
// validForMerge is the base logic about what PR can be automatically merged.
// PRs must pass this logic to be placed on the queue and they must pass this
// logic a second time to be retested/merged after they get to the top of
// the queue.
//
// If you update the logic PLEASE PLEASE PLEASE update serveMergeInfo() as well.
func (sq *SubmitQueue) validForMerge(obj *github.MungeObject) bool {
// Can't merge an issue!
if !obj.IsPR() {
return false
}
// Can't merge something already merged.
if m, err := obj.IsMerged(); err != nil {
glog.Errorf("%d: unknown err: %v", *obj.Issue.Number, err)
sq.SetMergeStatus(obj, unknown)
return false
} else if m {
sq.SetMergeStatus(obj, mergedByHand)
return false
}
if milestone := obj.Issue.Milestone; true {
title := ""
// Net set means the empty milestone, ""
if milestone != nil && milestone.Title != nil {
title = *milestone.Title
}
for _, blocked := range sq.DoNotMergeMilestones {
if title == blocked {
sq.SetMergeStatus(obj, unmergeableMilestone)
return false
}
}
}
// Must pass CLA checks
if !obj.HasLabel(claYesLabel) && !obj.HasLabel(claHumanLabel) && !obj.HasLabel(cncfClaYesLabel) {
sq.SetMergeStatus(obj, noCLA)
return false
}
// Obviously must be mergeable
if mergeable, err := obj.IsMergeable(); err != nil {
sq.SetMergeStatus(obj, undeterminedMergability)
return false
} else if !mergeable {
sq.SetMergeStatus(obj, unmergeable)
return false
}
// Validate the status information for this PR
if len(sq.RequiredStatusContexts) > 0 {
if ok := obj.IsStatusSuccess(sq.RequiredStatusContexts); !ok {
sq.SetMergeStatus(obj, ciFailure)
return false
}
}
if len(sq.RequiredRetestContexts) > 0 {
if ok := obj.IsStatusSuccess(sq.RequiredRetestContexts); !ok {
sq.SetMergeStatus(obj, ciFailure)
return false
}
}
// Clearly
if !(obj.HasLabel(lgtmLabel) || obj.HasLabel(approvedLabel)) {
sq.SetMergeStatus(obj, noLGTM)
return false
}
// PR cannot change since LGTM was added
lastModifiedTime := obj.LastModifiedTime()
// lgtmTime and approvedTime cannot both be nil at this point (see check above)
earliestApproved := getEarliestApprovedTime(obj)
if lastModifiedTime == nil || earliestApproved == nil {
glog.Errorf("PR %d was unable to determine when LGTM was added or when last modified", *obj.Issue.Number)
sq.SetMergeStatus(obj, unknown)
return false
}
if lastModifiedTime.After(*earliestApproved) {
sq.SetMergeStatus(obj, lgtmEarly)
return false
}
// PR cannot have the label which prevents merging.
if obj.HasLabel(doNotMergeLabel) {
sq.SetMergeStatus(obj, noMerge)
return false
}
return true
}
// Munge is the workhorse the will actually make updates to the PR
func (sq *SubmitQueue) Munge(obj *github.MungeObject) {
if !obj.IsPR() {
return
}
e2e := sq.e2e
userSet := sq.userWhitelist
if !obj.HasLabels([]string{claYes}) && !obj.HasLabels([]string{claHuman}) {
sq.SetMergeStatus(obj, noCLA, false)
return
}
if mergeable, err := obj.IsMergeable(); err != nil {
sq.SetMergeStatus(obj, undeterminedMergability, false)
return
} else if !mergeable {
sq.SetMergeStatus(obj, unmergeable, false)
return
}
// Validate the status information for this PR
contexts := sq.requiredStatusContexts(obj)
if ok := obj.IsStatusSuccess(contexts); !ok {
sq.SetMergeStatus(obj, ciFailure, false)
return
}
if !obj.HasLabel(sq.WhitelistOverride) && !userSet.Has(*obj.Issue.User.Login) {
if !obj.HasLabel(needsOKToMergeLabel) {
obj.AddLabels([]string{needsOKToMergeLabel})
body := "The author of this PR is not in the whitelist for merge, can one of the admins add the 'ok-to-merge' label?"
obj.WriteComment(body)
}
sq.SetMergeStatus(obj, needsok, false)
return
}
// Tidy up the issue list.
if obj.HasLabel(needsOKToMergeLabel) {
obj.RemoveLabel(needsOKToMergeLabel)
}
if !obj.HasLabels([]string{"lgtm"}) {
sq.SetMergeStatus(obj, noLGTM, false)
return
}
lastModifiedTime := obj.LastModifiedTime()
lgtmTime := obj.LabelTime("lgtm")
if lastModifiedTime == nil || lgtmTime == nil {
glog.Errorf("PR %d was unable to determine when LGTM was added or when last modified", *obj.Issue.Number)
sq.SetMergeStatus(obj, unknown, false)
return
}
if lastModifiedTime.After(*lgtmTime) {
sq.SetMergeStatus(obj, lgtmEarly, false)
return
}
if !e2e.Stable() {
sq.flushGithubE2EQueue(e2eFailure)
sq.SetMergeStatus(obj, e2eFailure, false)
return
}
// if there is a 'e2e-not-required' label, just merge it.
if obj.HasLabel(e2eNotRequiredLabel) {
obj.MergePR("submit-queue")
sq.SetMergeStatus(obj, merged, true)
return
}
added := false
sq.Lock()
if _, ok := sq.githubE2EQueue[*obj.Issue.Number]; !ok {
sq.githubE2EQueue[*obj.Issue.Number] = obj
sq.githubE2EWakeup <- true
added = true
}
sq.Unlock()
if added {
sq.SetMergeStatus(obj, ghE2EQueued, true)
}
return
}
// Munge is the workhorse the will actually make updates to the PR
func (sq *SubmitQueue) Munge(obj *github.MungeObject) {
if !obj.IsPR() {
return
}
userSet := sq.userWhitelist
if !obj.HasLabels([]string{claYes}) && !obj.HasLabels([]string{claHuman}) {
sq.SetMergeStatus(obj, noCLA, false)
return
}
if mergeable, err := obj.IsMergeable(); err != nil {
sq.SetMergeStatus(obj, undeterminedMergability, false)
return
} else if !mergeable {
sq.SetMergeStatus(obj, unmergeable, false)
return
}
// Validate the status information for this PR
contexts := sq.requiredStatusContexts(obj)
if ok := obj.IsStatusSuccess(contexts); !ok {
sq.SetMergeStatus(obj, ciFailure, false)
return
}
if !obj.HasLabel(sq.WhitelistOverride) && !userSet.Has(*obj.Issue.User.Login) {
if !obj.HasLabel(needsOKToMergeLabel) {
obj.AddLabels([]string{needsOKToMergeLabel})
body := "The author of this PR is not in the whitelist for merge, can one of the admins add the 'ok-to-merge' label?"
obj.WriteComment(body)
}
sq.SetMergeStatus(obj, needsok, false)
return
}
// Tidy up the issue list.
if obj.HasLabel(needsOKToMergeLabel) {
obj.RemoveLabel(needsOKToMergeLabel)
}
if !obj.HasLabels([]string{"lgtm"}) {
sq.SetMergeStatus(obj, noLGTM, false)
return
}
lastModifiedTime := obj.LastModifiedTime()
lgtmTime := obj.LabelTime("lgtm")
if lastModifiedTime == nil || lgtmTime == nil {
glog.Errorf("PR %d was unable to determine when LGTM was added or when last modified", *obj.Issue.Number)
sq.SetMergeStatus(obj, unknown, false)
return
}
if lastModifiedTime.After(*lgtmTime) {
sq.SetMergeStatus(obj, lgtmEarly, false)
return
}
added := false
sq.Lock()
if _, ok := sq.githubE2EQueue[*obj.Issue.Number]; !ok {
added = true
}
// Add this most-recent object in place of the existing object. It will
// have more up2date information. Even though we explicitly refresh the
// PR information before do anything with it, this allow things like the
// queue order to change dynamically as labels are added/removed.
sq.githubE2EQueue[*obj.Issue.Number] = obj
sq.Unlock()
if added {
sq.SetMergeStatus(obj, ghE2EQueued, true)
}
return
}
// validForMerge is the base logic about what PR can be automatically merged.
// PRs must pass this logic to be placed on the queue and they must pass this
// logic a second time to be retested/merged after they get to the top of
// the queue.
//
// If you update the logic PLEASE PLEASE PLEASE update serveMergeInfo() as well.
func (sq *SubmitQueue) validForMerge(obj *github.MungeObject) bool {
// Can't merge an issue!
if !obj.IsPR() {
return false
}
// Can't merge something already merged.
if m, err := obj.IsMerged(); err != nil {
glog.Errorf("%d: unknown err: %v", *obj.Issue.Number, err)
sq.SetMergeStatus(obj, unknown)
return false
} else if m {
sq.SetMergeStatus(obj, merged)
return false
}
userSet := sq.userWhitelist
// Must pass CLA checks
if !obj.HasLabel(claYesLabel) && !obj.HasLabel(claHumanLabel) {
sq.SetMergeStatus(obj, noCLA)
return false
}
// Obviously must be mergeable
if mergeable, err := obj.IsMergeable(); err != nil {
sq.SetMergeStatus(obj, undeterminedMergability)
return false
} else if !mergeable {
sq.SetMergeStatus(obj, unmergeable)
return false
}
// Validate the status information for this PR
contexts := sq.requiredStatusContexts(obj)
if ok := obj.IsStatusSuccess(contexts); !ok {
sq.SetMergeStatus(obj, ciFailure)
return false
}
// The user either must be on the whitelist or have ok-to-merge
if !obj.HasLabel(okToMergeLabel) && !userSet.Has(*obj.Issue.User.Login) {
if !obj.HasLabel(needsOKToMergeLabel) {
obj.AddLabels([]string{needsOKToMergeLabel})
obj.WriteComment(notInWhitelistBody)
}
sq.SetMergeStatus(obj, needsok)
return false
}
// Tidy up the issue list.
if obj.HasLabel(needsOKToMergeLabel) {
obj.RemoveLabel(needsOKToMergeLabel)
}
// Clearly
if !obj.HasLabel(lgtmLabel) {
sq.SetMergeStatus(obj, noLGTM)
return false
}
// PR cannot change since LGTM was added
lastModifiedTime := obj.LastModifiedTime()
lgtmTime := obj.LabelTime(lgtmLabel)
if lastModifiedTime == nil || lgtmTime == nil {
glog.Errorf("PR %d was unable to determine when LGTM was added or when last modified", *obj.Issue.Number)
sq.SetMergeStatus(obj, unknown)
return false
}
if lastModifiedTime.After(*lgtmTime) {
sq.SetMergeStatus(obj, lgtmEarly)
return false
}
// PR cannot have the label which prevents merging.
if obj.HasLabel(doNotMergeLabel) {
sq.SetMergeStatus(obj, noMerge)
return false
}
return true
}