mungers

package
v0.0.0-...-71304e1 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 6, 2017 License: Apache-2.0 Imports: 42 Imported by: 0

Documentation

Overview

Package mungers deals with munging of github pull requests

Index

Constants

View Source
const (
	NOTIFNAME       = "INACTIVE-PULL-REQUEST"
	CREATIONTIMECAP = 36 * 30 * 24 * time.Hour //period since PR creation time
	COMMENTTIMECAP  = 7 * 24 * time.Hour       //period since last IssueComment and PullRequestComment being posted
	REMINDERNUMCAP  = 5                        //maximum number of times this munger will post reminder IssueComment
	LEAFOWNERSONLY  = false                    //setting for Blunderbuss to fetch only leaf owners or all owners
)

Variables

View Source
var AssociatedIssueRegex = regexp.MustCompile(`(?:kubernetes/[^/]+/issues/|#)(\d+)`)

Functions

func EachLoop

func EachLoop() error

EachLoop will be called before we start a poll loop and will run the EachLoop function for all active mungers

func InitializeMungers

func InitializeMungers(config *github.Config, features *features.Features) error

InitializeMungers will call munger.Initialize() for the requested mungers.

func MungeIssue

func MungeIssue(obj *github.MungeObject) error

MungeIssue will call each activated munger with the given object

func NewPublisherLog

func NewPublisherLog(buf *bytes.Buffer) *plog

func RegisterMunger

func RegisterMunger(munger Munger) error

RegisterMunger should be called in `init()` by each munger to make itself available by name

func RegisterMungerOrDie

func RegisterMungerOrDie(munger Munger)

RegisterMungerOrDie will call RegisterMunger but will be fatal on error

func RegisterMungers

func RegisterMungers(requestedMungers []string) error

RegisterMungers will check if a requested munger exists and add it to the list.

func RegisterOptions

func RegisterOptions(opts *options.Options) sets.String

func RegisterStaleIssueComments

func RegisterStaleIssueComments(s StaleIssueComment)

RegisterStaleIssueComments is the method for a munger to register that it creates issue comments which might go stale and need to be cleaned up.

func RequestedFeatures

func RequestedFeatures() []string

RequestedFeatures returns a list of all feature which should be enabled for the running mungers

func SyncLabels

func SyncLabels(allLabels, desiredLabels sets.String, obj *github.MungeObject) error

SyncLabels properly syncs a set of labels. 'allLabels' must be a superset of 'desiredLabels'; to disable removing labels, set them to be the same set. Multiple mungers must somehow coordinate on which labels the bot ought to apply, otherwise the bot will fight with itself.

TODO: fix error handling.

Types

type ApprovalHandler

type ApprovalHandler struct {
	// contains filtered or unexported fields
}

ApprovalHandler will try to add "approved" label once all files of change has been approved by approvers.

func (*ApprovalHandler) EachLoop

func (*ApprovalHandler) EachLoop() error

EachLoop is called at the start of every munge loop

func (*ApprovalHandler) Initialize

func (h *ApprovalHandler) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (*ApprovalHandler) Munge

func (h *ApprovalHandler) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the PR The algorithm goes as: - Initially, we build an approverSet

  • Go through all comments in order of creation.
  • (Issue/PR comments, PR review comments, and PR review bodies are considered as comments)
  • If anyone said "/approve" or "/lgtm", add them to approverSet.

- Then, for each file, we see if any approver of this file is in approverSet and keep track of files without approval

  • An approver of a file is defined as:
  • Someone listed as an "approver" in an OWNERS file in the files directory OR
  • in one of the file's parent directorie
  • Iff all files have been approved, the bot will add the "approved" label.
  • Iff a cancel command is found, that reviewer will be removed from the approverSet and the munger will remove the approved label if it has been applied

func (*ApprovalHandler) Name

func (*ApprovalHandler) Name() string

Name is the name usable in --pr-mungers

func (*ApprovalHandler) RegisterOptions

func (h *ApprovalHandler) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*ApprovalHandler) RequiredFeatures

func (*ApprovalHandler) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

type AssignFixesMunger

type AssignFixesMunger struct {
	// contains filtered or unexported fields
}

AssignFixesMunger will assign issues to users based on the config file provided by --assignfixes-config.

func (*AssignFixesMunger) EachLoop

func (a *AssignFixesMunger) EachLoop() error

EachLoop is called at the start of every munge loop

func (*AssignFixesMunger) Initialize

func (a *AssignFixesMunger) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (*AssignFixesMunger) Munge

func (a *AssignFixesMunger) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the PR

func (*AssignFixesMunger) Name

func (a *AssignFixesMunger) Name() string

Name is the name usable in --pr-mungers

func (*AssignFixesMunger) RegisterOptions

func (a *AssignFixesMunger) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*AssignFixesMunger) RequiredFeatures

func (a *AssignFixesMunger) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

type Batch

type Batch struct {
	BaseName string
	BaseSha  string
	Pulls    []batchPull
}

Batch represents a specific merge state: a base branch and SHA, and the SHAs of each PR merged into it.

func (*Batch) String

func (b *Batch) String() string

type BlockPath

type BlockPath struct {
	// contains filtered or unexported fields
}

BlockPath will add a label to block auto merge if a PR touches certain paths

func (*BlockPath) EachLoop

func (b *BlockPath) EachLoop() error

EachLoop is called at the start of every munge loop

func (*BlockPath) Initialize

func (b *BlockPath) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (*BlockPath) Munge

func (b *BlockPath) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the PR

func (*BlockPath) Name

func (b *BlockPath) Name() string

Name is the name usable in --pr-mungers

func (*BlockPath) RegisterOptions

func (b *BlockPath) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*BlockPath) RequiredFeatures

func (b *BlockPath) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

func (*BlockPath) StaleIssueComments

func (b *BlockPath) StaleIssueComments(obj *github.MungeObject, comments []*githubapi.IssueComment) []*githubapi.IssueComment

StaleIssueComments returns a slice of stale issue comments.

type BlunderbussConfig

type BlunderbussConfig struct {
	PrefixMap map[string][]string `json:"prefixMap,omitempty" yaml:"prefixMap,omitempty"`
}

A BlunderbussConfig maps a set of file prefixes to a set of owner names (github users)

type BlunderbussMunger

type BlunderbussMunger struct {
	// contains filtered or unexported fields
}

BlunderbussMunger will assign issues to users based on the config file provided by --blunderbuss-config and/or OWNERS files.

func (*BlunderbussMunger) EachLoop

func (b *BlunderbussMunger) EachLoop() error

EachLoop is called at the start of every munge loop

func (*BlunderbussMunger) Initialize

func (b *BlunderbussMunger) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (*BlunderbussMunger) Munge

func (b *BlunderbussMunger) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the PR

func (*BlunderbussMunger) Name

func (b *BlunderbussMunger) Name() string

Name is the name usable in --pr-mungers

func (*BlunderbussMunger) RegisterOptions

func (b *BlunderbussMunger) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*BlunderbussMunger) RequiredFeatures

func (b *BlunderbussMunger) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

type CheckLabelsMunger

type CheckLabelsMunger struct {
	// contains filtered or unexported fields
}

CheckLabelsMunger will check that the labels specified in the labels yaml file are created.

func (*CheckLabelsMunger) EachLoop

func (c *CheckLabelsMunger) EachLoop() error

EachLoop is called at the start of every munge loop

func (*CheckLabelsMunger) Initialize

func (c *CheckLabelsMunger) Initialize(config *githubhelper.Config, features *features.Features) error

Initialize will initialize the munger.

func (*CheckLabelsMunger) Munge

Munge is unused by this munger.

func (*CheckLabelsMunger) Name

func (c *CheckLabelsMunger) Name() string

Name is the name usable in --pr-mungers

func (*CheckLabelsMunger) RegisterOptions

func (c *CheckLabelsMunger) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*CheckLabelsMunger) RequiredFeatures

func (c *CheckLabelsMunger) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided.

type CherrypickAutoApprove

type CherrypickAutoApprove struct {
	// contains filtered or unexported fields
}

CherrypickAutoApprove will add 'cherrypick-approved' to PRs which are for 'cherrypick-approved' parents. This only works if the PR (against the 'release-*' branch was done using the script.

func (*CherrypickAutoApprove) EachLoop

func (c *CherrypickAutoApprove) EachLoop() error

EachLoop is called at the start of every munge loop

func (*CherrypickAutoApprove) Initialize

func (c *CherrypickAutoApprove) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (*CherrypickAutoApprove) Munge

func (c *CherrypickAutoApprove) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the PR

func (*CherrypickAutoApprove) Name

func (c *CherrypickAutoApprove) Name() string

Name is the name usable in --pr-mungers

func (*CherrypickAutoApprove) RegisterOptions

func (c *CherrypickAutoApprove) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*CherrypickAutoApprove) RequiredFeatures

func (c *CherrypickAutoApprove) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

type CherrypickQueue

type CherrypickQueue struct {
	sync.Mutex
	// contains filtered or unexported fields
}

CherrypickQueue will merge PR which meet a set of requirements.

func (*CherrypickQueue) EachLoop

func (c *CherrypickQueue) EachLoop() error

EachLoop is called at the start of every munge loop

func (*CherrypickQueue) Initialize

func (c *CherrypickQueue) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (*CherrypickQueue) Munge

func (c *CherrypickQueue) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the PR

func (*CherrypickQueue) Name

func (c *CherrypickQueue) Name() string

Name is the name usable in --pr-mungers

func (*CherrypickQueue) RegisterOptions

func (c *CherrypickQueue) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*CherrypickQueue) RequiredFeatures

func (c *CherrypickQueue) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

type ClearPickAfterMerge

type ClearPickAfterMerge struct {
	// contains filtered or unexported fields
}

ClearPickAfterMerge will remove the the cherrypick-candidate label from any PR that does not have a 'release' milestone set.

func (*ClearPickAfterMerge) EachLoop

func (c *ClearPickAfterMerge) EachLoop() error

EachLoop is called at the start of every munge loop

func (*ClearPickAfterMerge) Initialize

func (c *ClearPickAfterMerge) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (*ClearPickAfterMerge) Munge

func (c *ClearPickAfterMerge) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the PR

func (*ClearPickAfterMerge) Name

func (c *ClearPickAfterMerge) Name() string

Name is the name usable in --pr-mungers

func (*ClearPickAfterMerge) RegisterOptions

func (c *ClearPickAfterMerge) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*ClearPickAfterMerge) RequiredFeatures

func (c *ClearPickAfterMerge) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

type CloseStale

type CloseStale struct{}

CloseStale will ask the Bot to close any PR/Issue that didn't have any human interactions in `stalePeriod` duration.

This is done by checking both review and issue comments, and by ignoring comments done with a bot name. We also consider re-open on the PR/Issue.

func (CloseStale) EachLoop

func (CloseStale) EachLoop() error

EachLoop is called at the start of every munge loop

func (CloseStale) Initialize

func (CloseStale) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (CloseStale) Munge

func (CloseStale) Munge(obj *github.MungeObject)

Munge is the workhorse that will actually close the PRs/Issues

func (CloseStale) Name

func (CloseStale) Name() string

Name is the name usable in --pr-mungers

func (CloseStale) RegisterOptions

func (CloseStale) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (CloseStale) RequiredFeatures

func (CloseStale) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

func (CloseStale) StaleIssueComments

func (s CloseStale) StaleIssueComments(obj *github.MungeObject, comments []*githubapi.IssueComment) []*githubapi.IssueComment

StaleIssueComments returns a slice of stale issue comments.

type CommentDeleter

type CommentDeleter struct{}

CommentDeleter looks for comments which are no longer useful and deletes them

func (CommentDeleter) EachLoop

func (CommentDeleter) EachLoop() error

EachLoop is called at the start of every munge loop

func (CommentDeleter) Initialize

func (CommentDeleter) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (CommentDeleter) Munge

func (CommentDeleter) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the PR

func (CommentDeleter) Name

func (CommentDeleter) Name() string

Name is the name usable in --pr-mungers

func (CommentDeleter) RegisterOptions

func (CommentDeleter) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (CommentDeleter) RequiredFeatures

func (CommentDeleter) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

type CommentDeleterJenkins

type CommentDeleterJenkins struct{}

CommentDeleterJenkins looks for jenkins comments which are no longer useful and deletes them

func (CommentDeleterJenkins) StaleIssueComments

func (CommentDeleterJenkins) StaleIssueComments(obj *github.MungeObject, comments []*githubapi.IssueComment) []*githubapi.IssueComment

StaleIssueComments returns a slice of stale issue comments.

type DocsNeedNoRetest

type DocsNeedNoRetest struct{}

DocsNeedNoRetest automatically labels documentation only pull-requests as retest-not-required

func (DocsNeedNoRetest) EachLoop

func (DocsNeedNoRetest) EachLoop() error

EachLoop is called at the start of every munge loop

func (*DocsNeedNoRetest) Initialize

func (s *DocsNeedNoRetest) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (DocsNeedNoRetest) Munge

func (DocsNeedNoRetest) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the PR

func (DocsNeedNoRetest) Name

func (DocsNeedNoRetest) Name() string

Name is the name usable in --pr-mungers

func (DocsNeedNoRetest) RegisterOptions

func (DocsNeedNoRetest) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (DocsNeedNoRetest) RequiredFeatures

func (DocsNeedNoRetest) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

type InactiveReviewHandler

type InactiveReviewHandler struct {
	// contains filtered or unexported fields
}

func (*InactiveReviewHandler) EachLoop

func (i *InactiveReviewHandler) EachLoop() error

EachLoop is called at the start of every munge loop

func (*InactiveReviewHandler) Initialize

func (i *InactiveReviewHandler) Initialize(config *github.Config, features *features.Features) error

func (*InactiveReviewHandler) Munge

func (i *InactiveReviewHandler) Munge(obj *github.MungeObject)

Munge is the workhorse encouraging PR author to assign a new reviewer after getting no response from current reviewer for "COMMENTTIMECAP" duration The algorithm: (1) find latest comment posting time (2) if the time is "COMMENTTIMECAP" or longer before today's time, create a comment

encouraging the author to assign a new reviewer and unassign the old reviewer

(3) suggest the new reviewer using Blunderbuss algorithm, making sure the old reviewer is not suggested Note: the munger will post at most "REMINDERNUMCAP" number of times

func (*InactiveReviewHandler) Name

func (i *InactiveReviewHandler) Name() string

func (*InactiveReviewHandler) RegisterOptions

func (*InactiveReviewHandler) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*InactiveReviewHandler) RequiredFeatures

func (i *InactiveReviewHandler) RequiredFeatures() []string

type LGTMAfterCommitMunger

type LGTMAfterCommitMunger struct{}

LGTMAfterCommitMunger will remove the LGTM flag from an PR which has been updated since the reviewer added LGTM

func (LGTMAfterCommitMunger) EachLoop

func (LGTMAfterCommitMunger) EachLoop() error

EachLoop is called at the start of every munge loop

func (LGTMAfterCommitMunger) Initialize

func (LGTMAfterCommitMunger) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (LGTMAfterCommitMunger) Munge

Munge is the workhorse the will actually make updates to the PR

func (LGTMAfterCommitMunger) Name

Name is the name usable in --pr-mungers

func (LGTMAfterCommitMunger) RegisterOptions

func (LGTMAfterCommitMunger) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (LGTMAfterCommitMunger) RequiredFeatures

func (LGTMAfterCommitMunger) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

func (LGTMAfterCommitMunger) StaleIssueComments

func (l LGTMAfterCommitMunger) StaleIssueComments(obj *github.MungeObject, comments []*githubapi.IssueComment) []*githubapi.IssueComment

StaleIssueComments returns a list of stale issue comments.

type LabelMunger

type LabelMunger struct {
	// contains filtered or unexported fields
}

LabelMunger will update a label on a PR based on how many lines are changed. It will exclude certain files in it's calculations based on the config file provided in --generated-files-config

func (*LabelMunger) EachLoop

func (*LabelMunger) EachLoop() error

EachLoop is called at the start of every munge loop

func (*LabelMunger) Initialize

func (*LabelMunger) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (*LabelMunger) Munge

func (lm *LabelMunger) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the PR

func (*LabelMunger) Name

func (*LabelMunger) Name() string

Name is the name usable in --pr-mungers

func (*LabelMunger) RegisterOptions

func (lm *LabelMunger) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*LabelMunger) RequiredFeatures

func (*LabelMunger) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

type LabelUnapprovedPicks

type LabelUnapprovedPicks struct{}

LabelUnapprovedPicks will add `do-not-merge` to PRs against a release branch which do not have `cherrypick-approved`.

func (LabelUnapprovedPicks) EachLoop

func (LabelUnapprovedPicks) EachLoop() error

EachLoop is called at the start of every munge loop

func (LabelUnapprovedPicks) Initialize

func (LabelUnapprovedPicks) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (LabelUnapprovedPicks) Munge

Munge is the workhorse the will actually make updates to the PR

func (LabelUnapprovedPicks) Name

Name is the name usable in --pr-mungers

func (LabelUnapprovedPicks) RegisterOptions

func (LabelUnapprovedPicks) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (LabelUnapprovedPicks) RequiredFeatures

func (LabelUnapprovedPicks) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

func (LabelUnapprovedPicks) StaleIssueComments

func (l LabelUnapprovedPicks) StaleIssueComments(obj *github.MungeObject, comments []*githubapi.IssueComment) []*githubapi.IssueComment

StaleIssueComments returns a list of stale issue comments.

type MilestoneMaintainer

type MilestoneMaintainer struct {
	// contains filtered or unexported fields
}

MilestoneMaintainer enforces the process for shepherding issues into the release.

func NewMilestoneMaintainer

func NewMilestoneMaintainer() *MilestoneMaintainer

func (*MilestoneMaintainer) EachLoop

func (m *MilestoneMaintainer) EachLoop() error

EachLoop is called at the start of every munge loop. This function is a no-op for the munger because to munge an issue it only needs the state local to the issue.

func (*MilestoneMaintainer) Initialize

func (m *MilestoneMaintainer) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (*MilestoneMaintainer) Munge

func (m *MilestoneMaintainer) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the issue

func (*MilestoneMaintainer) Name

func (m *MilestoneMaintainer) Name() string

Name is the name usable in --pr-mungers

func (*MilestoneMaintainer) RegisterOptions

func (m *MilestoneMaintainer) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*MilestoneMaintainer) RequiredFeatures

func (m *MilestoneMaintainer) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

type Munger

type Munger interface {
	// Take action on a specific github issue:
	Munge(obj *github.MungeObject)
	RegisterOptions(opts *options.Options) sets.String
	Name() string
	RequiredFeatures() []string
	Initialize(*github.Config, *features.Features) error
	EachLoop() error
}

Munger is the interface which all mungers must implement to register

func GetActiveMungers

func GetActiveMungers() []Munger

GetActiveMungers returns a slice of all mungers which both registered and were requested by the user

func GetAllMungers

func GetAllMungers() []Munger

GetAllMungers returns a slice of all registered mungers. This list is completely independent of the mungers selected at runtime in --pr-mungers. This is all possible mungers.

type NagFlakeIssues

type NagFlakeIssues struct {
	// contains filtered or unexported fields
}

NagFlakeIssues pings assignees on flaky-test issues

func (NagFlakeIssues) EachLoop

func (NagFlakeIssues) EachLoop() error

EachLoop is called at the start of every munge loop

func (*NagFlakeIssues) Initialize

func (n *NagFlakeIssues) Initialize(config *mgh.Config, features *features.Features) error

Initialize will initialize the munger

func (*NagFlakeIssues) Munge

func (n *NagFlakeIssues) Munge(obj *mgh.MungeObject)

Munge is the workhorse the will actually make updates to the PR

func (NagFlakeIssues) Name

func (NagFlakeIssues) Name() string

Name is the name usable in --pr-mungers

func (NagFlakeIssues) RegisterOptions

func (NagFlakeIssues) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (NagFlakeIssues) RequiredFeatures

func (NagFlakeIssues) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

func (*NagFlakeIssues) StaleIssueComments

func (n *NagFlakeIssues) StaleIssueComments(obj *mgh.MungeObject, issueComments []*github.IssueComment) []*github.IssueComment

StaleIssueComments returns a slice of stale issue comments.

type NeedsRebaseMunger

type NeedsRebaseMunger struct{}

NeedsRebaseMunger will add the "needs-rebase" label to any issue which is unable to be automatically merged

func (NeedsRebaseMunger) EachLoop

func (NeedsRebaseMunger) EachLoop() error

EachLoop is called at the start of every munge loop

func (NeedsRebaseMunger) Initialize

func (NeedsRebaseMunger) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (NeedsRebaseMunger) Munge

func (NeedsRebaseMunger) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the PR

func (NeedsRebaseMunger) Name

func (NeedsRebaseMunger) Name() string

Name is the name usable in --pr-mungers

func (NeedsRebaseMunger) RegisterOptions

func (NeedsRebaseMunger) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (NeedsRebaseMunger) RequiredFeatures

func (NeedsRebaseMunger) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

func (NeedsRebaseMunger) StaleIssueComments

func (n NeedsRebaseMunger) StaleIssueComments(obj *github.MungeObject, comments []*githubapi.IssueComment) []*githubapi.IssueComment

StaleIssueComments returns a slice of stale issue comments.

type OldTestGetter

type OldTestGetter struct {
	// contains filtered or unexported fields
}

OldTestGetter files issues for flaky tests.

func (*OldTestGetter) EachLoop

func (p *OldTestGetter) EachLoop() error

EachLoop is called at the start of every munge loop

func (*OldTestGetter) Initialize

func (p *OldTestGetter) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (*OldTestGetter) Munge

func (p *OldTestGetter) Munge(obj *github.MungeObject)

Munge is unused by this munger.

func (*OldTestGetter) Name

func (p *OldTestGetter) Name() string

Name is the name usable in --pr-mungers

func (*OldTestGetter) RegisterOptions

func (p *OldTestGetter) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*OldTestGetter) RequiredFeatures

func (p *OldTestGetter) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

type OwnerLabelMunger

type OwnerLabelMunger struct {
	// contains filtered or unexported fields
}

OwnerLabelMunger will label issues as specified in OWNERS files.

func (*OwnerLabelMunger) EachLoop

func (b *OwnerLabelMunger) EachLoop() error

EachLoop is called at the start of every munge loop

func (*OwnerLabelMunger) Initialize

func (b *OwnerLabelMunger) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (*OwnerLabelMunger) Munge

func (b *OwnerLabelMunger) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the PR

func (*OwnerLabelMunger) Name

func (b *OwnerLabelMunger) Name() string

Name is the name usable in --pr-mungers

func (*OwnerLabelMunger) RegisterOptions

func (b *OwnerLabelMunger) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*OwnerLabelMunger) RequiredFeatures

func (b *OwnerLabelMunger) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

type PathLabelMunger

type PathLabelMunger struct {
	// contains filtered or unexported fields
}

PathLabelMunger will add labels to PRs based on what files it modified. The mapping of files to labels if provided in a file in --path-label-config

func (*PathLabelMunger) EachLoop

func (p *PathLabelMunger) EachLoop() error

EachLoop is called at the start of every munge loop

func (*PathLabelMunger) Initialize

func (p *PathLabelMunger) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (*PathLabelMunger) Munge

func (p *PathLabelMunger) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the PR

func (*PathLabelMunger) Name

func (p *PathLabelMunger) Name() string

Name is the name usable in --pr-mungers

func (*PathLabelMunger) RegisterOptions

func (p *PathLabelMunger) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*PathLabelMunger) RequiredFeatures

func (p *PathLabelMunger) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

type PickMustHaveMilestone

type PickMustHaveMilestone struct{}

PickMustHaveMilestone will remove the the cherrypick-candidate label from any PR that does not have a 'release' milestone set.

func (PickMustHaveMilestone) EachLoop

func (PickMustHaveMilestone) EachLoop() error

EachLoop is called at the start of every munge loop

func (PickMustHaveMilestone) Initialize

func (PickMustHaveMilestone) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (PickMustHaveMilestone) Munge

Munge is the workhorse the will actually make updates to the PR

func (PickMustHaveMilestone) Name

Name is the name usable in --pr-mungers

func (PickMustHaveMilestone) RegisterOptions

func (PickMustHaveMilestone) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (PickMustHaveMilestone) RequiredFeatures

func (PickMustHaveMilestone) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

func (PickMustHaveMilestone) StaleIssueComments

func (p PickMustHaveMilestone) StaleIssueComments(obj *github.MungeObject, comments []*githubapi.IssueComment) []*githubapi.IssueComment

StaleIssueComments returns a slice of stale issue comments.

type PublisherMunger

type PublisherMunger struct {
	// contains filtered or unexported fields
}

PublisherMunger publishes content from one repository to another one.

func (*PublisherMunger) EachLoop

func (p *PublisherMunger) EachLoop() error

EachLoop is called at the start of every munge loop

func (*PublisherMunger) Initialize

func (p *PublisherMunger) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (*PublisherMunger) Munge

func (p *PublisherMunger) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the PR

func (*PublisherMunger) Name

func (p *PublisherMunger) Name() string

Name is the name usable in --pr-mungers

func (*PublisherMunger) RegisterOptions

func (p *PublisherMunger) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*PublisherMunger) RequiredFeatures

func (p *PublisherMunger) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

type SigMentionHandler

type SigMentionHandler struct{}

func (*SigMentionHandler) EachLoop

func (*SigMentionHandler) EachLoop() error

EachLoop is called at the start of every munge loop

func (*SigMentionHandler) HasNeedsSigLabel

func (*SigMentionHandler) HasNeedsSigLabel(obj *github.MungeObject) bool

func (*SigMentionHandler) HasSigLabel

func (*SigMentionHandler) HasSigLabel(obj *github.MungeObject) bool

func (*SigMentionHandler) Initialize

func (s *SigMentionHandler) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (*SigMentionHandler) Munge

func (s *SigMentionHandler) Munge(obj *github.MungeObject)

Munge is the workhorse notifying issue owner to add a @kubernetes/sig mention if there is none The algorithm: (1) return if it is a PR and/or the issue is closed (2) find if the issue has a sig label (3) find if the issue has a needs-sig label (4) if the issue has both the sig and needs-sig labels, remove the needs-sig label (5) if the issue has none of the labels, add the needs-sig label and comment (6) if the issue has only the sig label, do nothing (7) if the issue has only the needs-sig label, do nothing

func (*SigMentionHandler) Name

func (*SigMentionHandler) Name() string

Name is the name usable in --pr-mungers

func (*SigMentionHandler) RegisterOptions

func (*SigMentionHandler) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*SigMentionHandler) RequiredFeatures

func (*SigMentionHandler) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

type StaleGreenCI

type StaleGreenCI struct {
	sync.Mutex
	// contains filtered or unexported fields
}

StaleGreenCI will re-run passed tests for LGTM PRs if they are more than 96 hours old.

func (*StaleGreenCI) EachLoop

func (s *StaleGreenCI) EachLoop() error

EachLoop is called at the start of every munge loop

func (*StaleGreenCI) Initialize

func (s *StaleGreenCI) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (*StaleGreenCI) Munge

func (s *StaleGreenCI) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the PR

func (*StaleGreenCI) Name

func (s *StaleGreenCI) Name() string

Name is the name usable in --pr-mungers

func (*StaleGreenCI) RegisterOptions

func (s *StaleGreenCI) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*StaleGreenCI) RequiredFeatures

func (s *StaleGreenCI) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

func (*StaleGreenCI) StaleIssueComments

func (s *StaleGreenCI) StaleIssueComments(obj *github.MungeObject, comments []*githubapi.IssueComment) []*githubapi.IssueComment

StaleIssueComments returns a slice of stale issue comments.

type StaleIssueComment

type StaleIssueComment interface {
	StaleIssueComments(*github.MungeObject, []*githubapi.IssueComment) []*githubapi.IssueComment
}

StaleIssueComment is an interface for a munger which writes issue comments which might go stale and which should be cleaned up.

type StalePendingCI

type StalePendingCI struct{}

StalePendingCI will ask the testBot-to test any PR with a LGTM that has been pending for more than 24 hours. This can happen when the jenkins VM is restarted.

The real fix would be for the jenkins VM restart to not move every single PR to pending without actually testing...

But this is our world and so we should really do this for all PRs which aren't likely to get another push (everything that is mergeable). Since that can be a lot of PRs, I'm just doing it for the LGTM PRs automatically...

func (*StalePendingCI) EachLoop

func (s *StalePendingCI) EachLoop() error

EachLoop is called at the start of every munge loop

func (*StalePendingCI) Initialize

func (s *StalePendingCI) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (*StalePendingCI) Munge

func (s *StalePendingCI) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the PR

func (*StalePendingCI) Name

func (s *StalePendingCI) Name() string

Name is the name usable in --pr-mungers

func (*StalePendingCI) RegisterOptions

func (s *StalePendingCI) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*StalePendingCI) RequiredFeatures

func (s *StalePendingCI) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

func (*StalePendingCI) StaleIssueComments

func (s *StalePendingCI) StaleIssueComments(obj *github.MungeObject, comments []*githubapi.IssueComment) []*githubapi.IssueComment

StaleIssueComments returns a slice of stale issue comments.

type SubmitQueue

type SubmitQueue struct {
	NonBlockingJobNames []string

	GateApproved                 bool
	GateCLA                      bool
	GateGHReviewApproved         bool
	GateGHReviewChangesRequested bool

	// AdditionalRequiredLabels is a set of additional labels required for merging
	// on top of the existing required ("lgtm", "approved", "cncf-cla: yes").
	AdditionalRequiredLabels []string

	// If FakeE2E is true, don't try to connect to JenkinsHost, all jobs are passing.
	FakeE2E bool

	DoNotMergeMilestones []string

	Metadata  submitQueueMetadata
	AdminPort int

	sync.Mutex

	ProwURL      string // prow base page
	BatchEnabled bool
	ContextURL   string

	// MergeToMasterMessage is an extra message when PR is merged to master branch,
	// it must not end in a period.
	MergeToMasterMessage string
	// contains filtered or unexported fields
}

SubmitQueue will merge PR which meet a set of requirements.

PR must have LGTM after the last commit
PR must have passed all github CI checks
The google internal jenkins instance must be passing the BlockingJobNames e2e tests

func (*SubmitQueue) EachLoop

func (sq *SubmitQueue) EachLoop() error

EachLoop is called at the start of every munge loop

func (*SubmitQueue) EmergencyStopHTTP

func (sq *SubmitQueue) EmergencyStopHTTP(res http.ResponseWriter, req *http.Request)

EmergencyStopHTTP sets the emergency stop flag. It expects the path of req.URL to contain either "emergency/stop", "emergency/resume", or "emergency/status".

func (*SubmitQueue) Initialize

func (sq *SubmitQueue) Initialize(config *github.Config, features *features.Features) error

Initialize will initialize the munger

func (*SubmitQueue) Munge

func (sq *SubmitQueue) Munge(obj *github.MungeObject)

Munge is the workhorse the will actually make updates to the PR

func (*SubmitQueue) Name

func (sq *SubmitQueue) Name() string

Name is the name usable in --pr-mungers

func (*SubmitQueue) RegisterOptions

func (sq *SubmitQueue) RegisterOptions(opts *options.Options) sets.String

RegisterOptions registers options for this munger; returns any that require a restart when changed.

func (*SubmitQueue) RequiredFeatures

func (sq *SubmitQueue) RequiredFeatures() []string

RequiredFeatures is a slice of 'features' that must be provided

func (*SubmitQueue) SetMergeStatus

func (sq *SubmitQueue) SetMergeStatus(obj *github.MungeObject, reason string)

SetMergeStatus will set the status given a particular PR. This function should be used instead of manipulating the prStatus directly as sq.Lock() must be called when manipulating that structure `obj` is the active github object `reason` is the new 'status' for this object

func (*SubmitQueue) StaleIssueComments

func (sq *SubmitQueue) StaleIssueComments(obj *github.MungeObject, comments []*githubapi.IssueComment) []*githubapi.IssueComment

StaleIssueComments returns a slice of stale issue comments.

Directories

Path Synopsis
e2e

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL