-
Notifications
You must be signed in to change notification settings - Fork 115
/
interactor.go
388 lines (349 loc) · 13.5 KB
/
interactor.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
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
/*
Copyright 2019 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package git
import (
"bufio"
"bytes"
"errors"
"fmt"
"os"
"strings"
"github.com/sirupsen/logrus"
)
// Interactor knows how to operate on a git repository cloned from GitHub
// using a local cache.
type Interactor interface {
// Directory exposes the directory in which the repository has been cloned
Directory() string
// Clean removes the repository. It is up to the user to call this once they are done
Clean() error
// Checkout runs `git checkout`
Checkout(commitlike string) error
// RevParse runs `git rev-parse`
RevParse(commitlike string) (string, error)
// BranchExists determines if a branch with the name exists
BranchExists(branch string) bool
// CheckoutNewBranch creates a new branch from HEAD and checks it out
CheckoutNewBranch(branch string) error
// Merge merges the commitlike into the current HEAD
Merge(commitlike string) (bool, error)
// MergeWithStrategy merges the commitlike into the current HEAD with the strategy
MergeWithStrategy(commitlike, mergeStrategy string, opts ...MergeOpt) (bool, error)
// MergeAndCheckout merges all commitlikes into the current HEAD with the appropriate strategy
MergeAndCheckout(baseSHA string, mergeStrategy string, headSHAs ...string) error
// Am calls `git am`
Am(path string) error
// Fetch calls `git fetch`
Fetch() error
// FetchRef fetches the refspec
FetchRef(refspec string) error
// FetchFromRemote fetches the branch of the given remote
FetchFromRemote(remote RemoteResolver, branch string) error
// CheckoutPullRequest fetches and checks out the synthetic refspec from GitHub for a pull request HEAD
CheckoutPullRequest(number int) error
// Config runs `git config`
Config(key, value string) error
// Diff runs `git diff`
Diff(head, sha string) (changes []string, err error)
// MergeCommitsExistBetween determines if merge commits exist between target and HEAD
MergeCommitsExistBetween(target, head string) (bool, error)
// ShowRef returns the commit for a commitlike. Unlike rev-parse it does not require a checkout.
ShowRef(commitlike string) (string, error)
// HasSHA checks if a ref is a sha we have fetched locally
HasSHA(ref string) (string, error)
}
// cacher knows how to cache and update repositories in a central cache
type cacher interface {
// MirrorClone sets up a mirror of the source repository.
MirrorClone() error
// RemoteUpdate fetches all updates from the remote.
RemoteUpdate() error
}
// cloner knows how to clone repositories from a central cache
type cloner interface {
// Clone clones the repository from a local path.
Clone(from string) error
}
// MergeOpt holds options for git merge operations.
// Currently only commit message option is supported.
type MergeOpt struct {
CommitMessage string
}
type interactor struct {
executor Executor
remote RemoteResolver
dir string
logger *logrus.Entry
}
// Directory exposes the directory in which this repository has been cloned
func (i *interactor) Directory() string {
return i.dir
}
// Clean cleans up the repository from the on-disk cache
func (i *interactor) Clean() error {
return os.RemoveAll(i.dir)
}
// Clone clones the repository from a local path.
func (i *interactor) Clone(from string) error {
i.logger.Debugf("Creating a clone of the repo at %s from %s", i.dir, from)
if out, err := i.executor.Run("clone", from, i.dir); err != nil {
return fmt.Errorf("error creating a clone: %v %v", err, string(out))
}
return nil
}
// MirrorClone sets up a mirror of the source repository.
func (i *interactor) MirrorClone() error {
i.logger.Debugf("Creating a mirror of the repo at %s", i.dir)
remote, err := i.remote()
if err != nil {
return fmt.Errorf("could not resolve remote for cloning: %v", err)
}
out, err := i.executor.Run("clone", "--mirror", remote, i.dir)
if err != nil {
// the returned error is not being reported
i.logger.Errorf("error creating a mirror clone: %v %v", err, string(out))
return fmt.Errorf("error creating a mirror clone: %v %v", err, string(out))
}
return nil
}
// Checkout runs git checkout.
func (i *interactor) Checkout(commitlike string) error {
i.logger.Debugf("Checking out %q", commitlike)
if out, err := i.executor.Run("checkout", commitlike); err != nil {
return fmt.Errorf("error checking out %q: %v %v", commitlike, err, string(out))
}
return nil
}
// RevParse runs git rev-parse.
func (i *interactor) RevParse(commitlike string) (string, error) {
i.logger.Infof("Parsing revision %q", commitlike)
out, err := i.executor.Run("rev-parse", commitlike)
if err != nil {
return "", fmt.Errorf("error parsing %q: %v %v", commitlike, err, string(out))
}
return string(out), nil
}
// BranchExists returns true if branch exists in heads.
func (i *interactor) BranchExists(branch string) bool {
i.logger.Infof("Checking if branch %q exists", branch)
_, err := i.executor.Run("ls-remote", "--exit-code", "--heads", "origin", branch)
return err == nil
}
// CheckoutNewBranch creates a new branch and checks it out.
func (i *interactor) CheckoutNewBranch(branch string) error {
i.logger.Infof("Checking out new branch %q", branch)
if out, err := i.executor.Run("checkout", "-b", branch); err != nil {
return fmt.Errorf("error checking out new branch %q: %v %v", branch, err, string(out))
}
return nil
}
// Merge attempts to merge commitlike into the current branch. It returns true
// if the merge completes. It returns an error if the abort fails.
func (i *interactor) Merge(commitlike string) (bool, error) {
return i.MergeWithStrategy(commitlike, "merge")
}
// MergeWithStrategy attempts to merge commitlike into the current branch given the merge strategy.
// It returns true if the merge completes. if the merge does not complete successfully, we try to
// abort it and return an error if the abort fails.
func (i *interactor) MergeWithStrategy(commitlike, mergeStrategy string, opts ...MergeOpt) (bool, error) {
i.logger.Infof("Merging %q using the %q strategy", commitlike, mergeStrategy)
switch mergeStrategy {
case "merge":
return i.mergeMerge(commitlike, opts...)
case "squash":
return i.squashMerge(commitlike)
default:
return false, fmt.Errorf("merge strategy %q is not supported", mergeStrategy)
}
}
func (i *interactor) mergeMerge(commitlike string, opts ...MergeOpt) (bool, error) {
args := []string{"merge", "--no-ff", "--no-stat"}
if len(opts) == 0 {
args = append(args, []string{"-m", "merge"}...)
} else {
for _, opt := range opts {
args = append(args, []string{"-m", opt.CommitMessage}...)
}
}
args = append(args, commitlike)
out, err := i.executor.Run(args...)
if err == nil {
return true, nil
}
i.logger.WithError(err).Warnf("Error merging %q: %s", commitlike, string(out))
if out, err := i.executor.Run("merge", "--abort"); err != nil {
return false, fmt.Errorf("error aborting merge of %q: %v %v", commitlike, err, string(out))
}
return false, nil
}
func (i *interactor) squashMerge(commitlike string) (bool, error) {
out, err := i.executor.Run("merge", "--squash", "--no-stat", commitlike)
if err != nil {
i.logger.WithError(err).Warnf("Error staging merge for %q: %s", commitlike, string(out))
if out, err := i.executor.Run("reset", "--hard", "HEAD"); err != nil {
return false, fmt.Errorf("error aborting merge of %q: %v %v", commitlike, err, string(out))
}
return false, nil
}
out, err = i.executor.Run("commit", "--no-stat", "-m", "merge")
if err != nil {
i.logger.WithError(err).Warnf("Error committing merge for %q: %s", commitlike, string(out))
if out, err := i.executor.Run("reset", "--hard", "HEAD"); err != nil {
return false, fmt.Errorf("error aborting merge of %q: %v %v", commitlike, err, string(out))
}
return false, nil
}
return true, nil
}
// Only the `merge` and `squash` strategies are supported.
func (i *interactor) MergeAndCheckout(baseSHA string, mergeStrategy string, headSHAs ...string) error {
if baseSHA == "" {
return errors.New("baseSHA must be set")
}
if err := i.Checkout(baseSHA); err != nil {
return err
}
for _, headSHA := range headSHAs {
ok, err := i.MergeWithStrategy(headSHA, mergeStrategy)
if err != nil {
return err
} else if !ok {
return fmt.Errorf("failed to merge %q", headSHA)
}
}
return nil
}
// Am tries to apply the patch in the given path into the current branch
// by performing a three-way merge (similar to git cherry-pick). It returns
// an error if the patch cannot be applied.
func (i *interactor) Am(path string) error {
i.logger.Infof("Applying patch at %s", path)
out, err := i.executor.Run("am", "--3way", path)
if err == nil {
return nil
}
i.logger.WithError(err).Infof("Patch apply failed with output: %s", string(out))
if abortOut, abortErr := i.executor.Run("am", "--abort"); err != nil {
i.logger.WithError(abortErr).Warningf("Aborting patch apply failed with output: %s", string(abortOut))
}
return errors.New(string(bytes.TrimPrefix(out, []byte("The copy of the patch that failed is found in: .git/rebase-apply/patch"))))
}
// RemoteUpdate fetches all updates from the remote.
func (i *interactor) RemoteUpdate() error {
i.logger.Info("Updating from remote")
if out, err := i.executor.Run("remote", "update"); err != nil {
return fmt.Errorf("error updating: %v %v", err, string(out))
}
return nil
}
// Fetch fetches all updates from the remote.
func (i *interactor) Fetch() error {
remote, err := i.remote()
if err != nil {
return fmt.Errorf("could not resolve remote for fetching: %v", err)
}
i.logger.Debugf("Fetching from %s", remote)
if out, err := i.executor.Run("fetch", "--force", remote); err != nil {
return fmt.Errorf("error fetching: %v %v", err, string(out))
}
return nil
}
// FetchRef fetches a refspec from the remote and leaves it as FETCH_HEAD.
func (i *interactor) FetchRef(refspec string) error {
remote, err := i.remote()
if err != nil {
return fmt.Errorf("could not resolve remote for fetching: %v", err)
}
i.logger.Debugf("Fetching %q from %s", refspec, remote)
if out, err := i.executor.Run("fetch", "--tags", "--force", remote, refspec); err != nil {
return fmt.Errorf("error fetching %q: %v %v", refspec, err, string(out))
}
return nil
}
// FetchFromRemote fetches all update from a specific remote and branch and leaves it as FETCH_HEAD.
func (i *interactor) FetchFromRemote(remote RemoteResolver, branch string) error {
r, err := remote()
if err != nil {
return fmt.Errorf("couldn't get remote: %v", err)
}
i.logger.Debugf("Fetching %s from %s", branch, r)
if out, err := i.executor.Run("fetch", "--force", r, branch); err != nil {
return fmt.Errorf("error fetching %s from %s: %v %v", branch, r, err, string(out))
}
return nil
}
// CheckoutPullRequest fetches the HEAD of a pull request using a synthetic refspec
// available on GitHub remotes and creates a branch at that commit.
func (i *interactor) CheckoutPullRequest(number int) error {
i.logger.Infof("Checking out pull request %d", number)
if err := i.FetchRef(fmt.Sprintf("pull/%d/head", number)); err != nil {
return err
}
if err := i.Checkout("FETCH_HEAD"); err != nil {
return err
}
if err := i.CheckoutNewBranch(fmt.Sprintf("pull%d", number)); err != nil {
return err
}
return nil
}
// Config runs git config.
func (i *interactor) Config(key, value string) error {
i.logger.Infof("Configuring %q=%q", key, value)
if out, err := i.executor.Run("config", key, value); err != nil {
return fmt.Errorf("error configuring %q=%q: %v %v", key, value, err, string(out))
}
return nil
}
// Diff lists the difference between the two references, returning the output
// line by line.
func (i *interactor) Diff(head, sha string) ([]string, error) {
i.logger.Infof("Finding the differences between %q and %q", head, sha)
out, err := i.executor.Run("diff", head, sha, "--name-only")
if err != nil {
return nil, err
}
var changes []string
scan := bufio.NewScanner(bytes.NewReader(out))
scan.Split(bufio.ScanLines)
for scan.Scan() {
changes = append(changes, scan.Text())
}
return changes, nil
}
// MergeCommitsExistBetween runs 'git log <target>..<head> --merged' to verify
// if merge commits exist between "target" and "head".
func (i *interactor) MergeCommitsExistBetween(target, head string) (bool, error) {
i.logger.Infof("Determining if merge commits exist between %q and %q", target, head)
out, err := i.executor.Run("log", fmt.Sprintf("%s..%s", target, head), "--oneline", "--merges")
if err != nil {
return false, fmt.Errorf("error verifying if merge commits exist between %q and %q: %v %s", target, head, err, string(out))
}
return len(out) != 0, nil
}
func (i *interactor) ShowRef(commitlike string) (string, error) {
i.logger.Infof("Getting the commit sha for commitlike %s", commitlike)
out, err := i.executor.Run("show-ref", "-s", commitlike)
if err != nil {
return "", fmt.Errorf("failed to get commit sha for commitlike %s: %v", commitlike, err)
}
return strings.TrimSpace(string(out)), nil
}
func (i *interactor) HasSHA(ref string) (string, error) {
i.logger.Infof("Checking if %s is a fetched SHA", ref)
out, err := i.executor.Run("cat-file", "commit", ref)
if err != nil {
return "", fmt.Errorf("failed to verify ref is a sha: %s: %v", ref, err)
}
return strings.TrimSpace(string(out)), nil
}