BlueGit

timfa bluegit

Files

bluegit / internal / access / access.go

access.go

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