BlueGit

timfa bluegit

Files

bluegit / internal / store / store.go

store.go

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