forked from runatlantis/atlantis
-
Notifications
You must be signed in to change notification settings - Fork 0
/
client.go
286 lines (264 loc) · 9.53 KB
/
client.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
package bitbucketserver
import (
"bytes"
"encoding/json"
"fmt"
"io"
"io/ioutil"
"net/http"
"net/url"
"regexp"
"strings"
"github.com/runatlantis/atlantis/server/events/vcs/common"
"github.com/pkg/errors"
"github.com/runatlantis/atlantis/server/events/models"
"gopkg.in/go-playground/validator.v9"
)
// maxCommentLength is the maximum number of chars allowed by Bitbucket in a
// single comment.
const maxCommentLength = 32768
type Client struct {
HTTPClient *http.Client
Username string
Password string
BaseURL string
AtlantisURL string
}
// NewClient builds a bitbucket cloud client. Returns an error if the baseURL is
// malformed. httpClient is the client to use to make the requests, username
// and password are used as basic auth in the requests, baseURL is the API's
// baseURL, ex. https://corp.com:7990. Don't include the API version, ex.
// '/1.0' since that changes based on the API call. atlantisURL is the
// URL for Atlantis that will be linked to from the build status icons. This
// linking is annoying because we don't have anywhere good to link but a URL is
// required.
func NewClient(httpClient *http.Client, username string, password string, baseURL string, atlantisURL string) (*Client, error) {
if httpClient == nil {
httpClient = http.DefaultClient
}
// Remove the trailing '/' from the URL.
parsedURL, err := url.Parse(baseURL)
if err != nil {
return nil, errors.Wrapf(err, "parsing %s", baseURL)
}
if parsedURL.Scheme == "" {
return nil, fmt.Errorf("must have 'http://' or 'https://' in base url %q", baseURL)
}
urlWithoutPath := fmt.Sprintf("%s://%s", parsedURL.Scheme, parsedURL.Host)
return &Client{
HTTPClient: httpClient,
Username: username,
Password: password,
BaseURL: urlWithoutPath,
AtlantisURL: atlantisURL,
}, nil
}
// GetModifiedFiles returns the names of files that were modified in the merge request.
// The names include the path to the file from the repo root, ex. parent/child/file.txt.
func (b *Client) GetModifiedFiles(repo models.Repo, pull models.PullRequest) ([]string, error) {
var files []string
projectKey, err := b.GetProjectKey(repo.Name, repo.SanitizedCloneURL)
if err != nil {
return nil, err
}
nextPageStart := 0
baseURL := fmt.Sprintf("%s/rest/api/1.0/projects/%s/repos/%s/pull-requests/%d/changes",
b.BaseURL, projectKey, repo.Name, pull.Num)
// We'll only loop 1000 times as a safety measure.
maxLoops := 1000
for i := 0; i < maxLoops; i++ {
resp, err := b.makeRequest("GET", fmt.Sprintf("%s?start=%d", baseURL, nextPageStart), nil)
if err != nil {
return nil, err
}
var changes Changes
if err := json.Unmarshal(resp, &changes); err != nil {
return nil, errors.Wrapf(err, "Could not parse response %q", string(resp))
}
if err := validator.New().Struct(changes); err != nil {
return nil, errors.Wrapf(err, "API response %q was missing fields", string(resp))
}
for _, v := range changes.Values {
files = append(files, *v.Path.ToString)
// If the file was renamed, we'll want to run plan in the directory
// it was moved from as well.
if v.SrcPath != nil {
files = append(files, *v.SrcPath.ToString)
}
}
if *changes.IsLastPage {
break
}
nextPageStart = *changes.NextPageStart
}
// Now ensure all files are unique.
hash := make(map[string]bool)
var unique []string
for _, f := range files {
if !hash[f] {
unique = append(unique, f)
hash[f] = true
}
}
return unique, nil
}
func (b *Client) GetProjectKey(repoName string, cloneURL string) (string, error) {
// Get the project key out of the repo clone URL.
// Given http://bitbucket.corp:7990/scm/at/atlantis-example.git
// we want to get 'at'.
expr := fmt.Sprintf(".*/(.*?)/%s\\.git", repoName)
capture, err := regexp.Compile(expr)
if err != nil {
return "", errors.Wrapf(err, "constructing regex from %q", expr)
}
matches := capture.FindStringSubmatch(cloneURL)
if len(matches) != 2 {
return "", fmt.Errorf("could not extract project key from %q, regex returned %q", cloneURL, strings.Join(matches, ","))
}
return matches[1], nil
}
// CreateComment creates a comment on the merge request. It will write multiple
// comments if a single comment is too long.
func (b *Client) CreateComment(repo models.Repo, pullNum int, comment string) error {
sepEnd := "\n```\n**Warning**: Output length greater than max comment size. Continued in next comment."
sepStart := "Continued from previous comment.\n```diff\n"
comments := common.SplitComment(comment, maxCommentLength, sepEnd, sepStart)
for _, c := range comments {
if err := b.postComment(repo, pullNum, c); err != nil {
return err
}
}
return nil
}
// postComment actually posts the comment. It's a helper for CreateComment().
func (b *Client) postComment(repo models.Repo, pullNum int, comment string) error {
bodyBytes, err := json.Marshal(map[string]string{"text": comment})
if err != nil {
return errors.Wrap(err, "json encoding")
}
projectKey, err := b.GetProjectKey(repo.Name, repo.SanitizedCloneURL)
if err != nil {
return err
}
path := fmt.Sprintf("%s/rest/api/1.0/projects/%s/repos/%s/pull-requests/%d/comments", b.BaseURL, projectKey, repo.Name, pullNum)
_, err = b.makeRequest("POST", path, bytes.NewBuffer(bodyBytes))
return err
}
// PullIsApproved returns true if the merge request was approved.
func (b *Client) PullIsApproved(repo models.Repo, pull models.PullRequest) (bool, error) {
projectKey, err := b.GetProjectKey(repo.Name, repo.SanitizedCloneURL)
if err != nil {
return false, err
}
path := fmt.Sprintf("%s/rest/api/1.0/projects/%s/repos/%s/pull-requests/%d", b.BaseURL, projectKey, repo.Name, pull.Num)
resp, err := b.makeRequest("GET", path, nil)
if err != nil {
return false, err
}
var pullResp PullRequest
if err := json.Unmarshal(resp, &pullResp); err != nil {
return false, errors.Wrapf(err, "Could not parse response %q", string(resp))
}
if err := validator.New().Struct(pullResp); err != nil {
return false, errors.Wrapf(err, "API response %q was missing fields", string(resp))
}
for _, reviewer := range pullResp.Reviewers {
if *reviewer.Approved {
return true, nil
}
}
return false, nil
}
// PullIsMergeable returns true if the merge request has no conflicts and can be merged.
func (b *Client) PullIsMergeable(repo models.Repo, pull models.PullRequest) (bool, error) {
projectKey, err := b.GetProjectKey(repo.Name, repo.SanitizedCloneURL)
if err != nil {
return false, err
}
path := fmt.Sprintf("%s/rest/api/1.0/projects/%s/repos/%s/pull-requests/%d/merge", b.BaseURL, projectKey, repo.Name, pull.Num)
resp, err := b.makeRequest("GET", path, nil)
if err != nil {
return false, err
}
var mergeStatus MergeStatus
if err := json.Unmarshal(resp, &mergeStatus); err != nil {
return false, errors.Wrapf(err, "Could not parse response %q", string(resp))
}
if err := validator.New().Struct(mergeStatus); err != nil {
return false, errors.Wrapf(err, "API response %q was missing fields", string(resp))
}
if *mergeStatus.CanMerge && !*mergeStatus.Conflicted {
return true, nil
}
return false, nil
}
// UpdateStatus updates the status of a commit.
func (b *Client) UpdateStatus(repo models.Repo, pull models.PullRequest, status models.CommitStatus, description string) error {
bbState := "FAILED"
switch status {
case models.PendingCommitStatus:
bbState = "INPROGRESS"
case models.SuccessCommitStatus:
bbState = "SUCCESSFUL"
case models.FailedCommitStatus:
bbState = "FAILED"
}
bodyBytes, err := json.Marshal(map[string]string{
"key": "atlantis",
"url": b.AtlantisURL,
"state": bbState,
"description": description,
})
path := fmt.Sprintf("%s/rest/build-status/1.0/commits/%s", b.BaseURL, pull.HeadCommit)
if err != nil {
return errors.Wrap(err, "json encoding")
}
_, err = b.makeRequest("POST", path, bytes.NewBuffer(bodyBytes))
return err
}
// MergePull merges the pull request.
func (b *Client) MergePull(pull models.PullRequest) error {
projectKey, err := b.GetProjectKey(pull.BaseRepo.Name, pull.BaseRepo.SanitizedCloneURL)
if err != nil {
return err
}
path := fmt.Sprintf("%s/rest/api/1.0/projects/%s/repos/%s/pull-requests/%d/merge", b.BaseURL, projectKey, pull.BaseRepo.Name, pull.Num)
_, err = b.makeRequest("POST", path, nil)
return err
}
// prepRequest adds auth and necessary headers.
func (b *Client) prepRequest(method string, path string, body io.Reader) (*http.Request, error) {
req, err := http.NewRequest(method, path, body)
if err != nil {
return nil, err
}
req.SetBasicAuth(b.Username, b.Password)
if body != nil {
req.Header.Add("Content-Type", "application/json")
}
// Add this header to disable CSRF checks.
// See https://confluence.atlassian.com/cloudkb/xsrf-check-failed-when-calling-cloud-apis-826874382.html
req.Header.Add("X-Atlassian-Token", "no-check")
return req, nil
}
func (b *Client) makeRequest(method string, path string, reqBody io.Reader) ([]byte, error) {
req, err := b.prepRequest(method, path, reqBody)
if err != nil {
return nil, errors.Wrap(err, "constructing request")
}
resp, err := b.HTTPClient.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close() // nolint: errcheck
requestStr := fmt.Sprintf("%s %s", method, path)
if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated && resp.StatusCode != 204 {
respBody, _ := ioutil.ReadAll(resp.Body)
return nil, fmt.Errorf("making request %q unexpected status code: %d, body: %s", requestStr, resp.StatusCode, string(respBody))
}
respBody, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, errors.Wrapf(err, "reading response from request %q", requestStr)
}
return respBody, nil
}