BlueGit

timfa bluegit

Files

bluegit / internal / store / store.go

store.go

feat: merge-request-pipelines en merge na een geslaagde run
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Failed 24b281c4 History
store.go 24.5 KiB Download Raw
1// Package store bewaart BlueGit in één SQLite-bestand op de datadisk.
2package store
3
4import (
5 "context"
6 "crypto/rand"
7 "crypto/sha256"
8 "database/sql"
9 "encoding/hex"
10 "encoding/json"
11 "errors"
12 "fmt"
13 "strings"
14 "time"
15
16 "gitlab.com/Timfa/bluegit/internal/i18n"
17 "gitlab.com/Timfa/bluegit/internal/names"
18 "gitlab.com/Timfa/bluegit/internal/secretbox"
19
20 _ "modernc.org/sqlite"
21)
22
23// Store is de metadata van deze installatie.
24type Store struct {
25 db *sql.DB
26 key []byte
27}
28
29// Open opent of maakt het databasebestand. key is 32 bytes voor geheimen.
30func Open(path string, key []byte) (*Store, error) {
31 if len(key) != 32 {
32 return nil, fmt.Errorf("geheime sleutel moet 32 bytes zijn")
33 }
34 dsn := "file:" + path + "?_pragma=busy_timeout(5000)&_pragma=foreign_keys(1)"
35 db, err := sql.Open("sqlite", dsn)
36 if err != nil {
37 return nil, err
38 }
39 db.SetMaxOpenConns(8)
40 s := &Store{db: db, key: key}
41 if _, err := db.Exec(`PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON;`); err != nil {
42 _ = db.Close()
43 return nil, err
44 }
45 if err := s.migrate(); err != nil {
46 _ = db.Close()
47 return nil, err
48 }
49 return s, nil
50}
51
52// Close sluit de database.
53func (s *Store) Close() error { return s.db.Close() }
54
55func (s *Store) migrate() error {
56 if _, err := s.db.Exec(schema); err != nil {
57 return err
58 }
59 alters := []string{
60 `ALTER TABLE users ADD COLUMN language TEXT NOT NULL DEFAULT 'en'`,
61 `ALTER TABLE groups ADD COLUMN visibility TEXT NOT NULL DEFAULT 'private'`,
62 `ALTER TABLE groups ADD COLUMN default_role TEXT NOT NULL DEFAULT 'developer'`,
63 `ALTER TABLE groups ADD COLUMN logo_mime TEXT NOT NULL DEFAULT ''`,
64 `ALTER TABLE repos ADD COLUMN logo_mime TEXT NOT NULL DEFAULT ''`,
65 `ALTER TABLE webhooks ADD COLUMN method TEXT NOT NULL DEFAULT 'POST'`,
66 `ALTER TABLE notes ADD COLUMN file_path TEXT NOT NULL DEFAULT ''`,
67 `ALTER TABLE notes ADD COLUMN line_start INTEGER NOT NULL DEFAULT 0`,
68 `ALTER TABLE notes ADD COLUMN line_end INTEGER NOT NULL DEFAULT 0`,
69 `ALTER TABLE notes ADD COLUMN suggestion TEXT NOT NULL DEFAULT ''`,
70 `ALTER TABLE notes ADD COLUMN base_text TEXT NOT NULL DEFAULT ''`,
71 `ALTER TABLE pipelines ADD COLUMN source TEXT NOT NULL DEFAULT 'push'`,
72 `ALTER TABLE pipelines ADD COLUMN actor TEXT NOT NULL DEFAULT ''`,
73 `ALTER TABLE pipelines ADD COLUMN commit_title TEXT NOT NULL DEFAULT ''`,
74 `ALTER TABLE pipelines ADD COLUMN started_at TEXT`,
75 `ALTER TABLE jobs ADD COLUMN before_script TEXT NOT NULL DEFAULT ''`,
76 `ALTER TABLE jobs ADD COLUMN after_script TEXT NOT NULL DEFAULT ''`,
77 `ALTER TABLE jobs ADD COLUMN when_mode TEXT NOT NULL DEFAULT 'on_success'`,
78 `ALTER TABLE jobs ADD COLUMN timeout_seconds INTEGER NOT NULL DEFAULT 0`,
79 `ALTER TABLE jobs ADD COLUMN tags_json TEXT NOT NULL DEFAULT '[]'`,
80 `ALTER TABLE jobs ADD COLUMN cache_paths TEXT NOT NULL DEFAULT '[]'`,
81 `ALTER TABLE jobs ADD COLUMN cache_key TEXT NOT NULL DEFAULT ''`,
82 `ALTER TABLE jobs ADD COLUMN resource_group TEXT NOT NULL DEFAULT ''`,
83 `ALTER TABLE jobs ADD COLUMN optional_json TEXT NOT NULL DEFAULT '[]'`,
84 `ALTER TABLE pipelines ADD COLUMN mr_id INTEGER NOT NULL DEFAULT 0`,
85 }
86 for _, q := range alters {
87 if _, err := s.db.Exec(q); err != nil && !strings.Contains(strings.ToLower(err.Error()), "duplicate column") {
88 return err
89 }
90 }
91 return nil
92}
93
94const schema = `
95CREATE TABLE IF NOT EXISTS users (
96 id INTEGER PRIMARY KEY,
97 auth_id INTEGER NOT NULL UNIQUE,
98 username TEXT NOT NULL UNIQUE,
99 avatar_url TEXT NOT NULL DEFAULT '',
100 auth_admin INTEGER NOT NULL DEFAULT 0,
101 instance_admin INTEGER NOT NULL DEFAULT 0,
102 language TEXT NOT NULL DEFAULT 'en',
103 created_at TEXT NOT NULL,
104 updated_at TEXT NOT NULL
105);
106CREATE TABLE IF NOT EXISTS sessions (
107 id TEXT PRIMARY KEY,
108 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
109 access_token TEXT NOT NULL,
110 expires_at TEXT NOT NULL,
111 csrf TEXT NOT NULL,
112 created_at TEXT NOT NULL
113);
114CREATE TABLE IF NOT EXISTS access_tokens (
115 id INTEGER PRIMARY KEY,
116 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
117 name TEXT NOT NULL,
118 token_hash TEXT NOT NULL UNIQUE,
119 prefix TEXT NOT NULL,
120 created_at TEXT NOT NULL,
121 last_used_at TEXT,
122 expires_at TEXT
123);
124CREATE TABLE IF NOT EXISTS ssh_keys (
125 id INTEGER PRIMARY KEY,
126 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
127 name TEXT NOT NULL,
128 public_key TEXT NOT NULL,
129 fingerprint TEXT NOT NULL UNIQUE,
130 created_at TEXT NOT NULL
131);
132CREATE TABLE IF NOT EXISTS groups (
133 id INTEGER PRIMARY KEY,
134 name TEXT NOT NULL,
135 path TEXT NOT NULL UNIQUE,
136 description TEXT NOT NULL DEFAULT '',
137 visibility TEXT NOT NULL DEFAULT 'private',
138 default_role TEXT NOT NULL DEFAULT 'developer',
139 logo_mime TEXT NOT NULL DEFAULT '',
140 created_by INTEGER NOT NULL,
141 created_at TEXT NOT NULL
142);
143CREATE TABLE IF NOT EXISTS group_members (
144 group_id INTEGER NOT NULL REFERENCES groups(id) ON DELETE CASCADE,
145 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
146 role TEXT NOT NULL,
147 PRIMARY KEY (group_id, user_id)
148);
149CREATE TABLE IF NOT EXISTS repos (
150 id INTEGER PRIMARY KEY,
151 owner_kind TEXT NOT NULL,
152 owner_id INTEGER NOT NULL,
153 name TEXT NOT NULL,
154 description TEXT NOT NULL DEFAULT '',
155 default_branch TEXT NOT NULL,
156 visibility TEXT NOT NULL DEFAULT 'private',
157 logo_mime TEXT NOT NULL DEFAULT '',
158 created_at TEXT NOT NULL,
159 UNIQUE(owner_kind, owner_id, name)
160);
161CREATE TABLE IF NOT EXISTS repo_members (
162 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
163 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
164 role TEXT NOT NULL,
165 PRIMARY KEY (repo_id, user_id)
166);
167CREATE TABLE IF NOT EXISTS pending_members (
168 id INTEGER PRIMARY KEY,
169 scope_kind TEXT NOT NULL,
170 scope_id INTEGER NOT NULL,
171 username TEXT NOT NULL,
172 role TEXT NOT NULL,
173 UNIQUE(scope_kind, scope_id, username)
174);
175CREATE TABLE IF NOT EXISTS protected_branches (
176 id INTEGER PRIMARY KEY,
177 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
178 pattern TEXT NOT NULL,
179 UNIQUE(repo_id, pattern)
180);
181CREATE TABLE IF NOT EXISTS secrets (
182 id INTEGER PRIMARY KEY,
183 scope_kind TEXT NOT NULL,
184 scope_id INTEGER NOT NULL,
185 name TEXT NOT NULL,
186 ciphertext BLOB NOT NULL,
187 nonce BLOB NOT NULL,
188 protected INTEGER NOT NULL DEFAULT 0,
189 created_at TEXT NOT NULL,
190 UNIQUE(scope_kind, scope_id, name)
191);
192CREATE TABLE IF NOT EXISTS webhooks (
193 id INTEGER PRIMARY KEY,
194 scope_kind TEXT NOT NULL,
195 scope_id INTEGER NOT NULL,
196 name TEXT NOT NULL,
197 preset TEXT NOT NULL,
198 url_template TEXT NOT NULL,
199 headers_json TEXT NOT NULL,
200 body_template TEXT NOT NULL,
201 events_json TEXT NOT NULL,
202 branch_filter TEXT NOT NULL DEFAULT '',
203 active INTEGER NOT NULL DEFAULT 1,
204 method TEXT NOT NULL DEFAULT 'POST',
205 created_at TEXT NOT NULL
206);
207CREATE TABLE IF NOT EXISTS webhook_deliveries (
208 id INTEGER PRIMARY KEY,
209 webhook_id INTEGER NOT NULL REFERENCES webhooks(id) ON DELETE CASCADE,
210 event_type TEXT NOT NULL,
211 status_code INTEGER NOT NULL DEFAULT 0,
212 error TEXT NOT NULL DEFAULT '',
213 created_at TEXT NOT NULL
214);
215CREATE TABLE IF NOT EXISTS merge_requests (
216 id INTEGER PRIMARY KEY,
217 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
218 number INTEGER NOT NULL,
219 title TEXT NOT NULL,
220 description TEXT NOT NULL DEFAULT '',
221 source_branch TEXT NOT NULL,
222 target_branch TEXT NOT NULL,
223 author_id INTEGER NOT NULL,
224 status TEXT NOT NULL,
225 created_at TEXT NOT NULL,
226 updated_at TEXT NOT NULL,
227 UNIQUE(repo_id, number)
228);
229CREATE TABLE IF NOT EXISTS pipelines (
230 id INTEGER PRIMARY KEY,
231 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
232 commit_sha TEXT NOT NULL,
233 ref TEXT NOT NULL,
234 status TEXT NOT NULL,
235 created_at TEXT NOT NULL,
236 finished_at TEXT,
237 source TEXT NOT NULL DEFAULT 'push',
238 actor TEXT NOT NULL DEFAULT '',
239 commit_title TEXT NOT NULL DEFAULT '',
240 started_at TEXT
241);
242CREATE TABLE IF NOT EXISTS jobs (
243 id INTEGER PRIMARY KEY,
244 pipeline_id INTEGER NOT NULL REFERENCES pipelines(id) ON DELETE CASCADE,
245 repo_id INTEGER NOT NULL,
246 name TEXT NOT NULL,
247 stage TEXT NOT NULL,
248 position INTEGER NOT NULL,
249 status TEXT NOT NULL,
250 image TEXT NOT NULL,
251 script TEXT NOT NULL,
252 needs_json TEXT NOT NULL,
253 needs_set INTEGER NOT NULL,
254 variables_json TEXT NOT NULL,
255 artifact_paths TEXT NOT NULL,
256 artifact_expire_seconds INTEGER NOT NULL DEFAULT 0,
257 allow_failure INTEGER NOT NULL DEFAULT 0,
258 log TEXT NOT NULL DEFAULT '',
259 started_at TEXT,
260 finished_at TEXT,
261 before_script TEXT NOT NULL DEFAULT '',
262 after_script TEXT NOT NULL DEFAULT '',
263 when_mode TEXT NOT NULL DEFAULT 'on_success',
264 timeout_seconds INTEGER NOT NULL DEFAULT 0,
265 tags_json TEXT NOT NULL DEFAULT '[]',
266 cache_paths TEXT NOT NULL DEFAULT '[]',
267 cache_key TEXT NOT NULL DEFAULT '',
268 resource_group TEXT NOT NULL DEFAULT '',
269 optional_json TEXT NOT NULL DEFAULT '[]',
270 UNIQUE(pipeline_id, name)
271);
272CREATE TABLE IF NOT EXISTS artifacts (
273 id INTEGER PRIMARY KEY,
274 job_id INTEGER NOT NULL REFERENCES jobs(id) ON DELETE CASCADE,
275 path TEXT NOT NULL,
276 storage_path TEXT NOT NULL,
277 size INTEGER NOT NULL,
278 expires_at TEXT
279);
280CREATE TABLE IF NOT EXISTS job_tokens (
281 job_id INTEGER PRIMARY KEY REFERENCES jobs(id) ON DELETE CASCADE,
282 token_hash TEXT NOT NULL UNIQUE,
283 created_at TEXT NOT NULL
284);
285CREATE TABLE IF NOT EXISTS releases (
286 id INTEGER PRIMARY KEY,
287 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
288 tag TEXT NOT NULL,
289 commit_sha TEXT NOT NULL,
290 name TEXT NOT NULL,
291 body TEXT NOT NULL DEFAULT '',
292 author_id INTEGER,
293 job_id INTEGER,
294 created_at TEXT NOT NULL,
295 UNIQUE(repo_id, tag)
296);
297CREATE TABLE IF NOT EXISTS release_assets (
298 id INTEGER PRIMARY KEY,
299 release_id INTEGER NOT NULL REFERENCES releases(id) ON DELETE CASCADE,
300 name TEXT NOT NULL,
301 storage_path TEXT NOT NULL,
302 size INTEGER NOT NULL,
303 UNIQUE(release_id, name)
304);
305CREATE TABLE IF NOT EXISTS contributions (
306 id INTEGER PRIMARY KEY,
307 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
308 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
309 kind TEXT NOT NULL,
310 ref TEXT NOT NULL,
311 occurred_at TEXT NOT NULL,
312 UNIQUE(repo_id, kind, ref)
313);
314CREATE INDEX IF NOT EXISTS contributions_repo_time ON contributions(repo_id, occurred_at);
315CREATE INDEX IF NOT EXISTS contributions_user_time ON contributions(user_id, occurred_at);
316CREATE TABLE IF NOT EXISTS contribution_sync (
317 repo_id INTEGER PRIMARY KEY REFERENCES repos(id) ON DELETE CASCADE,
318 synced_at TEXT NOT NULL
319);
320CREATE TABLE IF NOT EXISTS stars (
321 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
322 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
323 created_at TEXT NOT NULL,
324 PRIMARY KEY (user_id, repo_id)
325);
326CREATE TABLE IF NOT EXISTS notes (
327 id INTEGER PRIMARY KEY,
328 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
329 mr_id INTEGER NOT NULL REFERENCES merge_requests(id) ON DELETE CASCADE,
330 author_id INTEGER NOT NULL REFERENCES users(id),
331 body TEXT NOT NULL,
332 created_at TEXT NOT NULL,
333 file_path TEXT NOT NULL DEFAULT '',
334 line_start INTEGER NOT NULL DEFAULT 0,
335 line_end INTEGER NOT NULL DEFAULT 0,
336 suggestion TEXT NOT NULL DEFAULT '',
337 base_text TEXT NOT NULL DEFAULT ''
338);
339CREATE TABLE IF NOT EXISTS commit_pushers (
340 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
341 sha TEXT NOT NULL,
342 user_id INTEGER NOT NULL REFERENCES users(id),
343 author_name TEXT NOT NULL,
344 author_email TEXT NOT NULL,
345 created_at TEXT NOT NULL,
346 PRIMARY KEY (repo_id, sha)
347);
348`
349
350func now() string { return time.Now().UTC().Format(time.RFC3339) }
351
352func parseTime(s string) time.Time {
353 t, err := time.Parse(time.RFC3339, s)
354 if err != nil {
355 return time.Time{}
356 }
357 return t
358}
359
360// User is een ingelogd account van de auth-server.
361type User struct {
362 ID int64
363 AuthID int64
364 Username string
365 AvatarURL string
366 AuthAdmin bool
367 InstanceAdmin bool
368 Language string
369 CreatedAt time.Time
370}
371
372// UpsertUser maakt of ververst een account. De eerste gebruiker wordt
373// installatiebeheerder. Wachtende lidmaatschappen op deze naam worden gekoppeld.
374func (s *Store) UpsertUser(ctx context.Context, authID int64, username, avatar string, authAdmin bool) (User, error) {
375 username = strings.ToLower(strings.TrimSpace(username))
376 if err := names.ValidUsername(username); err != nil {
377 return User{}, err
378 }
379 tx, err := s.db.BeginTx(ctx, nil)
380 if err != nil {
381 return User{}, err
382 }
383 defer func() { _ = tx.Rollback() }()
384
385 var count int
386 if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM users`).Scan(&count); err != nil {
387 return User{}, err
388 }
389 ts := now()
390 var existingID int64
391 err = tx.QueryRowContext(ctx, `SELECT id FROM users WHERE auth_id = ?`, authID).Scan(&existingID)
392 if errors.Is(err, sql.ErrNoRows) {
393 var nameTaken int
394 if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM users WHERE username = ?`, username).Scan(&nameTaken); err != nil {
395 return User{}, err
396 }
397 if nameTaken > 0 {
398 return User{}, i18n.E("err.userTaken", username)
399 }
400 admin := 0
401 if count == 0 {
402 admin = 1
403 }
404 res, err := tx.ExecContext(ctx, `INSERT INTO users (auth_id, username, avatar_url, auth_admin, instance_admin, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)`,
405 authID, username, avatar, boolInt(authAdmin), admin, ts, ts)
406 if err != nil {
407 return User{}, err
408 }
409 existingID, _ = res.LastInsertId()
410 } else if err != nil {
411 return User{}, err
412 } else {
413 if _, err := tx.ExecContext(ctx, `UPDATE users SET username = ?, avatar_url = ?, auth_admin = ?, updated_at = ? WHERE id = ? AND username = ?`,
414 username, avatar, boolInt(authAdmin), ts, existingID, username); err != nil {
415 return User{}, err
416 }
417 // Naamwijziging alleen als de nieuwe naam vrij is en gelijk blijft als hij botst.
418 var current string
419 if err := tx.QueryRowContext(ctx, `SELECT username FROM users WHERE id = ?`, existingID).Scan(&current); err != nil {
420 return User{}, err
421 }
422 if current != username {
423 var taken int
424 if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM users WHERE username = ? AND id <> ?`, username, existingID).Scan(&taken); err != nil {
425 return User{}, err
426 }
427 var groupTaken int
428 if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM groups WHERE path = ?`, username).Scan(&groupTaken); err != nil {
429 return User{}, err
430 }
431 if taken == 0 && groupTaken == 0 {
432 if _, err := tx.ExecContext(ctx, `UPDATE users SET username = ?, avatar_url = ?, auth_admin = ?, updated_at = ? WHERE id = ?`,
433 username, avatar, boolInt(authAdmin), ts, existingID); err != nil {
434 return User{}, err
435 }
436 } else if _, err := tx.ExecContext(ctx, `UPDATE users SET avatar_url = ?, auth_admin = ?, updated_at = ? WHERE id = ?`,
437 avatar, boolInt(authAdmin), ts, existingID); err != nil {
438 return User{}, err
439 }
440 }
441 }
442 if err := claimPending(ctx, tx, existingID, username); err != nil {
443 return User{}, err
444 }
445 if err := tx.Commit(); err != nil {
446 return User{}, err
447 }
448 return s.UserByID(ctx, existingID)
449}
450
451func claimPending(ctx context.Context, tx *sql.Tx, userID int64, username string) error {
452 rows, err := tx.QueryContext(ctx, `SELECT id, scope_kind, scope_id, role FROM pending_members WHERE username = ?`, username)
453 if err != nil {
454 return err
455 }
456 defer rows.Close()
457 type pend struct {
458 id, scopeID int64
459 kind, role string
460 }
461 var all []pend
462 for rows.Next() {
463 var p pend
464 if err := rows.Scan(&p.id, &p.kind, &p.scopeID, &p.role); err != nil {
465 return err
466 }
467 all = append(all, p)
468 }
469 if err := rows.Err(); err != nil {
470 return err
471 }
472 for _, p := range all {
473 switch p.kind {
474 case "group":
475 if _, err := tx.ExecContext(ctx, `INSERT OR IGNORE INTO group_members (group_id, user_id, role) VALUES (?, ?, ?)`, p.scopeID, userID, p.role); err != nil {
476 return err
477 }
478 case "repo":
479 if _, err := tx.ExecContext(ctx, `INSERT OR IGNORE INTO repo_members (repo_id, user_id, role) VALUES (?, ?, ?)`, p.scopeID, userID, p.role); err != nil {
480 return err
481 }
482 }
483 if _, err := tx.ExecContext(ctx, `DELETE FROM pending_members WHERE id = ?`, p.id); err != nil {
484 return err
485 }
486 }
487 return nil
488}
489
490// UserByID leest één account.
491func (s *Store) UserByID(ctx context.Context, id int64) (User, error) {
492 row := s.db.QueryRowContext(ctx, `SELECT id, auth_id, username, avatar_url, auth_admin, instance_admin, language, created_at FROM users WHERE id = ?`, id)
493 return scanUser(row)
494}
495
496// UserByUsername leest op naam.
497func (s *Store) UserByUsername(ctx context.Context, username string) (User, error) {
498 row := s.db.QueryRowContext(ctx, `SELECT id, auth_id, username, avatar_url, auth_admin, instance_admin, language, created_at FROM users WHERE username = ?`, strings.ToLower(username))
499 return scanUser(row)
500}
501
502func scanUser(row *sql.Row) (User, error) {
503 var u User
504 var admin, inst int
505 var created string
506 if err := row.Scan(&u.ID, &u.AuthID, &u.Username, &u.AvatarURL, &admin, &inst, &u.Language, &created); err != nil {
507 if errors.Is(err, sql.ErrNoRows) {
508 return User{}, errNotFound
509 }
510 return User{}, err
511 }
512 u.AuthAdmin = admin == 1
513 u.InstanceAdmin = inst == 1
514 if u.Language == "" {
515 u.Language = "en"
516 }
517 u.CreatedAt = parseTime(created)
518 return u, nil
519}
520
521// Session is een browsersessie.
522type Session struct {
523 ID string
524 UserID int64
525 AccessToken string
526 ExpiresAt time.Time
527 CSRF string
528 User User
529}
530
531// CreateSession bewaart het bearer-token van de auth-server.
532func (s *Store) CreateSession(ctx context.Context, userID int64, accessToken string, expiresAt time.Time) (Session, error) {
533 id, err := randomID()
534 if err != nil {
535 return Session{}, err
536 }
537 csrf, err := randomID()
538 if err != nil {
539 return Session{}, err
540 }
541 _, err = s.db.ExecContext(ctx, `INSERT INTO sessions (id, user_id, access_token, expires_at, csrf, created_at) VALUES (?, ?, ?, ?, ?, ?)`,
542 id, userID, accessToken, expiresAt.UTC().Format(time.RFC3339), csrf, now())
543 if err != nil {
544 return Session{}, err
545 }
546 return s.Session(ctx, id)
547}
548
549// Session leest een sessie met de gebruiker.
550func (s *Store) Session(ctx context.Context, id string) (Session, error) {
551 var sess Session
552 var exp string
553 err := s.db.QueryRowContext(ctx, `SELECT id, user_id, access_token, expires_at, csrf FROM sessions WHERE id = ?`, id).
554 Scan(&sess.ID, &sess.UserID, &sess.AccessToken, &exp, &sess.CSRF)
555 if errors.Is(err, sql.ErrNoRows) {
556 return Session{}, errNotFound
557 }
558 if err != nil {
559 return Session{}, err
560 }
561 sess.ExpiresAt = parseTime(exp)
562 u, err := s.UserByID(ctx, sess.UserID)
563 if err != nil {
564 return Session{}, err
565 }
566 sess.User = u
567 return sess, nil
568}
569
570// UpdateSessionExpiry schuift de lokale kopie van de auth-sessie op.
571func (s *Store) UpdateSessionExpiry(ctx context.Context, id string, expiresAt time.Time) error {
572 _, err := s.db.ExecContext(ctx, `UPDATE sessions SET expires_at = ? WHERE id = ?`, expiresAt.UTC().Format(time.RFC3339), id)
573 return err
574}
575
576// DeleteSession verwijdert de lokale sessie.
577func (s *Store) DeleteSession(ctx context.Context, id string) error {
578 _, err := s.db.ExecContext(ctx, `DELETE FROM sessions WHERE id = ?`, id)
579 return err
580}
581
582// TokenInfo is een persoonlijk toegangstoken zonder het geheim.
583type TokenInfo struct {
584 ID int64
585 Name string
586 Prefix string
587 CreatedAt time.Time
588 LastUsedAt time.Time
589}
590
591// CreateToken maakt een bg_-token. De tekst wordt één keer teruggegeven.
592func (s *Store) CreateToken(ctx context.Context, userID int64, name string) (string, error) {
593 name = strings.TrimSpace(name)
594 if name == "" || len(name) > 80 {
595 return "", i18n.E("err.tokenNeedsName")
596 }
597 plain, err := newToken("bg_")
598 if err != nil {
599 return "", err
600 }
601 _, err = s.db.ExecContext(ctx, `INSERT INTO access_tokens (user_id, name, token_hash, prefix, created_at) VALUES (?, ?, ?, ?, ?)`,
602 userID, name, hashToken(plain), plain[:10], now())
603 if err != nil {
604 return "", err
605 }
606 return plain, nil
607}
608
609// ListTokens toont de tokens van een gebruiker.
610func (s *Store) ListTokens(ctx context.Context, userID int64) ([]TokenInfo, error) {
611 rows, err := s.db.QueryContext(ctx, `SELECT id, name, prefix, created_at, COALESCE(last_used_at, '') FROM access_tokens WHERE user_id = ? ORDER BY id DESC`, userID)
612 if err != nil {
613 return nil, err
614 }
615 defer rows.Close()
616 var out []TokenInfo
617 for rows.Next() {
618 var t TokenInfo
619 var created, used string
620 if err := rows.Scan(&t.ID, &t.Name, &t.Prefix, &created, &used); err != nil {
621 return nil, err
622 }
623 t.CreatedAt = parseTime(created)
624 t.LastUsedAt = parseTime(used)
625 out = append(out, t)
626 }
627 return out, rows.Err()
628}
629
630// DeleteToken verwijdert een token van deze gebruiker.
631func (s *Store) DeleteToken(ctx context.Context, userID, id int64) error {
632 res, err := s.db.ExecContext(ctx, `DELETE FROM access_tokens WHERE id = ? AND user_id = ?`, id, userID)
633 if err != nil {
634 return err
635 }
636 n, _ := res.RowsAffected()
637 if n == 0 {
638 return errNotFound
639 }
640 return nil
641}
642
643// UserByToken zoekt de eigenaar van een persoonlijk token.
644func (s *Store) UserByToken(ctx context.Context, token string) (User, error) {
645 if !strings.HasPrefix(token, "bg_") {
646 return User{}, errNotFound
647 }
648 var userID, tokenID int64
649 err := s.db.QueryRowContext(ctx, `SELECT id, user_id FROM access_tokens WHERE token_hash = ?`, hashToken(token)).Scan(&tokenID, &userID)
650 if errors.Is(err, sql.ErrNoRows) {
651 return User{}, errNotFound
652 }
653 if err != nil {
654 return User{}, err
655 }
656 _, _ = s.db.ExecContext(ctx, `UPDATE access_tokens SET last_used_at = ? WHERE id = ?`, now(), tokenID)
657 return s.UserByID(ctx, userID)
658}
659
660// SSHKey is een publieke sleutel voor git-over-SSH.
661type SSHKey struct {
662 ID int64
663 UserID int64
664 Name string
665 PublicKey string
666 Fingerprint string
667 CreatedAt time.Time
668}
669
670// AddSSHKey bewaart één OpenSSH-regel.
671func (s *Store) AddSSHKey(ctx context.Context, userID int64, name, line, fingerprint string) error {
672 name = strings.TrimSpace(name)
673 if name == "" {
674 name = "sleutel"
675 }
676 _, err := s.db.ExecContext(ctx, `INSERT INTO ssh_keys (user_id, name, public_key, fingerprint, created_at) VALUES (?, ?, ?, ?, ?)`,
677 userID, name, strings.TrimSpace(line), fingerprint, now())
678 if err != nil && strings.Contains(err.Error(), "UNIQUE") {
679 return i18n.E("err.sshDup")
680 }
681 return err
682}
683
684// ListSSHKeys toont de sleutels van een gebruiker.
685func (s *Store) ListSSHKeys(ctx context.Context, userID int64) ([]SSHKey, error) {
686 rows, err := s.db.QueryContext(ctx, `SELECT id, user_id, name, public_key, fingerprint, created_at FROM ssh_keys WHERE user_id = ? ORDER BY id`, userID)
687 if err != nil {
688 return nil, err
689 }
690 defer rows.Close()
691 return scanKeys(rows)
692}
693
694// SSHKeyByFingerprint zoekt een sleutel voor de SSH-server.
695func (s *Store) SSHKeyByFingerprint(ctx context.Context, fingerprint string) (SSHKey, error) {
696 row := s.db.QueryRowContext(ctx, `SELECT id, user_id, name, public_key, fingerprint, created_at FROM ssh_keys WHERE fingerprint = ?`, fingerprint)
697 var k SSHKey
698 var created string
699 if err := row.Scan(&k.ID, &k.UserID, &k.Name, &k.PublicKey, &k.Fingerprint, &created); err != nil {
700 if errors.Is(err, sql.ErrNoRows) {
701 return SSHKey{}, errNotFound
702 }
703 return SSHKey{}, err
704 }
705 k.CreatedAt = parseTime(created)
706 return k, nil
707}
708
709// DeleteSSHKey verwijdert een sleutel van deze gebruiker.
710func (s *Store) DeleteSSHKey(ctx context.Context, userID, id int64) error {
711 res, err := s.db.ExecContext(ctx, `DELETE FROM ssh_keys WHERE id = ? AND user_id = ?`, id, userID)
712 if err != nil {
713 return err
714 }
715 n, _ := res.RowsAffected()
716 if n == 0 {
717 return errNotFound
718 }
719 return nil
720}
721
722func scanKeys(rows *sql.Rows) ([]SSHKey, error) {
723 var out []SSHKey
724 for rows.Next() {
725 var k SSHKey
726 var created string
727 if err := rows.Scan(&k.ID, &k.UserID, &k.Name, &k.PublicKey, &k.Fingerprint, &created); err != nil {
728 return nil, err
729 }
730 k.CreatedAt = parseTime(created)
731 out = append(out, k)
732 }
733 return out, rows.Err()
734}
735
736func randomID() (string, error) {
737 b := make([]byte, 32)
738 if _, err := rand.Read(b); err != nil {
739 return "", err
740 }
741 return hex.EncodeToString(b), nil
742}
743
744func newToken(prefix string) (string, error) {
745 b := make([]byte, 32)
746 if _, err := rand.Read(b); err != nil {
747 return "", err
748 }
749 return prefix + hex.EncodeToString(b), nil
750}
751
752func hashToken(token string) string {
753 sum := sha256.Sum256([]byte(token))
754 return hex.EncodeToString(sum[:])
755}
756
757func boolInt(b bool) int {
758 if b {
759 return 1
760 }
761 return 0
762}
763
764var errNotFound = fmt.Errorf("niet gevonden")
765
766// ErrNotFound is het resultaat als een rij ontbreekt.
767func ErrNotFound() error { return errNotFound }
768
769// IsNotFound meldt of err een ontbrekende rij is.
770func IsNotFound(err error) bool { return errors.Is(err, errNotFound) }
771
772func mustJSON(v any) string {
773 b, _ := json.Marshal(v)
774 if b == nil {
775 return "null"
776 }
777 return string(b)
778}
779
780// EncryptSecret versleutelt een geheim met de installatiesleutel.
781func (s *Store) encrypt(plain string) (nonce, ct []byte, err error) {
782 return secretbox.Encrypt(s.key, plain)
783}
784
785func (s *Store) decrypt(nonce, ct []byte) (string, error) {
786 return secretbox.Decrypt(s.key, nonce, ct)
787}