BlueGit

timfa bluegit

Files

bluegit / internal / server / events.go

events.go

events.go 13.7 KiB Download Raw
1package server
2
3import (
4 "bytes"
5 "context"
6 "io"
7 "net/http"
8 "net/url"
9 "os/exec"
10 "strings"
11 "time"
12
13 "gitlab.com/Timfa/bluegit/internal/access"
14 "gitlab.com/Timfa/bluegit/internal/ci"
15 "gitlab.com/Timfa/bluegit/internal/gitrepo"
16 "gitlab.com/Timfa/bluegit/internal/i18n"
17 "gitlab.com/Timfa/bluegit/internal/ssrf"
18 "gitlab.com/Timfa/bluegit/internal/store"
19 "gitlab.com/Timfa/bluegit/internal/webhook"
20)
21
22// postReceive is de enige route voor een ref-wijziging die BlueGit zelf maakt:
23// de Pipeline Editor, suggesties, een merge en een tag. mutate schrijft de refs.
24// Daarna geldt hetzelfde als na een git push: pipeline, webhook en activity.
25func (s *Server) postReceive(ctx context.Context, repo store.Repo, user store.User, dir string, mutate func() error) error {
26 before, err := gitrepo.Refs(ctx, s.Git, dir)
27 if err != nil {
28 before = map[string]string{}
29 }
30 if err := mutate(); err != nil {
31 return err
32 }
33 after, err := gitrepo.Refs(ctx, s.Git, dir)
34 if err != nil {
35 if s.Log != nil {
36 s.Log.Error("post-receive", "err", err)
37 }
38 return nil
39 }
40 s.AfterPush(repo, user, before, after)
41 return nil
42}
43
44// AfterPush behandelt elke nieuwe ref zoals een git push.
45// git http, SSH en postReceive zijn de enige aanroepers.
46func (s *Server) AfterPush(repo store.Repo, user store.User, before, after map[string]string) {
47 s.refsChanged(repo)
48 s.BackupChanged()
49 for ref, sha := range after {
50 if b, ok := strings.CutPrefix(ref, "refs/heads/"); ok && before[ref] != sha && !isZero(sha) && s.Store != nil {
51 s.refreshForkMRs(repo, user, b)
52 }
53 }
54 if s.Store != nil && refsMoved(before, after) {
55 _ = s.Store.TouchPushed(context.Background(), repo.ID, time.Now())
56 }
57 if after == nil {
58 return
59 }
60 actor := user.Username
61 var drop []mergedSource
62 for ref, sha := range after {
63 if before[ref] == sha || isZero(sha) {
64 continue
65 }
66 commit := s.peeled(repo, sha)
67 if strings.HasPrefix(ref, "refs/tags/") {
68 s.startPipeline(context.Background(), repo, commit, ref, actor, "push", before[ref], nil)
69 s.recordContribution(user.ID, repo.ID, "tag", ref, time.Now().UTC())
70 s.pushHook(repo, actor, ref, before[ref], sha)
71 continue
72 }
73 branch, ok := gitrepo.BranchOfRef(ref)
74 if !ok {
75 continue
76 }
77 s.recordPushContributions(repo, user, map[string]string{ref: before[ref]}, map[string]string{ref: sha})
78 s.startPipeline(context.Background(), repo, commit, ref, actor, "push", before[ref], nil)
79 s.startMergeRequestPipelines(context.Background(), repo, commit, branch, actor, before[ref])
80 s.recordMRPushes(repo, user, branch, before[ref], sha)
81 drop = append(drop, s.markContainedMRs(repo, user, branch, sha)...)
82 s.rerunMergeRequestsOnTarget(context.Background(), repo, branch, actor)
83 s.pushHook(repo, actor, ref, before[ref], sha)
84 if branch == repo.DefaultBranch {
85 s.closeIssuesOnPush(repo, user, before[ref], sha)
86 }
87 }
88 // Een ref die in before staat en in after weg is, is verwijderd.
89 // Daar hoort een push-webhook bij, zonder pipeline of activity.
90 for ref, old := range before {
91 if sha, ok := after[ref]; ok && !isZero(sha) {
92 continue
93 }
94 if isZero(old) {
95 continue
96 }
97 s.pushHook(repo, actor, ref, old, strings.Repeat("0", 40))
98 }
99 // Pas na de push zelf de bronbranch weghalen. Doen we dat midden in de
100 // lus, dan kan dezelfde push de tak nog als nieuwe ref behandelen.
101 s.dropMergedSources(repo, drop)
102}
103
104func (s *Server) pushHook(repo store.Repo, actor, ref, before, after string) {
105 if isZero(before) {
106 before = strings.Repeat("0", 40)
107 }
108 commit := after
109 if isZero(commit) {
110 commit = ""
111 }
112 name := refName(ref)
113 s.Dispatch(repo.ID, webhook.Event{
114 Type: webhook.EventPush,
115 Project: repo.FullPath(),
116 Branch: name,
117 Ref: ref,
118 Before: before,
119 After: after,
120 Commit: commit,
121 Summary: i18n.T(i18n.EN, "hook.push", actor, name, repo.FullPath()),
122 URL: strings.TrimRight(s.Cfg.BaseURL, "/") + "/" + repo.FullPath(),
123 Actor: actor,
124 })
125}
126
127func (s *Server) peeled(repo store.Repo, sha string) string {
128 if s.StoragePath() == "" || sha == "" {
129 return sha
130 }
131 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
132 if commit := gitOne(context.Background(), s.Git, dir, "rev-parse", "--verify", sha+"^{commit}"); commit != "" {
133 return commit
134 }
135 return sha
136}
137
138func isZero(sha string) bool {
139 return strings.Trim(sha, "0") == ""
140}
141
142func (s *Server) startPipeline(ctx context.Context, repo store.Repo, sha, ref, actor, source, before string, mr *ci.MRInfo) int64 {
143 if !s.Cfg.CI.Enabled || s.StoragePath() == "" {
144 return 0
145 }
146 if repo.CIPaused {
147 if s.Log != nil {
148 s.Log.Info("ci paused", "repo", repo.FullPath())
149 }
150 return 0
151 }
152 title, jobs, broken := s.planPipeline(ctx, repo, sha, ref, source, before, mr)
153 mrID, target := int64(0), ""
154 if mr != nil {
155 mrID, target = mr.ID, mr.TargetSHA
156 }
157 if broken != nil {
158 id, created, err := s.Store.RecordConfigFailure(ctx, repo.ID, sha, ref, source, broken.Error(), mrID, target)
159 if err != nil && s.Log != nil {
160 s.Log.Error("pipeline", "err", err)
161 }
162 if created && id != 0 {
163 s.cancelOlder(ctx, repo.ID, ref, id)
164 }
165 return id
166 }
167 if len(jobs) == 0 {
168 return 0
169 }
170 id, created, err := s.Store.OpenPipeline(ctx, repo.ID, sha, ref, source, actor, title, target, mrID, jobs)
171 if err != nil {
172 if s.Log != nil {
173 s.Log.Error("pipeline", "err", err)
174 }
175 return 0
176 }
177 if created {
178 s.cancelOlder(ctx, repo.ID, ref, id)
179 s.expireSuperseded(ctx, repo.ID, ref, id)
180 }
181 return id
182}
183
184func (s *Server) cancelOlder(ctx context.Context, repoID int64, ref string, keep int64) {
185 running, pipes, err := s.Store.CancelInterruptible(ctx, repoID, ref, keep)
186 if err != nil {
187 if s.Log != nil {
188 s.Log.Error("interruptible", "err", err)
189 }
190 return
191 }
192 if s.Runner != nil {
193 s.Runner.Interrupt(running)
194 }
195 for _, id := range pipes {
196 if _, err := s.Store.RefreshPipelineStatus(ctx, id); err != nil && s.Log != nil {
197 s.Log.Error("pipelinestatus", "err", err)
198 }
199 }
200}
201
202func gitOne(ctx context.Context, gitBin, dir string, args ...string) string {
203 out, err := exec.CommandContext(ctx, gitBin, append([]string{"-C", dir}, args...)...).Output()
204 if err != nil {
205 return ""
206 }
207 return strings.TrimSpace(string(out))
208}
209
210func gitLines(ctx context.Context, gitBin, dir string, args ...string) []string {
211 out := gitOne(ctx, gitBin, dir, args...)
212 if out == "" {
213 return []string{}
214 }
215 return strings.Split(out, "\n")
216}
217
218func changedFiles(ctx context.Context, gitBin, dir, sha, before string, all []string) []string {
219 if before == "" || strings.Trim(before, "0") == "" {
220 parent := gitOne(ctx, gitBin, dir, "rev-parse", "--verify", sha+"^")
221 if parent == "" {
222 return all
223 }
224 before = parent
225 }
226 out, err := exec.CommandContext(ctx, gitBin, "-C", dir, "diff", "--name-only", before, sha).Output()
227 if err != nil {
228 return nil
229 }
230 text := strings.TrimSpace(string(out))
231 if text == "" {
232 return []string{}
233 }
234 return strings.Split(text, "\n")
235}
236
237func (s *Server) Dispatch(repoID int64, ev webhook.Event) {
238 s.BackupChanged()
239 ctx := context.Background()
240 repo, err := s.Store.RepoByID(ctx, repoID)
241 if err != nil {
242 return
243 }
244 if ev.Project == "" {
245 ev.Project = repo.FullPath()
246 }
247 if !strings.HasPrefix(ev.URL, "http") {
248 ev.URL = strings.TrimRight(s.Cfg.BaseURL, "/") + ev.URL
249 }
250 if repo.OwnerKind == "group" {
251 if g, err := s.Store.GroupByID(ctx, repo.OwnerID); err == nil {
252 ev.Group = g.Path
253 }
254 }
255 ev = s.enrichEvent(ctx, repo, ev)
256 patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
257 protected := access.BranchProtected(patterns, ev.Branch)
258 s.deliver(ctx, "repo", repo.ID, ev, protected, repo)
259 if repo.OwnerKind == "group" {
260 s.deliver(ctx, "group", repo.OwnerID, ev, protected, repo)
261 }
262 if ev.Type == webhook.EventPipelineFailure {
263 s.queueFailureMail(repo, ev)
264 }
265}
266
267func (s *Server) deliver(ctx context.Context, kind string, scopeID int64, ev webhook.Event, refProtected bool, repo store.Repo) {
268 hooks, err := s.Store.ListWebhooks(ctx, kind, scopeID)
269 if err != nil {
270 return
271 }
272 secrets, err := s.hookSecrets(ctx, kind, scopeID, refProtected, repo)
273 if err != nil {
274 s.Log.Error("geheimen voor webhook", "err", err)
275 return
276 }
277 client := ssrf.NewClient(10 * time.Second)
278 for _, h := range hooks {
279 if !h.Active {
280 continue
281 }
282 ok, err := webhook.Allows(webhook.Hook{Preset: h.Preset, Events: h.Events, BranchFilter: h.BranchFilter}, ev)
283 if err != nil {
284 _ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, err.Error())
285 continue
286 }
287 if !ok {
288 continue
289 }
290 rawURL, err := webhook.Expand(h.URLTemplate, ev, secrets)
291 if err != nil {
292 _ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, err.Error())
293 continue
294 }
295 target, err := urlParse(rawURL)
296 if err != nil {
297 _ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, err.Error())
298 continue
299 }
300 if err := ssrf.ValidateURL(target); err != nil {
301 _ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, err.Error())
302 continue
303 }
304 headers, err := webhook.RenderHeaders(h.Preset, h.Headers, ev, secrets)
305 if err != nil {
306 _ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, err.Error())
307 continue
308 }
309 body, err := webhook.RenderBody(h.BodyTemplate, ev, secrets)
310 if err != nil {
311 _ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, err.Error())
312 continue
313 }
314 if s.hookSink != nil {
315 s.hookSink(body)
316 _ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, "")
317 continue
318 }
319 method := h.Method
320 if method == "" {
321 method = http.MethodPost
322 }
323 req, err := http.NewRequestWithContext(ctx, method, rawURL, bytes.NewReader(body))
324 if err != nil {
325 _ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, err.Error())
326 continue
327 }
328 for k, v := range headers {
329 if strings.ContainsAny(k, "\r\n") || strings.ContainsAny(v, "\r\n") {
330 continue
331 }
332 req.Header.Set(k, v)
333 }
334 res, err := client.Do(req)
335 if err != nil {
336 _ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, err.Error())
337 continue
338 }
339 _, _ = io.Copy(io.Discard, io.LimitReader(res.Body, 1<<20))
340 res.Body.Close()
341 _ = s.Store.AddDelivery(ctx, h.ID, ev.Type, res.StatusCode, "")
342 }
343}
344
345func urlParse(raw string) (*url.URL, error) {
346 u, err := url.Parse(raw)
347 if err != nil {
348 return nil, i18n.E("err.whURL")
349 }
350 return u, nil
351}
352
353// markContainedMRs zet open merge requests op merged wanneer de bron-head
354// al in de zojuist gepushte doelbranch zit. Dat is dezelfde regel als GitLab
355// na een merge die buiten de knop om is gepusht.
356func (s *Server) markContainedMRs(repo store.Repo, user store.User, branch, sha string) []mergedSource {
357 if s.Store == nil || s.StoragePath() == "" || branch == "" || isZero(sha) {
358 return nil
359 }
360 ctx := context.Background()
361 mrs, err := s.Store.OpenMergeRequestsByTarget(ctx, repo.ID, branch)
362 if err != nil {
363 return nil
364 }
365 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
366 var drop []mergedSource
367 for _, mr := range mrs {
368 if item, ok := s.markIfContained(ctx, repo, user, dir, mr, sha, true); ok {
369 drop = append(drop, item)
370 }
371 }
372 return drop
373}
374
375// absorbMergedMRs doet dezelfde controle bij het openen van een pagina,
376// zodat een merge die al gepusht was voordat deze code draaide alsnog merged wordt.
377func (s *Server) absorbMergedMRs(ctx context.Context, repo store.Repo) {
378 if s.Store == nil || s.StoragePath() == "" {
379 return
380 }
381 mrs, err := s.Store.ListMergeRequests(ctx, repo.ID)
382 if err != nil {
383 return
384 }
385 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
386 for _, mr := range mrs {
387 if mr.Status != "open" {
388 continue
389 }
390 s.markIfContained(ctx, repo, store.User{}, dir, mr, "", false)
391 }
392}
393
394func (s *Server) markIfContained(ctx context.Context, repo store.Repo, user store.User, dir string, mr store.MergeRequest, targetSHA string, deferDrop bool) (mergedSource, bool) {
395 if targetSHA == "" {
396 targetSHA = gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+mr.TargetBranch)
397 }
398 src := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+mr.SourceBranch)
399 if src == "" || targetSHA == "" || !gitrepo.IsAncestor(ctx, s.Git, dir, src, targetSHA) {
400 return mergedSource{}, false
401 }
402 if user.ID == 0 {
403 if pushers, err := s.Store.PushersBySHA(ctx, repo.ID, []string{targetSHA}); err == nil {
404 if p, ok := pushers[targetSHA]; ok && p.UserID != 0 {
405 user = store.User{ID: p.UserID, Username: p.Username}
406 }
407 }
408 }
409 if err := s.Store.SetMergeRequestStatus(ctx, mr.ID, "merged"); err != nil {
410 return mergedSource{}, false
411 }
412 body := ""
413 if shaLike(targetSHA) {
414 body = targetSHA
415 }
416 _ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "merged", body)
417 mr.Status = "merged"
418 s.mrHook(repo, mr, user.Username, "merged", "")
419 s.closeMergedMR(ctx, repo, user, mr)
420 plan, ok := s.mergedSourcePlan(ctx, repo, user, mr)
421 if !ok {
422 return mergedSource{}, false
423 }
424 if _, merging := s.mergingMR.Load(mr.ID); merging {
425 return mergedSource{}, false
426 }
427 if deferDrop {
428 return plan, true
429 }
430 s.deleteMergedSource(ctx, plan.user, plan.role, repo, plan.name)
431 return mergedSource{}, false
432}
433
434func (s *Server) closeMergedMR(ctx context.Context, repo store.Repo, user store.User, mr store.MergeRequest) {
435 texts := []string{mr.Description}
436 if s.StoragePath() != "" {
437 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
438 commits, err := gitrepo.RangeLog(ctx, s.Git, dir, mr.TargetBranch, mr.SourceBranch)
439 if err == nil {
440 for i, c := range commits {
441 if i >= 50 {
442 break
443 }
444 texts = append(texts, commitText(c))
445 }
446 }
447 }
448 s.closeIssueNumbers(ctx, repo, user, closingNumbers(texts...))
449}
450
451func gitSHA(r *http.Request, gitBin, dir, rev string) (string, error) {
452 out, err := exec.CommandContext(r.Context(), gitBin, "-C", dir, "rev-parse", "--verify", rev+"^{commit}").Output()
453 if err != nil {
454 return "", err
455 }
456 return strings.TrimSpace(string(out)), nil
457}
458
459// refsMoved meldt of een push werkelijk een ref veranderde.
460func refsMoved(before, after map[string]string) bool {
461 for ref, sha := range after {
462 if before[ref] != sha {
463 return true
464 }
465 }
466 for ref := range before {
467 if _, ok := after[ref]; !ok && after != nil {
468 return true
469 }
470 }
471 return false
472}