BlueGit

timfa bluegit

Files

bluegit / internal / server / ops_mr.go

ops_mr.go

fix: verwijder slash-branches en de bron na een push-merge
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Passed cfe6072c History
ops_mr.go 15.2 KiB Download Raw
1package server
2
3import (
4 "context"
5 "net/http"
6 "os"
7 "strings"
8
9 "gitlab.com/Timfa/bluegit/internal/access"
10 "gitlab.com/Timfa/bluegit/internal/gitrepo"
11 "gitlab.com/Timfa/bluegit/internal/i18n"
12 "gitlab.com/Timfa/bluegit/internal/store"
13)
14
15func (s *Server) opCreateMR(ctx context.Context, user store.User, repo store.Repo, title, description, source, target string, draft bool) (store.MergeRequest, error) {
16 role, err := s.repoRole(ctx, user, repo)
17 if err != nil {
18 return store.MergeRequest{}, err
19 }
20 if !role.CanWriteCode() {
21 return store.MergeRequest{}, fail(403, i18n.E("err.forbidden"))
22 }
23 source = safeRev(source, "")
24 target = safeRev(target, repo.DefaultBranch)
25 if source == "" || source == target {
26 return store.MergeRequest{}, fail(400, i18n.E("err.branches"))
27 }
28 mr, err := s.Store.CreateMergeRequest(ctx, repo.ID, user.ID, title, description, source, target)
29 if err != nil {
30 return store.MergeRequest{}, fail(400, err)
31 }
32 if draft {
33 _ = s.Store.SetDraft(ctx, mr.ID, true)
34 mr.Draft = true
35 }
36 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
37 if sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+source); sha != "" {
38 s.startOneMergePipeline(ctx, repo, sha, user.Username, "", mr)
39 }
40 s.mrHook(repo, mr, user.Username, "opened", "")
41 s.recordContribution(user.ID, repo.ID, "merge_request", mrRef(mr.ID), mr.CreatedAt)
42 return mr, nil
43}
44
45func (s *Server) opUpdateMR(ctx context.Context, user store.User, repo store.Repo, number int64, title, description, labels string) (store.MergeRequest, error) {
46 role, err := s.repoRole(ctx, user, repo)
47 if err != nil {
48 return store.MergeRequest{}, err
49 }
50 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
51 if err != nil {
52 return store.MergeRequest{}, notFound(err)
53 }
54 if mr.Status != "open" || (user.ID != mr.AuthorID && !role.CanWriteCode()) {
55 return store.MergeRequest{}, fail(403, i18n.E("err.forbidden"))
56 }
57 title = strings.TrimSpace(title)
58 labels = normalizeLabels(labels)
59 if err := s.Store.UpdateMergeRequest(ctx, mr.ID, title, description, labels); err != nil {
60 return store.MergeRequest{}, fail(400, err)
61 }
62 if title != mr.Title {
63 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "retitled", title)
64 }
65 if labels != normalizeLabels(mr.Labels) {
66 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "relabeled", labels)
67 }
68 mr.Title, mr.Description, mr.Labels = title, description, labels
69 return mr, nil
70}
71
72func (s *Server) opAddNote(r *http.Request, user store.User, repo store.Repo, number int64, body, path string, start, end int, parent int64) (store.Note, error) {
73 ctx := r.Context()
74 role, err := s.repoRole(ctx, user, repo)
75 if err != nil {
76 return store.Note{}, err
77 }
78 if !role.AtLeast(access.RoleReadonly) {
79 return store.Note{}, fail(403, i18n.E("err.forbidden"))
80 }
81 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
82 if err != nil {
83 return store.Note{}, notFound(err)
84 }
85 path, pathOK := repoPath(path)
86 if !pathOK {
87 return store.Note{}, fail(400, i18n.E("err.sugFile"))
88 }
89 if path == "" {
90 if parent > 0 {
91 note, err := s.Store.AddReply(ctx, repo.ID, mr.ID, user.ID, parent, body)
92 if err != nil {
93 return store.Note{}, fail(400, err)
94 }
95 s.mrHook(repo, mr, user.Username, "commented", body)
96 return note, nil
97 }
98 note, err := s.Store.AddNote(ctx, repo.ID, mr.ID, user.ID, body)
99 if err != nil {
100 return store.Note{}, fail(400, err)
101 }
102 s.mrHook(repo, mr, user.Username, "commented", body)
103 return note, nil
104 }
105 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
106 blob, err := gitrepo.BlobText(ctx, s.Git, dir, mr.SourceBranch, path)
107 if err != nil {
108 return store.Note{}, fail(400, i18n.E("err.sugFile"))
109 }
110 lines := gitrepo.SplitLines(blob)
111 if start < 1 || end < start || end > len(lines) {
112 return store.Note{}, fail(400, i18n.E("err.sugLines"))
113 }
114 base := strings.Join(lines[start-1:end], "\n")
115 suggestion, _ := gitrepo.ParseSuggestion(body)
116 note, err := s.Store.AddLineNote(ctx, repo.ID, mr.ID, user.ID, body, path, start, end, suggestion, base)
117 if err != nil {
118 return store.Note{}, fail(400, err)
119 }
120 s.noteRequestsChanges(r, repo, mr, user.ID, suggestion)
121 s.mrHook(repo, mr, user.Username, "commented", body)
122 return note, nil
123}
124
125func (s *Server) opReview(ctx context.Context, user store.User, repo store.Repo, number int64, status string) error {
126 role, err := s.repoRole(ctx, user, repo)
127 if err != nil {
128 return err
129 }
130 if !role.CanWriteCode() {
131 return fail(403, i18n.E("err.forbidden"))
132 }
133 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
134 if err != nil || mr.Status != "open" {
135 return notFound(err)
136 }
137 switch status {
138 case "approved", "changes", "rejected":
139 default:
140 return fail(400, i18n.E("rev.bad"))
141 }
142 if status == "approved" {
143 if user.ID == mr.AuthorID {
144 return fail(400, i18n.E("rev.own"))
145 }
146 pol, _, err := s.Store.EffectiveApproval(ctx, repo)
147 if err != nil || !approvalCounts(role, pol) {
148 return fail(403, i18n.E("err.forbidden"))
149 }
150 }
151 if err := s.Store.UpsertReview(ctx, repo.ID, mr.ID, user.ID, status); err != nil {
152 return fail(400, err)
153 }
154 return nil
155}
156
157func (s *Server) opDismissReview(ctx context.Context, user store.User, repo store.Repo, number, targetUser int64) error {
158 role, err := s.repoRole(ctx, user, repo)
159 if err != nil {
160 return err
161 }
162 if !role.CanManageSettings() {
163 return fail(403, i18n.E("err.forbidden"))
164 }
165 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
166 if err != nil {
167 return notFound(err)
168 }
169 if targetUser == 0 {
170 return fail(400, i18n.E("rev.bad"))
171 }
172 if err := s.Store.UpsertReview(ctx, repo.ID, mr.ID, targetUser, "dismissed"); err != nil {
173 return fail(400, err)
174 }
175 return nil
176}
177
178func (s *Server) opApplySuggestions(ctx context.Context, user store.User, repo store.Repo, number int64, title, description string, ids []int64) error {
179 role, err := s.repoRole(ctx, user, repo)
180 if err != nil {
181 return err
182 }
183 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
184 if err != nil || mr.Status != "open" {
185 return notFound(err)
186 }
187 patterns, err := s.Store.ProtectedPatterns(ctx, repo.ID)
188 if err != nil {
189 return fail(400, err)
190 }
191 if !role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch)) {
192 return fail(403, i18n.E("err.sugBranch", mr.SourceBranch))
193 }
194 title = strings.TrimSpace(title)
195 if title == "" || strings.ContainsAny(title, "\r\n") {
196 return fail(400, i18n.E("err.sugTitle"))
197 }
198 notes, err := s.Store.ListNotes(ctx, mr.ID)
199 if err != nil {
200 return fail(400, err)
201 }
202 byID := map[int64]store.Note{}
203 for _, n := range notes {
204 byID[n.ID] = n
205 }
206 var edits []gitrepo.SuggestionEdit
207 seen := map[int64]bool{}
208 for _, id := range ids {
209 if seen[id] {
210 continue
211 }
212 seen[id] = true
213 n, ok := byID[id]
214 if !ok || n.Suggestion == "" || n.FilePath == "" {
215 return fail(400, i18n.E("err.sugGone"))
216 }
217 edits = append(edits, gitrepo.SuggestionEdit{
218 Path: n.FilePath, Start: n.LineStart, End: n.LineEnd, Base: n.BaseText, Replacement: n.Suggestion,
219 })
220 }
221 if len(edits) == 0 {
222 return fail(400, i18n.E("err.sugEmpty"))
223 }
224 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
225 files := map[string]string{}
226 for _, e := range edits {
227 if _, ok := files[e.Path]; ok {
228 continue
229 }
230 body, err := gitrepo.BlobText(ctx, s.Git, dir, mr.SourceBranch, e.Path)
231 if err != nil {
232 return fail(400, i18n.E("err.sugConflict", e.Path, e.Start, e.End))
233 }
234 files[e.Path] = body
235 }
236 updated, err := gitrepo.ApplySuggestions(files, edits)
237 if err != nil {
238 return fail(400, err)
239 }
240 branch := safeRev(mr.SourceBranch, "")
241 if branch == "" {
242 return fail(400, i18n.E("err.sugBranch", mr.SourceBranch))
243 }
244 work, err := s.scratchDir("suggest")
245 if err != nil {
246 return fail(500, err)
247 }
248 defer os.RemoveAll(work)
249 if err := s.postReceive(ctx, repo, user, dir, func() error {
250 return gitrepo.CommitOnBranch(ctx, s.Git, dir, work, branch, user.Username, userEmail(user.Username), title, description, updated, role, patterns)
251 }); err != nil {
252 return fail(400, err)
253 }
254 return nil
255}
256
257// mergeChoice is de keuze uit het formulier of de API.
258// FromForm betekent dat een browser de vakjes postte: een ontbrekend vakje staat uit.
259// De API laat FromForm uit en gebruikt de pointers. nil houdt de opgeslagen waarde.
260type mergeChoice struct {
261 FromForm bool
262 Remove *bool
263 Squash *bool
264 Message *string
265 Force bool
266 Confirm bool
267}
268
269// mergeOutcome vertelt de pagina en de API wat er na de merge met de bronbranch gebeurde.
270type mergeOutcome struct {
271 Notice string
272 Arg string
273 Removed bool
274 Skip string
275}
276
277func applyMergeChoice(mr store.MergeRequest, choice mergeChoice) (remove, squash bool, message string) {
278 remove, squash, message = mr.RemoveSourceBranch, mr.Squash, mr.SquashMessage
279 if choice.FromForm {
280 remove, squash, message = false, false, ""
281 }
282 if choice.Remove != nil {
283 remove = *choice.Remove
284 }
285 if choice.Squash != nil {
286 squash = *choice.Squash
287 }
288 if choice.Message != nil {
289 message = *choice.Message
290 }
291 return remove, squash, message
292}
293
294func (s *Server) opMergeMR(r *http.Request, user store.User, repo store.Repo, number int64, choice mergeChoice) (mergeOutcome, error) {
295 ctx := r.Context()
296 role, err := s.repoRole(ctx, user, repo)
297 if err != nil {
298 return mergeOutcome{}, err
299 }
300 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
301 if err != nil || mr.Status != "open" {
302 return mergeOutcome{}, notFound(err)
303 }
304 patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
305 if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) {
306 return mergeOutcome{}, fail(403, i18n.E("err.targetAccess"))
307 }
308 remove, squash, message := applyMergeChoice(mr, choice)
309 if err := s.Store.SetMergeOptions(ctx, mr.ID, remove, squash, message); err != nil {
310 return mergeOutcome{}, fail(400, err)
311 }
312 mr.RemoveSourceBranch, mr.Squash, mr.SquashMessage = remove, squash, message
313 blocks := s.mergeBlocks(r, repo, mr)
314 force := choice.Force && role.CanManageSettings()
315 if len(blocks) > 0 {
316 if !force {
317 return mergeOutcome{}, fail(409, i18n.E("err.mrBlocked", strings.Join(blocks, " ")))
318 }
319 if !choice.Confirm {
320 return mergeOutcome{}, fail(409, i18n.E("mr.force.need"))
321 }
322 }
323 texts := s.mergeCloseTexts(r, repo, mr)
324 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
325 work, err := s.scratchDir("merge")
326 if err != nil {
327 return mergeOutcome{}, fail(500, err)
328 }
329 defer os.RemoveAll(work)
330 msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'"
331 if squash {
332 msg = strings.TrimSpace(message)
333 if msg == "" {
334 msg = mr.Title
335 }
336 }
337 s.mergingMR.Store(mr.ID, true)
338 defer s.mergingMR.Delete(mr.ID)
339 if err := s.postReceive(ctx, repo, user, dir, func() error {
340 return gitrepo.Merge(ctx, s.Git, dir, work, mr.SourceBranch, mr.TargetBranch, user.Username, userEmail(user.Username), msg, squash, role, patterns)
341 }); err != nil {
342 return mergeOutcome{}, fail(400, err)
343 }
344 fresh, ferr := s.Store.MergeRequestByNumber(ctx, repo.ID, mr.Number)
345 if ferr != nil || fresh.Status != "merged" {
346 _ = s.Store.SetMergeRequestStatus(ctx, mr.ID, "merged")
347 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "merged", "")
348 mr.Status = "merged"
349 s.mrHook(repo, mr, user.Username, "merged", "")
350 s.closeIssueNumbers(ctx, repo, user, closingNumbers(texts...))
351 }
352 if force && len(blocks) > 0 {
353 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "forced", strings.Join(blocks, "\n"))
354 }
355 if !remove {
356 return mergeOutcome{Notice: "flash.merged", Skip: "disabled"}, nil
357 }
358 skip, deleted := s.deleteMergedSource(ctx, user, role, repo, mr.SourceBranch)
359 return mergedNotice(deleted, skip, mr.SourceBranch), nil
360}
361
362// sourceDeleteSkip zegt waarom de bronbranch moet blijven.
363// Een lege tekst betekent dat verwijderen mag.
364func sourceDeleteSkip(role access.Role, defaultBranch, name string, exists, protected bool) string {
365 if name == "" || !exists {
366 return "missing"
367 }
368 if name == defaultBranch {
369 return "default"
370 }
371 if protected {
372 return "protected"
373 }
374 if !role.CanWriteCode() {
375 return "forbidden"
376 }
377 return ""
378}
379
380// mergedSource is een bronbranch die na een gedetecteerde merge weg mag.
381type mergedSource struct {
382 user store.User
383 role access.Role
384 name string
385}
386
387// mergedSourcePlan zegt of deze merge de bronbranch hoort te verwijderen.
388// De voorwaarden zijn dezelfde als bij de mergeknop: de tak staat in deze
389// repo, is niet protected of de default, en de pusher mag code schrijven.
390func (s *Server) mergedSourcePlan(ctx context.Context, repo store.Repo, user store.User, mr store.MergeRequest) (mergedSource, bool) {
391 if !mr.RemoveSourceBranch || user.ID == 0 {
392 return mergedSource{}, false
393 }
394 name := strings.TrimSpace(mr.SourceBranch)
395 if name == "" || name == strings.TrimSpace(mr.TargetBranch) {
396 return mergedSource{}, false
397 }
398 role, err := s.repoRole(ctx, user, repo)
399 if err != nil {
400 return mergedSource{}, false
401 }
402 return mergedSource{user: user, role: role, name: name}, true
403}
404
405// dropMergedSources verwijdert bronbranches nadat de push zelf klaar is.
406func (s *Server) dropMergedSources(repo store.Repo, list []mergedSource) {
407 seen := map[string]bool{}
408 ctx := context.Background()
409 for _, item := range list {
410 if item.name == "" || seen[item.name] {
411 continue
412 }
413 seen[item.name] = true
414 s.deleteMergedSource(ctx, item.user, item.role, repo, item.name)
415 }
416}
417
418// deleteMergedSource haalt de bronbranch weg na een geslaagde merge.
419// Dat is een eigen push, zodat een mislukte verwijdering de merge-webhook niet uitwist.
420func (s *Server) deleteMergedSource(ctx context.Context, user store.User, role access.Role, repo store.Repo, name string) (skip string, deleted bool) {
421 name = strings.TrimSpace(name)
422 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
423 exists := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+name) != ""
424 patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
425 if skip = sourceDeleteSkip(role, repo.DefaultBranch, name, exists, access.BranchProtected(patterns, name)); skip != "" {
426 return skip, false
427 }
428 if err := s.postReceive(ctx, repo, user, dir, func() error {
429 return gitrepo.DeleteBranch(ctx, s.Git, dir, name)
430 }); err != nil {
431 return "error", false
432 }
433 return "", true
434}
435
436func mergedNotice(deleted bool, skip, branch string) mergeOutcome {
437 if deleted {
438 return mergeOutcome{Notice: "flash.mergedDeleted", Arg: branch, Removed: true}
439 }
440 key := map[string]string{
441 "protected": "flash.mergedKeptProtected",
442 "default": "flash.mergedKeptDefault",
443 "forbidden": "flash.mergedKeptRights",
444 "missing": "flash.mergedKeptMissing",
445 "error": "flash.mergedKeptError",
446 }[skip]
447 if key == "" {
448 return mergeOutcome{Notice: "flash.merged", Skip: skip}
449 }
450 return mergeOutcome{Notice: key, Arg: branch, Skip: skip}
451}
452
453func (s *Server) opCloseMR(ctx context.Context, user store.User, repo store.Repo, number int64, reopen bool) error {
454 role, err := s.repoRole(ctx, user, repo)
455 if err != nil {
456 return err
457 }
458 mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
459 if err != nil {
460 return notFound(err)
461 }
462 if user.ID != mr.AuthorID && !role.CanManageSettings() {
463 return fail(403, i18n.E("err.forbidden"))
464 }
465 want, kind := "closed", "closed"
466 if reopen {
467 if mr.Status != "closed" {
468 return notFound(nil)
469 }
470 want, kind = "open", "reopened"
471 }
472 if err := s.Store.SetMergeRequestStatus(ctx, mr.ID, want); err != nil {
473 return fail(400, err)
474 }
475 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, kind, "")
476 return nil
477}