gitea

1
// Copyright 2019 The Gitea Authors.
2
// All rights reserved.
3
// SPDX-License-Identifier: MIT
4

5
package pull
6

7
import (
8
	"context"
9
	"errors"
10
	"fmt"
11
	"strconv"
12
	"strings"
13

14
	"code.gitea.io/gitea/models"
15
	"code.gitea.io/gitea/models/db"
16
	git_model "code.gitea.io/gitea/models/git"
17
	issues_model "code.gitea.io/gitea/models/issues"
18
	access_model "code.gitea.io/gitea/models/perm/access"
19
	repo_model "code.gitea.io/gitea/models/repo"
20
	"code.gitea.io/gitea/models/unit"
21
	user_model "code.gitea.io/gitea/models/user"
22
	"code.gitea.io/gitea/modules/git"
23
	"code.gitea.io/gitea/modules/gitrepo"
24
	"code.gitea.io/gitea/modules/globallock"
25
	"code.gitea.io/gitea/modules/graceful"
26
	"code.gitea.io/gitea/modules/log"
27
	"code.gitea.io/gitea/modules/process"
28
	"code.gitea.io/gitea/modules/queue"
29
	"code.gitea.io/gitea/modules/timeutil"
30
	asymkey_service "code.gitea.io/gitea/services/asymkey"
31
	notify_service "code.gitea.io/gitea/services/notify"
32
)
33

34
// prPatchCheckerQueue represents a queue to handle update pull request tests
35
var prPatchCheckerQueue *queue.WorkerPoolQueue[string]
36

37
var (
38
	ErrIsClosed              = errors.New("pull is closed")
39
	ErrUserNotAllowedToMerge = models.ErrDisallowedToMerge{}
40
	ErrHasMerged             = errors.New("has already been merged")
41
	ErrIsWorkInProgress      = errors.New("work in progress PRs cannot be merged")
42
	ErrIsChecking            = errors.New("cannot merge while conflict checking is in progress")
43
	ErrNotMergeableState     = errors.New("not in mergeable state")
44
	ErrDependenciesLeft      = errors.New("is blocked by an open dependency")
45
)
46

47
// AddToTaskQueue adds itself to pull request test task queue.
48
func AddToTaskQueue(ctx context.Context, pr *issues_model.PullRequest) {
49
	pr.Status = issues_model.PullRequestStatusChecking
50
	err := pr.UpdateColsIfNotMerged(ctx, "status")
51
	if err != nil {
52
		log.Error("AddToTaskQueue(%-v).UpdateCols.(add to queue): %v", pr, err)
53
		return
54
	}
55
	log.Trace("Adding %-v to the test pull requests queue", pr)
56
	err = prPatchCheckerQueue.Push(strconv.FormatInt(pr.ID, 10))
57
	if err != nil && err != queue.ErrAlreadyInQueue {
58
		log.Error("Error adding %-v to the test pull requests queue: %v", pr, err)
59
	}
60
}
61

62
type MergeCheckType int
63

64
const (
65
	MergeCheckTypeGeneral  MergeCheckType = iota // general merge checks for "merge", "rebase", "squash", etc
66
	MergeCheckTypeManually                       // Manually Merged button (mark a PR as merged manually)
67
	MergeCheckTypeAuto                           // Auto Merge (Scheduled Merge) After Checks Succeed
68
)
69

70
// CheckPullMergeable check if the pull mergeable based on all conditions (branch protection, merge options, ...)
71
func CheckPullMergeable(stdCtx context.Context, doer *user_model.User, perm *access_model.Permission, pr *issues_model.PullRequest, mergeCheckType MergeCheckType, adminSkipProtectionCheck bool) error {
72
	return db.WithTx(stdCtx, func(ctx context.Context) error {
73
		if pr.HasMerged {
74
			return ErrHasMerged
75
		}
76

77
		if err := pr.LoadIssue(ctx); err != nil {
78
			log.Error("Unable to load issue[%d] for %-v: %v", pr.IssueID, pr, err)
79
			return err
80
		} else if pr.Issue.IsClosed {
81
			return ErrIsClosed
82
		}
83

84
		if allowedMerge, err := IsUserAllowedToMerge(ctx, pr, *perm, doer); err != nil {
85
			log.Error("Error whilst checking if %-v is allowed to merge %-v: %v", doer, pr, err)
86
			return err
87
		} else if !allowedMerge {
88
			return ErrUserNotAllowedToMerge
89
		}
90

91
		if mergeCheckType == MergeCheckTypeManually {
92
			// if doer is doing "manually merge" (mark as merged manually), do not check anything
93
			return nil
94
		}
95

96
		if pr.IsWorkInProgress(ctx) {
97
			return ErrIsWorkInProgress
98
		}
99

100
		if !pr.CanAutoMerge() && !pr.IsEmpty() {
101
			return ErrNotMergeableState
102
		}
103

104
		if pr.IsChecking() {
105
			return ErrIsChecking
106
		}
107

108
		if err := CheckPullBranchProtections(ctx, pr, false); err != nil {
109
			if !models.IsErrDisallowedToMerge(err) {
110
				log.Error("Error whilst checking pull branch protection for %-v: %v", pr, err)
111
				return err
112
			}
113

114
			// Now the branch protection check failed, check whether the failure could be skipped (skip by setting err = nil)
115

116
			// * when doing Auto Merge (Scheduled Merge After Checks Succeed), skip the branch protection check
117
			if mergeCheckType == MergeCheckTypeAuto {
118
				err = nil
119
			}
120

121
			// * if the doer is admin, they could skip the branch protection check
122
			if adminSkipProtectionCheck {
123
				if isRepoAdmin, errCheckAdmin := access_model.IsUserRepoAdmin(ctx, pr.BaseRepo, doer); errCheckAdmin != nil {
124
					log.Error("Unable to check if %-v is a repo admin in %-v: %v", doer, pr.BaseRepo, errCheckAdmin)
125
					return errCheckAdmin
126
				} else if isRepoAdmin {
127
					err = nil // repo admin can skip the check, so clear the error
128
				}
129
			}
130

131
			// If there is still a branch protection check error, return it
132
			if err != nil {
133
				return err
134
			}
135
		}
136

137
		if _, err := isSignedIfRequired(ctx, pr, doer); err != nil {
138
			return err
139
		}
140

141
		if noDeps, err := issues_model.IssueNoDependenciesLeft(ctx, pr.Issue); err != nil {
142
			return err
143
		} else if !noDeps {
144
			return ErrDependenciesLeft
145
		}
146

147
		return nil
148
	})
149
}
150

151
// isSignedIfRequired check if merge will be signed if required
152
func isSignedIfRequired(ctx context.Context, pr *issues_model.PullRequest, doer *user_model.User) (bool, error) {
153
	pb, err := git_model.GetFirstMatchProtectedBranchRule(ctx, pr.BaseRepoID, pr.BaseBranch)
154
	if err != nil {
155
		return false, err
156
	}
157

158
	if pb == nil || !pb.RequireSignedCommits {
159
		return true, nil
160
	}
161

162
	sign, _, _, err := asymkey_service.SignMerge(ctx, pr, doer, pr.BaseRepo.RepoPath(), pr.BaseBranch, pr.GetGitRefName())
163

164
	return sign, err
165
}
166

167
// checkAndUpdateStatus checks if pull request is possible to leaving checking status,
168
// and set to be either conflict or mergeable.
169
func checkAndUpdateStatus(ctx context.Context, pr *issues_model.PullRequest) {
170
	// If status has not been changed to conflict by testPatch then we are mergeable
171
	if pr.Status == issues_model.PullRequestStatusChecking {
172
		pr.Status = issues_model.PullRequestStatusMergeable
173
	}
174

175
	// Make sure there is no waiting test to process before leaving the checking status.
176
	has, err := prPatchCheckerQueue.Has(strconv.FormatInt(pr.ID, 10))
177
	if err != nil {
178
		log.Error("Unable to check if the queue is waiting to reprocess %-v. Error: %v", pr, err)
179
	}
180

181
	if has {
182
		log.Trace("Not updating status for %-v as it is due to be rechecked", pr)
183
		return
184
	}
185

186
	if err := pr.UpdateColsIfNotMerged(ctx, "merge_base", "status", "conflicted_files", "changed_protected_files"); err != nil {
187
		log.Error("Update[%-v]: %v", pr, err)
188
	}
189
}
190

191
// getMergeCommit checks if a pull request has been merged
192
// Returns the git.Commit of the pull request if merged
193
func getMergeCommit(ctx context.Context, pr *issues_model.PullRequest) (*git.Commit, error) {
194
	if err := pr.LoadBaseRepo(ctx); err != nil {
195
		return nil, fmt.Errorf("unable to load base repo for %s: %w", pr, err)
196
	}
197

198
	prHeadRef := pr.GetGitRefName()
199

200
	// Check if the pull request is merged into BaseBranch
201
	if _, _, err := git.NewCommand(ctx, "merge-base", "--is-ancestor").
202
		AddDynamicArguments(prHeadRef, pr.BaseBranch).
203
		RunStdString(&git.RunOpts{Dir: pr.BaseRepo.RepoPath()}); err != nil {
204
		if strings.Contains(err.Error(), "exit status 1") {
205
			// prHeadRef is not an ancestor of the base branch
206
			return nil, nil
207
		}
208
		// Errors are signaled by a non-zero status that is not 1
209
		return nil, fmt.Errorf("%-v git merge-base --is-ancestor: %w", pr, err)
210
	}
211

212
	// If merge-base successfully exits then prHeadRef is an ancestor of pr.BaseBranch
213

214
	// Find the head commit id
215
	prHeadCommitID, err := git.GetFullCommitID(ctx, pr.BaseRepo.RepoPath(), prHeadRef)
216
	if err != nil {
217
		return nil, fmt.Errorf("GetFullCommitID(%s) in %s: %w", prHeadRef, pr.BaseRepo.FullName(), err)
218
	}
219

220
	gitRepo, err := gitrepo.OpenRepository(ctx, pr.BaseRepo)
221
	if err != nil {
222
		return nil, fmt.Errorf("%-v OpenRepository: %w", pr.BaseRepo, err)
223
	}
224
	defer gitRepo.Close()
225

226
	objectFormat := git.ObjectFormatFromName(pr.BaseRepo.ObjectFormatName)
227

228
	// Get the commit from BaseBranch where the pull request got merged
229
	mergeCommit, _, err := git.NewCommand(ctx, "rev-list", "--ancestry-path", "--merges", "--reverse").
230
		AddDynamicArguments(prHeadCommitID + ".." + pr.BaseBranch).
231
		RunStdString(&git.RunOpts{Dir: pr.BaseRepo.RepoPath()})
232
	if err != nil {
233
		return nil, fmt.Errorf("git rev-list --ancestry-path --merges --reverse: %w", err)
234
	} else if len(mergeCommit) < objectFormat.FullLength() {
235
		// PR was maybe fast-forwarded, so just use last commit of PR
236
		mergeCommit = prHeadCommitID
237
	}
238
	mergeCommit = strings.TrimSpace(mergeCommit)
239

240
	commit, err := gitRepo.GetCommit(mergeCommit)
241
	if err != nil {
242
		return nil, fmt.Errorf("GetMergeCommit[%s]: %w", mergeCommit, err)
243
	}
244

245
	return commit, nil
246
}
247

248
// manuallyMerged checks if a pull request got manually merged
249
// When a pull request got manually merged mark the pull request as merged
250
func manuallyMerged(ctx context.Context, pr *issues_model.PullRequest) bool {
251
	if err := pr.LoadBaseRepo(ctx); err != nil {
252
		log.Error("%-v LoadBaseRepo: %v", pr, err)
253
		return false
254
	}
255

256
	if unit, err := pr.BaseRepo.GetUnit(ctx, unit.TypePullRequests); err == nil {
257
		config := unit.PullRequestsConfig()
258
		if !config.AutodetectManualMerge {
259
			return false
260
		}
261
	} else {
262
		log.Error("%-v BaseRepo.GetUnit(unit.TypePullRequests): %v", pr, err)
263
		return false
264
	}
265

266
	commit, err := getMergeCommit(ctx, pr)
267
	if err != nil {
268
		log.Error("%-v getMergeCommit: %v", pr, err)
269
		return false
270
	}
271

272
	if commit == nil {
273
		// no merge commit found
274
		return false
275
	}
276

277
	pr.MergedCommitID = commit.ID.String()
278
	pr.MergedUnix = timeutil.TimeStamp(commit.Author.When.Unix())
279
	pr.Status = issues_model.PullRequestStatusManuallyMerged
280
	merger, _ := user_model.GetUserByEmail(ctx, commit.Author.Email)
281

282
	// When the commit author is unknown set the BaseRepo owner as merger
283
	if merger == nil {
284
		if pr.BaseRepo.Owner == nil {
285
			if err = pr.BaseRepo.LoadOwner(ctx); err != nil {
286
				log.Error("%-v BaseRepo.LoadOwner: %v", pr, err)
287
				return false
288
			}
289
		}
290
		merger = pr.BaseRepo.Owner
291
	}
292
	pr.Merger = merger
293
	pr.MergerID = merger.ID
294

295
	if merged, err := pr.SetMerged(ctx); err != nil {
296
		log.Error("%-v setMerged : %v", pr, err)
297
		return false
298
	} else if !merged {
299
		return false
300
	}
301

302
	notify_service.MergePullRequest(ctx, merger, pr)
303

304
	log.Info("manuallyMerged[%-v]: Marked as manually merged into %s/%s by commit id: %s", pr, pr.BaseRepo.Name, pr.BaseBranch, commit.ID.String())
305
	return true
306
}
307

308
// InitializePullRequests checks and tests untested patches of pull requests.
309
func InitializePullRequests(ctx context.Context) {
310
	prs, err := issues_model.GetPullRequestIDsByCheckStatus(ctx, issues_model.PullRequestStatusChecking)
311
	if err != nil {
312
		log.Error("Find Checking PRs: %v", err)
313
		return
314
	}
315
	for _, prID := range prs {
316
		select {
317
		case <-ctx.Done():
318
			return
319
		default:
320
			log.Trace("Adding PR[%d] to the pull requests patch checking queue", prID)
321
			if err := prPatchCheckerQueue.Push(strconv.FormatInt(prID, 10)); err != nil {
322
				log.Error("Error adding PR[%d] to the pull requests patch checking queue %v", prID, err)
323
			}
324
		}
325
	}
326
}
327

328
// handle passed PR IDs and test the PRs
329
func handler(items ...string) []string {
330
	for _, s := range items {
331
		id, _ := strconv.ParseInt(s, 10, 64)
332
		testPR(id)
333
	}
334
	return nil
335
}
336

337
func testPR(id int64) {
338
	ctx := graceful.GetManager().HammerContext()
339
	releaser, err := globallock.Lock(ctx, getPullWorkingLockKey(id))
340
	if err != nil {
341
		log.Error("lock.Lock(): %v", err)
342
		return
343
	}
344
	defer releaser()
345

346
	ctx, _, finished := process.GetManager().AddContext(ctx, fmt.Sprintf("Test PR[%d] from patch checking queue", id))
347
	defer finished()
348

349
	pr, err := issues_model.GetPullRequestByID(ctx, id)
350
	if err != nil {
351
		log.Error("Unable to GetPullRequestByID[%d] for testPR: %v", id, err)
352
		return
353
	}
354

355
	log.Trace("Testing %-v", pr)
356
	defer func() {
357
		log.Trace("Done testing %-v (status: %s)", pr, pr.Status)
358
	}()
359

360
	if pr.HasMerged {
361
		log.Trace("%-v is already merged (status: %s, merge commit: %s)", pr, pr.Status, pr.MergedCommitID)
362
		return
363
	}
364

365
	if manuallyMerged(ctx, pr) {
366
		log.Trace("%-v is manually merged (status: %s, merge commit: %s)", pr, pr.Status, pr.MergedCommitID)
367
		return
368
	}
369

370
	if err := TestPatch(pr); err != nil {
371
		log.Error("testPatch[%-v]: %v", pr, err)
372
		pr.Status = issues_model.PullRequestStatusError
373
		if err := pr.UpdateCols(ctx, "status"); err != nil {
374
			log.Error("update pr [%-v] status to PullRequestStatusError failed: %v", pr, err)
375
		}
376
		return
377
	}
378
	checkAndUpdateStatus(ctx, pr)
379
}
380

381
// CheckPRsForBaseBranch check all pulls with baseBrannch
382
func CheckPRsForBaseBranch(ctx context.Context, baseRepo *repo_model.Repository, baseBranchName string) error {
383
	prs, err := issues_model.GetUnmergedPullRequestsByBaseInfo(ctx, baseRepo.ID, baseBranchName)
384
	if err != nil {
385
		return err
386
	}
387

388
	for _, pr := range prs {
389
		AddToTaskQueue(ctx, pr)
390
	}
391

392
	return nil
393
}
394

395
// Init runs the task queue to test all the checking status pull requests
396
func Init() error {
397
	prPatchCheckerQueue = queue.CreateUniqueQueue(graceful.GetManager().ShutdownContext(), "pr_patch_checker", handler)
398

399
	if prPatchCheckerQueue == nil {
400
		return fmt.Errorf("unable to create pr_patch_checker queue")
401
	}
402

403
	go graceful.GetManager().RunWithCancel(prPatchCheckerQueue)
404
	go graceful.GetManager().RunWithShutdownContext(InitializePullRequests)
405
	return nil
406
}
407