mungers

package
v0.0.0-...-09dbe69 Latest Latest
Warning

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

 Go to latest Published: Nov 10, 2016 License: Apache-2.0 Imports: 41 Imported by: 0

Documentation

Overview

Package mungers deals with munging of github pull requests

Index

Constants

This section is empty.

Variables

This section is empty.

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 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 RegisterStaleComments 

func RegisterStaleComments(s StaleComment)

RegisterStaleComments is the method for a munger to register that it creates comment 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

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) AddFlags 

func (*ApprovalHandler) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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 set up approverSet

  • Go through all comments after latest commit. If any approver said "/approve", add him to approverSet.

- For each file, we see if any approver of this file is in approverSet.

  • An approver of a file is defined as:
  • It's known that each dir has a list of approvers. (This might not hold true. For usability, current situation is enough.)
  • Approver of a dir is also the approver of child dirs.
  • We look at top N (default 3) level dir approvers. For example, for file "/a/b/c/d/e", we might search for approver from "/", "/a/", "/a/b/"

- Iff all files has been approved, the bot will add "approved" label.

func (*ApprovalHandler) Name 

func (*ApprovalHandler) Name() string

Name is the name usable in --pr-mungers

func (*ApprovalHandler) RequiredFeatures 

func (*ApprovalHandler) RequiredFeatures() []string

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

type AssignFixesMunger 

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

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

func (*AssignFixesMunger) AddFlags 

func (a *AssignFixesMunger) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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) RequiredFeatures 

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

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

type BlockPath 

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

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

func (*BlockPath) AddFlags 

func (b *BlockPath) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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) RequiredFeatures 

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

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

func (*BlockPath) StaleComments 

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

StaleComments returns a slice of stale 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 {
	BlunderbussReassign bool
	// contains filtered or unexported fields
}

BlunderbussMunger will assign issues to users based on the config file provided by --blunderbuss-config.

func (*BlunderbussMunger) AddFlags 

func (b *BlunderbussMunger) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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) RequiredFeatures 

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

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

type CheckLabelsMunger 

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

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

func (*CheckLabelsMunger) AddFlags 

func (c *CheckLabelsMunger) AddFlags(cmd *cobra.Command, config *githubhelper.Config)

AddFlags will add any request flags to the cobra `cmd`.

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 

func (c *CheckLabelsMunger) Munge(obj *githubhelper.MungeObject)

Munge is unused by this munger.

func (*CheckLabelsMunger) Name 

func (c *CheckLabelsMunger) Name() string

Name is the name usable in --pr-mungers

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) AddFlags 

func (c *CherrypickAutoApprove) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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) 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) AddFlags 

func (c *CherrypickQueue) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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) RequiredFeatures 

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

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

type ClaMunger 

type ClaMunger struct {
	CLAStatusContext string
	// contains filtered or unexported fields
}

ClaMunger will check the CLA status of the PR and apply a label.

func (*ClaMunger) AddFlags 

func (cla *ClaMunger) AddFlags(cmd *cobra.Command, config *githubhelper.Config)

AddFlags will add any request flags to the cobra `cmd`.

func (*ClaMunger) EachLoop 

func (cla *ClaMunger) EachLoop() error

EachLoop is called at the start of every munge loop

func (*ClaMunger) Initialize 

func (cla *ClaMunger) Initialize(config *githubhelper.Config, features *features.Features) error

Initialize will initialize the munger.

func (*ClaMunger) Munge 

func (cla *ClaMunger) Munge(obj *githubhelper.MungeObject)

Munge is unused by this munger.

func (*ClaMunger) Name 

func (cla *ClaMunger) Name() string

Name is the name usable in --pr-mungers

func (*ClaMunger) RequiredFeatures 

func (cla *ClaMunger) 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) AddFlags 

func (c *ClearPickAfterMerge) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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) RequiredFeatures 

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

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

type CloseStalePR 

type CloseStalePR struct{}

CloseStalePR will ask the Bot to close any PullRequest that didn't have any human interactions in `stalePullRequest` 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.

func (CloseStalePR) AddFlags 

func (CloseStalePR) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

func (CloseStalePR) EachLoop 

func (CloseStalePR) EachLoop() error

EachLoop is called at the start of every munge loop

func (CloseStalePR) Initialize 

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

Initialize will initialize the munger

func (CloseStalePR) Munge 

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

Munge is the workhorse that will actually close the PRs

func (CloseStalePR) Name 

func (CloseStalePR) Name() string

Name is the name usable in --pr-mungers

func (CloseStalePR) RequiredFeatures 

func (CloseStalePR) RequiredFeatures() []string

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

func (CloseStalePR) StaleComments 

func (s CloseStalePR) StaleComments(obj *github.MungeObject, comments []*githubapi.IssueComment) []*githubapi.IssueComment

StaleComments returns a slice of stale comments

type CommentDeleter 

type CommentDeleter struct{}

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

func (CommentDeleter) AddFlags 

func (CommentDeleter) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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) 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) StaleComments 

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

StaleComments returns a slice of comments which are stale

type DocsNeedNoRetest 

type DocsNeedNoRetest struct{}

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

func (DocsNeedNoRetest) AddFlags 

func (DocsNeedNoRetest) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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) RequiredFeatures 

func (DocsNeedNoRetest) RequiredFeatures() []string

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

type FlakeManager 

type FlakeManager struct {
	OwnerPath string
	// contains filtered or unexported fields
}

FlakeManager files issues for flaky tests.

func (*FlakeManager) AddFlags 

func (p *FlakeManager) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

func (*FlakeManager) EachLoop 

func (p *FlakeManager) EachLoop() error

EachLoop is called at the start of every munge loop

func (*FlakeManager) Initialize 

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

Initialize will initialize the munger

func (*FlakeManager) Munge 

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

Munge is unused by this munger.

func (*FlakeManager) Name 

func (p *FlakeManager) Name() string

Name is the name usable in --pr-mungers

func (*FlakeManager) RequiredFeatures 

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

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

type IssueCacher 

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

IssueCacher keeps track of issues that track flaky tests, so we can find them.

func (*IssueCacher) AddFlags 

func (p *IssueCacher) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

func (*IssueCacher) AllIssuesForKey 

func (p *IssueCacher) AllIssuesForKey(key string) []int

AllIssuesForKey returns all known issues matching the key, oldest first.

func (*IssueCacher) Created 

func (p *IssueCacher) Created(key string, number int)

Created adds this entry to the cache, in case you try to access it again before another complete pass is made.

func (*IssueCacher) EachLoop 

func (p *IssueCacher) EachLoop() error

EachLoop is called at the start of every munge loop

func (*IssueCacher) Initialize 

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

Initialize will initialize the munger

func (*IssueCacher) Munge 

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

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

func (*IssueCacher) Name 

func (p *IssueCacher) Name() string

Name is the name usable in --pr-mungers

func (*IssueCacher) RequiredFeatures 

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

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

func (*IssueCacher) Synced 

func (p *IssueCacher) Synced() bool

Synced returns true if we've made at least one complete pass through all issues.

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) AddFlags 

func (LGTMAfterCommitMunger) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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 

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

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

func (LGTMAfterCommitMunger) Name 

func (LGTMAfterCommitMunger) Name() string

Name is the name usable in --pr-mungers

func (LGTMAfterCommitMunger) RequiredFeatures 

func (LGTMAfterCommitMunger) RequiredFeatures() []string

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

func (LGTMAfterCommitMunger) StaleComments 

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

StaleComments returns a list of comments which are stale

type LabelMunger 

type LabelMunger struct {
	TriagerUrl string
}

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) AddFlags 

func (lm *LabelMunger) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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) 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) AddFlags 

func (LabelUnapprovedPicks) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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 

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

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

func (LabelUnapprovedPicks) Name 

func (LabelUnapprovedPicks) Name() string

Name is the name usable in --pr-mungers

func (LabelUnapprovedPicks) RequiredFeatures 

func (LabelUnapprovedPicks) RequiredFeatures() []string

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

func (LabelUnapprovedPicks) StaleComments 

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

StaleComments returns a list of stale comments

type Munger 

type Munger interface {
	// Take action on a specific github issue:
	Munge(obj *github.MungeObject)
	AddFlags(cmd *cobra.Command, config *github.Config)
	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 independant of the mungers selected at runtime in --pr-mungers. This is all possible mungers.

type NagFlakeIssues 

type NagFlakeIssues struct{}

NagFlakeIssues pings assignees on flaky-test issues

func (NagFlakeIssues) AddFlags 

func (NagFlakeIssues) AddFlags(cmd *cobra.Command, config *mgh.Config)

AddFlags will add any request flags to the cobra `cmd`

func (NagFlakeIssues) EachLoop 

func (NagFlakeIssues) EachLoop() error

EachLoop is called at the start of every munge loop

func (NagFlakeIssues) Initialize 

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

Initialize will initialize the munger

func (NagFlakeIssues) Munge 

func (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) RequiredFeatures 

func (NagFlakeIssues) RequiredFeatures() []string

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

func (NagFlakeIssues) StaleComments 

func (NagFlakeIssues) StaleComments(obj *mgh.MungeObject, comments []*github.IssueComment) []*github.IssueComment

StaleComments returns a slice of stale 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) AddFlags 

func (NeedsRebaseMunger) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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) RequiredFeatures 

func (NeedsRebaseMunger) RequiredFeatures() []string

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

func (NeedsRebaseMunger) StaleComments 

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

StaleComments returns a slice of comments which are stale

type OldTestGetter 

type OldTestGetter struct {
	// Keep track of which jobs we've done this for.
	NumberOfOldTestsToGet int
	// contains filtered or unexported fields
}

OldTestGetter files issues for flaky tests.

func (*OldTestGetter) AddFlags 

func (p *OldTestGetter) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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) RequiredFeatures 

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

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

type PathLabelMunger 

type PathLabelMunger struct {
	PathLabelFile string
	// 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) AddFlags 

func (p *PathLabelMunger) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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) 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) AddFlags 

func (PickMustHaveMilestone) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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 

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

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

func (PickMustHaveMilestone) Name 

func (PickMustHaveMilestone) Name() string

Name is the name usable in --pr-mungers

func (PickMustHaveMilestone) RequiredFeatures 

func (PickMustHaveMilestone) RequiredFeatures() []string

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

func (PickMustHaveMilestone) StaleComments 

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

StaleComments returns a slice of stale comments

type PublisherMunger 

type PublisherMunger struct {
	// Command for the 'publisher' munger to run periodically.
	PublishCommand string
	// contains filtered or unexported fields
}

PublisherMunger publishes content from one repository to another one.

func (*PublisherMunger) AddFlags 

func (p *PublisherMunger) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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) RequiredFeatures 

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

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

type ReleaseNoteLabel 

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

ReleaseNoteLabel will add the doNotMergeLabel to a PR which has not set one of the appropriete 'release-note-*' labels but has LGTM

func (*ReleaseNoteLabel) AddFlags 

func (r *ReleaseNoteLabel) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

func (*ReleaseNoteLabel) EachLoop 

func (r *ReleaseNoteLabel) EachLoop() error

EachLoop is called at the start of every munge loop

func (*ReleaseNoteLabel) Initialize 

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

Initialize will initialize the munger

func (*ReleaseNoteLabel) Munge 

func (r *ReleaseNoteLabel) Munge(obj *github.MungeObject)

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

func (*ReleaseNoteLabel) Name 

func (r *ReleaseNoteLabel) Name() string

Name is the name usable in --pr-mungers

func (*ReleaseNoteLabel) RequiredFeatures 

func (r *ReleaseNoteLabel) RequiredFeatures() []string

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

func (*ReleaseNoteLabel) StaleComments 

func (r *ReleaseNoteLabel) StaleComments(obj *github.MungeObject, comments []*githubapi.IssueComment) []*githubapi.IssueComment

StaleComments returns a slice of stale comments

type SizeMunger 

type SizeMunger struct {
	GeneratedFilesFile string
	// contains filtered or unexported fields
}

SizeMunger 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 (*SizeMunger) AddFlags 

func (s *SizeMunger) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

func (SizeMunger) EachLoop 

func (SizeMunger) EachLoop() error

EachLoop is called at the start of every munge loop

func (*SizeMunger) Initialize 

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

Initialize will initialize the munger

func (*SizeMunger) Munge 

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

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

func (SizeMunger) Name 

func (SizeMunger) Name() string

Name is the name usable in --pr-mungers

func (SizeMunger) RequiredFeatures 

func (SizeMunger) RequiredFeatures() []string

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

func (*SizeMunger) StaleComments 

func (s *SizeMunger) StaleComments(obj *github.MungeObject, comments []*githubapi.IssueComment) []*githubapi.IssueComment

StaleComments returns a slice of stale comments

type StaleComment 

type StaleComment interface {
	StaleComments(*github.MungeObject, []*githubapi.IssueComment) []*githubapi.IssueComment
}

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

type StaleGreenCI 

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

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

func (*StaleGreenCI) AddFlags 

func (s *StaleGreenCI) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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) RequiredFeatures 

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

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

func (*StaleGreenCI) StaleComments 

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

StaleComments returns a slice of stale comments

type StalePendingCI 

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

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) AddFlags 

func (s *StalePendingCI) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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) RequiredFeatures 

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

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

func (*StalePendingCI) StaleComments 

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

StaleComments returns a slice of stale comments

type SubmitQueue 

type SubmitQueue struct {
	BlockingJobNames    []string
	NonBlockingJobNames []string
	PresubmitJobNames   []string
	WeakStableJobNames  []string

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

	Committers             string
	RequiredStatusContexts []string
	DoNotMergeMilestones   []string

	RequiredRetestContexts []string
	RetestBody             string
	Metadata               submitQueueMetadata
	AdminPort              int

	sync.Mutex
	// 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) AddFlags 

func (sq *SubmitQueue) AddFlags(cmd *cobra.Command, config *github.Config)

AddFlags will add any request flags to the cobra `cmd`

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) 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) StaleComments 

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

StaleComments returns a slice of stale comments

Source Files

View all Source files

Directories

Path Synopsis
e2e
fake
matchers
comment
event

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.