- feat(storage): libraries table (name, path); audio_files points at a library
by id instead of repeating the root path; migration 0005 for both drivers
turns every existing root into a library and keeps file ids, tracks and the
missing flag
- feat(library): Libraries service validates names and paths: absolute, an
existing directory, never the filesystem root, never inside or around
another library (checked on real paths, so symlinks cannot hide an overlap)
- feat(api): admin-only GET/POST /libraries, PATCH/DELETE /libraries/{id} and
POST /libraries/{id}/scan; deleting a library drops its index entries and
keeps tracks and listening history
- feat(library): the scanner and the scan manager work on libraries; scanning
with no libraries answers 409 no_libraries
- feat(streaming): the library directory comes from the database instead of
a configured list of roots
- breaking(config): library.roots is removed; an old config fails with a hint
to use POST /api/v1/libraries
- test: CRUD and duplicates on both databases, path change keeps files,
upgrade of a database written before libraries existed
244 lines
7.1 KiB
Go
244 lines
7.1 KiB
Go
package streaming
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
)
|
|
|
|
type fakeSource struct {
|
|
files map[int64]File
|
|
err error
|
|
}
|
|
|
|
func (f fakeSource) PlayableFile(_ context.Context, trackID int64) (File, error) {
|
|
if f.err != nil {
|
|
return File{}, f.err
|
|
}
|
|
file, ok := f.files[trackID]
|
|
if !ok {
|
|
return File{}, ErrNotFound
|
|
}
|
|
return file, nil
|
|
}
|
|
|
|
func write(t *testing.T, path, content string) {
|
|
t.Helper()
|
|
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func service(files map[int64]File) *Service {
|
|
return NewService(fakeSource{files: files})
|
|
}
|
|
|
|
func TestOpenServesTheFile(t *testing.T) {
|
|
root := t.TempDir()
|
|
write(t, filepath.Join(root, "Artist/song.mp3"), "audio-bytes")
|
|
s := service(map[int64]File{1: {Root: root, RelPath: "Artist/song.mp3"}})
|
|
|
|
st, err := s.Open(context.Background(), 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer st.Close()
|
|
|
|
data, _ := io.ReadAll(st.File)
|
|
if string(data) != "audio-bytes" {
|
|
t.Errorf("content = %q", data)
|
|
}
|
|
if st.ContentType != "audio/mpeg" || st.Name != "song.mp3" || st.ModTime.IsZero() {
|
|
t.Errorf("stream = %+v", st)
|
|
}
|
|
}
|
|
|
|
func TestContentTypeFollowsTheExtension(t *testing.T) {
|
|
root := t.TempDir()
|
|
write(t, filepath.Join(root, "a.FLAC"), "x")
|
|
write(t, filepath.Join(root, "b.mp3"), "x")
|
|
write(t, filepath.Join(root, "c.xyz"), "x")
|
|
s := service(map[int64]File{
|
|
1: {Root: root, RelPath: "a.FLAC"},
|
|
2: {Root: root, RelPath: "b.mp3"},
|
|
3: {Root: root, RelPath: "c.xyz"},
|
|
})
|
|
want := map[int64]string{1: "audio/flac", 2: "audio/mpeg", 3: "application/octet-stream"}
|
|
for id, ct := range want {
|
|
st, err := s.Open(context.Background(), id)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if st.ContentType != ct {
|
|
t.Errorf("track %d: content type = %q, want %q", id, st.ContentType, ct)
|
|
}
|
|
st.Close()
|
|
}
|
|
}
|
|
|
|
func TestOpenUnknownTrack(t *testing.T) {
|
|
s := service(nil)
|
|
if _, err := s.Open(context.Background(), 42); !errors.Is(err, ErrNotFound) {
|
|
t.Fatalf("err = %v, want ErrNotFound", err)
|
|
}
|
|
}
|
|
|
|
func TestOpenPropagatesSourceErrors(t *testing.T) {
|
|
boom := errors.New("db down")
|
|
s := NewService(fakeSource{err: boom})
|
|
if _, err := s.Open(context.Background(), 1); !errors.Is(err, boom) {
|
|
t.Fatalf("err = %v, want the source error", err)
|
|
}
|
|
}
|
|
|
|
func TestOpenMissingFileOnDisk(t *testing.T) {
|
|
root := t.TempDir()
|
|
s := service(map[int64]File{1: {Root: root, RelPath: "gone.mp3"}})
|
|
if _, err := s.Open(context.Background(), 1); !errors.Is(err, ErrFileMissing) {
|
|
t.Fatalf("err = %v, want ErrFileMissing", err)
|
|
}
|
|
}
|
|
|
|
func TestOpenRejectsUnsafePaths(t *testing.T) {
|
|
root := t.TempDir()
|
|
outside := t.TempDir()
|
|
write(t, filepath.Join(outside, "secret.mp3"), "secret")
|
|
write(t, filepath.Join(root, "ok.mp3"), "ok")
|
|
|
|
tests := []struct {
|
|
name string
|
|
file File
|
|
}{
|
|
{"dot dot", File{Root: root, RelPath: "../" + filepath.Base(outside) + "/secret.mp3"}},
|
|
{"deep dot dot", File{Root: root, RelPath: "a/../../x.mp3"}},
|
|
{"absolute path", File{Root: root, RelPath: filepath.Join(outside, "secret.mp3")}},
|
|
{"empty path", File{Root: root, RelPath: ""}},
|
|
{"the root itself", File{Root: root, RelPath: "."}},
|
|
{"relative root", File{Root: "relative/dir", RelPath: "ok.mp3"}},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
s := service(map[int64]File{1: tt.file})
|
|
st, err := s.Open(context.Background(), 1)
|
|
if err == nil {
|
|
st.Close()
|
|
t.Fatal("unsafe path was opened")
|
|
}
|
|
if !errors.Is(err, ErrUnsafePath) && !errors.Is(err, ErrFileMissing) {
|
|
t.Fatalf("err = %v, want ErrUnsafePath", err)
|
|
}
|
|
if errors.Is(err, ErrNotFound) {
|
|
t.Fatal("must not look like a plain not-found")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestOpenRejectsSymlinkEscapingTheRoot(t *testing.T) {
|
|
root := t.TempDir()
|
|
outside := t.TempDir()
|
|
write(t, filepath.Join(outside, "secret.mp3"), "secret")
|
|
|
|
if err := os.Symlink(filepath.Join(outside, "secret.mp3"), filepath.Join(root, "link.mp3")); err != nil {
|
|
t.Skip("symlinks not supported:", err)
|
|
}
|
|
if err := os.Symlink(outside, filepath.Join(root, "dirlink")); err != nil {
|
|
t.Skip("symlinks not supported:", err)
|
|
}
|
|
|
|
for _, rel := range []string{"link.mp3", "dirlink/secret.mp3"} {
|
|
s := service(map[int64]File{1: {Root: root, RelPath: rel}})
|
|
st, err := s.Open(context.Background(), 1)
|
|
if err == nil {
|
|
data, _ := io.ReadAll(st.File)
|
|
st.Close()
|
|
t.Fatalf("%s: symlink escaped the root and served %q", rel, data)
|
|
}
|
|
if !errors.Is(err, ErrUnsafePath) {
|
|
t.Errorf("%s: err = %v, want ErrUnsafePath", rel, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestOpenAllowsRelativeSymlinkThatStaysInsideTheRoot(t *testing.T) {
|
|
root := t.TempDir()
|
|
write(t, filepath.Join(root, "real/song.mp3"), "ok")
|
|
if err := os.Symlink("real", filepath.Join(root, "alias")); err != nil {
|
|
t.Skip("symlinks not supported:", err)
|
|
}
|
|
s := service(map[int64]File{1: {Root: root, RelPath: "alias/song.mp3"}})
|
|
st, err := s.Open(context.Background(), 1)
|
|
if err != nil {
|
|
t.Fatalf("relative symlink inside the root rejected: %v", err)
|
|
}
|
|
st.Close()
|
|
}
|
|
|
|
// os.Root refuses absolute symlink targets even when they point back inside the
|
|
// root. The scanner never indexes through a symlink, so this only costs files
|
|
// that were linked in after the scan, and it keeps the rule simple and safe.
|
|
func TestOpenRefusesAbsoluteSymlinksEvenInsideTheRoot(t *testing.T) {
|
|
root := t.TempDir()
|
|
write(t, filepath.Join(root, "real/song.mp3"), "ok")
|
|
if err := os.Symlink(filepath.Join(root, "real"), filepath.Join(root, "alias")); err != nil {
|
|
t.Skip("symlinks not supported:", err)
|
|
}
|
|
s := service(map[int64]File{1: {Root: root, RelPath: "alias/song.mp3"}})
|
|
st, err := s.Open(context.Background(), 1)
|
|
if err == nil {
|
|
st.Close()
|
|
t.Fatal("an absolute symlink was followed")
|
|
}
|
|
if !errors.Is(err, ErrUnsafePath) {
|
|
t.Errorf("err = %v, want ErrUnsafePath", err)
|
|
}
|
|
}
|
|
|
|
func TestOpenAcceptsASymlinkedRoot(t *testing.T) {
|
|
real := t.TempDir()
|
|
write(t, filepath.Join(real, "song.mp3"), "ok")
|
|
link := filepath.Join(t.TempDir(), "music")
|
|
if err := os.Symlink(real, link); err != nil {
|
|
t.Skip("symlinks not supported:", err)
|
|
}
|
|
s := service(map[int64]File{1: {Root: link, RelPath: "song.mp3"}})
|
|
st, err := s.Open(context.Background(), 1)
|
|
if err != nil {
|
|
t.Fatalf("a symlinked root is a normal setup: %v", err)
|
|
}
|
|
st.Close()
|
|
}
|
|
|
|
func TestOpenRejectsDirectories(t *testing.T) {
|
|
root := t.TempDir()
|
|
if err := os.MkdirAll(filepath.Join(root, "album.mp3"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s := service(map[int64]File{1: {Root: root, RelPath: "album.mp3"}})
|
|
st, err := s.Open(context.Background(), 1)
|
|
if err == nil {
|
|
st.Close()
|
|
t.Fatal("a directory was opened as a stream")
|
|
}
|
|
if !errors.Is(err, ErrUnsafePath) {
|
|
t.Errorf("err = %v, want ErrUnsafePath", err)
|
|
}
|
|
}
|
|
|
|
func TestRootsAreComparedAfterCleaning(t *testing.T) {
|
|
root := t.TempDir()
|
|
write(t, filepath.Join(root, "song.mp3"), "ok")
|
|
// A stored directory with a trailing slash is still the same directory.
|
|
s := service(map[int64]File{1: {Root: root + "/", RelPath: "song.mp3"}})
|
|
st, err := s.Open(context.Background(), 1)
|
|
if err != nil {
|
|
t.Fatalf("trailing slash on the stored root: %v", err)
|
|
}
|
|
st.Close()
|
|
}
|