package server import ( "context" "math" "net/url" "strconv" "strings" "time" "gitlab.com/Timfa/bluegit/internal/gitrepo" "gitlab.com/Timfa/bluegit/internal/i18n" "gitlab.com/Timfa/bluegit/internal/store" "gitlab.com/Timfa/bluegit/internal/webhook" ) // enrichEvent vult de details die de JSON-body van een webhook meestuurt. func (s *Server) enrichEvent(ctx context.Context, repo store.Repo, ev webhook.Event) webhook.Event { switch ev.Type { case webhook.EventPipelineSuccess, webhook.EventPipelineFailure: s.fillPipelineEvent(ctx, repo, &ev) case webhook.EventPush: s.fillPushEvent(ctx, repo, &ev) case webhook.EventMergeRequest: s.fillMREvent(ctx, repo, &ev) } return ev } func (s *Server) fillPipelineEvent(ctx context.Context, repo store.Repo, ev *webhook.Event) { id, err := strconv.ParseInt(ev.PipelineID, 10, 64) if err != nil || id <= 0 || s.Store == nil { return } p, err := s.Store.PipelineByID(ctx, repo.ID, id) if err != nil { return } base := strings.TrimRight(s.Cfg.BaseURL, "/") pipeURL := base + "/" + repo.FullPath() + "/-/pipelines/" + strconv.FormatInt(p.ID, 10) if ev.URL == "" || !strings.HasPrefix(ev.URL, "http") { ev.URL = pipeURL } if ev.Commit == "" { ev.Commit = p.CommitSHA } if ev.Branch == "" { ev.Branch = refName(p.Ref) } if ev.Actor == "" { ev.Actor = p.Actor } msg := p.CommitTitle author := p.Actor if s.Git != "" && s.StoragePath() != "" && p.CommitSHA != "" { dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) if c, err := gitrepo.Show(ctx, s.Git, dir, p.CommitSHA); err == nil && c.SHA != "" { if text := commitText(c); text != "" { msg = text } if author == "" { author = commitAuthor(c) } } } ev.PipelineID = strconv.FormatInt(p.ID, 10) ev.Pipeline = &webhook.PipelineInfo{ ID: p.ID, Status: p.Status, Ref: p.Ref, SHA: p.CommitSHA, CommitMessage: msg, Author: author, Duration: elapsedSeconds(p.StartedAt, p.FinishedAt), URL: pipeURL, } jobs, err := s.Store.JobsByPipeline(ctx, p.ID) if err != nil { return } secrets := s.maskSecrets(ctx, repo) ev.Jobs = make([]webhook.JobInfo, 0, len(jobs)) for _, j := range jobs { logText, truncated := webhook.TailLog(j.Log, secrets) info := webhook.JobInfo{ Name: j.Name, Stage: j.Stage, Status: j.Status, Duration: elapsedSeconds(j.StartedAt, j.FinishedAt), AllowFailure: j.AllowFailure, WebURL: pipeURL + "/jobs/" + strconv.FormatInt(j.ID, 10), Log: logText, LogTruncated: truncated, CancelReason: j.CancelReason(), FailureReason: j.FailureReason(), } if truncated { info.LogURL = jobLogAPIURL(s.Cfg.BaseURL, repo, j.ID) } ev.Jobs = append(ev.Jobs, info) } } func (s *Server) fillPushEvent(ctx context.Context, repo store.Repo, ev *webhook.Event) { if ev.Commits != nil || s.Git == "" || s.StoragePath() == "" || ev.After == "" { if ev.Commits == nil { ev.Commits = []webhook.CommitInfo{} } return } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) list, err := gitrepo.RangeLog(ctx, s.Git, dir, ev.Before, ev.After) if err != nil || len(list) == 0 { ev.Commits = []webhook.CommitInfo{} return } if len(list) > webhook.MaxPushCommits { list = list[:webhook.MaxPushCommits] } ev.Commits = make([]webhook.CommitInfo, 0, len(list)) for i := len(list) - 1; i >= 0; i-- { ev.Commits = append(ev.Commits, s.commitInfo(ctx, repo, list[i])) } } func (s *Server) fillMREvent(ctx context.Context, repo store.Repo, ev *webhook.Event) { if ev.MergeRequest == nil { return } mr := ev.MergeRequest if mr.Reviewers == nil { mr.Reviewers = []webhook.ReviewerInfo{} } if mr.Comments == nil { mr.Comments = []webhook.CommentInfo{} } if mr.Commits == nil { mr.Commits = []webhook.CommitInfo{} } if mr.DiffStats.Files == nil { mr.DiffStats.Files = []webhook.FileChange{} } mr.DiffURL = mrDiffAPIURL(s.Cfg.BaseURL, repo, mr.ID) if s.Store != nil && mr.ID > 0 { if stored, err := s.Store.MergeRequestByNumber(ctx, repo.ID, mr.ID); err == nil { if revs, err := s.Store.ListReviews(ctx, stored.ID); err == nil { mr.Reviewers = make([]webhook.ReviewerInfo, 0, len(revs)) for _, rev := range revs { mr.Reviewers = append(mr.Reviewers, webhook.ReviewerInfo{Username: rev.Username, Status: rev.Status}) } } if notes, err := s.Store.ListNotes(ctx, stored.ID); err == nil { mr.Comments = make([]webhook.CommentInfo, 0, len(notes)) for _, n := range notes { mr.Comments = append(mr.Comments, webhook.CommentInfo{ ID: n.ID, Author: n.Author, Body: n.Body, CreatedAt: n.CreatedAt.UTC().Format(time.RFC3339), FilePath: n.FilePath, LineStart: n.LineStart, LineEnd: n.LineEnd, ParentID: n.ParentID, }) } } } } if s.Git == "" || s.StoragePath() == "" || mr.SourceBranch == "" || mr.TargetBranch == "" { return } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) if changes, err := gitrepo.CompareChanges(ctx, s.Git, dir, mr.TargetBranch, mr.SourceBranch); err == nil { stats := webhook.DiffStats{Files: fileChanges(changes)} for _, f := range stats.Files { stats.Additions += f.Additions stats.Deletions += f.Deletions } mr.DiffStats = stats } list, err := gitrepo.Log(ctx, s.Git, dir, mr.TargetBranch+".."+mr.SourceBranch, webhook.MaxPushCommits) if err != nil || len(list) == 0 { mr.Commits = []webhook.CommitInfo{} return } mr.Commits = make([]webhook.CommitInfo, 0, len(list)) for i := len(list) - 1; i >= 0; i-- { mr.Commits = append(mr.Commits, s.commitInfo(ctx, repo, list[i])) } } func (s *Server) commitInfo(ctx context.Context, repo store.Repo, c gitrepo.Commit) webhook.CommitInfo { base := strings.TrimRight(s.Cfg.BaseURL, "/") info := webhook.CommitInfo{ SHA: c.SHA, Message: commitText(c), Author: commitAuthor(c), Timestamp: time.Unix(c.Unix, 0).UTC().Format(time.RFC3339), URL: base + "/" + repo.FullPath() + "/-/commit/" + c.SHA, DiffURL: commitDiffAPIURL(base, repo, c.SHA), Files: []webhook.FileChange{}, } if s.Git == "" || s.StoragePath() == "" { return info } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) files, err := gitrepo.CommitFileChanges(ctx, s.Git, dir, c.SHA) if err != nil { return info } info.Files = fileChanges(files) return info } func fileChanges(list []gitrepo.Change) []webhook.FileChange { out := make([]webhook.FileChange, 0, len(list)) for _, c := range list { out = append(out, webhook.FileChange{ Path: c.Path, Status: c.Status, PreviousPath: c.OldPath, Additions: c.Added, Deletions: c.Deleted, Binary: c.Binary, }) } return out } func (s *Server) maskSecrets(ctx context.Context, repo store.Repo) []string { if s.Store == nil { return nil } var out []string add := func(kind string, id int64) { vals, err := s.Store.SecretValues(ctx, kind, id, true) if err != nil { return } for _, v := range vals { out = append(out, v) } } add("repo", repo.ID) if repo.OwnerKind == "group" { add("group", repo.OwnerID) } return out } func (s *Server) mrEvent(repo store.Repo, mr store.MergeRequest, actor, action, comment string) webhook.Event { num := strconv.FormatInt(mr.Number, 10) path := strings.TrimRight(s.Cfg.BaseURL, "/") + repoURL(repo) + "/-/merge-requests/" + num summary := i18n.T(i18n.EN, "hook.mr", num, mr.Title) switch action { case "merged": summary = i18n.T(i18n.EN, "hook.mrMerged", num, mr.Title) case "commented": summary = i18n.T(i18n.EN, "hook.mrComment", num) } return webhook.Event{ Type: webhook.EventMergeRequest, Project: repo.FullPath(), Branch: mr.TargetBranch, Actor: actor, Summary: summary, URL: path, Comment: comment, MergeRequest: &webhook.MRInfo{ ID: mr.Number, Title: mr.Title, Description: mr.Description, SourceBranch: mr.SourceBranch, TargetBranch: mr.TargetBranch, Status: mr.Status, Author: mr.Author, Action: action, URL: path, }, } } func (s *Server) mrHook(repo store.Repo, mr store.MergeRequest, actor, action, comment string) { s.Dispatch(repo.ID, s.mrEvent(repo, mr, actor, action, comment)) } func (s *Server) releaseEvent(repo store.Repo, tag, name, commit string, assets []store.ReleaseAsset) webhook.Event { base := strings.TrimRight(s.Cfg.BaseURL, "/") page := base + repoURL(repo) + "/-/releases" list := make([]webhook.AssetInfo, 0, len(assets)) for _, a := range assets { list = append(list, webhook.AssetInfo{ Name: a.Name, Size: a.Size, URL: base + repoURL(repo) + "/-/releases/" + url.PathEscape(tag) + "/assets/" + url.PathEscape(a.Name), }) } return webhook.Event{ Type: webhook.EventRelease, Project: repo.FullPath(), Commit: commit, ReleaseTag: tag, Summary: i18n.T(i18n.EN, "hook.release", tag, repo.FullPath()), URL: page, Release: &webhook.ReleaseInfo{Tag: tag, Name: name, Commit: commit, Assets: list}, } } func commitDiffAPIURL(base string, repo store.Repo, sha string) string { return strings.TrimRight(base, "/") + "/api/v1/repos/" + url.PathEscape(repo.OwnerPath) + "/" + url.PathEscape(repo.Name) + "/commits/" + url.PathEscape(sha) + "/diff" } func mrDiffAPIURL(base string, repo store.Repo, number int64) string { return strings.TrimRight(base, "/") + "/api/v1/repos/" + url.PathEscape(repo.OwnerPath) + "/" + url.PathEscape(repo.Name) + "/merge-requests/" + strconv.FormatInt(number, 10) + "/diff" } func jobLogAPIURL(base string, repo store.Repo, jobID int64) string { return strings.TrimRight(base, "/") + "/api/v1/repos/" + url.PathEscape(repo.OwnerPath) + "/" + url.PathEscape(repo.Name) + "/jobs/" + strconv.FormatInt(jobID, 10) + "/log" } func refName(ref string) string { if b, ok := gitrepo.BranchOfRef(ref); ok { return b } if name, ok := strings.CutPrefix(ref, "refs/tags/"); ok && name != "" { return name } return ref } func commitText(c gitrepo.Commit) string { if c.Subject == "" { return strings.TrimSpace(c.Body) } if strings.TrimSpace(c.Body) == "" { return c.Subject } return c.Subject + "\n\n" + strings.TrimSpace(c.Body) } func commitAuthor(c gitrepo.Commit) string { name := strings.TrimSpace(c.Author) email := strings.TrimSpace(c.Email) switch { case name == "": return email case email == "": return name default: return name + " <" + email + ">" } } func elapsedSeconds(start, end time.Time) float64 { if start.IsZero() || end.IsZero() || end.Before(start) { return 0 } return math.Round(end.Sub(start).Seconds()*1000) / 1000 }