BlueGit

timfa bluegit

Files

bluegit / internal / server / pipeline_page.go

pipeline_page.go

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