BlueGit

timfa bluegit

Files

bluegit / internal / access / access.go

access.go

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