package server import ( "bytes" "encoding/json" "net/http" "net/url" "strconv" "strings" "time" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/ci" "gitlab.com/Timfa/bluegit/internal/i18n" "gitlab.com/Timfa/bluegit/internal/store" ) // PipeRow is één rij in het pipeline-overzicht. type PipeRow struct { ID int64 Status string Label string Duration string When string Title string SHA string Short string Ref string RefKind string Source string SourceLabel string MRNumber int64 Actor string ActorURL string Avatar string Initial string Stages []StageView Failed bool Live bool } // StageView is één bolletje in de stages-kolom. type StageView struct { Name string Status string Label string Tip string Jobs []JobLink } // JobLink is een job in een stage-popover of in de zijbalk. type JobLink struct { ID int64 Name string Status string Label string Queue string Current bool Stage string // DNI: doNotInterrupt staat aan (badge met tooltip). DNI bool } // CancelView is een annuleerknop met eigen bevestigingsvenster. Force staat // aan als er een lopende doNotInterrupt-job bij is; de vraag waarschuwt dan. type CancelView struct { Label string Ask string OK string Force bool } // cancelView bouwt de knop voor jobs die gestopt zouden worden; nil als er // niets te annuleren valt. func cancelView(tr func(string, ...any) string, label, ask string, jobs []store.Job) *CancelView { open := false for _, j := range jobs { switch j.Status { case "queued", "running", "manual", "created", "pending": open = true } } if !open { return nil } v := &CancelView{Label: label, Ask: ask, OK: label} if prot := store.ProtectedRunning(jobs); len(prot) > 0 { v.Ask = tr("pipe.cancelDNI", jobNames(prot)) v.OK = tr("pipe.cancelDNIOk") v.Force = true } return v } func (s *Server) cancelJobWeb(w http.ResponseWriter, r *http.Request) { u, repo, _, ok := s.guard(w, r, access.RoleDeveloper) if !ok || !s.csrfOK(w, r) { return } p, job, ok := s.jobFromRequest(w, r, repo) if !ok { return } back := repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(p.ID, 10) + "/jobs/" + strconv.FormatInt(job.ID, 10) if _, err := s.opJobActionForce(r.Context(), u, repo, p.ID, job.ID, "cancel", forceParam(r)); err != nil { s.redirect(w, r, back, "", i18n.Text(s.langOf(r), err)) return } s.redirect(w, r, back, s.tr(r, "flash.canceled"), "") } func (s *Server) cancelPipelineWeb(w http.ResponseWriter, r *http.Request) { u, repo, _, ok := s.guard(w, r, access.RoleDeveloper) if !ok || !s.csrfOK(w, r) { return } id, err := strconv.ParseInt(r.PathValue("id"), 10, 64) if err != nil { http.NotFound(w, r) return } back := repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(id, 10) if err := s.opCancelPipeline(r.Context(), u, repo, id, forceParam(r)); err != nil { s.redirect(w, r, back, "", i18n.Text(s.langOf(r), err)) return } s.redirect(w, r, back, s.tr(r, "flash.canceled"), "") } // JobPage is de console van één job. type JobPage struct { Expired string // uitleg als dit een verlopen handmatige job is Job store.Job Runner string Pipe store.Pipeline Name string Status string Label string Actor string ActorURL string Avatar string Initial string When string Duration string Finished string Queued string Timeout string Source string Ref string RefKind string Short string Title string Stage string PipeStatus string PipeLabel string Stages []string Related []JobLink Blocks []LogBlock Running bool LogBytes int Cancel *CancelView CanPlay bool Environment string EnvironmentURL string EnvironmentLink string Queue string } // LogBlock is een losse regel of een inklapbare sectie. type LogBlock struct { Section bool Title string Duration string Open bool Lines []LogLine } // LogLine is één regel in de console. type LogLine struct { N int Time string Text string Spans []LogSpan } func (s *Server) fillPipelines(r *http.Request, v *View, repo store.Repo) { lang := s.langOf(r) list, _ := s.Store.ListPipelines(r.Context(), repo.ID) q := strings.ToLower(strings.TrimSpace(r.URL.Query().Get("q"))) v.Query = r.URL.Query().Get("q") ranks := s.queueRanks(r.Context()) users := map[string]store.User{} for _, p := range list { row := s.pipeRow(r, lang, repo, p, users, ranks) if q != "" && !pipeMatches(row, q) { continue } if rowLive(row) { v.Live = true } v.PipeRows = append(v.PipeRows, row) } v.LiveURL = repoURL(repo) + "/-/pipelines" if raw := strings.TrimSpace(r.URL.Query().Get("q")); raw != "" { v.LiveURL += "?q=" + url.QueryEscape(raw) } } func rowLive(row PipeRow) bool { if row.Status == "pending" || row.Status == "running" { return true } for _, st := range row.Stages { if st.Status == "pending" || st.Status == "running" { return true } for _, j := range st.Jobs { if j.Status == "pending" || j.Status == "running" { return true } } } return false } func (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 { jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID) name, kind := ci.SplitRef(p.Ref) status := displayStatus(s.pipeStatusFor(p), jobs) actor, avatar, actorURL := s.actorOf(r, p.Actor, users) initial := "" if actor != "" { initial = strings.ToUpper(actor[:1]) } sourceLabel, mrNumber := s.pipelineSourceLabel(r, repo, p) row := PipeRow{ ID: p.ID, Status: status, Label: s.tr(r, "pipe."+status), Duration: pipelineClock(p), When: i18n.Ago(lang, p.CreatedAt.Unix()), Title: p.CommitTitle, SHA: p.CommitSHA, Short: shortSHA(p.CommitSHA), Ref: name, RefKind: kind, Source: p.Source, SourceLabel: sourceLabel, MRNumber: mrNumber, Actor: actor, ActorURL: actorURL, Avatar: avatar, Initial: initial, Stages: stageViews(jobs, ranks, func(key string, args ...any) string { return s.tr(r, key, args...) }), Failed: jobsFailed(jobs), } row.Live = rowLive(row) return row } func jobsFailed(jobs []store.Job) bool { for _, j := range jobs { if j.Status == "failed" { return true } } return false } // pipelineSourceLabel benoemt een pipeline die bij een merge request hoort, // ook wanneer de rij als push is gestart en daarna gekoppeld is. // Een gewone push zonder merge request krijgt geen extra label. func (s *Server) pipelineSourceLabel(r *http.Request, repo store.Repo, p store.Pipeline) (string, int64) { if p.MRID != 0 { var number int64 if mr, err := s.Store.MergeRequest(r.Context(), repo.ID, p.MRID); err == nil { number = mr.Number } return s.tr(r, "pipe.src.merge_request_event"), number } if p.Source == "" || p.Source == "push" { return "", 0 } key := "pipe.src." + p.Source label := s.tr(r, key) if label == key { label = p.Source } return label, 0 } func (s *Server) pipelineSourceText(r *http.Request, repo store.Repo, p store.Pipeline) string { label, number := s.pipelineSourceLabel(r, repo, p) if label == "" { return "" } if number == 0 { return label } return label + " !" + strconv.FormatInt(number, 10) } func (s *Server) actorOf(r *http.Request, name string, cache map[string]store.User) (string, string, string) { name = strings.TrimSpace(name) if name == "" { return "", "", "" } u, ok := cache[name] if !ok { found, err := s.Store.UserByUsername(r.Context(), name) if err == nil { u = found } cache[name] = u } if u.ID == 0 { return name, "", "" } return u.Username, u.AvatarURL, "/users/" + u.Username } func pipeMatches(row PipeRow, q string) bool { bits := []string{row.Label, row.Title, row.SHA, row.Short, row.Ref, row.Actor, row.SourceLabel, strconv.FormatInt(row.ID, 10), row.Status} for _, st := range row.Stages { bits = append(bits, st.Name) for _, j := range st.Jobs { bits = append(bits, j.Name) } } for _, b := range bits { if strings.Contains(strings.ToLower(b), q) { return true } } return false } func displayStatus(pipe string, jobs []store.Job) string { switch pipe { case "failed": return "failed" case "running": return "running" case "manual": // Alleen handmatige jobs (en wat daarop wacht) zijn over. return "blocked" case "queued": return "pending" case "canceled": if store.PipelineObsolete(jobs) { return "obsolete" } return "canceled" case "waiting_for_update": return "waiting_for_update" case "waiting_for_job": return "waiting_for_job" } warn := false for _, j := range jobs { if (j.Status == "failed" || j.Status == "canceled") && j.AllowFailure && !j.Obsolete() { warn = true } } if warn { return "warning" } if pipe == "success" { return "passed" } if pipe == "" { return "pending" } return pipe } func stageViews(jobs []store.Job, ranks map[int64]int, tr func(string, ...any) string) []StageView { var order []string by := map[string][]store.Job{} for _, j := range jobs { if _, ok := by[j.Stage]; !ok { order = append(order, j.Stage) } by[j.Stage] = append(by[j.Stage], j) } var out []StageView for _, name := range order { group := by[name] status := stageStatus(group) label := tr("pipe." + status) var links []JobLink for _, j := range group { st := jobDisplay(j) links = append(links, JobLink{ ID: j.ID, Name: j.Name, Status: st, Label: tr("pipe." + st), Stage: j.Stage, Queue: queueText(tr, ranks, j.ID), }) } stip := name + ": " + strings.ToLower(label) if status == "obsolete" { stip += " (" + tr("pipe.obsolete.tip") + ")" } out = append(out, StageView{Name: name, Status: status, Label: label, Tip: stip, Jobs: links}) } return out } func stageStatus(jobs []store.Job) string { pending, failed, warning, running, canceled := false, false, false, false, false softCanceled, passed := false, false seen := false for _, j := range jobs { seen = true switch { case j.Status == "running": running = true case j.Status == "failed" && !j.AllowFailure: failed = true case j.Status == "canceled" && !j.AllowFailure: canceled = true case j.Status == "canceled": // allow_failure telt niet als fout, maar een geannuleerde job // is nooit geslaagd: alleen-geannuleerd wordt grijs, gemengd // met geslaagde jobs een waarschuwing. softCanceled = true case j.Status == "failed" && j.AllowFailure: warning = true case j.Status == "success": passed = true case j.Status == "queued" || j.Status == "manual": pending = true } } if !seen { return "skipped" } if running { return "running" } if failed { return "failed" } if canceled || (softCanceled && !passed && !warning && !pending) { if store.PipelineObsolete(jobs) || (!canceled && allCanceledObsolete(jobs)) { return "obsolete" } return "canceled" } if warning || (softCanceled && passed) { return "warning" } if pending { return "pending" } allSkip := true for _, j := range jobs { if j.Status != "skipped" { allSkip = false } } if allSkip { return "skipped" } return "passed" } func jobDisplay(j store.Job) string { if j.Status == "failed" && j.AllowFailure { return "warning" } if j.Obsolete() { return "obsolete" } switch j.Status { case "success": return "passed" case "queued": return "pending" case "": return "pending" default: return j.Status } } func pipelineClock(p store.Pipeline) string { end := p.FinishedAt if end.IsZero() { end = time.Now() } start := p.StartedAt if start.IsZero() { start = p.CreatedAt } if start.IsZero() { return "" } return formatClock(end.Sub(start)) } func formatClock(d time.Duration) string { if d < 0 { d = 0 } s := int(d.Seconds()) return pad2(s/3600) + ":" + pad2((s%3600)/60) + ":" + pad2(s%60) } func pad2(n int) string { if n < 10 { return "0" + strconv.Itoa(n) } return strconv.Itoa(n) } func shortSHA(sha string) string { if len(sha) > 8 { return sha[:8] } return sha } func (s *Server) showJob(w http.ResponseWriter, r *http.Request) { _, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } p, job, ok := s.jobFromRequest(w, r, repo) if !ok { return } v := s.repoView(w, r, repo, role, job.Name) v.Wide = true v.Page = "pipelines" v.Pipe = &p v.JobPage = s.jobPage(r, repo, p, job, role) s.render(w, "job", v) } func (s *Server) jobLog(w http.ResponseWriter, r *http.Request) { _, repo, _, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } _, job, ok := s.jobFromRequest(w, r, repo) if !ok { return } if r.URL.Query().Get("raw") == "1" { w.Header().Set("Content-Type", "text/plain; charset=utf-8") _, _ = w.Write([]byte(job.Log)) return } offset, _ := strconv.Atoi(r.URL.Query().Get("offset")) if offset < 0 || offset > len(job.Log) { offset = 0 } queue := "" if job.Status == "queued" { tr := func(key string, args ...any) string { return s.tr(r, key, args...) } queue = queueText(tr, s.queueRanks(r.Context()), job.ID) } w.Header().Set("Content-Type", "application/json") w.Header().Set("Cache-Control", "no-store") _ = json.NewEncoder(w).Encode(map[string]any{ "offset": len(job.Log), "status": job.Status, "text": job.Log[offset:], "queue": queue, }) } func (s *Server) retryPipeline(w http.ResponseWriter, r *http.Request) { u, repo, _, ok := s.guard(w, r, access.RoleDeveloper) if !ok || !s.csrfOK(w, r) { return } id, err := strconv.ParseInt(r.PathValue("id"), 10, 64) if err != nil { http.NotFound(w, r) return } back := safeRepoBack(repo, r.FormValue("back")) if back == "" { back = repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(id, 10) } newID, err := s.opRetryPipeline(r.Context(), u, repo, id, r.FormValue("mode")) if !s.uiOK(w, r, back, err) { return } dest := back if r.FormValue("mode") == "all" { dest = repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(newID, 10) } s.redirect(w, r, dest, s.tr(r, "flash.pipeRetry"), "") } func safeRepoBack(repo store.Repo, back string) string { back = strings.TrimSpace(back) prefix := "/" + repo.FullPath() if back != prefix && !strings.HasPrefix(back, prefix+"/") { return "" } if strings.Contains(back, "..") || strings.Contains(back, "\\") || strings.Contains(back, "\n") || strings.Contains(back, "?") { return "" } return back } func (s *Server) playJob(w http.ResponseWriter, r *http.Request) { u, repo, _, ok := s.guard(w, r, access.RoleDeveloper) if !ok || !s.csrfOK(w, r) { return } p, job, ok := s.jobFromRequest(w, r, repo) if !ok { return } _, _ = s.opJobAction(r.Context(), u, repo, p.ID, job.ID, "play") s.redirect(w, r, repoURL(repo)+"/-/pipelines/"+strconv.FormatInt(p.ID, 10)+"/jobs/"+strconv.FormatInt(job.ID, 10), s.tr(r, "flash.pipeline"), "") } func (s *Server) jobFromRequest(w http.ResponseWriter, r *http.Request, repo store.Repo) (store.Pipeline, store.Job, bool) { pid, err := strconv.ParseInt(r.PathValue("id"), 10, 64) if err != nil { http.NotFound(w, r) return store.Pipeline{}, store.Job{}, false } jid, err := strconv.ParseInt(r.PathValue("job"), 10, 64) if err != nil { http.NotFound(w, r) return store.Pipeline{}, store.Job{}, false } p, err := s.Store.PipelineByID(r.Context(), repo.ID, pid) if err != nil { http.NotFound(w, r) return store.Pipeline{}, store.Job{}, false } jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID) for _, j := range jobs { if j.ID == jid { return p, j, true } } http.NotFound(w, r) return store.Pipeline{}, store.Job{}, false } func (s *Server) jobPage(r *http.Request, repo store.Repo, p store.Pipeline, job store.Job, role access.Role) *JobPage { lang := s.langOf(r) jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID) users := map[string]store.User{} actor, avatar, actorURL := s.actorOf(r, p.Actor, users) initial := "" if actor != "" { initial = strings.ToUpper(actor[:1]) } name, kind := ci.SplitRef(p.Ref) status := jobDisplay(job) pipeStatus := displayStatus(s.pipeStatusFor(p), jobs) end := job.FinishedAt if end.IsZero() && (job.Status == "success" || job.Status == "failed" || job.Status == "skipped") { end = p.FinishedAt } start := job.StartedAt dur := "" if !start.IsZero() { until := end if until.IsZero() { until = time.Now() } dur = formatClock(until.Sub(start)) } queued := "" if !start.IsZero() && !p.CreatedAt.IsZero() { queued = formatClock(start.Sub(p.CreatedAt)) } timeout := formatClock(job.Timeout) if job.Timeout == 0 && s.Cfg.CI.TimeoutSec > 0 { timeout = formatClock(time.Duration(s.Cfg.CI.TimeoutSec) * time.Second) } finished := "" if !end.IsZero() { finished = i18n.Ago(lang, end.Unix()) } ranks := s.queueRanks(r.Context()) tr := func(key string, args ...any) string { return s.tr(r, key, args...) } var stages []string seen := map[string]bool{} var related []JobLink for _, j := range jobs { if !seen[j.Stage] { seen[j.Stage] = true stages = append(stages, j.Stage) } st := jobDisplay(j) related = append(related, JobLink{ ID: j.ID, Name: j.Name, Status: st, Label: tr("pipe." + st), Current: j.ID == job.ID, Stage: j.Stage, Queue: queueText(tr, ranks, j.ID), }) } sourceKey := "pipe.src." + p.Source source := s.tr(r, sourceKey) if source == sourceKey { source = p.Source } return &JobPage{ Runner: s.Store.JobRun(r.Context(), job.ID).RunnerName, Job: job, Pipe: p, Name: job.Name, Status: status, Label: s.tr(r, "pipe."+status), Actor: actor, ActorURL: actorURL, Avatar: avatar, Initial: initial, When: i18n.Ago(lang, p.CreatedAt.Unix()), Duration: dur, Finished: finished, Queued: queued, Timeout: timeout, Source: source, Ref: name, RefKind: kind, Short: shortSHA(p.CommitSHA), Title: p.CommitTitle, Stage: job.Stage, PipeStatus: pipeStatus, PipeLabel: s.tr(r, "pipe."+pipeStatus), Stages: stages, Related: related, Blocks: parseLog(job.Log), Running: job.Status == "running" || job.Status == "queued", LogBytes: len(job.Log), CanPlay: job.Status == "manual" && role.CanWriteCode(), Expired: expiredText(tr, job), Cancel: jobCancel(tr, role.CanWriteCode(), job), Queue: queueText(tr, ranks, job.ID), Environment: job.Environment, EnvironmentURL: job.EnvironmentURL, EnvironmentLink: safeEnvironmentURL(job.EnvironmentURL), } } func safeEnvironmentURL(raw string) string { if strings.Contains(raw, "$") { return "" } if strings.HasPrefix(raw, "https://") || strings.HasPrefix(raw, "http://") { return raw } return "" } func parseLog(raw string) []LogBlock { var blocks []LogBlock var cur *LogBlock n := 0 flush := func() { if cur == nil { return } blocks = append(blocks, *cur) cur = nil } for _, row := range strings.Split(raw, "\n") { if row == "" { continue } ts, text := row, row if i := strings.IndexByte(row, '\t'); i >= 0 { ts, text = row[:i], row[i+1:] } if strings.HasPrefix(text, "section_start:") { flush() body := strings.TrimPrefix(text, "section_start:") title := body if i := strings.IndexByte(body, ':'); i >= 0 { title = body[i+1:] } cur = &LogBlock{Section: true, Title: title, Open: true} continue } if strings.HasPrefix(text, "section_end:") { dur := "" body := strings.TrimPrefix(text, "section_end:") if i := strings.IndexByte(body, '\t'); i >= 0 { dur = body[i+1:] } if cur != nil { cur.Duration = dur flush() } continue } n++ line := LogLine{N: n, Time: clockOf(ts), Text: text, Spans: ansiSpans(text)} if cur != nil { cur.Lines = append(cur.Lines, line) continue } blocks = append(blocks, LogBlock{Lines: []LogLine{line}}) } if cur != nil { flush() } return blocks } func wantsJSON(r *http.Request) bool { return strings.Contains(r.Header.Get("Accept"), "application/json") } func jobsLive(pipe string, jobs []store.Job) bool { if pipe == "queued" || pipe == "running" { return true } for _, j := range jobs { if j.Status == "queued" || j.Status == "running" { return true } } return false } func linksFor(jobs []store.Job, ranks map[int64]int, tr func(string, ...any) string) []JobLink { out := make([]JobLink, 0, len(jobs)) for _, j := range jobs { st := jobDisplay(j) out = append(out, JobLink{ ID: j.ID, Name: j.Name, Status: st, Label: tr("pipe." + st), Stage: j.Stage, Queue: queueText(tr, ranks, j.ID), DNI: j.DoNotInterrupt, }) } return out } func (s *Server) partial(name string, v View) string { var buf bytes.Buffer tmpl := s.byLang[v.Lang] if tmpl == nil { tmpl = s.tmpl } if tmpl == nil { return "" } if err := tmpl.ExecuteTemplate(&buf, name, v); err != nil && s.Log != nil { s.Log.Error("sjabloon", "name", name, "err", err) } return buf.String() } func (s *Server) writePipeList(w http.ResponseWriter, v View) { type job struct { ID int64 `json:"id"` Name string `json:"name"` Status string `json:"status"` Label string `json:"label"` Queue string `json:"queue"` } type stage struct { Name string `json:"name"` Status string `json:"status"` Tip string `json:"tip"` Jobs []job `json:"jobs"` } type row struct { ID int64 `json:"id"` Status string `json:"status"` Label string `json:"label"` Duration string `json:"duration"` When string `json:"when"` Stages []stage `json:"stages"` HTML string `json:"html"` } rows := make([]row, 0, len(v.PipeRows)) for _, pr := range v.PipeRows { one := v one.PipeRows = []PipeRow{pr} item := row{ ID: pr.ID, Status: pr.Status, Label: pr.Label, Duration: pr.Duration, When: pr.When, HTML: s.partial("pipe-rows", one), } for _, st := range pr.Stages { jobs := make([]job, 0, len(st.Jobs)) for _, j := range st.Jobs { jobs = append(jobs, job{ID: j.ID, Name: j.Name, Status: j.Status, Label: j.Label, Queue: j.Queue}) } item.Stages = append(item.Stages, stage{Name: st.Name, Status: st.Status, Tip: st.Tip, Jobs: jobs}) } rows = append(rows, item) } w.Header().Set("Content-Type", "application/json") w.Header().Set("Cache-Control", "no-store") _ = json.NewEncoder(w).Encode(map[string]any{"active": v.Live, "rows": rows}) } func (s *Server) writePipeDetail(w http.ResponseWriter, v View) { type job struct { ID int64 `json:"id"` Name string `json:"name"` Status string `json:"status"` Label string `json:"label"` Stage string `json:"stage"` Queue string `json:"queue"` } type stageJob struct { ID int64 `json:"id"` Name string `json:"name"` Status string `json:"status"` Label string `json:"label"` Queue string `json:"queue"` } type stage struct { Name string `json:"name"` Status string `json:"status"` Tip string `json:"tip"` Jobs []stageJob `json:"jobs"` } jobs := make([]job, 0, len(v.PipeJobs)) for _, j := range v.PipeJobs { jobs = append(jobs, job{ID: j.ID, Name: j.Name, Status: j.Status, Label: j.Label, Stage: j.Stage, Queue: j.Queue}) } stages := make([]stage, 0, len(v.PipeStages)) for _, st := range v.PipeStages { item := stage{Name: st.Name, Status: st.Status, Tip: st.Tip, Jobs: make([]stageJob, 0, len(st.Jobs))} for _, j := range st.Jobs { item.Jobs = append(item.Jobs, stageJob{ID: j.ID, Name: j.Name, Status: j.Status, Label: j.Label, Queue: j.Queue}) } stages = append(stages, item) } dur := "" html := "" if v.Pipe != nil { dur = pipelineClock(*v.Pipe) if v.Repo != nil { head := CommitRow{PipeID: v.Pipe.ID, PipeStages: v.PipeStages} html = s.partial("stage-dots", View{Lang: v.Lang, Repo: v.Repo, Head: &head}) } } w.Header().Set("Content-Type", "application/json") w.Header().Set("Cache-Control", "no-store") _ = json.NewEncoder(w).Encode(map[string]any{ "active": v.Live, "status": v.PipeStatus, "label": v.PipeLabel, "duration": dur, "jobs": jobs, "stages": stages, "html": html, }) } func clockOf(ts string) string { if t, err := time.Parse(time.RFC3339, ts); err == nil { return t.UTC().Format("15:04:05") } if len(ts) >= 19 && strings.Contains(ts, "T") { return ts[11:19] } return "" } func jobCancel(tr func(string, ...any) string, can bool, job store.Job) *CancelView { if !can { return nil } return cancelView(tr, tr("pipe.cancelJob"), tr("pipe.cancelAsk"), []store.Job{job}) } // allCanceledObsolete: elke geannuleerde job (ook allow_failure) is // automatisch door een nieuwere pipeline gestopt. func allCanceledObsolete(jobs []store.Job) bool { seen := false for _, j := range jobs { if j.Status != "canceled" { continue } if !j.Obsolete() { return false } seen = true } return seen } // expiredText legt uit waarom een verlopen handmatige job niet meer start. func expiredText(tr func(string, ...any) string, j store.Job) string { if !expiredManualJob(j) { return "" } if j.Reason == store.ReasonStaleManual { return tr("stale.expired.age") } return tr("stale.expired.superseded") }