BlueGit

timfa bluegit

Files

bluegit / internal / server / pipeline_page.go

pipeline_page.go

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