32 |
Info
33 |
34 |
35 |
36 | | Project Name: |
37 | {{ .projectName }} |
38 |
39 |
40 | | Branch Name: |
41 | {{ .branchName }} |
42 |
43 |
44 | | Currently running: |
45 |
46 | {{ if .currentlyRunning }}yes{{ else }}no{{ end }}
47 | |
48 |
49 |
50 | | HEAD: |
51 |
52 | {{ if .HEAD }}{{ .HEAD }}{{ else }}-{{ end }}
53 | |
54 |
55 |
56 |
57 |
58 |
WIP Chain
59 | {{ if .wipChain }}
60 | {{ block "chain" .wipChain }}{{ end }}
61 | {{ else }}
62 | -
63 | {{ end }}
64 |
65 |
Log
66 | {{ range $entry := .memory.Entries }}
67 |
68 |
{{ $entry.Timestamp.Format "2006-01-02 15:04:05 UTC"}}
69 |
{{ $entry.Message }}
70 |
71 |
72 | {{ fieldsToJSON $entry.Fields }}
73 |
74 | {{ end }}
75 |
76 |
77 |
--------------------------------------------------------------------------------
/gerrit/chain.go:
--------------------------------------------------------------------------------
1 | package gerrit
2 |
3 | import (
4 | "fmt"
5 | "strings"
6 |
7 | "github.com/apex/log"
8 | )
9 |
10 | // Chain represents a list of successive changesets with an unbroken parent -> child relation,
11 | // starting from the parent.
12 | type Chain struct {
13 | ChangeSets []*Changeset
14 | }
15 |
16 | // GetParentCommitIDs returns the parent commit IDs
17 | func (s *Chain) GetParentCommitIDs() ([]string, error) {
18 | if len(s.ChangeSets) == 0 {
19 | return nil, fmt.Errorf("can't return parent on a chain with zero ChangeSets")
20 | }
21 | return s.ChangeSets[0].ParentCommitIDs, nil
22 | }
23 |
24 | // GetLeafCommitID returns the commit id of the last commit in ChangeSets
25 | func (s *Chain) GetLeafCommitID() (string, error) {
26 | if len(s.ChangeSets) == 0 {
27 | return "", fmt.Errorf("can't return leaf on a chain with zero ChangeSets")
28 | }
29 | return s.ChangeSets[len(s.ChangeSets)-1].CommitID, nil
30 | }
31 |
32 | // Validate checks that the chain contains a properly ordered and connected chain of commits
33 | func (s *Chain) Validate() error {
34 | logger := log.WithField("chain", s)
35 | // an empty chain is invalid
36 | if len(s.ChangeSets) == 0 {
37 | return fmt.Errorf("an empty chain is invalid")
38 | }
39 |
40 | previousCommitID := ""
41 | for i, changeset := range s.ChangeSets {
42 | // we can't really check the parent of the first commit
43 | // so skip verifying that one
44 | logger.WithFields(log.Fields{
45 | "changeset": changeset.String(),
46 | "previousCommitID": fmt.Sprintf("%.7s", previousCommitID),
47 | }).Debug(" - verifying changeset")
48 |
49 | parentCommitIDs := changeset.ParentCommitIDs
50 | if len(parentCommitIDs) == 0 {
51 | return fmt.Errorf("changesets without any parent are not supported")
52 | }
53 | // we don't check parents of the first changeset in a chain
54 | if i != 0 {
55 | if len(parentCommitIDs) != 1 {
56 | return fmt.Errorf("merge commits in the middle of a chain are not supported (only at the beginning)")
57 | }
58 | if parentCommitIDs[0] != previousCommitID {
59 | return fmt.Errorf("changesets parent commit id doesn't match previous commit id")
60 | }
61 | }
62 | // update previous commit id for the next loop iteration
63 | previousCommitID = changeset.CommitID
64 | }
65 | return nil
66 | }
67 |
68 | // AllChangesets applies a filter function on all of the changesets in the chain.
69 | // returns true if it returns true for all changesets, false otherwise
70 | func (s *Chain) AllChangesets(f func(c *Changeset) bool) bool {
71 | for _, changeset := range s.ChangeSets {
72 | if !f(changeset) {
73 | return false
74 | }
75 | }
76 | return true
77 | }
78 |
79 | func (s *Chain) String() string {
80 | var sb strings.Builder
81 | sb.WriteString(fmt.Sprintf("Chain[%d]", len(s.ChangeSets)))
82 | if len(s.ChangeSets) == 0 {
83 | sb.WriteString("()\n")
84 | return sb.String()
85 | }
86 | parentCommitIDs, err := s.GetParentCommitIDs()
87 | if err == nil {
88 | if len(parentCommitIDs) == 1 {
89 | sb.WriteString(fmt.Sprintf("(parent: %.7s)", parentCommitIDs[0]))
90 | } else {
91 | sb.WriteString("(merge: ")
92 |
93 | for i, parentCommitID := range parentCommitIDs {
94 | sb.WriteString(fmt.Sprintf("%.7s", parentCommitID))
95 | if i < len(parentCommitIDs) {
96 | sb.WriteString(", ")
97 | }
98 | }
99 |
100 | sb.WriteString(")")
101 |
102 | }
103 | }
104 | sb.WriteString(fmt.Sprintf("(%.7s..%.7s)",
105 | s.ChangeSets[0].CommitID,
106 | s.ChangeSets[len(s.ChangeSets)-1].CommitID))
107 | return sb.String()
108 | }
109 |
--------------------------------------------------------------------------------
/gerrit/chains.go:
--------------------------------------------------------------------------------
1 | package gerrit
2 |
3 | import (
4 | "sort"
5 |
6 | "github.com/apex/log"
7 | )
8 |
9 | // AssembleChain consumes a list of changesets, and groups them together to chains.
10 | //
11 | // Initially, every changeset is put in its own individual chain.
12 | //
13 | // we maintain a lookup table, mapLeafToChain,
14 | // which allows to lookup a chain by its leaf commit id
15 | // We concat chains in a fixpoint approach
16 | // because both appending and prepending is much more complex.
17 | // Concatenation moves changesets of the later changeset in the previous one
18 | // in a cleanup phase, we remove orphaned chains (those without any changesets inside)
19 | // afterwards, we do an integrity check, just to be on the safe side.
20 | func AssembleChain(changesets []*Changeset, logger *log.Logger) ([]*Chain, error) {
21 | chains := make([]*Chain, 0)
22 | mapLeafToChain := make(map[string]*Chain, 0)
23 |
24 | for _, changeset := range changesets {
25 | l := logger.WithField("changeset", changeset.String())
26 |
27 | l.Debug("creating initial chain")
28 | chain := &Chain{
29 | ChangeSets: []*Changeset{changeset},
30 | }
31 | chains = append(chains, chain)
32 | mapLeafToChain[changeset.CommitID] = chain
33 | }
34 |
35 | // Combine chain using a fixpoint approach, with a max iteration count.
36 | logger.Debug("glueing together phase")
37 | for i := 1; i < 100; i++ {
38 | didUpdate := false
39 | logger.Debugf("at iteration %d", i)
40 | for j, chain := range chains {
41 | l := logger.WithFields(log.Fields{
42 | "i": i,
43 | "j": j,
44 | "chain": chain.String(),
45 | })
46 | parentCommitIDs, err := chain.GetParentCommitIDs()
47 | if err != nil {
48 | return chains, err
49 | }
50 | if len(parentCommitIDs) != 1 {
51 | // We can't append merge commits to other chains
52 | l.Infof("No single parent, skipping.")
53 | continue
54 | }
55 | parentCommitID := parentCommitIDs[0]
56 | l.Debug("Looking for a predecessor.")
57 | // if there's another chain that has this parent as a leaf, glue together
58 | if otherChain, ok := mapLeafToChain[parentCommitID]; ok {
59 | if otherChain == chain {
60 | continue
61 | }
62 | l = l.WithField("otherChain", otherChain)
63 |
64 | myLeafCommitID, err := chain.GetLeafCommitID()
65 | if err != nil {
66 | return chains, err
67 | }
68 |
69 | // append our changesets to the other chain
70 | l.Debug("Splicing together.")
71 | otherChain.ChangeSets = append(otherChain.ChangeSets, chain.ChangeSets...)
72 |
73 | delete(mapLeafToChain, parentCommitID)
74 | mapLeafToChain[myLeafCommitID] = otherChain
75 |
76 | // orphan our chain
77 | chain.ChangeSets = []*Changeset{}
78 | // remove the orphaned chain from the lookup table
79 | delete(mapLeafToChain, myLeafCommitID)
80 |
81 | didUpdate = true
82 | } else {
83 | l.Debug("Not found.")
84 | }
85 | }
86 | chains = removeOrphanedChains(chains)
87 | if !didUpdate {
88 | logger.Infof("converged after %d iterations", i)
89 | break
90 | }
91 | }
92 |
93 | // Check integrity, just to be on the safe side.
94 | for _, chain := range chains {
95 | l := logger.WithField("chain", chain.String())
96 | l.Debugf("checking integrity")
97 | err := chain.Validate()
98 | if err != nil {
99 | l.Errorf("checking integrity failed: %s", err)
100 | }
101 | }
102 | return chains, nil
103 | }
104 |
105 | // removeOrphanedChains removes all empty chains (that contain zero changesets)
106 | func removeOrphanedChains(chains []*Chain) []*Chain {
107 | newChains := []*Chain{}
108 | for _, chain := range chains {
109 | if len(chain.ChangeSets) != 0 {
110 | newChains = append(newChains, chain)
111 | }
112 | }
113 | return newChains
114 | }
115 |
116 | // SortChains sorts a list of chains by the number of changesets in each chain, descending
117 | func SortChains(chains []*Chain) []*Chain {
118 | newChains := make([]*Chain, len(chains))
119 | copy(newChains, chains)
120 | sort.Slice(newChains, func(i, j int) bool {
121 | // the weight depends on the amount of changesets in the chain
122 | return len(chains[i].ChangeSets) > len(chains[j].ChangeSets)
123 | })
124 | return newChains
125 | }
126 |
--------------------------------------------------------------------------------
/gerrit/changeset.go:
--------------------------------------------------------------------------------
1 | package gerrit
2 |
3 | import (
4 | "bytes"
5 | "fmt"
6 |
7 | goGerrit "github.com/andygrunwald/go-gerrit"
8 | "github.com/apex/log"
9 | )
10 |
11 | // Changeset represents a single changeset
12 | type Changeset struct {
13 | changeInfo *goGerrit.ChangeInfo
14 | ChangeID string
15 | Number int
16 | Verified int
17 | CodeReviewed int
18 | Autosubmit int
19 | Submittable bool
20 | CommitID string
21 | ParentCommitIDs []string
22 | OwnerName string
23 | Subject string
24 | }
25 |
26 | // MakeChangeset creates a new Changeset object out of a goGerrit.ChangeInfo object
27 | func MakeChangeset(changeInfo *goGerrit.ChangeInfo) *Changeset {
28 | return &Changeset{
29 | changeInfo: changeInfo,
30 | ChangeID: changeInfo.ChangeID,
31 | Number: changeInfo.Number,
32 | Verified: labelInfoToInt(changeInfo.Labels["Verified"]),
33 | CodeReviewed: labelInfoToInt(changeInfo.Labels["Code-Review"]),
34 | Autosubmit: labelInfoToInt(changeInfo.Labels["Autosubmit"]),
35 | Submittable: changeInfo.Submittable,
36 | CommitID: changeInfo.CurrentRevision, // yes, this IS the commit ID.
37 | ParentCommitIDs: getParentCommitIDs(changeInfo),
38 | OwnerName: changeInfo.Owner.Name,
39 | Subject: changeInfo.Subject,
40 | }
41 | }
42 |
43 | // IsAutosubmit returns true if the changeset is intended to be
44 | // automatically submitted by gerrit-queue.
45 | //
46 | // This is determined by the Change Owner setting +1 on the
47 | // "Autosubmit" label.
48 | func (c *Changeset) IsAutosubmit() bool {
49 | return c.Autosubmit == 1
50 | }
51 |
52 | // IsVerified returns true if the changeset passed CI,
53 | // that's when somebody left the Approved (+1) on the "Verified" label
54 | func (c *Changeset) IsVerified() bool {
55 | return c.Verified == 1
56 | }
57 |
58 | // IsCodeReviewed returns true if the changeset passed code review,
59 | // that's when somebody left the Recommended (+2) on the "Code-Review" label
60 | func (c *Changeset) IsCodeReviewed() bool {
61 | return c.CodeReviewed == 2
62 | }
63 |
64 | func (c *Changeset) String() string {
65 | var b bytes.Buffer
66 | b.WriteString("Changeset")
67 | b.WriteString(fmt.Sprintf("(commitID: %.7s, author: %s, subject: %s, submittable: %v)",
68 | c.CommitID, c.OwnerName, c.Subject, c.Submittable))
69 | return b.String()
70 | }
71 |
72 | // FilterChangesets filters a list of Changeset by a given filter function
73 | func FilterChangesets(changesets []*Changeset, f func(*Changeset) bool) []*Changeset {
74 | newChangesets := make([]*Changeset, 0)
75 | for _, changeset := range changesets {
76 | if f(changeset) {
77 | newChangesets = append(newChangesets, changeset)
78 | } else {
79 | log.WithField("changeset", changeset.String()).Debug("dropped by filter")
80 | }
81 | }
82 | return newChangesets
83 | }
84 |
85 | // labelInfoToInt converts a goGerrit.LabelInfo to -2…+2 int
86 | // its behaviour for other labels is undefined.
87 | func labelInfoToInt(labelInfo goGerrit.LabelInfo) int {
88 | if labelInfo.Recommended.AccountID != 0 {
89 | return 2
90 | }
91 | if labelInfo.Approved.AccountID != 0 {
92 | return 1
93 | }
94 | if labelInfo.Disliked.AccountID != 0 {
95 | return -1
96 | }
97 | if labelInfo.Rejected.AccountID != 0 {
98 | return -2
99 | }
100 | return 0
101 | }
102 |
103 | // getParentCommitIDs returns the parent commit IDs of the goGerrit.ChangeInfo
104 | // There is usually only one parent commit ID, except for merge commits.
105 | func getParentCommitIDs(changeInfo *goGerrit.ChangeInfo) []string {
106 | // obtain the RevisionInfo object
107 | revisionInfo := changeInfo.Revisions[changeInfo.CurrentRevision]
108 |
109 | // obtain the Commit object
110 | commit := revisionInfo.Commit
111 |
112 | commitIDs := make([]string, len(commit.Parents))
113 | for i, commit := range commit.Parents {
114 | commitIDs[i] = commit.Commit
115 | }
116 | return commitIDs
117 | }
118 |
--------------------------------------------------------------------------------
/gerrit/changeset_test.go:
--------------------------------------------------------------------------------
1 | package gerrit
2 |
3 | import (
4 | "testing"
5 |
6 | goGerrit "github.com/andygrunwald/go-gerrit"
7 | "github.com/stretchr/testify/assert"
8 | )
9 |
10 | func TestIsAutosubmit(t *testing.T) {
11 | emptyChangeInfo := &goGerrit.ChangeInfo{}
12 | assert.Equal(t, false, MakeChangeset(emptyChangeInfo).IsAutosubmit(), "A changeset without the Autosubmit label present shouldn't be autosubmittable")
13 |
14 | // +1
15 | changeInfoWithAutosubmitLabelSet := &goGerrit.ChangeInfo{
16 | Labels: map[string]goGerrit.LabelInfo{
17 | "Autosubmit": {
18 | Approved: goGerrit.AccountInfo{AccountID: 1},
19 | },
20 | },
21 | }
22 | assert.Equal(t, true, MakeChangeset(changeInfoWithAutosubmitLabelSet).IsAutosubmit(), "Autosubmit label set to +1 should be autosubmittable")
23 |
24 | // ensure some common label values don't trigger autosubmit. We only trigger on a "+1"
25 |
26 | // +2
27 | changeInfoWithAutosubmitLabelSetToPlusTwo := &goGerrit.ChangeInfo{
28 | Labels: map[string]goGerrit.LabelInfo{
29 | "Autosubmit": {
30 | Recommended: goGerrit.AccountInfo{AccountID: 1},
31 | },
32 | },
33 | }
34 | assert.Equal(t, false, MakeChangeset(changeInfoWithAutosubmitLabelSetToPlusTwo).IsAutosubmit(), "Autosubmit label set to +2 should not be autosubmittable")
35 |
36 | // -1
37 | changeInfoWithAutosubmitLabelSetToMinusOne := &goGerrit.ChangeInfo{
38 | Labels: map[string]goGerrit.LabelInfo{
39 | "Autosubmit": {
40 | Disliked: goGerrit.AccountInfo{AccountID: 1},
41 | },
42 | },
43 | }
44 | assert.Equal(t, false, MakeChangeset(changeInfoWithAutosubmitLabelSetToMinusOne).IsAutosubmit(), "Autosubmit label set to -1 should not be autosubmittable")
45 |
46 | // -2
47 | changeInfoWithAutosubmitLabelSetToMinusTwo := &goGerrit.ChangeInfo{
48 | Labels: map[string]goGerrit.LabelInfo{
49 | "Autosubmit": {
50 | Rejected: goGerrit.AccountInfo{AccountID: 1},
51 | },
52 | },
53 | }
54 | assert.Equal(t, false, MakeChangeset(changeInfoWithAutosubmitLabelSetToMinusTwo).IsAutosubmit(), "Autosubmit label set to -2 should not be autosubmittable")
55 | }
56 |
--------------------------------------------------------------------------------
/gerrit/client.go:
--------------------------------------------------------------------------------
1 | package gerrit
2 |
3 | import (
4 | "fmt"
5 |
6 | goGerrit "github.com/andygrunwald/go-gerrit"
7 | "github.com/apex/log"
8 |
9 | "net/url"
10 | )
11 |
12 | // passed to gerrit when retrieving changesets
13 | var additionalFields = []string{
14 | "LABELS",
15 | "CURRENT_REVISION",
16 | "CURRENT_COMMIT",
17 | "DETAILED_ACCOUNTS",
18 | "SUBMITTABLE",
19 | }
20 |
21 | // IClient defines the gerrit.Client interface
22 | type IClient interface {
23 | Refresh() error
24 | GetHEAD() string
25 | GetBaseURL() string
26 | GetChangesetURL(changeset *Changeset) string
27 | SubmitChangeset(changeset *Changeset) (*Changeset, error)
28 | RebaseChangeset(changeset *Changeset, ref string) (*Changeset, error)
29 | ChangesetIsRebasedOnHEAD(changeset *Changeset) bool
30 | ChainIsRebasedOnHEAD(chain *Chain) bool
31 | FilterChains(filter func(s *Chain) bool) []*Chain
32 | FindFirstChain(filter func(s *Chain) bool) *Chain
33 | }
34 |
35 | var _ IClient = &Client{}
36 |
37 | // Client provides some ways to interact with a gerrit instance
38 | type Client struct {
39 | client *goGerrit.Client
40 | logger *log.Logger
41 | baseURL string
42 | projectName string
43 | branchName string
44 | chains []*Chain
45 | head string
46 | }
47 |
48 | // NewClient initializes a new gerrit client
49 | func NewClient(logger *log.Logger, URL, username, password, projectName, branchName string) (*Client, error) {
50 | urlParsed, err := url.Parse(URL)
51 | if err != nil {
52 | return nil, err
53 | }
54 | urlParsed.User = url.UserPassword(username, password)
55 |
56 | goGerritClient, err := goGerrit.NewClient(urlParsed.String(), nil)
57 | if err != nil {
58 | return nil, err
59 | }
60 | return &Client{
61 | client: goGerritClient,
62 | baseURL: URL,
63 | logger: logger,
64 | projectName: projectName,
65 | branchName: branchName,
66 | }, nil
67 | }
68 |
69 | // refreshHEAD queries the commit ID of the selected project and branch
70 | func (c *Client) refreshHEAD() (string, error) {
71 | branchInfo, _, err := c.client.Projects.GetBranch(c.projectName, c.branchName)
72 | if err != nil {
73 | return "", err
74 | }
75 | return branchInfo.Revision, nil
76 | }
77 |
78 | // GetHEAD returns the internally stored HEAD
79 | func (c *Client) GetHEAD() string {
80 | return c.head
81 | }
82 |
83 | // Refresh causes the client to refresh internal view of gerrit
84 | func (c *Client) Refresh() error {
85 | c.logger.Debug("refreshing from gerrit")
86 | HEAD, err := c.refreshHEAD()
87 | if err != nil {
88 | return err
89 | }
90 | c.head = HEAD
91 |
92 | var queryString = fmt.Sprintf("status:open project:%s branch:%s", c.projectName, c.branchName)
93 | c.logger.Debugf("fetching changesets: %s", queryString)
94 | changesets, err := c.fetchChangesets(queryString)
95 | if err != nil {
96 | return err
97 | }
98 |
99 | c.logger.Infof("assembling chains")
100 | chains, err := AssembleChain(changesets, c.logger)
101 | if err != nil {
102 | return err
103 | }
104 | chains = SortChains(chains)
105 | c.chains = chains
106 | return nil
107 | }
108 |
109 | // fetchChangesets fetches a list of changesets matching a passed query string
110 | func (c *Client) fetchChangesets(queryString string) (changesets []*Changeset, Error error) {
111 | opt := &goGerrit.QueryChangeOptions{}
112 | opt.Query = []string{
113 | queryString,
114 | }
115 | opt.AdditionalFields = additionalFields
116 | changes, _, err := c.client.Changes.QueryChanges(opt)
117 | if err != nil {
118 | return nil, err
119 | }
120 |
121 | changesets = make([]*Changeset, 0)
122 | for _, change := range *changes {
123 | changesets = append(changesets, MakeChangeset(&change))
124 | }
125 |
126 | return changesets, nil
127 | }
128 |
129 | // fetchChangeset downloads an existing Changeset from gerrit, by its ID
130 | // Gerrit's API is a bit sparse, and only returns what you explicitly ask it
131 | // This is used to refresh an existing changeset with more data.
132 | func (c *Client) fetchChangeset(changeID string) (*Changeset, error) {
133 | opt := goGerrit.ChangeOptions{}
134 | opt.AdditionalFields = []string{"LABELS", "DETAILED_ACCOUNTS"}
135 | changeInfo, _, err := c.client.Changes.GetChange(changeID, &opt)
136 | if err != nil {
137 | return nil, err
138 | }
139 | return MakeChangeset(changeInfo), nil
140 | }
141 |
142 | // SubmitChangeset submits a given changeset, and returns a changeset afterwards.
143 | func (c *Client) SubmitChangeset(changeset *Changeset) (*Changeset, error) {
144 | changeInfo, _, err := c.client.Changes.SubmitChange(changeset.ChangeID, &goGerrit.SubmitInput{})
145 | if err != nil {
146 | return nil, err
147 | }
148 | c.head = changeInfo.CurrentRevision
149 | return c.fetchChangeset(changeInfo.ChangeID)
150 | }
151 |
152 | // RebaseChangeset rebases a given changeset on top of a given ref
153 | func (c *Client) RebaseChangeset(changeset *Changeset, ref string) (*Changeset, error) {
154 | changeInfo, _, err := c.client.Changes.RebaseChange(changeset.ChangeID, &goGerrit.RebaseInput{
155 | Base: ref,
156 | OnBehalfOfUploader: true,
157 | })
158 | if err != nil {
159 | return changeset, err
160 | }
161 | return c.fetchChangeset(changeInfo.ChangeID)
162 | }
163 |
164 | // GetBaseURL returns the gerrit base URL
165 | func (c *Client) GetBaseURL() string {
166 | return c.baseURL
167 | }
168 |
169 | // GetProjectName returns the configured gerrit project name
170 | func (c *Client) GetProjectName() string {
171 | return c.projectName
172 | }
173 |
174 | // GetBranchName returns the configured gerrit branch name
175 | func (c *Client) GetBranchName() string {
176 | return c.branchName
177 | }
178 |
179 | // GetChangesetURL returns the URL to view a given changeset
180 | func (c *Client) GetChangesetURL(changeset *Changeset) string {
181 | return fmt.Sprintf("%s/c/%s/+/%d", c.GetBaseURL(), c.projectName, changeset.Number)
182 | }
183 |
184 | // ChangesetIsRebasedOnHEAD returns true if the changeset is rebased on the current HEAD
185 | func (c *Client) ChangesetIsRebasedOnHEAD(changeset *Changeset) bool {
186 | if len(changeset.ParentCommitIDs) != 1 {
187 | return false
188 | }
189 | return changeset.ParentCommitIDs[0] == c.head
190 | }
191 |
192 | // ChainIsRebasedOnHEAD returns true if the whole chain is rebased on the current HEAD
193 | // this is already the case if the first changeset in the chain is rebased on the current HEAD
194 | func (c *Client) ChainIsRebasedOnHEAD(chain *Chain) bool {
195 | // an empty chain should not exist
196 | if len(chain.ChangeSets) == 0 {
197 | return false
198 | }
199 | return c.ChangesetIsRebasedOnHEAD(chain.ChangeSets[0])
200 | }
201 |
202 | // FilterChains returns a subset of all chains, passing the given filter function
203 | func (c *Client) FilterChains(filter func(s *Chain) bool) []*Chain {
204 | matchedChains := []*Chain{}
205 | for _, chain := range c.chains {
206 | if filter(chain) {
207 | matchedChains = append(matchedChains, chain)
208 | }
209 | }
210 | return matchedChains
211 | }
212 |
213 | // FindFirstChain returns the first chain that matches the filter, or nil if none was found
214 | func (c *Client) FindFirstChain(filter func(s *Chain) bool) *Chain {
215 | for _, chain := range c.chains {
216 | if filter(chain) {
217 | return chain
218 | }
219 | }
220 | return nil
221 | }
222 |
--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
1 | module github.com/flokli/gerrit-queue
2 |
3 | go 1.16
4 |
5 | require (
6 | github.com/andygrunwald/go-gerrit v0.0.0-20190825170856-5959a9bf9ff8
7 | github.com/apex/log v1.1.1
8 | github.com/stretchr/testify v1.7.0
9 | github.com/urfave/cli v1.22.1
10 | )
11 |
12 | replace github.com/andygrunwald/go-gerrit => github.com/lukegb/go-gerrit v0.0.0-20231016235128-b5317f06cc92
13 |
--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
1 | github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
2 | github.com/andygrunwald/go-gerrit v0.0.0-20190825170856-5959a9bf9ff8 h1:9PvNa6zH6gOW4VVfbAx5rjDLpxunG+RSaXQB+8TEv4w=
3 | github.com/andygrunwald/go-gerrit v0.0.0-20190825170856-5959a9bf9ff8/go.mod h1:0iuRQp6WJ44ts+iihy5E/WlPqfg5RNeQxOmzRkxCdtk=
4 | github.com/apex/log v1.1.1 h1:BwhRZ0qbjYtTob0I+2M+smavV0kOC8XgcnGZcyL9liA=
5 | github.com/apex/log v1.1.1/go.mod h1:Ls949n1HFtXfbDcjiTTFQqkVUrte0puoIBfO3SVgwOA=
6 | github.com/aphistic/golf v0.0.0-20180712155816-02c07f170c5a/go.mod h1:3NqKYiepwy8kCu4PNA+aP7WUV72eXWJeP9/r3/K9aLE=
7 | github.com/aphistic/sweet v0.2.0/go.mod h1:fWDlIh/isSE9n6EPsRmC0det+whmX6dJid3stzu0Xys=
8 | github.com/aws/aws-sdk-go v1.20.6/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
9 | github.com/aybabtme/rgbterm v0.0.0-20170906152045-cc83f3b3ce59/go.mod h1:q/89r3U2H7sSsE2t6Kca0lfwTK8JdoNGS/yzM/4iH5I=
10 | github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d h1:U+s90UTSYgptZMwQh2aRr3LuazLJIa+Pg3Kc1ylSYVY=
11 | github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
12 | github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
13 | github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
14 | github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
15 | github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
16 | github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
17 | github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
18 | github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
19 | github.com/google/go-querystring v1.0.0 h1:Xkwi/a1rcvNg1PPYe5vI8GbeBY/jrVuDX5ASuANWTrk=
20 | github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
21 | github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
22 | github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
23 | github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
24 | github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
25 | github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
26 | github.com/jpillora/backoff v0.0.0-20180909062703-3050d21c67d7/go.mod h1:2iMrUgbbvHEiQClaW2NsSzMyGHqN+rDFqY705q49KG0=
27 | github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
28 | github.com/lukegb/go-gerrit v0.0.0-20231016235128-b5317f06cc92 h1:pJh+AdGbrPeTk6VRqzyc02kZ0ttLi8sPaS+sltPu2fQ=
29 | github.com/lukegb/go-gerrit v0.0.0-20231016235128-b5317f06cc92/go.mod h1:SeP12EkHZxEVjuJ2HZET304NBtHGG2X6w2Gzd0QXAZw=
30 | github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
31 | github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
32 | github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
33 | github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
34 | github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
35 | github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
36 | github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
37 | github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
38 | github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
39 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
40 | github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
41 | github.com/rogpeppe/fastuuid v1.1.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
42 | github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0RK8m9o+Q=
43 | github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
44 | github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
45 | github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=
46 | github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
47 | github.com/smartystreets/assertions v1.0.0/go.mod h1:kHHU4qYBaI3q23Pp3VPrmWhuIUrLW/7eUrw0BU5VaoM=
48 | github.com/smartystreets/go-aws-auth v0.0.0-20180515143844-0c1422d1fdb9/go.mod h1:SnhjPscd9TpLiy1LpzGSKh3bXCfxxXuqd9xmQJy3slM=
49 | github.com/smartystreets/gunit v1.0.0/go.mod h1:qwPWnhz6pn0NnRBP++URONOVyNkPyr4SauJk4cUOwJs=
50 | github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
51 | github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
52 | github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
53 | github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
54 | github.com/tj/assert v0.0.0-20171129193455-018094318fb0/go.mod h1:mZ9/Rh9oLWpLLDRpvE+3b7gP/C2YyLFYxNmcLnPTMe0=
55 | github.com/tj/go-elastic v0.0.0-20171221160941-36157cbbebc2/go.mod h1:WjeM0Oo1eNAjXGDx2yma7uG2XoyRZTq1uv3M/o7imD0=
56 | github.com/tj/go-kinesis v0.0.0-20171128231115-08b17f58cb1b/go.mod h1:/yhzCV0xPfx6jb1bBgRFjl5lytqVqZXEaeqWP8lTEao=
57 | github.com/tj/go-spin v1.1.0/go.mod h1:Mg1mzmePZm4dva8Qz60H2lHwmJ2loum4VIrLgVnKwh4=
58 | github.com/urfave/cli v1.22.1 h1:+mkCCcOFKPnCmVYVcURKps1Xe+3zP90gSYGNfRkjoIY=
59 | github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
60 | golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
61 | golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
62 | golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
63 | golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
64 | golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
65 | golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
66 | golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
67 | golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
68 | golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
69 | golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
70 | golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
71 | golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
72 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
73 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
74 | gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
75 | gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
76 | gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
77 | gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
78 | gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
79 | gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
80 |
--------------------------------------------------------------------------------
/main.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "os"
5 | "time"
6 |
7 | "net/http"
8 |
9 | "github.com/flokli/gerrit-queue/frontend"
10 | "github.com/flokli/gerrit-queue/gerrit"
11 | "github.com/flokli/gerrit-queue/misc"
12 | "github.com/flokli/gerrit-queue/submitqueue"
13 |
14 | "github.com/urfave/cli"
15 |
16 | "github.com/apex/log"
17 | "github.com/apex/log/handlers/multi"
18 | "github.com/apex/log/handlers/text"
19 | )
20 |
21 | func main() {
22 | var URL, username, password, projectName, branchName string
23 | var fetchOnly bool
24 | var triggerInterval int
25 |
26 | app := cli.NewApp()
27 | app.Name = "gerrit-queue"
28 | app.Description = "A merge bot for gerrit"
29 |
30 | app.Flags = []cli.Flag{
31 | cli.StringFlag{
32 | Name: "url",
33 | Usage: "URL to the gerrit instance",
34 | EnvVar: "GERRIT_URL",
35 | Destination: &URL,
36 | Required: true,
37 | },
38 | cli.StringFlag{
39 | Name: "username",
40 | Usage: "Username to use to login to gerrit",
41 | EnvVar: "GERRIT_USERNAME",
42 | Destination: &username,
43 | Required: true,
44 | },
45 | cli.StringFlag{
46 | Name: "password",
47 | Usage: "Password to use to login to gerrit",
48 | EnvVar: "GERRIT_PASSWORD",
49 | Destination: &password,
50 | Required: true,
51 | },
52 | cli.StringFlag{
53 | Name: "project",
54 | Usage: "Gerrit project name to run the submit queue for",
55 | EnvVar: "GERRIT_PROJECT",
56 | Destination: &projectName,
57 | Required: true,
58 | },
59 | cli.StringFlag{
60 | Name: "branch",
61 | Usage: "Destination branch",
62 | EnvVar: "GERRIT_BRANCH",
63 | Destination: &branchName,
64 | Value: "master",
65 | },
66 | cli.IntFlag{
67 | Name: "trigger-interval",
68 | Usage: "How often we should trigger ourselves (interval in seconds)",
69 | EnvVar: "SUBMIT_QUEUE_TRIGGER_INTERVAL",
70 | Destination: &triggerInterval,
71 | Value: 600,
72 | },
73 | cli.BoolFlag{
74 | Name: "fetch-only",
75 | Usage: "Only fetch changes and assemble queue, but don't actually write",
76 | EnvVar: "SUBMIT_QUEUE_FETCH_ONLY",
77 | Destination: &fetchOnly,
78 | },
79 | }
80 |
81 | rotatingLogHandler := misc.NewRotatingLogHandler(10000)
82 | l := &log.Logger{
83 | Handler: multi.New(
84 | text.New(os.Stderr),
85 | rotatingLogHandler,
86 | ),
87 | Level: log.DebugLevel,
88 | }
89 |
90 | app.Action = func(c *cli.Context) error {
91 | gerrit, err := gerrit.NewClient(l, URL, username, password, projectName, branchName)
92 | if err != nil {
93 | return err
94 | }
95 | log.Infof("Successfully connected to gerrit at %s", URL)
96 |
97 | runner := submitqueue.NewRunner(l, gerrit)
98 |
99 | handler := frontend.MakeFrontend(rotatingLogHandler, gerrit, runner)
100 |
101 | // fetch only on first run
102 | err = runner.Trigger(fetchOnly)
103 | if err != nil {
104 | log.Error(err.Error())
105 | }
106 |
107 | // ticker
108 | go func() {
109 | for {
110 | time.Sleep(time.Duration(triggerInterval) * time.Second)
111 | err = runner.Trigger(fetchOnly)
112 | if err != nil {
113 | log.Error(err.Error())
114 | }
115 | }
116 | }()
117 |
118 | server := http.Server{
119 | Addr: ":8080",
120 | Handler: handler,
121 | }
122 |
123 | err = server.ListenAndServe()
124 | if err != nil {
125 | log.Fatalf(err.Error())
126 | }
127 |
128 | return nil
129 | }
130 |
131 | err := app.Run(os.Args)
132 | if err != nil {
133 | log.Fatal(err.Error())
134 | }
135 |
136 | // TODOS:
137 | // - handle event log, either by accepting webhooks, or by streaming events?
138 | }
139 |
--------------------------------------------------------------------------------
/misc/rotatingloghandler.go:
--------------------------------------------------------------------------------
1 | package misc
2 |
3 | import (
4 | "sync"
5 |
6 | "github.com/apex/log"
7 | )
8 |
9 | // RotatingLogHandler implementation.
10 | type RotatingLogHandler struct {
11 | mu sync.Mutex
12 | Entries []*log.Entry
13 | maxEntries int
14 | }
15 |
16 | // NewRotatingLogHandler creates a new rotating log handler
17 | func NewRotatingLogHandler(maxEntries int) *RotatingLogHandler {
18 | return &RotatingLogHandler{
19 | maxEntries: maxEntries,
20 | }
21 | }
22 |
23 | // HandleLog implements log.Handler.
24 | func (h *RotatingLogHandler) HandleLog(e *log.Entry) error {
25 | h.mu.Lock()
26 | defer h.mu.Unlock()
27 | // drop tail if we have more entries than maxEntries
28 | if len(h.Entries) > h.maxEntries {
29 | h.Entries = append([]*log.Entry{e}, h.Entries[:(h.maxEntries-2)]...)
30 | } else {
31 | h.Entries = append([]*log.Entry{e}, h.Entries...)
32 | }
33 | return nil
34 | }
35 |
--------------------------------------------------------------------------------
/submitqueue/runner.go:
--------------------------------------------------------------------------------
1 | package submitqueue
2 |
3 | import (
4 | "fmt"
5 | "sync"
6 |
7 | "github.com/apex/log"
8 |
9 | "github.com/flokli/gerrit-queue/gerrit"
10 | )
11 |
12 | // Runner is a struct existing across the lifetime of a single run of the submit queue
13 | // it contains a mutex to avoid being run multiple times.
14 | // In fact, it even cancels runs while another one is still in progress.
15 | // It contains a Gerrit object facilitating access, a log object, the configured submit queue tag
16 | // and a `wipChain` (only populated if waiting for a rebase)
17 | type Runner struct {
18 | mut sync.Mutex
19 | currentlyRunning bool
20 | wipChain *gerrit.Chain
21 | logger *log.Logger
22 | gerrit *gerrit.Client
23 | }
24 |
25 | // NewRunner creates a new Runner struct
26 | func NewRunner(logger *log.Logger, gerrit *gerrit.Client) *Runner {
27 | return &Runner{
28 | logger: logger,
29 | gerrit: gerrit,
30 | }
31 | }
32 |
33 | // isAutoSubmittable determines if something could be autosubmitted, potentially requiring a rebase
34 | // for this, it needs to:
35 | // - have the "Autosubmit" label set to +1
36 | // - have gerrit's 'submittable' field set to true
37 | //
38 | // it doesn't check if the chain is rebased on HEAD
39 | func (r *Runner) isAutoSubmittable(s *gerrit.Chain) bool {
40 | for _, c := range s.ChangeSets {
41 | if !c.Submittable || !c.IsAutosubmit() {
42 | return false
43 | }
44 | }
45 | return true
46 | }
47 |
48 | // IsCurrentlyRunning returns true if the runner is currently running
49 | func (r *Runner) IsCurrentlyRunning() bool {
50 | return r.currentlyRunning
51 | }
52 |
53 | // GetWIPChain returns the current wipChain, if any, nil otherwiese
54 | // Acquires a lock, so check with IsCurrentlyRunning first
55 | func (r *Runner) GetWIPChain() *gerrit.Chain {
56 | r.mut.Lock()
57 | defer func() {
58 | r.mut.Unlock()
59 | }()
60 | return r.wipChain
61 | }
62 |
63 | // Trigger gets triggered periodically
64 | func (r *Runner) Trigger(fetchOnly bool) error {
65 | // TODO: If CI fails, remove the auto-submit labels => rules.pl
66 | // Only one trigger can run at the same time
67 | r.mut.Lock()
68 | if r.currentlyRunning {
69 | return fmt.Errorf("already running, skipping")
70 | }
71 | r.currentlyRunning = true
72 | r.mut.Unlock()
73 | defer func() {
74 | r.mut.Lock()
75 | r.currentlyRunning = false
76 | r.mut.Unlock()
77 | }()
78 |
79 | // Prepare the work by creating a local cache of gerrit state
80 | err := r.gerrit.Refresh()
81 | if err != nil {
82 | return err
83 | }
84 |
85 | // early return if we only want to fetch
86 | if fetchOnly {
87 | return nil
88 | }
89 |
90 | if r.wipChain != nil {
91 | // refresh wipChain with how it looks like in gerrit now
92 | wipChain := r.gerrit.FindFirstChain(func(s *gerrit.Chain) bool {
93 | // the new wipChain needs to have the same number of changesets
94 | if len(r.wipChain.ChangeSets) != len(s.ChangeSets) {
95 | return false
96 | }
97 | // … and the same ChangeIDs.
98 | for idx, c := range s.ChangeSets {
99 | if r.wipChain.ChangeSets[idx].ChangeID != c.ChangeID {
100 | return false
101 | }
102 | }
103 | return true
104 | })
105 | if wipChain == nil {
106 | r.logger.WithField("wipChain", r.wipChain).Warn("wipChain has disappeared")
107 | r.wipChain = nil
108 | } else {
109 | r.wipChain = wipChain
110 | }
111 | }
112 |
113 | for {
114 | // initialize logger
115 | r.logger.Info("Running")
116 | if r.wipChain != nil {
117 | // if we have a wipChain
118 | l := r.logger.WithField("wipChain", r.wipChain)
119 | l.Info("Checking wipChain")
120 |
121 | // discard wipChain not rebased on HEAD
122 | // we rebase them at the end of the loop, so this means master advanced without going through the submit queue
123 | if !r.gerrit.ChainIsRebasedOnHEAD(r.wipChain) {
124 | l.Warnf("HEAD has moved to %v while still waiting for wipChain, discarding it", r.gerrit.GetHEAD())
125 | r.wipChain = nil
126 | continue
127 | }
128 |
129 | // we now need to check CI feedback:
130 | // wipChain might have failed CI in the meantime
131 | for _, c := range r.wipChain.ChangeSets {
132 | if c == nil {
133 | l.Error("BUG: changeset is nil")
134 | continue
135 | }
136 | if c.Verified < 0 {
137 | l.WithField("failingChangeset", c).Warnf("wipChain failed CI in the meantime, discarding.")
138 | r.wipChain = nil
139 | continue
140 | }
141 | }
142 |
143 | // it might still be waiting for CI
144 | for _, c := range r.wipChain.ChangeSets {
145 | if c == nil {
146 | l.Error("BUG: changeset is nil")
147 | continue
148 | }
149 | if c.Verified == 0 {
150 | l.WithField("pendingChangeset", c).Warnf("still waiting for CI feedback in wipChain, going back to sleep.")
151 | // break the loop, take a look at it at the next trigger.
152 | return nil
153 | }
154 | }
155 |
156 | // it might be autosubmittable
157 | if r.isAutoSubmittable(r.wipChain) {
158 | l.Infof("submitting wipChain")
159 | // if the WIP changeset is ready (auto submittable and rebased on HEAD), submit
160 | for _, changeset := range r.wipChain.ChangeSets {
161 | _, err := r.gerrit.SubmitChangeset(changeset)
162 | if err != nil {
163 | l.WithField("changeset", changeset).Error("error submitting changeset")
164 | r.wipChain = nil
165 | return err
166 | }
167 | }
168 | r.wipChain = nil
169 | } else {
170 | l.Error("BUG: wipChain is not autosubmittable")
171 | r.wipChain = nil
172 | }
173 | }
174 |
175 | r.logger.Info("Looking for chains ready to submit")
176 | // Find chain, that:
177 | // * has the auto-submit label
178 | // * has +2 review
179 | // * has +1 CI
180 | // * is rebased on master
181 | chain := r.gerrit.FindFirstChain(func(s *gerrit.Chain) bool {
182 | return r.isAutoSubmittable(s) && s.ChangeSets[0].ParentCommitIDs[0] == r.gerrit.GetHEAD()
183 | })
184 | if chain != nil {
185 | r.logger.WithField("chain", chain).Info("Found chain to submit without necessary rebase")
186 | r.wipChain = chain
187 | continue
188 | }
189 |
190 | // Find chain, that:
191 | // * has the auto-submit label
192 | // * has +2 review
193 | // * has +1 CI
194 | // * is NOT rebased on master
195 | chain = r.gerrit.FindFirstChain(r.isAutoSubmittable)
196 | if chain == nil {
197 | r.logger.Info("no more submittable chain found, going back to sleep.")
198 | break
199 | }
200 |
201 | l := r.logger.WithField("chain", chain)
202 | l.Info("found chain, which needs a rebase")
203 | // TODO: move into Client.RebaseChangeset function
204 | head := r.gerrit.GetHEAD()
205 | for _, changeset := range chain.ChangeSets {
206 | changeset, err := r.gerrit.RebaseChangeset(changeset, head)
207 | if err != nil {
208 | l.Error(err.Error())
209 | return err
210 | }
211 | head = changeset.CommitID
212 | }
213 | // we don't need to care about updating the rebased changesets or getting the updated HEAD,
214 | // as we'll refetch it on the beginning of the next trigger anyways
215 | r.wipChain = chain
216 | break
217 | }
218 |
219 | r.logger.Info("Run complete")
220 | return nil
221 | }
222 |
--------------------------------------------------------------------------------