BlueGit

timfa bluegit

Files

bluegit / internal / access / access.go

access.go

feat: voeg een issue-tracker per repository toe
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
f3222d5f History
access.go 7.4 KiB Download Raw
1// Package access bevat de rolregels van BlueGit.
2// Een repository hoort bij een gebruiker of een groep. Leden hebben
3// Readonly, Reporter, Developer of Maintainer. De effectieve rol is de hoogste
4// van groepslidmaatschap, rechtstreeks repolidmaatschap en eigenaarschap.
5// Installatiebeheer is hier geen rol: dat geeft geen toegang tot
6// repositories, groepen of geheimen van anderen.
7package access
8
9import (
10 "path"
11 "regexp"
12 "strings"
13
14 "gitlab.com/Timfa/bluegit/internal/i18n"
15)
16
17// Role is een toegangsrol op een repository of groep.
18type Role string
19
20const (
21 RoleNone Role = ""
22 RoleReadonly Role = "readonly"
23 RoleReporter Role = "reporter"
24 RoleDeveloper Role = "developer"
25 RoleMaintainer Role = "maintainer"
26)
27
28// ParseRole herkent de rollen. Leeg is geen rol.
29func ParseRole(s string) (Role, error) {
30 switch Role(strings.ToLower(strings.TrimSpace(s))) {
31 case RoleReadonly:
32 return RoleReadonly, nil
33 case RoleReporter:
34 return RoleReporter, nil
35 case RoleDeveloper:
36 return RoleDeveloper, nil
37 case RoleMaintainer:
38 return RoleMaintainer, nil
39 case RoleNone:
40 return RoleNone, i18n.E("err.roleMissing")
41 default:
42 return RoleNone, i18n.E("err.roleUnknown", s)
43 }
44}
45
46// Label is de Engelse naam. De webinterface vertaalt via i18n.
47func (r Role) Label() string {
48 switch r {
49 case RoleReadonly:
50 return "Readonly"
51 case RoleReporter:
52 return "Reporter"
53 case RoleDeveloper:
54 return "Developer"
55 case RoleMaintainer:
56 return "Maintainer"
57 default:
58 return "None"
59 }
60}
61
62// Rank geeft een volgorde. Hoger mag meer.
63func (r Role) Rank() int {
64 switch r {
65 case RoleReadonly:
66 return 1
67 case RoleReporter:
68 return 2
69 case RoleDeveloper:
70 return 3
71 case RoleMaintainer:
72 return 4
73 default:
74 return 0
75 }
76}
77
78// Max geeft de hoogste van twee rollen.
79func Max(a, b Role) Role {
80 if a.Rank() >= b.Rank() {
81 return a
82 }
83 return b
84}
85
86// AtLeast meldt of de rol minstens other is.
87func (r Role) AtLeast(other Role) bool {
88 return r.Rank() >= other.Rank()
89}
90
91// CanRead geldt voor elke echte rol.
92func (r Role) CanRead() bool { return r.AtLeast(RoleReadonly) }
93
94// CanCreateIssue geldt voor Readonly en hoger, zoals een GitLab-Guest.
95// Anoniem (geen rol) mag geen issue aanmaken.
96func (r Role) CanCreateIssue() bool { return r.AtLeast(RoleReadonly) }
97
98// CanTriageIssue geldt voor Reporter en hoger: labels, toewijzing,
99// milestone, vervaldatum, andermans issue sluiten en vertrouwelijke issues zien.
100func (r Role) CanTriageIssue() bool { return r.AtLeast(RoleReporter) }
101
102// CanWriteCode geldt voor ontwikkelaar en beheerder.
103// Protected branches en secrets vallen hier buiten.
104func (r Role) CanWriteCode() bool { return r.AtLeast(RoleDeveloper) }
105
106// CanManageSecrets geldt alleen voor een beheerder.
107func (r Role) CanManageSecrets() bool { return r.AtLeast(RoleMaintainer) }
108
109// CanManageSettings dekt leden, webhooks, beschermde branches en tags, en verwijderen.
110func (r Role) CanManageSettings() bool { return r.AtLeast(RoleMaintainer) }
111
112// CanPushBranch meldt of deze rol naar een branch mag schrijven.
113// protected is waar als de branch op een beschermd patroon past.
114func (r Role) CanPushBranch(protected bool) bool {
115 if protected {
116 return r.CanManageSettings()
117 }
118 return r.CanWriteCode()
119}
120
121// CanMerge meldt of deze rol een merge request naar target mag samenvoegen.
122func (r Role) CanMerge(targetProtected bool) bool {
123 return r.CanPushBranch(targetProtected)
124}
125
126// Input is alles wat meespeelt bij de effectieve rol op één repository.
127// Installatiebeheer zit hier bewust niet in.
128type Input struct {
129 // UserOwner is waar als de repository van deze gebruiker zelf is.
130 UserOwner bool
131 // GroupRole is de rol in de groep die de repository bezit. Leeg als
132 // de repository niet van een groep is of de gebruiker geen lid is.
133 GroupRole Role
134 // RepoRole is een rechtstreeks lidmaatschap op de repository.
135 RepoRole Role
136}
137
138// Resolve kiest de effectieve rol.
139// De persoonlijke eigenaar is beheerder. Een groepsbeheerder blijft
140// beheerder van elke repository van de groep. Een expliciete
141// repositoryrol vervangt een lagere groepsrol, zodat de standaardrol
142// van de groep op een nieuwe repository kan gelden. Zonder
143// repositoryrol blijft de groepsrol van kracht.
144func Resolve(in Input) Role {
145 if in.UserOwner {
146 return RoleMaintainer
147 }
148 if in.GroupRole == RoleMaintainer {
149 return RoleMaintainer
150 }
151 if in.RepoRole != RoleNone {
152 return in.RepoRole
153 }
154 return in.GroupRole
155}
156
157// BranchProtected meldt of branch op een van de patronen past.
158// Een patroon is exact, of een glob waarin * één padsegment is
159// (path.Match). "release/*" past dus op "release/1.2" en niet op
160// "release/1.2/rc".
161func BranchProtected(patterns []string, branch string) bool {
162 for _, p := range patterns {
163 p = strings.TrimSpace(p)
164 if p == "" {
165 continue
166 }
167 if p == branch {
168 return true
169 }
170 ok, err := path.Match(p, branch)
171 if err == nil && ok {
172 return true
173 }
174 }
175 return false
176}
177
178// RefUpdate is één regel uit een pre-receive-hook.
179type RefUpdate struct {
180 Old string
181 New string
182 Ref string
183}
184
185// AuthorizeUpdate keurt één ref-update goed of af.
186// Een beschermde branch of een tag die op een beschermd patroon past
187// mag alleen een beheerder schrijven. Alleen-lezen mag niets schrijven.
188func AuthorizeUpdate(role Role, patterns, tagPatterns []string, u RefUpdate) error {
189 if !role.CanWriteCode() {
190 return i18n.E("err.hook.nowrite", u.Ref)
191 }
192 const tags = "refs/tags/"
193 if strings.HasPrefix(u.Ref, tags) {
194 name := strings.TrimPrefix(u.Ref, tags)
195 if name == "" || strings.HasPrefix(name, "-") || strings.HasPrefix(name, "/") || strings.HasSuffix(name, "/") || strings.Contains(name, "..") {
196 return i18n.E("err.tag", name)
197 }
198 if BranchProtected(tagPatterns, name) && !role.CanManageSettings() {
199 return i18n.E("err.hook.tag", name)
200 }
201 return nil
202 }
203 const heads = "refs/heads/"
204 if !strings.HasPrefix(u.Ref, heads) {
205 return nil
206 }
207 branch := strings.TrimPrefix(u.Ref, heads)
208 if branch == "" || strings.Contains(branch, "..") {
209 return i18n.E("err.hook.branch", branch)
210 }
211 if BranchProtected(patterns, branch) && !role.CanPushBranch(true) {
212 return i18n.E("err.hook.protected", branch)
213 }
214 return nil
215}
216
217// AuthorizeUpdates keurt een hele push goed. De eerste fout stopt.
218func AuthorizeUpdates(role Role, patterns, tagPatterns []string, updates []RefUpdate) error {
219 if len(updates) == 0 {
220 return i18n.E("err.hook.empty")
221 }
222 for _, u := range updates {
223 if err := AuthorizeUpdate(role, patterns, tagPatterns, u); err != nil {
224 return err
225 }
226 }
227 return nil
228}
229
230// InjectSecret meldt of een CI-job dit geheim als omgevingsvariabele krijgt.
231// Een beschermd geheim gaat alleen mee als de pipeline op een beschermde
232// branch draait. Onbeschermde geheimen gaan met elke job mee.
233// Dit is onafhankelijk van de UI: een ontwikkelaar leest geheimen nooit
234// terug, ook al belanden ze in een job die zijn pipeline startte.
235func InjectSecret(secretProtected, refProtected bool) bool {
236 if secretProtected {
237 return refProtected
238 }
239 return true
240}
241
242// secretNameRE is dezelfde vorm als een GitLab-variabele: een letter of
243// underscore, daarna letters, cijfers en underscores. Hoofdletters en
244// kleine letters zijn allebei geldig.
245var secretNameRE = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*$`)
246
247// ValidSecretName eist een omgevingsvariabelenaam.
248func ValidSecretName(name string) error {
249 if name == "" || len(name) > 80 {
250 return i18n.E("err.secretLen")
251 }
252 if !secretNameRE.MatchString(name) {
253 return i18n.E("err.secretForm", name)
254 }
255 return nil
256}