BlueGit

timfa bluegit

Files

bluegit / internal / webhook / webhook.go

webhook.go

webhook.go 7.6 KiB Download Raw
1// Package webhook filtert gebeurtenissen en vult URL, headers en body.
2package webhook
3
4import (
5 "encoding/json"
6 "regexp"
7 "strings"
8
9 "gitlab.com/Timfa/bluegit/internal/i18n"
10)
11
12// Soorten gebeurtenissen.
13const (
14 EventPush = "push"
15 EventMergeRequest = "merge_request"
16 EventPipelineSuccess = "pipeline_success"
17 EventPipelineFailure = "pipeline_failure"
18 EventRelease = "release_published"
19 EventIssue = "issue"
20
21 // Fijnere events. Een hook met "issue" of "merge_request" krijgt ze ook.
22 EventIssueOpened = "issue_opened"
23 EventIssueClosed = "issue_closed"
24 EventIssueReopened = "issue_reopened"
25 EventIssueUpdated = "issue_updated"
26 EventIssueComment = "issue_comment"
27 EventMRComment = "merge_request_comment"
28)
29
30// AllEvents is de vaste lijst die een webhook mag aanvinken.
31func AllEvents() []string {
32 return []string{EventPush, EventMergeRequest, EventPipelineSuccess, EventPipelineFailure, EventRelease, EventIssue,
33 EventIssueOpened, EventIssueClosed, EventIssueReopened, EventIssueUpdated, EventIssueComment, EventMRComment}
34}
35
36// SpecificEvents zijn de fijnere events die bij issue en merge_request horen.
37func SpecificEvents() []string {
38 return []string{EventIssueOpened, EventIssueClosed, EventIssueReopened, EventIssueUpdated, EventIssueComment, EventMRComment}
39}
40
41// Specific geeft de fijnere eventnaam van ev, of "" als die er niet is.
42func Specific(ev Event) string {
43 switch ev.Type {
44 case EventIssue:
45 if ev.Issue == nil {
46 return ""
47 }
48 switch ev.Issue.Action {
49 case "opened":
50 return EventIssueOpened
51 case "closed":
52 return EventIssueClosed
53 case "reopened":
54 return EventIssueReopened
55 case "updated":
56 return EventIssueUpdated
57 case "commented":
58 return EventIssueComment
59 }
60 case EventMergeRequest:
61 if ev.MergeRequest != nil && ev.MergeRequest.Action == "commented" {
62 return EventMRComment
63 }
64 }
65 return ""
66}
67
68// KnownEvent meldt of name een ondersteunde gebeurtenis is.
69func KnownEvent(name string) bool {
70 for _, e := range AllEvents() {
71 if e == name {
72 return true
73 }
74 }
75 return false
76}
77
78// Presets.
79const (
80 PresetDiscord = "discord"
81 PresetGrok = "grok"
82 PresetGeneric = "generic"
83)
84
85// Event is de gegevensset die een webhook te zien krijgt.
86// De platte velden blijven beschikbaar als {{event.veld}}.
87// Pipeline, Jobs, Ref/Before/After/Commits, MergeRequest en Release
88// vullen de JSON-body als het sjabloon leeg is.
89type Event struct {
90 Type string
91 Project string
92 Group string
93 Branch string
94 Commit string
95 Summary string
96 URL string
97 PipelineID string
98 ReleaseTag string
99 Actor string
100
101 Pipeline *PipelineInfo
102 Jobs []JobInfo
103 Ref string
104 Before string
105 After string
106 Commits []CommitInfo
107 MergeRequest *MRInfo
108 Comment string
109 Release *ReleaseInfo
110 Issue *IssueInfo
111}
112
113// Hook is de opgeslagen configuratie, zonder geheimen al ingevuld.
114type Hook struct {
115 Preset string
116 Events []string
117 BranchFilter string
118}
119
120// Allows meldt of deze hook de gebeurtenis wil ontvangen.
121// Het branchfilter geldt alleen voor push. Leeg betekent alle branches.
122// "re:" gevolgd door een reguliere expressie, anders een exacte branchnaam.
123func Allows(h Hook, ev Event) (bool, error) {
124 if !KnownEvent(ev.Type) {
125 return false, i18n.E("err.whEvent", ev.Type)
126 }
127 found := false
128 specific := Specific(ev)
129 for _, e := range h.Events {
130 if e == ev.Type || (specific != "" && e == specific) {
131 found = true
132 break
133 }
134 }
135 if !found {
136 return false, nil
137 }
138 if ev.Type != EventPush {
139 return true, nil
140 }
141 return MatchBranch(h.BranchFilter, ev.Branch)
142}
143
144// MatchBranch past een push-filter toe.
145func MatchBranch(filter, branch string) (bool, error) {
146 filter = strings.TrimSpace(filter)
147 if filter == "" {
148 return true, nil
149 }
150 if strings.HasPrefix(filter, "re:") {
151 re, err := regexp.Compile(strings.TrimPrefix(filter, "re:"))
152 if err != nil {
153 return false, i18n.E("err.whFilter", err.Error())
154 }
155 return re.MatchString(branch), nil
156 }
157 return filter == branch, nil
158}
159
160// Expand vult {{event.veld}} en {{secret.NAAM}}.
161// Een onbekend geheim of veld is een fout, zodat een webhook niet
162// per ongeluk met een leeg token vertrekt.
163func Expand(s string, ev Event, secrets map[string]string) (string, error) {
164 var b strings.Builder
165 for {
166 start := strings.Index(s, "{{")
167 if start < 0 {
168 b.WriteString(s)
169 break
170 }
171 b.WriteString(s[:start])
172 rest := s[start+2:]
173 end := strings.Index(rest, "}}")
174 if end < 0 {
175 return "", i18n.E("err.whTemplate")
176 }
177 key := strings.TrimSpace(rest[:end])
178 val, err := lookup(key, ev, secrets)
179 if err != nil {
180 return "", err
181 }
182 b.WriteString(val)
183 s = rest[end+2:]
184 }
185 return b.String(), nil
186}
187
188func lookup(key string, ev Event, secrets map[string]string) (string, error) {
189 switch {
190 case strings.HasPrefix(key, "secret."):
191 name := strings.TrimPrefix(key, "secret.")
192 v, ok := secrets[name]
193 if !ok {
194 return "", i18n.E("err.whSecret", name)
195 }
196 return v, nil
197 case strings.HasPrefix(key, "event."):
198 field := strings.TrimPrefix(key, "event.")
199 v, ok := eventField(ev, field)
200 if !ok {
201 return "", i18n.E("err.whField", field)
202 }
203 return v, nil
204 default:
205 return "", i18n.E("err.whPlaceholder", key)
206 }
207}
208
209func eventField(ev Event, field string) (string, bool) {
210 if base, ok := strings.CutSuffix(field, "_json"); ok && base != "" {
211 v, ok := eventField(ev, base)
212 if !ok {
213 return "", false
214 }
215 b, err := json.Marshal(v)
216 if err != nil {
217 return "", false
218 }
219 return string(b), true
220 }
221 switch field {
222 case "type":
223 return ev.Type, true
224 case "event_name":
225 if n := Specific(ev); n != "" {
226 return n, true
227 }
228 return ev.Type, true
229 case "project":
230 return ev.Project, true
231 case "group":
232 return ev.Group, true
233 case "branch":
234 return ev.Branch, true
235 case "commit":
236 return ev.Commit, true
237 case "summary":
238 return ev.Summary, true
239 case "url":
240 return ev.URL, true
241 case "pipeline_id":
242 return ev.PipelineID, true
243 case "release_tag":
244 return ev.ReleaseTag, true
245 case "actor":
246 return ev.Actor, true
247 case "payload":
248 b, err := json.Marshal(ev.Document())
249 if err != nil {
250 return "", false
251 }
252 return string(b), true
253 default:
254 return "", false
255 }
256}
257
258// PresetDefaults vult URL-headers en body als de gebruiker een preset kiest
259// en een veld leeg laat.
260func PresetDefaults(preset string) (headers map[string]string, body string) {
261 switch preset {
262 case PresetDiscord:
263 return map[string]string{"Content-Type": "application/json"}, `{"content":"{{event.summary}}"}`
264 case PresetGrok:
265 return map[string]string{
266 "Content-Type": "application/json",
267 "Authorization": "Bearer {{secret.GROK_TOKEN}}",
268 }, ""
269 default:
270 return map[string]string{"Content-Type": "application/json"}, ""
271 }
272}
273
274// RenderBody maakt de HTTP-body. Een lege sjabloon wordt de gebeurtenis als JSON.
275func RenderBody(bodyTemplate string, ev Event, secrets map[string]string) ([]byte, error) {
276 if strings.TrimSpace(bodyTemplate) == "" {
277 return json.Marshal(ev.Document())
278 }
279 s, err := Expand(bodyTemplate, ev, secrets)
280 if err != nil {
281 return nil, err
282 }
283 return []byte(s), nil
284}
285
286// RenderHeaders vult geheimen in headers. Preset-headers vullen alleen
287// ontbrekende sleutels aan.
288func RenderHeaders(preset string, configured map[string]string, ev Event, secrets map[string]string) (map[string]string, error) {
289 base, _ := PresetDefaults(preset)
290 if base == nil {
291 base = map[string]string{}
292 }
293 for k, v := range configured {
294 base[k] = v
295 }
296 out := map[string]string{}
297 for k, v := range base {
298 ek, err := Expand(k, ev, secrets)
299 if err != nil {
300 return nil, err
301 }
302 evv, err := Expand(v, ev, secrets)
303 if err != nil {
304 return nil, err
305 }
306 out[ek] = evv
307 }
308 return out, nil
309}