BlueGit

timfa bluegit

Files

bluegit / internal / server / pipeline_page.go

pipeline_page.go

pipeline_page.go 24.8 KiB Download Raw
1package server
2
3import (
4 "bytes"
5 "encoding/json"
6 "net/http"
7 "net/url"
8 "strconv"
9 "strings"
10 "time"
11
12 "gitlab.com/Timfa/bluegit/internal/access"
13 "gitlab.com/Timfa/bluegit/internal/ci"
14 "gitlab.com/Timfa/bluegit/internal/i18n"
15 "gitlab.com/Timfa/bluegit/internal/store"
16)
17
18// PipeRow is één rij in het pipeline-overzicht.
19type PipeRow struct {
20 ID int64
21 Status string
22 Label string
23 Duration string
24 When string
25 Title string
26 SHA string
27 Short string
28 Ref string
29 RefKind string
30 Source string
31 SourceLabel string
32 MRNumber int64
33 Actor string
34 ActorURL string
35 Avatar string
36 Initial string
37 Stages []StageView
38 Failed bool
39 Live bool
40}
41
42// StageView is één bolletje in de stages-kolom.
43type StageView struct {
44 Name string
45 Status string
46 Label string
47 Tip string
48 Jobs []JobLink
49}
50
51// JobLink is een job in een stage-popover of in de zijbalk.
52type JobLink struct {
53 ID int64
54 Name string
55 Status string
56 Label string
57 Queue string
58 Current bool
59 Stage string
60 // DNI: doNotInterrupt staat aan (badge met tooltip).
61 DNI bool
62}
63
64// CancelView is een annuleerknop met eigen bevestigingsvenster. Force staat
65// aan als er een lopende doNotInterrupt-job bij is; de vraag waarschuwt dan.
66type CancelView struct {
67 Label string
68 Ask string
69 OK string
70 Force bool
71}
72
73// cancelView bouwt de knop voor jobs die gestopt zouden worden; nil als er
74// niets te annuleren valt.
75func cancelView(tr func(string, ...any) string, label, ask string, jobs []store.Job) *CancelView {
76 open := false
77 for _, j := range jobs {
78 switch j.Status {
79 case "queued", "running", "manual", "created", "pending":
80 open = true
81 }
82 }
83 if !open {
84 return nil
85 }
86 v := &CancelView{Label: label, Ask: ask, OK: label}
87 if prot := store.ProtectedRunning(jobs); len(prot) > 0 {
88 v.Ask = tr("pipe.cancelDNI", jobNames(prot))
89 v.OK = tr("pipe.cancelDNIOk")
90 v.Force = true
91 }
92 return v
93}
94
95func (s *Server) cancelJobWeb(w http.ResponseWriter, r *http.Request) {
96 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
97 if !ok || !s.csrfOK(w, r) {
98 return
99 }
100 p, job, ok := s.jobFromRequest(w, r, repo)
101 if !ok {
102 return
103 }
104 back := repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(p.ID, 10) + "/jobs/" + strconv.FormatInt(job.ID, 10)
105 if _, err := s.opJobActionForce(r.Context(), u, repo, p.ID, job.ID, "cancel", forceParam(r)); err != nil {
106 s.redirect(w, r, back, "", i18n.Text(s.langOf(r), err))
107 return
108 }
109 s.redirect(w, r, back, s.tr(r, "flash.canceled"), "")
110}
111
112func (s *Server) cancelPipelineWeb(w http.ResponseWriter, r *http.Request) {
113 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
114 if !ok || !s.csrfOK(w, r) {
115 return
116 }
117 id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
118 if err != nil {
119 http.NotFound(w, r)
120 return
121 }
122 back := repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(id, 10)
123 if err := s.opCancelPipeline(r.Context(), u, repo, id, forceParam(r)); err != nil {
124 s.redirect(w, r, back, "", i18n.Text(s.langOf(r), err))
125 return
126 }
127 s.redirect(w, r, back, s.tr(r, "flash.canceled"), "")
128}
129
130// JobPage is de console van één job.
131type JobPage struct {
132 Expired string // uitleg als dit een verlopen handmatige job is
133 Job store.Job
134 Runner string
135 Pipe store.Pipeline
136 Name string
137 Status string
138 Label string
139 Actor string
140 ActorURL string
141 Avatar string
142 Initial string
143 When string
144 Duration string
145 Finished string
146 Queued string
147 Timeout string
148 Source string
149 Ref string
150 RefKind string
151 Short string
152 Title string
153 Stage string
154 PipeStatus string
155 PipeLabel string
156 Stages []string
157 Related []JobLink
158 Blocks []LogBlock
159 Running bool
160 LogBytes int
161 Cancel *CancelView
162 CanPlay bool
163 Environment string
164 EnvironmentURL string
165 EnvironmentLink string
166 Queue string
167}
168
169// LogBlock is een losse regel of een inklapbare sectie.
170type LogBlock struct {
171 Section bool
172 Title string
173 Duration string
174 Open bool
175 Lines []LogLine
176}
177
178// LogLine is één regel in de console.
179type LogLine struct {
180 N int
181 Time string
182 Text string
183 Spans []LogSpan
184}
185
186func (s *Server) fillPipelines(r *http.Request, v *View, repo store.Repo) {
187 lang := s.langOf(r)
188 list, _ := s.Store.ListPipelines(r.Context(), repo.ID)
189 q := strings.ToLower(strings.TrimSpace(r.URL.Query().Get("q")))
190 v.Query = r.URL.Query().Get("q")
191 ranks := s.queueRanks(r.Context())
192 users := map[string]store.User{}
193 for _, p := range list {
194 row := s.pipeRow(r, lang, repo, p, users, ranks)
195 if q != "" && !pipeMatches(row, q) {
196 continue
197 }
198 if rowLive(row) {
199 v.Live = true
200 }
201 v.PipeRows = append(v.PipeRows, row)
202 }
203 v.LiveURL = repoURL(repo) + "/-/pipelines"
204 if raw := strings.TrimSpace(r.URL.Query().Get("q")); raw != "" {
205 v.LiveURL += "?q=" + url.QueryEscape(raw)
206 }
207}
208
209func rowLive(row PipeRow) bool {
210 if row.Status == "pending" || row.Status == "running" {
211 return true
212 }
213 for _, st := range row.Stages {
214 if st.Status == "pending" || st.Status == "running" {
215 return true
216 }
217 for _, j := range st.Jobs {
218 if j.Status == "pending" || j.Status == "running" {
219 return true
220 }
221 }
222 }
223 return false
224}
225
226func (s *Server) pipeRow(r *http.Request, lang i18n.Lang, repo store.Repo, p store.Pipeline, users map[string]store.User, ranks map[int64]int) PipeRow {
227 jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
228 name, kind := ci.SplitRef(p.Ref)
229 status := displayStatus(s.pipeStatusFor(p), jobs)
230 actor, avatar, actorURL := s.actorOf(r, p.Actor, users)
231 initial := ""
232 if actor != "" {
233 initial = strings.ToUpper(actor[:1])
234 }
235 sourceLabel, mrNumber := s.pipelineSourceLabel(r, repo, p)
236 row := PipeRow{
237 ID: p.ID, Status: status, Label: s.tr(r, "pipe."+status),
238 Duration: pipelineClock(p), When: i18n.Ago(lang, p.CreatedAt.Unix()),
239 Title: p.CommitTitle, SHA: p.CommitSHA, Short: shortSHA(p.CommitSHA),
240 Ref: name, RefKind: kind, Source: p.Source, SourceLabel: sourceLabel, MRNumber: mrNumber,
241 Actor: actor, ActorURL: actorURL, Avatar: avatar, Initial: initial,
242 Stages: stageViews(jobs, ranks, func(key string, args ...any) string { return s.tr(r, key, args...) }),
243 Failed: jobsFailed(jobs),
244 }
245 row.Live = rowLive(row)
246 return row
247}
248
249func jobsFailed(jobs []store.Job) bool {
250 for _, j := range jobs {
251 if j.Status == "failed" {
252 return true
253 }
254 }
255 return false
256}
257
258// pipelineSourceLabel benoemt een pipeline die bij een merge request hoort,
259// ook wanneer de rij als push is gestart en daarna gekoppeld is.
260// Een gewone push zonder merge request krijgt geen extra label.
261func (s *Server) pipelineSourceLabel(r *http.Request, repo store.Repo, p store.Pipeline) (string, int64) {
262 if p.MRID != 0 {
263 var number int64
264 if mr, err := s.Store.MergeRequest(r.Context(), repo.ID, p.MRID); err == nil {
265 number = mr.Number
266 }
267 return s.tr(r, "pipe.src.merge_request_event"), number
268 }
269 if p.Source == "" || p.Source == "push" {
270 return "", 0
271 }
272 key := "pipe.src." + p.Source
273 label := s.tr(r, key)
274 if label == key {
275 label = p.Source
276 }
277 return label, 0
278}
279
280func (s *Server) pipelineSourceText(r *http.Request, repo store.Repo, p store.Pipeline) string {
281 label, number := s.pipelineSourceLabel(r, repo, p)
282 if label == "" {
283 return ""
284 }
285 if number == 0 {
286 return label
287 }
288 return label + " !" + strconv.FormatInt(number, 10)
289}
290
291func (s *Server) actorOf(r *http.Request, name string, cache map[string]store.User) (string, string, string) {
292 name = strings.TrimSpace(name)
293 if name == "" {
294 return "", "", ""
295 }
296 u, ok := cache[name]
297 if !ok {
298 found, err := s.Store.UserByUsername(r.Context(), name)
299 if err == nil {
300 u = found
301 }
302 cache[name] = u
303 }
304 if u.ID == 0 {
305 return name, "", ""
306 }
307 return u.Username, u.AvatarURL, "/users/" + u.Username
308}
309
310func pipeMatches(row PipeRow, q string) bool {
311 bits := []string{row.Label, row.Title, row.SHA, row.Short, row.Ref, row.Actor, row.SourceLabel, strconv.FormatInt(row.ID, 10), row.Status}
312 for _, st := range row.Stages {
313 bits = append(bits, st.Name)
314 for _, j := range st.Jobs {
315 bits = append(bits, j.Name)
316 }
317 }
318 for _, b := range bits {
319 if strings.Contains(strings.ToLower(b), q) {
320 return true
321 }
322 }
323 return false
324}
325
326func displayStatus(pipe string, jobs []store.Job) string {
327 switch pipe {
328 case "failed":
329 return "failed"
330 case "running":
331 return "running"
332 case "manual":
333 // Alleen handmatige jobs (en wat daarop wacht) zijn over.
334 return "blocked"
335 case "queued":
336 return "pending"
337 case "canceled":
338 if store.PipelineObsolete(jobs) {
339 return "obsolete"
340 }
341 return "canceled"
342 case "waiting_for_update":
343 return "waiting_for_update"
344 case "waiting_for_job":
345 return "waiting_for_job"
346 }
347 warn := false
348 for _, j := range jobs {
349 if (j.Status == "failed" || j.Status == "canceled") && j.AllowFailure && !j.Obsolete() {
350 warn = true
351 }
352 }
353 if warn {
354 return "warning"
355 }
356 if pipe == "success" {
357 return "passed"
358 }
359 if pipe == "" {
360 return "pending"
361 }
362 return pipe
363}
364
365func stageViews(jobs []store.Job, ranks map[int64]int, tr func(string, ...any) string) []StageView {
366 var order []string
367 by := map[string][]store.Job{}
368 for _, j := range jobs {
369 if _, ok := by[j.Stage]; !ok {
370 order = append(order, j.Stage)
371 }
372 by[j.Stage] = append(by[j.Stage], j)
373 }
374 var out []StageView
375 for _, name := range order {
376 group := by[name]
377 status := stageStatus(group)
378 label := tr("pipe." + status)
379 var links []JobLink
380 for _, j := range group {
381 st := jobDisplay(j)
382 links = append(links, JobLink{
383 ID: j.ID, Name: j.Name, Status: st, Label: tr("pipe." + st), Stage: j.Stage,
384 Queue: queueText(tr, ranks, j.ID),
385 })
386 }
387 stip := name + ": " + strings.ToLower(label)
388 if status == "obsolete" {
389 stip += " (" + tr("pipe.obsolete.tip") + ")"
390 }
391 out = append(out, StageView{Name: name, Status: status, Label: label, Tip: stip, Jobs: links})
392 }
393 return out
394}
395
396func stageStatus(jobs []store.Job) string {
397 pending, failed, warning, running, canceled := false, false, false, false, false
398 softCanceled, passed := false, false
399 seen := false
400 for _, j := range jobs {
401 seen = true
402 switch {
403 case j.Status == "running":
404 running = true
405 case j.Status == "failed" && !j.AllowFailure:
406 failed = true
407 case j.Status == "canceled" && !j.AllowFailure:
408 canceled = true
409 case j.Status == "canceled":
410 // allow_failure telt niet als fout, maar een geannuleerde job
411 // is nooit geslaagd: alleen-geannuleerd wordt grijs, gemengd
412 // met geslaagde jobs een waarschuwing.
413 softCanceled = true
414 case j.Status == "failed" && j.AllowFailure:
415 warning = true
416 case j.Status == "success":
417 passed = true
418 case j.Status == "queued" || j.Status == "manual":
419 pending = true
420 }
421 }
422 if !seen {
423 return "skipped"
424 }
425 if running {
426 return "running"
427 }
428 if failed {
429 return "failed"
430 }
431 if canceled || (softCanceled && !passed && !warning && !pending) {
432 if store.PipelineObsolete(jobs) || (!canceled && allCanceledObsolete(jobs)) {
433 return "obsolete"
434 }
435 return "canceled"
436 }
437 if warning || (softCanceled && passed) {
438 return "warning"
439 }
440 if pending {
441 return "pending"
442 }
443 allSkip := true
444 for _, j := range jobs {
445 if j.Status != "skipped" {
446 allSkip = false
447 }
448 }
449 if allSkip {
450 return "skipped"
451 }
452 return "passed"
453}
454
455func jobDisplay(j store.Job) string {
456 if j.Status == "failed" && j.AllowFailure {
457 return "warning"
458 }
459 if j.Obsolete() {
460 return "obsolete"
461 }
462 switch j.Status {
463 case "success":
464 return "passed"
465 case "queued":
466 return "pending"
467 case "":
468 return "pending"
469 default:
470 return j.Status
471 }
472}
473
474func pipelineClock(p store.Pipeline) string {
475 end := p.FinishedAt
476 if end.IsZero() {
477 end = time.Now()
478 }
479 start := p.StartedAt
480 if start.IsZero() {
481 start = p.CreatedAt
482 }
483 if start.IsZero() {
484 return ""
485 }
486 return formatClock(end.Sub(start))
487}
488
489func formatClock(d time.Duration) string {
490 if d < 0 {
491 d = 0
492 }
493 s := int(d.Seconds())
494 return pad2(s/3600) + ":" + pad2((s%3600)/60) + ":" + pad2(s%60)
495}
496
497func pad2(n int) string {
498 if n < 10 {
499 return "0" + strconv.Itoa(n)
500 }
501 return strconv.Itoa(n)
502}
503
504func shortSHA(sha string) string {
505 if len(sha) > 8 {
506 return sha[:8]
507 }
508 return sha
509}
510
511func (s *Server) showJob(w http.ResponseWriter, r *http.Request) {
512 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
513 if !ok {
514 return
515 }
516 p, job, ok := s.jobFromRequest(w, r, repo)
517 if !ok {
518 return
519 }
520 v := s.repoView(w, r, repo, role, job.Name)
521 v.Wide = true
522 v.Page = "pipelines"
523 v.Pipe = &p
524 v.JobPage = s.jobPage(r, repo, p, job, role)
525 s.render(w, "job", v)
526}
527
528func (s *Server) jobLog(w http.ResponseWriter, r *http.Request) {
529 _, repo, _, ok := s.guard(w, r, access.RoleReadonly)
530 if !ok {
531 return
532 }
533 _, job, ok := s.jobFromRequest(w, r, repo)
534 if !ok {
535 return
536 }
537 if r.URL.Query().Get("raw") == "1" {
538 w.Header().Set("Content-Type", "text/plain; charset=utf-8")
539 _, _ = w.Write([]byte(job.Log))
540 return
541 }
542 offset, _ := strconv.Atoi(r.URL.Query().Get("offset"))
543 if offset < 0 || offset > len(job.Log) {
544 offset = 0
545 }
546 queue := ""
547 if job.Status == "queued" {
548 tr := func(key string, args ...any) string { return s.tr(r, key, args...) }
549 queue = queueText(tr, s.queueRanks(r.Context()), job.ID)
550 }
551 w.Header().Set("Content-Type", "application/json")
552 w.Header().Set("Cache-Control", "no-store")
553 _ = json.NewEncoder(w).Encode(map[string]any{
554 "offset": len(job.Log),
555 "status": job.Status,
556 "text": job.Log[offset:],
557 "queue": queue,
558 })
559}
560
561func (s *Server) retryPipeline(w http.ResponseWriter, r *http.Request) {
562 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
563 if !ok || !s.csrfOK(w, r) {
564 return
565 }
566 id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
567 if err != nil {
568 http.NotFound(w, r)
569 return
570 }
571 back := safeRepoBack(repo, r.FormValue("back"))
572 if back == "" {
573 back = repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(id, 10)
574 }
575 newID, err := s.opRetryPipeline(r.Context(), u, repo, id, r.FormValue("mode"))
576 if !s.uiOK(w, r, back, err) {
577 return
578 }
579 dest := back
580 if r.FormValue("mode") == "all" {
581 dest = repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(newID, 10)
582 }
583 s.redirect(w, r, dest, s.tr(r, "flash.pipeRetry"), "")
584}
585
586func safeRepoBack(repo store.Repo, back string) string {
587 back = strings.TrimSpace(back)
588 prefix := "/" + repo.FullPath()
589 if back != prefix && !strings.HasPrefix(back, prefix+"/") {
590 return ""
591 }
592 if strings.Contains(back, "..") || strings.Contains(back, "\\") || strings.Contains(back, "\n") || strings.Contains(back, "?") {
593 return ""
594 }
595 return back
596}
597
598func (s *Server) playJob(w http.ResponseWriter, r *http.Request) {
599 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
600 if !ok || !s.csrfOK(w, r) {
601 return
602 }
603 p, job, ok := s.jobFromRequest(w, r, repo)
604 if !ok {
605 return
606 }
607 _, _ = s.opJobAction(r.Context(), u, repo, p.ID, job.ID, "play")
608 s.redirect(w, r, repoURL(repo)+"/-/pipelines/"+strconv.FormatInt(p.ID, 10)+"/jobs/"+strconv.FormatInt(job.ID, 10), s.tr(r, "flash.pipeline"), "")
609}
610
611func (s *Server) jobFromRequest(w http.ResponseWriter, r *http.Request, repo store.Repo) (store.Pipeline, store.Job, bool) {
612 pid, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
613 if err != nil {
614 http.NotFound(w, r)
615 return store.Pipeline{}, store.Job{}, false
616 }
617 jid, err := strconv.ParseInt(r.PathValue("job"), 10, 64)
618 if err != nil {
619 http.NotFound(w, r)
620 return store.Pipeline{}, store.Job{}, false
621 }
622 p, err := s.Store.PipelineByID(r.Context(), repo.ID, pid)
623 if err != nil {
624 http.NotFound(w, r)
625 return store.Pipeline{}, store.Job{}, false
626 }
627 jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
628 for _, j := range jobs {
629 if j.ID == jid {
630 return p, j, true
631 }
632 }
633 http.NotFound(w, r)
634 return store.Pipeline{}, store.Job{}, false
635}
636
637func (s *Server) jobPage(r *http.Request, repo store.Repo, p store.Pipeline, job store.Job, role access.Role) *JobPage {
638 lang := s.langOf(r)
639 jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
640 users := map[string]store.User{}
641 actor, avatar, actorURL := s.actorOf(r, p.Actor, users)
642 initial := ""
643 if actor != "" {
644 initial = strings.ToUpper(actor[:1])
645 }
646 name, kind := ci.SplitRef(p.Ref)
647 status := jobDisplay(job)
648 pipeStatus := displayStatus(s.pipeStatusFor(p), jobs)
649 end := job.FinishedAt
650 if end.IsZero() && (job.Status == "success" || job.Status == "failed" || job.Status == "skipped") {
651 end = p.FinishedAt
652 }
653 start := job.StartedAt
654 dur := ""
655 if !start.IsZero() {
656 until := end
657 if until.IsZero() {
658 until = time.Now()
659 }
660 dur = formatClock(until.Sub(start))
661 }
662 queued := ""
663 if !start.IsZero() && !p.CreatedAt.IsZero() {
664 queued = formatClock(start.Sub(p.CreatedAt))
665 }
666 timeout := formatClock(job.Timeout)
667 if job.Timeout == 0 && s.Cfg.CI.TimeoutSec > 0 {
668 timeout = formatClock(time.Duration(s.Cfg.CI.TimeoutSec) * time.Second)
669 }
670 finished := ""
671 if !end.IsZero() {
672 finished = i18n.Ago(lang, end.Unix())
673 }
674 ranks := s.queueRanks(r.Context())
675 tr := func(key string, args ...any) string { return s.tr(r, key, args...) }
676 var stages []string
677 seen := map[string]bool{}
678 var related []JobLink
679 for _, j := range jobs {
680 if !seen[j.Stage] {
681 seen[j.Stage] = true
682 stages = append(stages, j.Stage)
683 }
684 st := jobDisplay(j)
685 related = append(related, JobLink{
686 ID: j.ID, Name: j.Name, Status: st, Label: tr("pipe." + st), Current: j.ID == job.ID, Stage: j.Stage,
687 Queue: queueText(tr, ranks, j.ID),
688 })
689 }
690 sourceKey := "pipe.src." + p.Source
691 source := s.tr(r, sourceKey)
692 if source == sourceKey {
693 source = p.Source
694 }
695 return &JobPage{
696 Runner: s.Store.JobRun(r.Context(), job.ID).RunnerName,
697 Job: job, Pipe: p, Name: job.Name, Status: status, Label: s.tr(r, "pipe."+status),
698 Actor: actor, ActorURL: actorURL, Avatar: avatar, Initial: initial, When: i18n.Ago(lang, p.CreatedAt.Unix()),
699 Duration: dur, Finished: finished, Queued: queued, Timeout: timeout, Source: source,
700 Ref: name, RefKind: kind, Short: shortSHA(p.CommitSHA), Title: p.CommitTitle, Stage: job.Stage,
701 PipeStatus: pipeStatus, PipeLabel: s.tr(r, "pipe."+pipeStatus),
702 Stages: stages, Related: related, Blocks: parseLog(job.Log), Running: job.Status == "running" || job.Status == "queued",
703 LogBytes: len(job.Log), CanPlay: job.Status == "manual" && role.CanWriteCode(),
704 Expired: expiredText(tr, job),
705 Cancel: jobCancel(tr, role.CanWriteCode(), job),
706 Queue: queueText(tr, ranks, job.ID),
707 Environment: job.Environment, EnvironmentURL: job.EnvironmentURL, EnvironmentLink: safeEnvironmentURL(job.EnvironmentURL),
708 }
709}
710
711func safeEnvironmentURL(raw string) string {
712 if strings.Contains(raw, "$") {
713 return ""
714 }
715 if strings.HasPrefix(raw, "https://") || strings.HasPrefix(raw, "http://") {
716 return raw
717 }
718 return ""
719}
720
721func parseLog(raw string) []LogBlock {
722 var blocks []LogBlock
723 var cur *LogBlock
724 n := 0
725 flush := func() {
726 if cur == nil {
727 return
728 }
729 blocks = append(blocks, *cur)
730 cur = nil
731 }
732 for _, row := range strings.Split(raw, "\n") {
733 if row == "" {
734 continue
735 }
736 ts, text := row, row
737 if i := strings.IndexByte(row, '\t'); i >= 0 {
738 ts, text = row[:i], row[i+1:]
739 }
740 if strings.HasPrefix(text, "section_start:") {
741 flush()
742 body := strings.TrimPrefix(text, "section_start:")
743 title := body
744 if i := strings.IndexByte(body, ':'); i >= 0 {
745 title = body[i+1:]
746 }
747 cur = &LogBlock{Section: true, Title: title, Open: true}
748 continue
749 }
750 if strings.HasPrefix(text, "section_end:") {
751 dur := ""
752 body := strings.TrimPrefix(text, "section_end:")
753 if i := strings.IndexByte(body, '\t'); i >= 0 {
754 dur = body[i+1:]
755 }
756 if cur != nil {
757 cur.Duration = dur
758 flush()
759 }
760 continue
761 }
762 n++
763 line := LogLine{N: n, Time: clockOf(ts), Text: text, Spans: ansiSpans(text)}
764 if cur != nil {
765 cur.Lines = append(cur.Lines, line)
766 continue
767 }
768 blocks = append(blocks, LogBlock{Lines: []LogLine{line}})
769 }
770 if cur != nil {
771 flush()
772 }
773 return blocks
774}
775
776func wantsJSON(r *http.Request) bool {
777 return strings.Contains(r.Header.Get("Accept"), "application/json")
778}
779
780func jobsLive(pipe string, jobs []store.Job) bool {
781 if pipe == "queued" || pipe == "running" {
782 return true
783 }
784 for _, j := range jobs {
785 if j.Status == "queued" || j.Status == "running" {
786 return true
787 }
788 }
789 return false
790}
791
792func linksFor(jobs []store.Job, ranks map[int64]int, tr func(string, ...any) string) []JobLink {
793 out := make([]JobLink, 0, len(jobs))
794 for _, j := range jobs {
795 st := jobDisplay(j)
796 out = append(out, JobLink{
797 ID: j.ID, Name: j.Name, Status: st, Label: tr("pipe." + st), Stage: j.Stage,
798 Queue: queueText(tr, ranks, j.ID), DNI: j.DoNotInterrupt,
799 })
800 }
801 return out
802}
803
804func (s *Server) partial(name string, v View) string {
805 var buf bytes.Buffer
806 tmpl := s.byLang[v.Lang]
807 if tmpl == nil {
808 tmpl = s.tmpl
809 }
810 if tmpl == nil {
811 return ""
812 }
813 if err := tmpl.ExecuteTemplate(&buf, name, v); err != nil && s.Log != nil {
814 s.Log.Error("sjabloon", "name", name, "err", err)
815 }
816 return buf.String()
817}
818
819func (s *Server) writePipeList(w http.ResponseWriter, v View) {
820 type job struct {
821 ID int64 `json:"id"`
822 Name string `json:"name"`
823 Status string `json:"status"`
824 Label string `json:"label"`
825 Queue string `json:"queue"`
826 }
827 type stage struct {
828 Name string `json:"name"`
829 Status string `json:"status"`
830 Tip string `json:"tip"`
831 Jobs []job `json:"jobs"`
832 }
833 type row struct {
834 ID int64 `json:"id"`
835 Status string `json:"status"`
836 Label string `json:"label"`
837 Duration string `json:"duration"`
838 When string `json:"when"`
839 Stages []stage `json:"stages"`
840 HTML string `json:"html"`
841 }
842 rows := make([]row, 0, len(v.PipeRows))
843 for _, pr := range v.PipeRows {
844 one := v
845 one.PipeRows = []PipeRow{pr}
846 item := row{
847 ID: pr.ID, Status: pr.Status, Label: pr.Label, Duration: pr.Duration, When: pr.When,
848 HTML: s.partial("pipe-rows", one),
849 }
850 for _, st := range pr.Stages {
851 jobs := make([]job, 0, len(st.Jobs))
852 for _, j := range st.Jobs {
853 jobs = append(jobs, job{ID: j.ID, Name: j.Name, Status: j.Status, Label: j.Label, Queue: j.Queue})
854 }
855 item.Stages = append(item.Stages, stage{Name: st.Name, Status: st.Status, Tip: st.Tip, Jobs: jobs})
856 }
857 rows = append(rows, item)
858 }
859 w.Header().Set("Content-Type", "application/json")
860 w.Header().Set("Cache-Control", "no-store")
861 _ = json.NewEncoder(w).Encode(map[string]any{"active": v.Live, "rows": rows})
862}
863
864func (s *Server) writePipeDetail(w http.ResponseWriter, v View) {
865 type job struct {
866 ID int64 `json:"id"`
867 Name string `json:"name"`
868 Status string `json:"status"`
869 Label string `json:"label"`
870 Stage string `json:"stage"`
871 Queue string `json:"queue"`
872 }
873 type stageJob struct {
874 ID int64 `json:"id"`
875 Name string `json:"name"`
876 Status string `json:"status"`
877 Label string `json:"label"`
878 Queue string `json:"queue"`
879 }
880 type stage struct {
881 Name string `json:"name"`
882 Status string `json:"status"`
883 Tip string `json:"tip"`
884 Jobs []stageJob `json:"jobs"`
885 }
886 jobs := make([]job, 0, len(v.PipeJobs))
887 for _, j := range v.PipeJobs {
888 jobs = append(jobs, job{ID: j.ID, Name: j.Name, Status: j.Status, Label: j.Label, Stage: j.Stage, Queue: j.Queue})
889 }
890 stages := make([]stage, 0, len(v.PipeStages))
891 for _, st := range v.PipeStages {
892 item := stage{Name: st.Name, Status: st.Status, Tip: st.Tip, Jobs: make([]stageJob, 0, len(st.Jobs))}
893 for _, j := range st.Jobs {
894 item.Jobs = append(item.Jobs, stageJob{ID: j.ID, Name: j.Name, Status: j.Status, Label: j.Label, Queue: j.Queue})
895 }
896 stages = append(stages, item)
897 }
898 dur := ""
899 html := ""
900 if v.Pipe != nil {
901 dur = pipelineClock(*v.Pipe)
902 if v.Repo != nil {
903 head := CommitRow{PipeID: v.Pipe.ID, PipeStages: v.PipeStages}
904 html = s.partial("stage-dots", View{Lang: v.Lang, Repo: v.Repo, Head: &head})
905 }
906 }
907 w.Header().Set("Content-Type", "application/json")
908 w.Header().Set("Cache-Control", "no-store")
909 _ = json.NewEncoder(w).Encode(map[string]any{
910 "active": v.Live, "status": v.PipeStatus, "label": v.PipeLabel,
911 "duration": dur, "jobs": jobs, "stages": stages, "html": html,
912 })
913}
914
915func clockOf(ts string) string {
916 if t, err := time.Parse(time.RFC3339, ts); err == nil {
917 return t.UTC().Format("15:04:05")
918 }
919 if len(ts) >= 19 && strings.Contains(ts, "T") {
920 return ts[11:19]
921 }
922 return ""
923}
924
925func jobCancel(tr func(string, ...any) string, can bool, job store.Job) *CancelView {
926 if !can {
927 return nil
928 }
929 return cancelView(tr, tr("pipe.cancelJob"), tr("pipe.cancelAsk"), []store.Job{job})
930}
931
932// allCanceledObsolete: elke geannuleerde job (ook allow_failure) is
933// automatisch door een nieuwere pipeline gestopt.
934func allCanceledObsolete(jobs []store.Job) bool {
935 seen := false
936 for _, j := range jobs {
937 if j.Status != "canceled" {
938 continue
939 }
940 if !j.Obsolete() {
941 return false
942 }
943 seen = true
944 }
945 return seen
946}
947
948// expiredText legt uit waarom een verlopen handmatige job niet meer start.
949func expiredText(tr func(string, ...any) string, j store.Job) string {
950 if !expiredManualJob(j) {
951 return ""
952 }
953 if j.Reason == store.ReasonStaleManual {
954 return tr("stale.expired.age")
955 }
956 return tr("stale.expired.superseded")
957}