BlueGit

timfa bluegit

Files

bluegit / internal / server / pipeline_page.go

pipeline_page.go

pipeline_page.go 23.6 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.AllowFailure {
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 seen := false
398 for _, j := range jobs {
399 seen = true
400 switch {
401 case j.Status == "running":
402 running = true
403 case j.Status == "failed" && !j.AllowFailure:
404 failed = true
405 case j.Status == "canceled" && !j.AllowFailure:
406 canceled = true
407 case j.Status == "failed" && j.AllowFailure:
408 warning = true
409 case j.Status == "queued" || j.Status == "manual":
410 pending = true
411 }
412 }
413 if !seen {
414 return "skipped"
415 }
416 if running {
417 return "running"
418 }
419 if failed {
420 return "failed"
421 }
422 if canceled {
423 if store.PipelineObsolete(jobs) {
424 return "obsolete"
425 }
426 return "canceled"
427 }
428 if warning {
429 return "warning"
430 }
431 if pending {
432 return "pending"
433 }
434 allSkip := true
435 for _, j := range jobs {
436 if j.Status != "skipped" {
437 allSkip = false
438 }
439 }
440 if allSkip {
441 return "skipped"
442 }
443 return "passed"
444}
445
446func jobDisplay(j store.Job) string {
447 if j.Status == "failed" && j.AllowFailure {
448 return "warning"
449 }
450 if j.Obsolete() {
451 return "obsolete"
452 }
453 switch j.Status {
454 case "success":
455 return "passed"
456 case "queued":
457 return "pending"
458 case "":
459 return "pending"
460 default:
461 return j.Status
462 }
463}
464
465func pipelineClock(p store.Pipeline) string {
466 end := p.FinishedAt
467 if end.IsZero() {
468 end = time.Now()
469 }
470 start := p.StartedAt
471 if start.IsZero() {
472 start = p.CreatedAt
473 }
474 if start.IsZero() {
475 return ""
476 }
477 return formatClock(end.Sub(start))
478}
479
480func formatClock(d time.Duration) string {
481 if d < 0 {
482 d = 0
483 }
484 s := int(d.Seconds())
485 return pad2(s/3600) + ":" + pad2((s%3600)/60) + ":" + pad2(s%60)
486}
487
488func pad2(n int) string {
489 if n < 10 {
490 return "0" + strconv.Itoa(n)
491 }
492 return strconv.Itoa(n)
493}
494
495func shortSHA(sha string) string {
496 if len(sha) > 8 {
497 return sha[:8]
498 }
499 return sha
500}
501
502func (s *Server) showJob(w http.ResponseWriter, r *http.Request) {
503 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
504 if !ok {
505 return
506 }
507 p, job, ok := s.jobFromRequest(w, r, repo)
508 if !ok {
509 return
510 }
511 v := s.repoView(w, r, repo, role, job.Name)
512 v.Wide = true
513 v.Page = "pipelines"
514 v.Pipe = &p
515 v.JobPage = s.jobPage(r, repo, p, job, role)
516 s.render(w, "job", v)
517}
518
519func (s *Server) jobLog(w http.ResponseWriter, r *http.Request) {
520 _, repo, _, ok := s.guard(w, r, access.RoleReadonly)
521 if !ok {
522 return
523 }
524 _, job, ok := s.jobFromRequest(w, r, repo)
525 if !ok {
526 return
527 }
528 if r.URL.Query().Get("raw") == "1" {
529 w.Header().Set("Content-Type", "text/plain; charset=utf-8")
530 _, _ = w.Write([]byte(job.Log))
531 return
532 }
533 offset, _ := strconv.Atoi(r.URL.Query().Get("offset"))
534 if offset < 0 || offset > len(job.Log) {
535 offset = 0
536 }
537 queue := ""
538 if job.Status == "queued" {
539 tr := func(key string, args ...any) string { return s.tr(r, key, args...) }
540 queue = queueText(tr, s.queueRanks(r.Context()), job.ID)
541 }
542 w.Header().Set("Content-Type", "application/json")
543 w.Header().Set("Cache-Control", "no-store")
544 _ = json.NewEncoder(w).Encode(map[string]any{
545 "offset": len(job.Log),
546 "status": job.Status,
547 "text": job.Log[offset:],
548 "queue": queue,
549 })
550}
551
552func (s *Server) retryPipeline(w http.ResponseWriter, r *http.Request) {
553 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
554 if !ok || !s.csrfOK(w, r) {
555 return
556 }
557 id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
558 if err != nil {
559 http.NotFound(w, r)
560 return
561 }
562 back := safeRepoBack(repo, r.FormValue("back"))
563 if back == "" {
564 back = repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(id, 10)
565 }
566 newID, err := s.opRetryPipeline(r.Context(), u, repo, id, r.FormValue("mode"))
567 if !s.uiOK(w, r, back, err) {
568 return
569 }
570 dest := back
571 if r.FormValue("mode") == "all" {
572 dest = repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(newID, 10)
573 }
574 s.redirect(w, r, dest, s.tr(r, "flash.pipeRetry"), "")
575}
576
577func safeRepoBack(repo store.Repo, back string) string {
578 back = strings.TrimSpace(back)
579 prefix := "/" + repo.FullPath()
580 if back != prefix && !strings.HasPrefix(back, prefix+"/") {
581 return ""
582 }
583 if strings.Contains(back, "..") || strings.Contains(back, "\\") || strings.Contains(back, "\n") || strings.Contains(back, "?") {
584 return ""
585 }
586 return back
587}
588
589func (s *Server) playJob(w http.ResponseWriter, r *http.Request) {
590 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
591 if !ok || !s.csrfOK(w, r) {
592 return
593 }
594 p, job, ok := s.jobFromRequest(w, r, repo)
595 if !ok {
596 return
597 }
598 _, _ = s.opJobAction(r.Context(), u, repo, p.ID, job.ID, "play")
599 s.redirect(w, r, repoURL(repo)+"/-/pipelines/"+strconv.FormatInt(p.ID, 10)+"/jobs/"+strconv.FormatInt(job.ID, 10), s.tr(r, "flash.pipeline"), "")
600}
601
602func (s *Server) jobFromRequest(w http.ResponseWriter, r *http.Request, repo store.Repo) (store.Pipeline, store.Job, bool) {
603 pid, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
604 if err != nil {
605 http.NotFound(w, r)
606 return store.Pipeline{}, store.Job{}, false
607 }
608 jid, err := strconv.ParseInt(r.PathValue("job"), 10, 64)
609 if err != nil {
610 http.NotFound(w, r)
611 return store.Pipeline{}, store.Job{}, false
612 }
613 p, err := s.Store.PipelineByID(r.Context(), repo.ID, pid)
614 if err != nil {
615 http.NotFound(w, r)
616 return store.Pipeline{}, store.Job{}, false
617 }
618 jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
619 for _, j := range jobs {
620 if j.ID == jid {
621 return p, j, true
622 }
623 }
624 http.NotFound(w, r)
625 return store.Pipeline{}, store.Job{}, false
626}
627
628func (s *Server) jobPage(r *http.Request, repo store.Repo, p store.Pipeline, job store.Job, role access.Role) *JobPage {
629 lang := s.langOf(r)
630 jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
631 users := map[string]store.User{}
632 actor, avatar, actorURL := s.actorOf(r, p.Actor, users)
633 initial := ""
634 if actor != "" {
635 initial = strings.ToUpper(actor[:1])
636 }
637 name, kind := ci.SplitRef(p.Ref)
638 status := jobDisplay(job)
639 pipeStatus := displayStatus(s.pipeStatusFor(p), jobs)
640 end := job.FinishedAt
641 if end.IsZero() && (job.Status == "success" || job.Status == "failed" || job.Status == "skipped") {
642 end = p.FinishedAt
643 }
644 start := job.StartedAt
645 dur := ""
646 if !start.IsZero() {
647 until := end
648 if until.IsZero() {
649 until = time.Now()
650 }
651 dur = formatClock(until.Sub(start))
652 }
653 queued := ""
654 if !start.IsZero() && !p.CreatedAt.IsZero() {
655 queued = formatClock(start.Sub(p.CreatedAt))
656 }
657 timeout := formatClock(job.Timeout)
658 if job.Timeout == 0 && s.Cfg.CI.TimeoutSec > 0 {
659 timeout = formatClock(time.Duration(s.Cfg.CI.TimeoutSec) * time.Second)
660 }
661 finished := ""
662 if !end.IsZero() {
663 finished = i18n.Ago(lang, end.Unix())
664 }
665 ranks := s.queueRanks(r.Context())
666 tr := func(key string, args ...any) string { return s.tr(r, key, args...) }
667 var stages []string
668 seen := map[string]bool{}
669 var related []JobLink
670 for _, j := range jobs {
671 if !seen[j.Stage] {
672 seen[j.Stage] = true
673 stages = append(stages, j.Stage)
674 }
675 st := jobDisplay(j)
676 related = append(related, JobLink{
677 ID: j.ID, Name: j.Name, Status: st, Label: tr("pipe." + st), Current: j.ID == job.ID, Stage: j.Stage,
678 Queue: queueText(tr, ranks, j.ID),
679 })
680 }
681 sourceKey := "pipe.src." + p.Source
682 source := s.tr(r, sourceKey)
683 if source == sourceKey {
684 source = p.Source
685 }
686 return &JobPage{
687 Runner: s.Store.JobRun(r.Context(), job.ID).RunnerName,
688 Job: job, Pipe: p, Name: job.Name, Status: status, Label: s.tr(r, "pipe."+status),
689 Actor: actor, ActorURL: actorURL, Avatar: avatar, Initial: initial, When: i18n.Ago(lang, p.CreatedAt.Unix()),
690 Duration: dur, Finished: finished, Queued: queued, Timeout: timeout, Source: source,
691 Ref: name, RefKind: kind, Short: shortSHA(p.CommitSHA), Title: p.CommitTitle, Stage: job.Stage,
692 PipeStatus: pipeStatus, PipeLabel: s.tr(r, "pipe."+pipeStatus),
693 Stages: stages, Related: related, Blocks: parseLog(job.Log), Running: job.Status == "running" || job.Status == "queued",
694 LogBytes: len(job.Log), CanPlay: job.Status == "manual" && role.CanWriteCode(),
695 Cancel: jobCancel(tr, role.CanWriteCode(), job),
696 Queue: queueText(tr, ranks, job.ID),
697 Environment: job.Environment, EnvironmentURL: job.EnvironmentURL, EnvironmentLink: safeEnvironmentURL(job.EnvironmentURL),
698 }
699}
700
701func safeEnvironmentURL(raw string) string {
702 if strings.Contains(raw, "$") {
703 return ""
704 }
705 if strings.HasPrefix(raw, "https://") || strings.HasPrefix(raw, "http://") {
706 return raw
707 }
708 return ""
709}
710
711func parseLog(raw string) []LogBlock {
712 var blocks []LogBlock
713 var cur *LogBlock
714 n := 0
715 flush := func() {
716 if cur == nil {
717 return
718 }
719 blocks = append(blocks, *cur)
720 cur = nil
721 }
722 for _, row := range strings.Split(raw, "\n") {
723 if row == "" {
724 continue
725 }
726 ts, text := row, row
727 if i := strings.IndexByte(row, '\t'); i >= 0 {
728 ts, text = row[:i], row[i+1:]
729 }
730 if strings.HasPrefix(text, "section_start:") {
731 flush()
732 body := strings.TrimPrefix(text, "section_start:")
733 title := body
734 if i := strings.IndexByte(body, ':'); i >= 0 {
735 title = body[i+1:]
736 }
737 cur = &LogBlock{Section: true, Title: title, Open: true}
738 continue
739 }
740 if strings.HasPrefix(text, "section_end:") {
741 dur := ""
742 body := strings.TrimPrefix(text, "section_end:")
743 if i := strings.IndexByte(body, '\t'); i >= 0 {
744 dur = body[i+1:]
745 }
746 if cur != nil {
747 cur.Duration = dur
748 flush()
749 }
750 continue
751 }
752 n++
753 line := LogLine{N: n, Time: clockOf(ts), Text: text, Spans: ansiSpans(text)}
754 if cur != nil {
755 cur.Lines = append(cur.Lines, line)
756 continue
757 }
758 blocks = append(blocks, LogBlock{Lines: []LogLine{line}})
759 }
760 if cur != nil {
761 flush()
762 }
763 return blocks
764}
765
766func wantsJSON(r *http.Request) bool {
767 return strings.Contains(r.Header.Get("Accept"), "application/json")
768}
769
770func jobsLive(pipe string, jobs []store.Job) bool {
771 if pipe == "queued" || pipe == "running" {
772 return true
773 }
774 for _, j := range jobs {
775 if j.Status == "queued" || j.Status == "running" {
776 return true
777 }
778 }
779 return false
780}
781
782func linksFor(jobs []store.Job, ranks map[int64]int, tr func(string, ...any) string) []JobLink {
783 out := make([]JobLink, 0, len(jobs))
784 for _, j := range jobs {
785 st := jobDisplay(j)
786 out = append(out, JobLink{
787 ID: j.ID, Name: j.Name, Status: st, Label: tr("pipe." + st), Stage: j.Stage,
788 Queue: queueText(tr, ranks, j.ID), DNI: j.DoNotInterrupt,
789 })
790 }
791 return out
792}
793
794func (s *Server) partial(name string, v View) string {
795 var buf bytes.Buffer
796 tmpl := s.byLang[v.Lang]
797 if tmpl == nil {
798 tmpl = s.tmpl
799 }
800 if tmpl == nil {
801 return ""
802 }
803 if err := tmpl.ExecuteTemplate(&buf, name, v); err != nil && s.Log != nil {
804 s.Log.Error("sjabloon", "name", name, "err", err)
805 }
806 return buf.String()
807}
808
809func (s *Server) writePipeList(w http.ResponseWriter, v View) {
810 type job struct {
811 ID int64 `json:"id"`
812 Name string `json:"name"`
813 Status string `json:"status"`
814 Label string `json:"label"`
815 Queue string `json:"queue"`
816 }
817 type stage struct {
818 Name string `json:"name"`
819 Status string `json:"status"`
820 Tip string `json:"tip"`
821 Jobs []job `json:"jobs"`
822 }
823 type row struct {
824 ID int64 `json:"id"`
825 Status string `json:"status"`
826 Label string `json:"label"`
827 Duration string `json:"duration"`
828 When string `json:"when"`
829 Stages []stage `json:"stages"`
830 HTML string `json:"html"`
831 }
832 rows := make([]row, 0, len(v.PipeRows))
833 for _, pr := range v.PipeRows {
834 one := v
835 one.PipeRows = []PipeRow{pr}
836 item := row{
837 ID: pr.ID, Status: pr.Status, Label: pr.Label, Duration: pr.Duration, When: pr.When,
838 HTML: s.partial("pipe-rows", one),
839 }
840 for _, st := range pr.Stages {
841 jobs := make([]job, 0, len(st.Jobs))
842 for _, j := range st.Jobs {
843 jobs = append(jobs, job{ID: j.ID, Name: j.Name, Status: j.Status, Label: j.Label, Queue: j.Queue})
844 }
845 item.Stages = append(item.Stages, stage{Name: st.Name, Status: st.Status, Tip: st.Tip, Jobs: jobs})
846 }
847 rows = append(rows, item)
848 }
849 w.Header().Set("Content-Type", "application/json")
850 w.Header().Set("Cache-Control", "no-store")
851 _ = json.NewEncoder(w).Encode(map[string]any{"active": v.Live, "rows": rows})
852}
853
854func (s *Server) writePipeDetail(w http.ResponseWriter, v View) {
855 type job struct {
856 ID int64 `json:"id"`
857 Name string `json:"name"`
858 Status string `json:"status"`
859 Label string `json:"label"`
860 Stage string `json:"stage"`
861 Queue string `json:"queue"`
862 }
863 type stageJob struct {
864 ID int64 `json:"id"`
865 Name string `json:"name"`
866 Status string `json:"status"`
867 Label string `json:"label"`
868 Queue string `json:"queue"`
869 }
870 type stage struct {
871 Name string `json:"name"`
872 Status string `json:"status"`
873 Tip string `json:"tip"`
874 Jobs []stageJob `json:"jobs"`
875 }
876 jobs := make([]job, 0, len(v.PipeJobs))
877 for _, j := range v.PipeJobs {
878 jobs = append(jobs, job{ID: j.ID, Name: j.Name, Status: j.Status, Label: j.Label, Stage: j.Stage, Queue: j.Queue})
879 }
880 stages := make([]stage, 0, len(v.PipeStages))
881 for _, st := range v.PipeStages {
882 item := stage{Name: st.Name, Status: st.Status, Tip: st.Tip, Jobs: make([]stageJob, 0, len(st.Jobs))}
883 for _, j := range st.Jobs {
884 item.Jobs = append(item.Jobs, stageJob{ID: j.ID, Name: j.Name, Status: j.Status, Label: j.Label, Queue: j.Queue})
885 }
886 stages = append(stages, item)
887 }
888 dur := ""
889 html := ""
890 if v.Pipe != nil {
891 dur = pipelineClock(*v.Pipe)
892 if v.Repo != nil {
893 head := CommitRow{PipeID: v.Pipe.ID, PipeStages: v.PipeStages}
894 html = s.partial("stage-dots", View{Lang: v.Lang, Repo: v.Repo, Head: &head})
895 }
896 }
897 w.Header().Set("Content-Type", "application/json")
898 w.Header().Set("Cache-Control", "no-store")
899 _ = json.NewEncoder(w).Encode(map[string]any{
900 "active": v.Live, "status": v.PipeStatus, "label": v.PipeLabel,
901 "duration": dur, "jobs": jobs, "stages": stages, "html": html,
902 })
903}
904
905func clockOf(ts string) string {
906 if t, err := time.Parse(time.RFC3339, ts); err == nil {
907 return t.UTC().Format("15:04:05")
908 }
909 if len(ts) >= 19 && strings.Contains(ts, "T") {
910 return ts[11:19]
911 }
912 return ""
913}
914
915func jobCancel(tr func(string, ...any) string, can bool, job store.Job) *CancelView {
916 if !can {
917 return nil
918 }
919 return cancelView(tr, tr("pipe.cancelJob"), tr("pipe.cancelAsk"), []store.Job{job})
920}