1package sqlite
2
3import (
4 "context"
5 "errors"
6 "fmt"
7 "os"
8 "path/filepath"
9 "strings"
10
11 "github.com/charmbracelet/log"
12 "github.com/charmbracelet/soft-serve/git"
13 "github.com/charmbracelet/soft-serve/server/backend"
14 "github.com/charmbracelet/soft-serve/server/cache"
15 "github.com/charmbracelet/soft-serve/server/config"
16 "github.com/charmbracelet/soft-serve/server/hooks"
17 "github.com/charmbracelet/soft-serve/server/utils"
18 "github.com/jmoiron/sqlx"
19 _ "modernc.org/sqlite" // sqlite driver
20)
21
22// SqliteBackend is a backend that uses a SQLite database as a Soft Serve
23// backend.
24type SqliteBackend struct { //nolint: revive
25 cfg *config.Config
26 ctx context.Context
27 dp string
28 db *sqlx.DB
29 logger *log.Logger
30
31 // Repositories cache
32 cache cache.Cache
33}
34
35func (d *SqliteBackend) reposPath() string {
36 return filepath.Join(d.dp, "repos")
37}
38
39// NewSqliteBackend creates a new SqliteBackend.
40func NewSqliteBackend(ctx context.Context) (*SqliteBackend, error) {
41 cfg := config.FromContext(ctx)
42 dataPath := cfg.DataPath
43 if err := os.MkdirAll(dataPath, os.ModePerm); err != nil {
44 return nil, err
45 }
46
47 db, err := sqlx.Connect("sqlite", filepath.Join(dataPath, "soft-serve.db"+
48 "?_pragma=busy_timeout(5000)&_pragma=foreign_keys(1)"))
49 if err != nil {
50 return nil, err
51 }
52
53 d := &SqliteBackend{
54 cfg: cfg,
55 ctx: ctx,
56 dp: dataPath,
57 db: db,
58 cache: cache.FromContext(ctx),
59 logger: log.FromContext(ctx).WithPrefix("sqlite"),
60 }
61
62 if err := d.init(); err != nil {
63 return nil, err
64 }
65
66 if err := d.db.Ping(); err != nil {
67 return nil, err
68 }
69
70 return d, d.initRepos()
71}
72
73// WithContext returns a shallow copy of SqliteBackend with the given context.
74func (d SqliteBackend) WithContext(ctx context.Context) *SqliteBackend {
75 d.ctx = ctx
76 return &d
77}
78
79// AllowKeyless returns whether or not keyless access is allowed.
80//
81// It implements backend.Backend.
82func (d *SqliteBackend) AllowKeyless() bool {
83 var allow bool
84 if err := wrapTx(d.db, d.ctx, func(tx *sqlx.Tx) error {
85 return tx.Get(&allow, "SELECT value FROM settings WHERE key = ?;", "allow_keyless")
86 }); err != nil {
87 return false
88 }
89
90 return allow
91}
92
93// AnonAccess returns the level of anonymous access.
94//
95// It implements backend.Backend.
96func (d *SqliteBackend) AnonAccess() backend.AccessLevel {
97 var level string
98 if err := wrapTx(d.db, d.ctx, func(tx *sqlx.Tx) error {
99 return tx.Get(&level, "SELECT value FROM settings WHERE key = ?;", "anon_access")
100 }); err != nil {
101 return backend.NoAccess
102 }
103
104 return backend.ParseAccessLevel(level)
105}
106
107// SetAllowKeyless sets whether or not keyless access is allowed.
108//
109// It implements backend.Backend.
110func (d *SqliteBackend) SetAllowKeyless(allow bool) error {
111 return wrapDbErr(
112 wrapTx(d.db, d.ctx, func(tx *sqlx.Tx) error {
113 _, err := tx.Exec("UPDATE settings SET value = ?, updated_at = CURRENT_TIMESTAMP WHERE key = ?;", allow, "allow_keyless")
114 return err
115 }),
116 )
117}
118
119// SetAnonAccess sets the level of anonymous access.
120//
121// It implements backend.Backend.
122func (d *SqliteBackend) SetAnonAccess(level backend.AccessLevel) error {
123 return wrapDbErr(
124 wrapTx(d.db, d.ctx, func(tx *sqlx.Tx) error {
125 _, err := tx.Exec("UPDATE settings SET value = ?, updated_at = CURRENT_TIMESTAMP WHERE key = ?;", level.String(), "anon_access")
126 return err
127 }),
128 )
129}
130
131// CreateRepository creates a new repository.
132//
133// It implements backend.Backend.
134func (d *SqliteBackend) CreateRepository(name string, opts backend.RepositoryOptions) (backend.Repository, error) {
135 name = utils.SanitizeRepo(name)
136 if err := utils.ValidateRepo(name); err != nil {
137 return nil, err
138 }
139
140 repo := name + ".git"
141 rp := filepath.Join(d.reposPath(), repo)
142
143 if err := wrapTx(d.db, d.ctx, func(tx *sqlx.Tx) error {
144 if _, err := tx.Exec(`INSERT INTO repo (name, project_name, description, private, mirror, hidden, updated_at)
145 VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP);`,
146 name, opts.ProjectName, opts.Description, opts.Private, opts.Mirror, opts.Hidden); err != nil {
147 return err
148 }
149
150 _, err := git.Init(rp, true)
151 if err != nil {
152 d.logger.Debug("failed to create repository", "err", err)
153 return err
154 }
155
156 return nil
157 }); err != nil {
158 d.logger.Debug("failed to create repository in database", "err", err)
159 return nil, wrapDbErr(err)
160 }
161
162 r := &Repo{
163 name: name,
164 path: rp,
165 db: d.db,
166 }
167
168 // Set cache
169 d.cache.Set(d.ctx, cacheKey(name), r)
170
171 return r, d.initRepo(name)
172}
173
174// ImportRepository imports a repository from remote.
175func (d *SqliteBackend) ImportRepository(name string, remote string, opts backend.RepositoryOptions) (backend.Repository, error) {
176 name = utils.SanitizeRepo(name)
177 if err := utils.ValidateRepo(name); err != nil {
178 return nil, err
179 }
180
181 repo := name + ".git"
182 rp := filepath.Join(d.reposPath(), repo)
183
184 if _, err := os.Stat(rp); err == nil || os.IsExist(err) {
185 return nil, ErrRepoExist
186 }
187
188 copts := git.CloneOptions{
189 Bare: true,
190 Mirror: opts.Mirror,
191 Quiet: true,
192 CommandOptions: git.CommandOptions{
193 Timeout: -1,
194 Context: d.ctx,
195 Envs: []string{
196 fmt.Sprintf(`GIT_SSH_COMMAND=ssh -o UserKnownHostsFile="%s" -o StrictHostKeyChecking=no -i "%s"`,
197 filepath.Join(d.cfg.DataPath, "ssh", "known_hosts"),
198 d.cfg.SSH.ClientKeyPath,
199 ),
200 },
201 },
202 // Timeout: time.Hour,
203 }
204
205 if err := git.Clone(remote, rp, copts); err != nil {
206 d.logger.Error("failed to clone repository", "err", err, "mirror", opts.Mirror, "remote", remote, "path", rp)
207 // Cleanup the mess!
208 if rerr := os.RemoveAll(rp); rerr != nil {
209 err = errors.Join(err, rerr)
210 }
211 return nil, err
212 }
213
214 return d.CreateRepository(name, opts)
215}
216
217// DeleteRepository deletes a repository.
218//
219// It implements backend.Backend.
220func (d *SqliteBackend) DeleteRepository(name string) error {
221 name = utils.SanitizeRepo(name)
222 repo := name + ".git"
223 rp := filepath.Join(d.reposPath(), repo)
224
225 return wrapTx(d.db, d.ctx, func(tx *sqlx.Tx) error {
226 // Delete repo from cache
227 defer d.cache.Delete(d.ctx, cacheKey(name))
228
229 if _, err := tx.Exec("DELETE FROM repo WHERE name = ?;", name); err != nil {
230 return err
231 }
232
233 return os.RemoveAll(rp)
234 })
235}
236
237// RenameRepository renames a repository.
238//
239// It implements backend.Backend.
240func (d *SqliteBackend) RenameRepository(oldName string, newName string) error {
241 oldName = utils.SanitizeRepo(oldName)
242 if err := utils.ValidateRepo(oldName); err != nil {
243 return err
244 }
245
246 newName = utils.SanitizeRepo(newName)
247 if err := utils.ValidateRepo(newName); err != nil {
248 return err
249 }
250 oldRepo := oldName + ".git"
251 newRepo := newName + ".git"
252 op := filepath.Join(d.reposPath(), oldRepo)
253 np := filepath.Join(d.reposPath(), newRepo)
254 if _, err := os.Stat(op); err != nil {
255 return ErrRepoNotExist
256 }
257
258 if _, err := os.Stat(np); err == nil {
259 return ErrRepoExist
260 }
261
262 if err := wrapTx(d.db, d.ctx, func(tx *sqlx.Tx) error {
263 // Delete cache
264 defer d.cache.Delete(d.ctx, cacheKey(oldName))
265
266 _, err := tx.Exec("UPDATE repo SET name = ?, updated_at = CURRENT_TIMESTAMP WHERE name = ?;", newName, oldName)
267 if err != nil {
268 return err
269 }
270
271 // Make sure the new repository parent directory exists.
272 if err := os.MkdirAll(filepath.Dir(np), os.ModePerm); err != nil {
273 return err
274 }
275
276 if err := os.Rename(op, np); err != nil {
277 return err
278 }
279
280 return nil
281 }); err != nil {
282 return wrapDbErr(err)
283 }
284
285 return nil
286}
287
288// Repositories returns a list of all repositories.
289//
290// It implements backend.Backend.
291func (d *SqliteBackend) Repositories() ([]backend.Repository, error) {
292 repos := make([]backend.Repository, 0)
293
294 if err := wrapTx(d.db, d.ctx, func(tx *sqlx.Tx) error {
295 rows, err := tx.Query("SELECT name FROM repo")
296 if err != nil {
297 return err
298 }
299
300 defer rows.Close() // nolint: errcheck
301 for rows.Next() {
302 var name string
303 if err := rows.Scan(&name); err != nil {
304 return err
305 }
306
307 if r, ok := d.cache.Get(d.ctx, cacheKey(name)); ok && r != nil {
308 if r, ok := r.(*Repo); ok {
309 repos = append(repos, r)
310 }
311 continue
312 }
313
314 r := &Repo{
315 name: name,
316 path: filepath.Join(d.reposPath(), name+".git"),
317 db: d.db,
318 }
319
320 // Cache repositories
321 d.cache.Set(d.ctx, cacheKey(name), r)
322
323 repos = append(repos, r)
324 }
325
326 return nil
327 }); err != nil {
328 return nil, wrapDbErr(err)
329 }
330
331 return repos, nil
332}
333
334// Repository returns a repository by name.
335//
336// It implements backend.Backend.
337func (d *SqliteBackend) Repository(repo string) (backend.Repository, error) {
338 repo = utils.SanitizeRepo(repo)
339
340 if r, ok := d.cache.Get(d.ctx, cacheKey(repo)); ok && r != nil {
341 if r, ok := r.(*Repo); ok {
342 return r, nil
343 }
344 }
345
346 rp := filepath.Join(d.reposPath(), repo+".git")
347 if _, err := os.Stat(rp); err != nil {
348 return nil, os.ErrNotExist
349 }
350
351 var count int
352 if err := wrapTx(d.db, d.ctx, func(tx *sqlx.Tx) error {
353 return tx.Get(&count, "SELECT COUNT(*) FROM repo WHERE name = ?", repo)
354 }); err != nil {
355 return nil, wrapDbErr(err)
356 }
357
358 if count == 0 {
359 d.logger.Warn("repository exists but not found in database", "repo", repo)
360 return nil, ErrRepoNotExist
361 }
362
363 r := &Repo{
364 name: repo,
365 path: rp,
366 db: d.db,
367 }
368
369 // Add to cache
370 d.cache.Set(d.ctx, cacheKey(repo), r)
371
372 return r, nil
373}
374
375// Description returns the description of a repository.
376//
377// It implements backend.Backend.
378func (d *SqliteBackend) Description(repo string) (string, error) {
379 r, err := d.Repository(repo)
380 if err != nil {
381 return "", err
382 }
383
384 return r.Description(), nil
385}
386
387// IsMirror returns true if the repository is a mirror.
388//
389// It implements backend.Backend.
390func (d *SqliteBackend) IsMirror(repo string) (bool, error) {
391 r, err := d.Repository(repo)
392 if err != nil {
393 return false, err
394 }
395
396 return r.IsMirror(), nil
397}
398
399// IsPrivate returns true if the repository is private.
400//
401// It implements backend.Backend.
402func (d *SqliteBackend) IsPrivate(repo string) (bool, error) {
403 r, err := d.Repository(repo)
404 if err != nil {
405 return false, err
406 }
407
408 return r.IsPrivate(), nil
409}
410
411// IsHidden returns true if the repository is hidden.
412//
413// It implements backend.Backend.
414func (d *SqliteBackend) IsHidden(repo string) (bool, error) {
415 r, err := d.Repository(repo)
416 if err != nil {
417 return false, err
418 }
419
420 return r.IsHidden(), nil
421}
422
423// SetHidden sets the hidden flag of a repository.
424//
425// It implements backend.Backend.
426func (d *SqliteBackend) SetHidden(repo string, hidden bool) error {
427 repo = utils.SanitizeRepo(repo)
428
429 // Delete cache
430 d.cache.Delete(d.ctx, cacheKey(repo))
431
432 return wrapDbErr(wrapTx(d.db, d.ctx, func(tx *sqlx.Tx) error {
433 var count int
434 if err := tx.Get(&count, "SELECT COUNT(*) FROM repo WHERE name = ?", repo); err != nil {
435 return err
436 }
437 if count == 0 {
438 return ErrRepoNotExist
439 }
440 _, err := tx.Exec("UPDATE repo SET hidden = ?, updated_at = CURRENT_TIMESTAMP WHERE name = ?;", hidden, repo)
441 return err
442 }))
443}
444
445// ProjectName returns the project name of a repository.
446//
447// It implements backend.Backend.
448func (d *SqliteBackend) ProjectName(repo string) (string, error) {
449 r, err := d.Repository(repo)
450 if err != nil {
451 return "", err
452 }
453
454 return r.ProjectName(), nil
455}
456
457// SetDescription sets the description of a repository.
458//
459// It implements backend.Backend.
460func (d *SqliteBackend) SetDescription(repo string, desc string) error {
461 repo = utils.SanitizeRepo(repo)
462
463 // Delete cache
464 d.cache.Delete(d.ctx, cacheKey(repo))
465
466 return wrapTx(d.db, d.ctx, func(tx *sqlx.Tx) error {
467 var count int
468 if err := tx.Get(&count, "SELECT COUNT(*) FROM repo WHERE name = ?", repo); err != nil {
469 return err
470 }
471 if count == 0 {
472 return ErrRepoNotExist
473 }
474 _, err := tx.Exec("UPDATE repo SET description = ?, updated_at = CURRENT_TIMESTAMP WHERE name = ?", desc, repo)
475 return err
476 })
477}
478
479// SetPrivate sets the private flag of a repository.
480//
481// It implements backend.Backend.
482func (d *SqliteBackend) SetPrivate(repo string, private bool) error {
483 repo = utils.SanitizeRepo(repo)
484
485 // Delete cache
486 d.cache.Delete(d.ctx, cacheKey(repo))
487
488 return wrapDbErr(
489 wrapTx(d.db, d.ctx, func(tx *sqlx.Tx) error {
490 var count int
491 if err := tx.Get(&count, "SELECT COUNT(*) FROM repo WHERE name = ?", repo); err != nil {
492 return err
493 }
494 if count == 0 {
495 return ErrRepoNotExist
496 }
497 _, err := tx.Exec("UPDATE repo SET private = ?, updated_at = CURRENT_TIMESTAMP WHERE name = ?", private, repo)
498 return err
499 }),
500 )
501}
502
503// SetProjectName sets the project name of a repository.
504//
505// It implements backend.Backend.
506func (d *SqliteBackend) SetProjectName(repo string, name string) error {
507 repo = utils.SanitizeRepo(repo)
508
509 // Delete cache
510 d.cache.Delete(d.ctx, cacheKey(repo))
511
512 return wrapDbErr(
513 wrapTx(d.db, d.ctx, func(tx *sqlx.Tx) error {
514 var count int
515 if err := tx.Get(&count, "SELECT COUNT(*) FROM repo WHERE name = ?", repo); err != nil {
516 return err
517 }
518 if count == 0 {
519 return ErrRepoNotExist
520 }
521 _, err := tx.Exec("UPDATE repo SET project_name = ?, updated_at = CURRENT_TIMESTAMP WHERE name = ?", name, repo)
522 return err
523 }),
524 )
525}
526
527// AddCollaborator adds a collaborator to a repository.
528//
529// It implements backend.Backend.
530func (d *SqliteBackend) AddCollaborator(repo string, username string) error {
531 username = strings.ToLower(username)
532 if err := utils.ValidateUsername(username); err != nil {
533 return err
534 }
535
536 repo = utils.SanitizeRepo(repo)
537 return wrapDbErr(wrapTx(d.db, d.ctx, func(tx *sqlx.Tx) error {
538 _, err := tx.Exec(`INSERT INTO collab (user_id, repo_id, updated_at)
539 VALUES (
540 (SELECT id FROM user WHERE username = ?),
541 (SELECT id FROM repo WHERE name = ?),
542 CURRENT_TIMESTAMP
543 );`, username, repo)
544 return err
545 }),
546 )
547}
548
549// Collaborators returns a list of collaborators for a repository.
550//
551// It implements backend.Backend.
552func (d *SqliteBackend) Collaborators(repo string) ([]string, error) {
553 repo = utils.SanitizeRepo(repo)
554 var users []string
555 if err := wrapTx(d.db, d.ctx, func(tx *sqlx.Tx) error {
556 return tx.Select(&users, `SELECT user.username FROM user
557 INNER JOIN collab ON user.id = collab.user_id
558 INNER JOIN repo ON repo.id = collab.repo_id
559 WHERE repo.name = ?`, repo)
560 }); err != nil {
561 return nil, wrapDbErr(err)
562 }
563
564 return users, nil
565}
566
567// IsCollaborator returns true if the user is a collaborator of the repository.
568//
569// It implements backend.Backend.
570func (d *SqliteBackend) IsCollaborator(repo string, username string) (bool, error) {
571 repo = utils.SanitizeRepo(repo)
572 var count int
573 if err := wrapTx(d.db, d.ctx, func(tx *sqlx.Tx) error {
574 return tx.Get(&count, `SELECT COUNT(*) FROM user
575 INNER JOIN collab ON user.id = collab.user_id
576 INNER JOIN repo ON repo.id = collab.repo_id
577 WHERE repo.name = ? AND user.username = ?`, repo, username)
578 }); err != nil {
579 return false, wrapDbErr(err)
580 }
581
582 return count > 0, nil
583}
584
585// RemoveCollaborator removes a collaborator from a repository.
586//
587// It implements backend.Backend.
588func (d *SqliteBackend) RemoveCollaborator(repo string, username string) error {
589 repo = utils.SanitizeRepo(repo)
590 return wrapDbErr(
591 wrapTx(d.db, d.ctx, func(tx *sqlx.Tx) error {
592 _, err := tx.Exec(`DELETE FROM collab
593 WHERE user_id = (SELECT id FROM user WHERE username = ?)
594 AND repo_id = (SELECT id FROM repo WHERE name = ?)`, username, repo)
595 return err
596 }),
597 )
598}
599
600func (d *SqliteBackend) initRepo(repo string) error {
601 return hooks.GenerateHooks(d.ctx, d.cfg, repo)
602}
603
604func (d *SqliteBackend) initRepos() error {
605 repos, err := d.Repositories()
606 if err != nil {
607 return err
608 }
609
610 for _, repo := range repos {
611 if err := d.initRepo(repo.Name()); err != nil {
612 return err
613 }
614 }
615
616 return nil
617}
618
619// cacheKey returns the cache key for a repository.
620func cacheKey(name string) string {
621 return fmt.Sprintf("repo:%s", name)
622}