BlueGit

timfa bluegit

Files

bluegit / internal / server / pipeline_page.go

pipeline_page.go

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