Restructure backend into services and fix security, crash and sync issues

Security
- Serve character images through os.Root so names like ../ can't escape
  the characters folder
- Sync start and /sync/reset are POST only (legacy and /api/v1)
- /api/v1/token/cleanup requires a token, password compared in constant
  time, tokens no longer logged
- Echo's rate limiter replaces the custom one; TRUSTED_PROXIES enables
  X-Forwarded-For for reverse proxies

Crashes and races
- Sync state lives in SyncService with atomics and a mutex instead of
  unsynchronised globals (fixes concurrent map writes during full sync)
- Only one sync can run; /api/v1 sync and music routes are locked during
  sync like the legacy ones
- No log.Fatal outside startup: errors become 4xx/5xx responses
- Search uses an in-order character match instead of unescaped regexes
- Empty queue / no songs return 404 instead of panicking or looping

Behaviour
- Sync result is computed once and stays the same between polls
- Swagger and /openapi serve the embedded spec
- Shutdown stops HTTP before closing the database
- Expired tokens are deleted with a context that outlives the request
- Files are served with Range support and correct content types; audio
  has no write deadline

Performance
- Migration 000006 adds soundtrack.fingerprint (names, sizes, mtimes) so
  unchanged folders are skipped without reading any files
- Songs are reconciled per soundtrack with one query plus needed writes;
  renames keep play counts
- Moved MUSIC_PATH updates soundtrack and song paths
- .id cleanup only runs for changed soundtracks or a full sync
- Classic random uses one SQL query; Gitea release lookups are cached
  with a timeout

Structure
- internal/config reads all environment variables once
- sqlc emits a Querier interface; backend globals become services
  injected into handlers
- One route registration shared by legacy and /api/v1
- Removed dead code (dbHelper.go, unused middleware, duplicate Gitea
  functions, embedded Swagger UI copy) and lib/pq
- templ and swag pinned as go tools
This commit is contained in:
Sansan committed 2026-10-06 15:20:14 +02:00
1 parent 75b6f0c1cf
commit 090e794460
78 files changed
+2919 -6303

No files matched your search

-204
View File
@@ -1,204 +0,0 @@
package backend
import (
"io/fs"
"os"
"testing"
"time"
)
func TestContains(t *testing.T) {
tests := []struct {
name string
slice []string
search string
expected bool
}{
{
name: "element exists",
slice: []string{"a", "b", "c"},
search: "b",
expected: true,
},
{
name: "element does not exist",
slice: []string{"a", "b", "c"},
search: "d",
expected: false,
},
{
name: "empty slice",
slice: []string{},
search: "a",
expected: false,
},
{
name: "element at start",
slice: []string{"a", "b", "c"},
search: "a",
expected: true,
},
{
name: "element at end",
slice: []string{"a", "b", "c"},
search: "c",
expected: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := contains(tt.slice, tt.search)
if result != tt.expected {
t.Errorf("contains() = %v, want %v", result, tt.expected)
}
})
}
}
func TestIsSong(t *testing.T) {
mockFileInfo := &mockFileInfoForSong{name: "test.mp3", isDir: false, size: 100}
result := isSong(mockFileInfo)
if !result {
t.Error("isSong() should return true for .mp3 file")
}
mockFileInfo2 := &mockFileInfoForSong{name: "test.txt", isDir: false, size: 100}
result = isSong(mockFileInfo2)
if result {
t.Error("isSong() should return false for .txt file")
}
mockFileInfo3 := &mockFileInfoForSong{name: "test", isDir: true, size: 100}
result = isSong(mockFileInfo3)
if result {
t.Error("isSong() should return false for directory")
}
}
func TestIsCoverImage(t *testing.T) {
tests := []struct {
name string
fileInfo fs.FileInfo
expected bool
}{
{
name: "cover.jpg",
fileInfo: &mockFileInfoForCover{name: "cover.jpg", isDir: false, size: 100},
expected: true,
},
{
name: "cover.png",
fileInfo: &mockFileInfoForCover{name: "cover.png", isDir: false, size: 100},
expected: true,
},
{
name: "my_cover.jpg",
fileInfo: &mockFileInfoForCover{name: "my_cover.jpg", isDir: false, size: 100},
expected: true,
},
{
name: "image.jpg",
fileInfo: &mockFileInfoForCover{name: "image.jpg", isDir: false, size: 100},
expected: false,
},
{
name: "cover.txt",
fileInfo: &mockFileInfoForCover{name: "cover.txt", isDir: false, size: 100},
expected: false,
},
{
name: "directory",
fileInfo: &mockFileInfoForCover{name: "cover", isDir: true, size: 100},
expected: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := isCoverImage(tt.fileInfo)
if result != tt.expected {
t.Errorf("isCoverImage() = %v, want %v", result, tt.expected)
}
})
}
}
func TestGetIdFromFileNew(t *testing.T) {
tests := []struct {
name string
fileInfo os.FileInfo
expected int32
}{
{
name: "valid id file",
fileInfo: &mockFileInfoForId{name: ".123.id", isDir: false, size: 100},
expected: 123,
},
{
name: "invalid id file (directory)",
fileInfo: &mockFileInfoForId{name: ".123.id", isDir: true, size: 100},
expected: -1,
},
{
name: "invalid id file (no .id extension)",
fileInfo: &mockFileInfoForId{name: "123.txt", isDir: false, size: 100},
expected: -1,
},
{
name: "invalid id file (not a number)",
fileInfo: &mockFileInfoForId{name: ".abc.id", isDir: false, size: 100},
expected: 0, // strconv.Atoi returns 0 for invalid numbers (error is ignored)
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := getIdFromFile(tt.fileInfo)
if result != tt.expected {
t.Errorf("getIdFromFile() = %v, want %v", result, tt.expected)
}
})
}
}
// Mock types for testing
type mockFileInfoForSong struct {
name string
isDir bool
size int64
}
func (m *mockFileInfoForSong) Name() string { return m.name }
func (m *mockFileInfoForSong) Size() int64 { return m.size }
func (m *mockFileInfoForSong) Mode() os.FileMode { return 0 }
func (m *mockFileInfoForSong) ModTime() time.Time { return time.Time{} }
func (m *mockFileInfoForSong) IsDir() bool { return m.isDir }
func (m *mockFileInfoForSong) Sys() interface{} { return nil }
type mockFileInfoForCover struct {
name string
isDir bool
size int64
}
func (m *mockFileInfoForCover) Name() string { return m.name }
func (m *mockFileInfoForCover) Size() int64 { return m.size }
func (m *mockFileInfoForCover) Mode() os.FileMode { return 0 }
func (m *mockFileInfoForCover) ModTime() time.Time { return time.Time{} }
func (m *mockFileInfoForCover) IsDir() bool { return m.isDir }
func (m *mockFileInfoForCover) Sys() interface{} { return nil }
type mockFileInfoForId struct {
name string
isDir bool
size int64
}
func (m *mockFileInfoForId) Name() string { return m.name }
func (m *mockFileInfoForId) Size() int64 { return m.size }
func (m *mockFileInfoForId) Mode() os.FileMode { return 0 }
func (m *mockFileInfoForId) ModTime() time.Time { return time.Time{} }
func (m *mockFileInfoForId) IsDir() bool { return m.isDir }
func (m *mockFileInfoForId) Sys() interface{} { return nil }