BlueGit

timfa bluegit

Files

bluegit / internal / access / access.go

access.go

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