BlueGit

timfa bluegit

Files

bluegit / internal / store / repos.go

repos.go

fix: installatiebeheerder ziet andermans gegevens niet
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 4 weeks ago
77270b74 History
repos.go 18.5 KiB Download Raw
1package store
2
3import (
4 "context"
5 "database/sql"
6 "errors"
7 "fmt"
8 "strings"
9 "time"
10
11 "gitlab.com/Timfa/bluegit/internal/access"
12 "gitlab.com/Timfa/bluegit/internal/names"
13)
14
15// Group is een verzameling repositories en leden.
16type Group struct {
17 ID int64
18 Name string
19 Path string
20 Description string
21 CreatedBy int64
22 CreatedAt time.Time
23}
24
25// Repo is een git-repository van een gebruiker of een groep.
26type Repo struct {
27 ID int64
28 OwnerKind string
29 OwnerID int64
30 OwnerPath string
31 Name string
32 Description string
33 DefaultBranch string
34 Visibility string
35 CreatedAt time.Time
36}
37
38// FullPath is owner/naam.
39func (r Repo) FullPath() string { return r.OwnerPath + "/" + r.Name }
40
41// CreateGroup maakt een groep. De maker wordt beheerder.
42func (s *Store) CreateGroup(ctx context.Context, creator int64, name, path, description string) (Group, error) {
43 name = strings.TrimSpace(name)
44 path = strings.ToLower(strings.TrimSpace(path))
45 if name == "" {
46 return Group{}, fmt.Errorf("de groep heeft een naam nodig")
47 }
48 if err := names.ValidGroupPath(path); err != nil {
49 return Group{}, err
50 }
51 if err := s.ensurePathFree(ctx, path); err != nil {
52 return Group{}, err
53 }
54 res, err := s.db.ExecContext(ctx, `INSERT INTO groups (name, path, description, created_by, created_at) VALUES (?, ?, ?, ?, ?)`,
55 name, path, strings.TrimSpace(description), creator, now())
56 if err != nil {
57 return Group{}, err
58 }
59 id, _ := res.LastInsertId()
60 if _, err := s.db.ExecContext(ctx, `INSERT INTO group_members (group_id, user_id, role) VALUES (?, ?, ?)`, id, creator, string(access.RoleMaintainer)); err != nil {
61 return Group{}, err
62 }
63 return s.GroupByID(ctx, id)
64}
65
66func (s *Store) ensurePathFree(ctx context.Context, path string) error {
67 var n int
68 if err := s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM users WHERE username = ?`, path).Scan(&n); err != nil {
69 return err
70 }
71 if n > 0 {
72 return fmt.Errorf("pad %s is al een gebruiker", path)
73 }
74 if err := s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM groups WHERE path = ?`, path).Scan(&n); err != nil {
75 return err
76 }
77 if n > 0 {
78 return fmt.Errorf("pad %s is al een groep", path)
79 }
80 return nil
81}
82
83// GroupByPath leest een groep.
84func (s *Store) GroupByPath(ctx context.Context, path string) (Group, error) {
85 row := s.db.QueryRowContext(ctx, `SELECT id, name, path, description, created_by, created_at FROM groups WHERE path = ?`, path)
86 return scanGroup(row)
87}
88
89// GroupByID leest een groep.
90func (s *Store) GroupByID(ctx context.Context, id int64) (Group, error) {
91 row := s.db.QueryRowContext(ctx, `SELECT id, name, path, description, created_by, created_at FROM groups WHERE id = ?`, id)
92 return scanGroup(row)
93}
94
95func scanGroup(row *sql.Row) (Group, error) {
96 var g Group
97 var created string
98 if err := row.Scan(&g.ID, &g.Name, &g.Path, &g.Description, &g.CreatedBy, &created); err != nil {
99 if errors.Is(err, sql.ErrNoRows) {
100 return Group{}, errNotFound
101 }
102 return Group{}, err
103 }
104 g.CreatedAt = parseTime(created)
105 return g, nil
106}
107
108// GroupRole is de rol van een gebruiker in een groep.
109// Installatiebeheer geeft geen lidmaatschap.
110func (s *Store) GroupRole(ctx context.Context, groupID, userID int64) (access.Role, error) {
111 if userID == 0 {
112 return access.RoleNone, nil
113 }
114 var role string
115 err := s.db.QueryRowContext(ctx, `SELECT role FROM group_members WHERE group_id = ? AND user_id = ?`, groupID, userID).Scan(&role)
116 if errors.Is(err, sql.ErrNoRows) {
117 return access.RoleNone, nil
118 }
119 if err != nil {
120 return access.RoleNone, err
121 }
122 return access.Role(role), nil
123}
124
125// ListGroups geeft de groepen waarvan deze gebruiker lid is.
126func (s *Store) ListGroups(ctx context.Context, userID int64) ([]Group, error) {
127 q := `SELECT id, name, path, description, created_by, created_at FROM groups WHERE id IN (SELECT group_id FROM group_members WHERE user_id = ?) ORDER BY path`
128 args := []any{userID}
129 rows, err := s.db.QueryContext(ctx, q, args...)
130 if err != nil {
131 return nil, err
132 }
133 defer rows.Close()
134 var out []Group
135 for rows.Next() {
136 var g Group
137 var created string
138 if err := rows.Scan(&g.ID, &g.Name, &g.Path, &g.Description, &g.CreatedBy, &created); err != nil {
139 return nil, err
140 }
141 g.CreatedAt = parseTime(created)
142 out = append(out, g)
143 }
144 return out, rows.Err()
145}
146
147// CreateRepo maakt de metadata. De schijfmap maakt de aanroeper.
148func (s *Store) CreateRepo(ctx context.Context, ownerKind string, ownerID int64, name, description, defaultBranch, visibility string) (Repo, error) {
149 if ownerKind != "user" && ownerKind != "group" {
150 return Repo{}, fmt.Errorf("eigenaar moet user of group zijn")
151 }
152 if err := names.ValidRepoName(name); err != nil {
153 return Repo{}, err
154 }
155 if visibility != "public" && visibility != "private" {
156 return Repo{}, fmt.Errorf("zichtbaarheid moet public of private zijn")
157 }
158 if defaultBranch == "" {
159 defaultBranch = "master"
160 }
161 if ownerKind == "user" {
162 u, err := s.UserByID(ctx, ownerID)
163 if err != nil {
164 return Repo{}, err
165 }
166 var n int
167 if err := s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM groups WHERE path = ?`, u.Username).Scan(&n); err != nil {
168 return Repo{}, err
169 }
170 if n > 0 {
171 return Repo{}, fmt.Errorf("er bestaat al een groep %s; persoonlijke repositories zijn dan niet bereikbaar", u.Username)
172 }
173 }
174 res, err := s.db.ExecContext(ctx, `INSERT INTO repos (owner_kind, owner_id, name, description, default_branch, visibility, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)`,
175 ownerKind, ownerID, name, strings.TrimSpace(description), defaultBranch, visibility, now())
176 if err != nil {
177 if strings.Contains(err.Error(), "UNIQUE") {
178 return Repo{}, fmt.Errorf("er is al een repository %s", name)
179 }
180 return Repo{}, err
181 }
182 id, _ := res.LastInsertId()
183 return s.RepoByID(ctx, id)
184}
185
186// RepoByID leest een repository.
187func (s *Store) RepoByID(ctx context.Context, id int64) (Repo, error) {
188 row := s.db.QueryRowContext(ctx, repoSelect+` WHERE r.id = ?`, id)
189 return scanRepo(row)
190}
191
192// RepoByPath leest owner/naam.
193func (s *Store) RepoByPath(ctx context.Context, owner, name string) (Repo, error) {
194 row := s.db.QueryRowContext(ctx, repoSelect+`
195 WHERE r.name = ? AND (
196 (r.owner_kind = 'user' AND r.owner_id = (SELECT id FROM users WHERE username = ?))
197 OR (r.owner_kind = 'group' AND r.owner_id = (SELECT id FROM groups WHERE path = ?))
198 )`, name, owner, owner)
199 return scanRepo(row)
200}
201
202const repoSelect = `
203SELECT r.id, r.owner_kind, r.owner_id,
204 CASE r.owner_kind WHEN 'user' THEN (SELECT username FROM users WHERE id = r.owner_id) ELSE (SELECT path FROM groups WHERE id = r.owner_id) END,
205 r.name, r.description, r.default_branch, r.visibility, r.created_at
206FROM repos r`
207
208func scanRepo(row *sql.Row) (Repo, error) {
209 var r Repo
210 var created string
211 var owner sql.NullString
212 if err := row.Scan(&r.ID, &r.OwnerKind, &r.OwnerID, &owner, &r.Name, &r.Description, &r.DefaultBranch, &r.Visibility, &created); err != nil {
213 if errors.Is(err, sql.ErrNoRows) {
214 return Repo{}, errNotFound
215 }
216 return Repo{}, err
217 }
218 r.OwnerPath = owner.String
219 r.CreatedAt = parseTime(created)
220 return r, nil
221}
222
223// UpdateRepo wijzigt beschrijving en zichtbaarheid.
224func (s *Store) UpdateRepo(ctx context.Context, id int64, description, visibility string) error {
225 if visibility != "public" && visibility != "private" {
226 return fmt.Errorf("zichtbaarheid moet public of private zijn")
227 }
228 _, err := s.db.ExecContext(ctx, `UPDATE repos SET description = ?, visibility = ? WHERE id = ?`, strings.TrimSpace(description), visibility, id)
229 return err
230}
231
232// DeleteRepo verwijdert de metadata. Bestanden verwijdert de aanroeper.
233func (s *Store) DeleteRepo(ctx context.Context, id int64) error {
234 _, err := s.db.ExecContext(ctx, `DELETE FROM repos WHERE id = ?`, id)
235 return err
236}
237
238// ListRepoIDs geeft repositories die deze gebruiker mag zien:
239// openbare repositories, eigen repositories, repositories van een groep
240// waarvan hij lid is, en repositories met een rechtstreeks lidmaatschap.
241// Installatiebeheer voegt daar niets aan toe.
242func (s *Store) ListRepoIDs(ctx context.Context, userID int64) ([]int64, error) {
243 q := `SELECT id FROM repos WHERE visibility = 'public'`
244 args := []any{}
245 if userID != 0 {
246 q = `SELECT DISTINCT id FROM repos WHERE visibility = 'public'
247 OR (owner_kind = 'user' AND owner_id = ?)
248 OR (owner_kind = 'group' AND owner_id IN (SELECT group_id FROM group_members WHERE user_id = ?))
249 OR id IN (SELECT repo_id FROM repo_members WHERE user_id = ?)`
250 args = []any{userID, userID, userID}
251 }
252 q += ` ORDER BY id DESC`
253 rows, err := s.db.QueryContext(ctx, q, args...)
254 if err != nil {
255 return nil, err
256 }
257 defer rows.Close()
258 var ids []int64
259 for rows.Next() {
260 var id int64
261 if err := rows.Scan(&id); err != nil {
262 return nil, err
263 }
264 ids = append(ids, id)
265 }
266 return ids, rows.Err()
267}
268
269// ReposByGroup geeft de repositories van een groep.
270func (s *Store) ReposByGroup(ctx context.Context, groupID int64) ([]Repo, error) {
271 rows, err := s.db.QueryContext(ctx, repoSelect+` WHERE r.owner_kind = 'group' AND r.owner_id = ? ORDER BY r.name`, groupID)
272 if err != nil {
273 return nil, err
274 }
275 defer rows.Close()
276 return scanRepos(rows)
277}
278
279// ReposByIDs laadt een lijst.
280func (s *Store) ReposByIDs(ctx context.Context, ids []int64) ([]Repo, error) {
281 var out []Repo
282 for _, id := range ids {
283 r, err := s.RepoByID(ctx, id)
284 if err != nil {
285 return nil, err
286 }
287 out = append(out, r)
288 }
289 return out, nil
290}
291
292func scanRepos(rows *sql.Rows) ([]Repo, error) {
293 var out []Repo
294 for rows.Next() {
295 var r Repo
296 var created string
297 var owner sql.NullString
298 if err := rows.Scan(&r.ID, &r.OwnerKind, &r.OwnerID, &owner, &r.Name, &r.Description, &r.DefaultBranch, &r.Visibility, &created); err != nil {
299 return nil, err
300 }
301 r.OwnerPath = owner.String
302 r.CreatedAt = parseTime(created)
303 out = append(out, r)
304 }
305 return out, rows.Err()
306}
307
308// AllRepos is voor het verversen van hooks bij het starten.
309func (s *Store) AllRepos(ctx context.Context) ([]Repo, error) {
310 rows, err := s.db.QueryContext(ctx, repoSelect+` ORDER BY r.id`)
311 if err != nil {
312 return nil, err
313 }
314 defer rows.Close()
315 return scanRepos(rows)
316}
317
318// EffectiveRole past de rolregels toe op een repository.
319func (s *Store) EffectiveRole(ctx context.Context, userID, repoID int64) (access.Role, error) {
320 if userID == 0 {
321 return access.RoleNone, nil
322 }
323 if _, err := s.UserByID(ctx, userID); err != nil {
324 return access.RoleNone, err
325 }
326 repo, err := s.RepoByID(ctx, repoID)
327 if err != nil {
328 return access.RoleNone, err
329 }
330 in := access.Input{}
331 if repo.OwnerKind == "user" && repo.OwnerID == userID {
332 in.UserOwner = true
333 }
334 if repo.OwnerKind == "group" {
335 var role string
336 err := s.db.QueryRowContext(ctx, `SELECT role FROM group_members WHERE group_id = ? AND user_id = ?`, repo.OwnerID, userID).Scan(&role)
337 if err != nil && !errors.Is(err, sql.ErrNoRows) {
338 return access.RoleNone, err
339 }
340 if err == nil {
341 in.GroupRole = access.Role(role)
342 }
343 }
344 var role string
345 err = s.db.QueryRowContext(ctx, `SELECT role FROM repo_members WHERE repo_id = ? AND user_id = ?`, repoID, userID).Scan(&role)
346 if err != nil && !errors.Is(err, sql.ErrNoRows) {
347 return access.RoleNone, err
348 }
349 if err == nil {
350 in.RepoRole = access.Role(role)
351 }
352 return access.Resolve(in), nil
353}
354
355// Member is een lid of een uitnodiging op gebruikersnaam.
356type Member struct {
357 UserID int64
358 Username string
359 Role access.Role
360 Pending bool
361}
362
363// SetMember zet een lidmaatschap. Een onbekende naam blijft wachten tot de eerste login.
364func (s *Store) SetMember(ctx context.Context, scopeKind string, scopeID int64, username string, role access.Role) error {
365 if scopeKind != "repo" && scopeKind != "group" {
366 return fmt.Errorf("scope moet repo of group zijn")
367 }
368 if _, err := access.ParseRole(string(role)); err != nil {
369 return err
370 }
371 username = strings.ToLower(strings.TrimSpace(username))
372 if err := names.ValidUsername(username); err != nil {
373 return err
374 }
375 u, err := s.UserByUsername(ctx, username)
376 if IsNotFound(err) {
377 _, err = s.db.ExecContext(ctx, `INSERT INTO pending_members (scope_kind, scope_id, username, role) VALUES (?, ?, ?, ?)
378 ON CONFLICT(scope_kind, scope_id, username) DO UPDATE SET role = excluded.role`, scopeKind, scopeID, username, string(role))
379 return err
380 }
381 if err != nil {
382 return err
383 }
384 table, col := "repo_members", "repo_id"
385 if scopeKind == "group" {
386 table, col = "group_members", "group_id"
387 }
388 _, err = s.db.ExecContext(ctx, `INSERT INTO `+table+` (`+col+`, user_id, role) VALUES (?, ?, ?)
389 ON CONFLICT(`+col+`, user_id) DO UPDATE SET role = excluded.role`, scopeID, u.ID, string(role))
390 return err
391}
392
393// RemoveMember haalt een lid of een uitnodiging weg.
394func (s *Store) RemoveMember(ctx context.Context, scopeKind string, scopeID int64, username string) error {
395 username = strings.ToLower(strings.TrimSpace(username))
396 _, err := s.db.ExecContext(ctx, `DELETE FROM pending_members WHERE scope_kind = ? AND scope_id = ? AND username = ?`, scopeKind, scopeID, username)
397 if err != nil {
398 return err
399 }
400 u, err := s.UserByUsername(ctx, username)
401 if IsNotFound(err) {
402 return nil
403 }
404 if err != nil {
405 return err
406 }
407 if scopeKind == "group" {
408 _, err = s.db.ExecContext(ctx, `DELETE FROM group_members WHERE group_id = ? AND user_id = ?`, scopeID, u.ID)
409 return err
410 }
411 _, err = s.db.ExecContext(ctx, `DELETE FROM repo_members WHERE repo_id = ? AND user_id = ?`, scopeID, u.ID)
412 return err
413}
414
415// ListMembers geeft leden van een repository of groep, plus open uitnodigingen.
416func (s *Store) ListMembers(ctx context.Context, scopeKind string, scopeID int64) ([]Member, error) {
417 var q string
418 if scopeKind == "group" {
419 q = `SELECT u.id, u.username, m.role FROM group_members m JOIN users u ON u.id = m.user_id WHERE m.group_id = ? ORDER BY u.username`
420 } else {
421 q = `SELECT u.id, u.username, m.role FROM repo_members m JOIN users u ON u.id = m.user_id WHERE m.repo_id = ? ORDER BY u.username`
422 }
423 rows, err := s.db.QueryContext(ctx, q, scopeID)
424 if err != nil {
425 return nil, err
426 }
427 defer rows.Close()
428 var out []Member
429 for rows.Next() {
430 var m Member
431 var role string
432 if err := rows.Scan(&m.UserID, &m.Username, &role); err != nil {
433 return nil, err
434 }
435 m.Role = access.Role(role)
436 out = append(out, m)
437 }
438 if err := rows.Err(); err != nil {
439 return nil, err
440 }
441 prows, err := s.db.QueryContext(ctx, `SELECT username, role FROM pending_members WHERE scope_kind = ? AND scope_id = ? ORDER BY username`, scopeKind, scopeID)
442 if err != nil {
443 return nil, err
444 }
445 defer prows.Close()
446 for prows.Next() {
447 var m Member
448 var role string
449 if err := prows.Scan(&m.Username, &role); err != nil {
450 return nil, err
451 }
452 m.Role = access.Role(role)
453 m.Pending = true
454 out = append(out, m)
455 }
456 return out, prows.Err()
457}
458
459// ProtectedPatterns geeft de beschermde branchpatronen.
460func (s *Store) ProtectedPatterns(ctx context.Context, repoID int64) ([]string, error) {
461 rows, err := s.db.QueryContext(ctx, `SELECT pattern FROM protected_branches WHERE repo_id = ? ORDER BY pattern`, repoID)
462 if err != nil {
463 return nil, err
464 }
465 defer rows.Close()
466 var out []string
467 for rows.Next() {
468 var p string
469 if err := rows.Scan(&p); err != nil {
470 return nil, err
471 }
472 out = append(out, p)
473 }
474 return out, rows.Err()
475}
476
477// AddProtected voegt een patroon toe.
478func (s *Store) AddProtected(ctx context.Context, repoID int64, pattern string) error {
479 pattern = strings.TrimSpace(pattern)
480 if pattern == "" || strings.Contains(pattern, " ") || strings.Contains(pattern, "..") {
481 return fmt.Errorf("patroon %q is niet bruikbaar", pattern)
482 }
483 _, err := s.db.ExecContext(ctx, `INSERT INTO protected_branches (repo_id, pattern) VALUES (?, ?)`, repoID, pattern)
484 if err != nil && strings.Contains(err.Error(), "UNIQUE") {
485 return nil
486 }
487 return err
488}
489
490// RemoveProtected haalt een patroon weg.
491func (s *Store) RemoveProtected(ctx context.Context, repoID int64, pattern string) error {
492 _, err := s.db.ExecContext(ctx, `DELETE FROM protected_branches WHERE repo_id = ? AND pattern = ?`, repoID, pattern)
493 return err
494}
495
496// SecretMeta is een geheim zonder de waarde.
497type SecretMeta struct {
498 Name string
499 Protected bool
500 CreatedAt time.Time
501}
502
503// PutSecret bewaart een versleutelde waarde. De naam is een omgevingsvariabele.
504func (s *Store) PutSecret(ctx context.Context, scopeKind string, scopeID int64, name, value string, protected bool) error {
505 if scopeKind != "repo" && scopeKind != "group" {
506 return fmt.Errorf("scope moet repo of group zijn")
507 }
508 if err := access.ValidSecretName(name); err != nil {
509 return err
510 }
511 if strings.TrimSpace(value) == "" {
512 return fmt.Errorf("de waarde is leeg")
513 }
514 nonce, ct, err := s.encrypt(value)
515 if err != nil {
516 return err
517 }
518 _, err = s.db.ExecContext(ctx, `INSERT INTO secrets (scope_kind, scope_id, name, ciphertext, nonce, protected, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)
519 ON CONFLICT(scope_kind, scope_id, name) DO UPDATE SET ciphertext = excluded.ciphertext, nonce = excluded.nonce, protected = excluded.protected`,
520 scopeKind, scopeID, name, ct, nonce, boolInt(protected), now())
521 return err
522}
523
524// DeleteSecret verwijdert een geheim.
525func (s *Store) DeleteSecret(ctx context.Context, scopeKind string, scopeID int64, name string) error {
526 _, err := s.db.ExecContext(ctx, `DELETE FROM secrets WHERE scope_kind = ? AND scope_id = ? AND name = ?`, scopeKind, scopeID, name)
527 return err
528}
529
530// ListSecrets geeft namen, niet de waarden.
531func (s *Store) ListSecrets(ctx context.Context, scopeKind string, scopeID int64) ([]SecretMeta, error) {
532 rows, err := s.db.QueryContext(ctx, `SELECT name, protected, created_at FROM secrets WHERE scope_kind = ? AND scope_id = ? ORDER BY name`, scopeKind, scopeID)
533 if err != nil {
534 return nil, err
535 }
536 defer rows.Close()
537 var out []SecretMeta
538 for rows.Next() {
539 var m SecretMeta
540 var p int
541 var created string
542 if err := rows.Scan(&m.Name, &p, &created); err != nil {
543 return nil, err
544 }
545 m.Protected = p == 1
546 m.CreatedAt = parseTime(created)
547 out = append(out, m)
548 }
549 return out, rows.Err()
550}
551
552// SecretValues ontcijfert geheimen voor een job of webhook.
553// refProtected bepaalt of beschermde geheimen meegaan.
554func (s *Store) SecretValues(ctx context.Context, scopeKind string, scopeID int64, refProtected bool) (map[string]string, error) {
555 rows, err := s.db.QueryContext(ctx, `SELECT name, ciphertext, nonce, protected FROM secrets WHERE scope_kind = ? AND scope_id = ?`, scopeKind, scopeID)
556 if err != nil {
557 return nil, err
558 }
559 defer rows.Close()
560 out := map[string]string{}
561 for rows.Next() {
562 var name string
563 var ct, nonce []byte
564 var p int
565 if err := rows.Scan(&name, &ct, &nonce, &p); err != nil {
566 return nil, err
567 }
568 if !access.InjectSecret(p == 1, refProtected) {
569 continue
570 }
571 val, err := s.decrypt(nonce, ct)
572 if err != nil {
573 return nil, err
574 }
575 out[name] = val
576 }
577 return out, rows.Err()
578}