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 } // 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 } // JobPage is de console van één job. type JobPage struct { Job store.Job 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 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(p.Status, 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) return 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...) }), } } // 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": return "manual" case "queued": return "pending" case "canceled": return "canceled" } warn := false for _, j := range jobs { if j.Status == "failed" && j.AllowFailure { 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), }) } out = append(out, StageView{Name: name, Status: status, Label: label, Tip: name + ": " + strings.ToLower(label), Jobs: links}) } return out } func stageStatus(jobs []store.Job) string { pending, failed, warning, running, canceled := false, false, false, 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 == "failed" && j.AllowFailure: warning = true case j.Status == "queued" || j.Status == "manual": pending = true } } if !seen { return "skipped" } if running { return "running" } if failed { return "failed" } if canceled { return "canceled" } if warning { 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" } 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) 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(p.Status, 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{ 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(), 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), }) } 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 "" }