OpenSubsonic: playback, covers, lists and search #13

Merged
squid merged 1 commit from feat/opensubsonic-media into main 2026-11-16 08:45:31 +00:00
15 changed files with 1275 additions and 27 deletions

View file

@ -303,6 +303,8 @@ func run() error {
// Other apps (OpenSubsonic) log in with the password of a device, never with the account password.
deviceSvc := devices.NewService(storage.NewDevicesRepo(db), []byte(cfg.Auth.JWTSecret))
catalogSvc := catalog.NewService(storage.NewCatalogRepo(db))
streamSvc := streaming.NewService(libraryRepo)
subsonicRepo := storage.NewSubsonicRepo(db, cfg.Listening.MinListen())
router := httpapi.NewRouter(httpapi.Deps{
Logger: logger,
@ -315,7 +317,8 @@ func run() error {
Devices: deviceSvc,
OpenSubsonic: &opensubsonic.Deps{
Login: deviceSvc, Catalog: catalogSvc, Libraries: libraries,
Extras: storage.NewSubsonicRepo(db), ServerVersion: version,
Extras: subsonicRepo, Lists: subsonicRepo, Streams: streamSvc, Covers: pictures, ArtistImages: pictures,
ServerVersion: version,
},
Scan: scanControl{ctx: ctx, m: scans},
Libraries: libraries,
@ -344,7 +347,7 @@ func run() error {
ArtistImages: pictures,
About: descriptions,
Settings: userSettings,
Streams: streaming.NewService(libraryRepo),
Streams: streamSvc,
Federation: federation.NewService(storage.NewFederationRepo(db), federation.NewClient()),
PeerCatalog: catalog.NewService(storage.NewSharedCatalogRepo(db)),
PeerStreams: streaming.NewService(libraryRepo.Shared()),

View file

@ -142,9 +142,12 @@ func newTestEnvDB(t *testing.T, mutate func(*Deps, *bun.DB)) (http.Handler, *bun
deps.ArtistImagesJob = jobs.Runner{Ctx: context.Background(), Job: images.NewArtistImagesJob(imageSvc, imageRepo)}
mutate(&deps, db)
if deps.OpenSubsonic == nil {
subsonic := storage.NewSubsonicRepo(db, 20*time.Second)
deps.OpenSubsonic = &opensubsonic.Deps{
Login: deps.Devices.(opensubsonic.Login), Catalog: deps.Catalog.(opensubsonic.Catalog),
Libraries: deps.Libraries.(opensubsonic.Libraries), Extras: storage.NewSubsonicRepo(db), ServerVersion: "test",
Libraries: deps.Libraries.(opensubsonic.Libraries), ServerVersion: "test",
Extras: subsonic, Lists: subsonic, Streams: deps.Streams.(opensubsonic.Streams),
Covers: deps.Images.(opensubsonic.Covers), ArtistImages: deps.ArtistImages.(opensubsonic.ArtistImages),
}
}
if deps.About == nil {

View file

@ -3,6 +3,7 @@ package httpapi
import (
"context"
"net/http"
"reflect"
"sort"
"testing"
@ -198,7 +199,7 @@ func TestCatalogQueryParametersReachTheService(t *testing.T) {
do(t, h, "GET", "/api/v1/tracks?q=black+sabbath&limit=25&offset=50&library_id=2&artist_id=3&album_id=4", tok, nil)
want := catalog.Filter{Query: "black sabbath", Limit: 25, Offset: 50, LibraryID: 2, ArtistID: 3, AlbumID: 4}
if fc.last != want {
if !reflect.DeepEqual(fc.last, want) {
t.Errorf("filter = %+v, want %+v", fc.last, want)
}

View file

@ -9,6 +9,7 @@ import (
"image/jpeg"
"net/http"
"net/http/httptest"
"net/url"
"os"
"path/filepath"
"sync/atomic"
@ -19,6 +20,7 @@ import (
"git.kmalloc.org/squid/sonda/internal/images"
"git.kmalloc.org/squid/sonda/internal/library"
"git.kmalloc.org/squid/sonda/internal/storage"
"git.kmalloc.org/squid/sonda/internal/streaming"
)
type fakeArchive struct {
@ -80,6 +82,7 @@ func newCoversEnv(t *testing.T) *coversEnv {
svc.SetAlbumRemote(e.archive)
e.svc = svc
d.Images = svc
d.Streams = streaming.NewService(storage.NewLibraryRepo(db))
})
e.token = registerAndLogin(t, e.h)
@ -301,3 +304,60 @@ func TestACoverOfFilesThatCannotBeReadIsServiceUnavailableNotNoCover(t *testing.
t.Errorf("the archive was asked %d times about files that could not be read", n)
}
}
func TestAnAppGetsCoversAndSongsOverRest(t *testing.T) {
e := newCoversEnv(t)
secret := do(t, e.h, "POST", "/api/v1/me/devices", e.token, map[string]any{"name": "Phone"}).Body["secret"].(string)
get := func(path string, q url.Values) *httptest.ResponseRecorder {
q.Set("apiKey", secret)
rec := httptest.NewRecorder()
e.h.ServeHTTP(rec, httptest.NewRequest("GET", "/rest/"+path+"?"+q.Encode(), nil))
return rec
}
// The cover, small and large, is the one the main API makes.
for size, max := range map[string]int{"150": 300, "1200": 1000} {
rec := get("getCoverArt", url.Values{"id": {"al-" + itoa(e.withArt)}, "size": {size}})
if rec.Code != 200 || rec.Header().Get("Content-Type") != "image/jpeg" {
t.Fatalf("size %s: %d %s %s", size, rec.Code, rec.Header().Get("Content-Type"), rec.Body.String())
}
img, err := jpeg.Decode(rec.Body)
if err != nil || img.Bounds().Dx() > max || img.Bounds().Dx() < 100 {
t.Fatalf("size %s: %v %v", size, err, img.Bounds())
}
}
if rec := get("getCoverArt", url.Values{"id": {"al-" + itoa(e.without)}, "f": {"json"}}); errorFrom(t, rec) != 70 {
t.Fatalf("an album with no picture: %s", rec.Body.String())
}
// The album, found by search, has a song that plays: the file as it is, with Range.
res := get("search3", url.Values{"query": {"With Art"}, "f": {"json"}})
var found struct {
R struct {
S struct {
Song []struct{ ID, Suffix, CoverArt string } `json:"song"`
} `json:"searchResult3"`
} `json:"subsonic-response"`
}
if err := json.Unmarshal(res.Body.Bytes(), &found); err != nil || len(found.R.S.Song) != 1 {
t.Fatalf("search: %v %s", err, res.Body.String())
}
song := found.R.S.Song[0]
if song.Suffix != "mp3" || song.CoverArt != "al-"+itoa(e.withArt) {
t.Fatalf("song %+v", song)
}
if rec := get("stream", url.Values{"id": {song.ID}}); rec.Code != 200 || rec.Body.String() != "not audio" || rec.Header().Get("Content-Type") != "audio/mpeg" {
t.Fatalf("stream: %d %q %q", rec.Code, rec.Body.String(), rec.Header().Get("Content-Type"))
}
}
func errorFrom(t *testing.T, rec *httptest.ResponseRecorder) int {
t.Helper()
var out struct {
R map[string]any `json:"subsonic-response"`
}
if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil {
t.Fatalf("%v: %s", err, rec.Body.String())
}
return errorCode(out.R)
}

View file

@ -36,11 +36,12 @@ const (
// Filter selects and pages a list. Zero IDs mean "any". Each list uses the
// fields that make sense for it and ignores the others.
type Filter struct {
Query string // case-insensitive substring of the name or title (accents are kept)
LibraryID int64 // only items with a playable file in this library
ArtistID int64 // albums: album artist; tracks: credited artist
AlbumID int64 // tracks only
Sort string // albums only: "" or SortTitle (by title), SortRecent (the newest files first)
Query string // case-insensitive substring of the name or title (accents are kept)
LibraryID int64 // only items with a playable file in this library
ArtistID int64 // albums: album artist; tracks: credited artist
AlbumID int64 // tracks only
Sort string // albums only: "" or SortTitle (by title), SortRecent (the newest files first)
IDs []int64 // albums and tracks: only these ids (at most MaxLimit); nil is no limit
Limit int
Offset int
}
@ -125,6 +126,9 @@ func normalize(f Filter) (Filter, error) {
if f.Limit < 0 || f.Offset < 0 {
return f, fmt.Errorf("%w: limit and offset cannot be negative", ErrInvalidQuery)
}
if len(f.IDs) > MaxLimit {
return f, fmt.Errorf("%w: at most %d ids", ErrInvalidQuery, MaxLimit)
}
if f.LibraryID < 0 || f.ArtistID < 0 || f.AlbumID < 0 {
return f, fmt.Errorf("%w: ids cannot be negative", ErrInvalidQuery)
}

View file

@ -49,6 +49,10 @@ type Deps struct {
Catalog Catalog
Libraries Libraries
Extras Extras
Lists Lists
Streams Streams
Covers Covers
ArtistImages ArtistImages
ServerVersion string
}
@ -71,18 +75,29 @@ func (k *call) param(name string) string { return k.c.Request.Form.Get(name) }
func Register(r gin.IRoutes, d Deps) {
h := &handler{Deps: d}
h.calls = map[string]func(*call) (*Response, *Error){
"ping": func(*call) (*Response, *Error) { return &Response{}, nil },
"getLicense": func(*call) (*Response, *Error) { return &Response{License: &License{Valid: true}}, nil },
"tokenInfo": h.tokenInfo,
"getMusicFolders": h.musicFolders,
"getArtists": h.artists,
"getArtist": h.artist,
"getAlbum": h.album,
"getSong": h.song,
"getGenres": h.genres,
"getOpenSubsonicExtensions": nil, // answered before the login: see serve
"ping": func(*call) (*Response, *Error) { return &Response{}, nil },
"getLicense": func(*call) (*Response, *Error) { return &Response{License: &License{Valid: true}}, nil },
"tokenInfo": h.tokenInfo,
"getMusicFolders": h.musicFolders,
"getArtists": h.artists,
"getArtist": h.artist,
"getAlbum": h.album,
"getSong": h.song,
"getGenres": h.genres,
"getAlbumList2": h.albumList2,
"getRandomSongs": h.randomSongs,
"getSongsByGenre": h.songsByGenre,
"search3": h.search3,
"getStarred2": h.starred2,
"star": nothing,
"unstar": nothing,
"setRating": nothing,
"stream": h.stream,
"download": h.download,
"getCoverArt": h.coverArt,
}
r.GET("/rest/:method", h.serve)
r.HEAD("/rest/:method", h.serve)
r.POST("/rest/:method", h.serve)
}
@ -102,6 +117,8 @@ func (h *handler) serve(c *gin.Context) {
resp, fail := h.dispatch(c, method)
if fail != nil {
resp = &Response{Error: fail}
} else if resp == served {
return // the call wrote its own answer
}
h.write(c, asJSON, resp)
}
@ -111,7 +128,7 @@ func (h *handler) dispatch(c *gin.Context, method string) (*Response, *Error) {
return &Response{OpenSubsonicExtensions: extensions}, nil
}
fn, known := h.calls[method]
if !known || fn == nil {
if !known {
return nil, &Error{Code: ErrGeneric, Message: "unknown method: " + method}
}
k := &call{c: c, ctx: c.Request.Context()}

View file

@ -4,9 +4,11 @@ import (
"context"
"encoding/json"
"encoding/xml"
"fmt"
"net/http"
"net/http/httptest"
"net/url"
"os"
"strings"
"testing"
"time"
@ -15,7 +17,9 @@ import (
"git.kmalloc.org/squid/sonda/internal/catalog"
"git.kmalloc.org/squid/sonda/internal/devices"
"git.kmalloc.org/squid/sonda/internal/images"
"git.kmalloc.org/squid/sonda/internal/library"
"git.kmalloc.org/squid/sonda/internal/streaming"
)
const secret = "0123456789abcdef0123456789abcdef0123456789abcdef"
@ -81,14 +85,36 @@ func (c *fakeCatalog) Albums(_ context.Context, f catalog.Filter) (catalog.Page[
if f.ArtistID == 0 || f.ArtistID == 1 {
all = []catalog.Album{okComputer}
}
if f.IDs != nil {
var keep []catalog.Album
for _, a := range all {
for _, id := range f.IDs {
if a.ID == id {
keep = append(keep, a)
}
}
}
all = keep
}
return catalog.Page[catalog.Album]{Items: page(all, f), Total: len(all), Limit: f.Limit, Offset: f.Offset}, nil
}
func (c *fakeCatalog) Tracks(_ context.Context, f catalog.Filter) (catalog.Page[catalog.Track], error) {
var all []catalog.Track
if f.AlbumID == 7 {
if f.AlbumID == 7 || f.IDs != nil {
all = []catalog.Track{airbag, karma}
}
if f.IDs != nil {
var keep []catalog.Track
for _, t := range all {
for _, id := range f.IDs {
if t.ID == id {
keep = append(keep, t)
}
}
}
all = keep
}
return catalog.Page[catalog.Track]{Items: page(all, f), Total: len(all), Limit: f.Limit, Offset: f.Offset}, nil
}
@ -485,3 +511,291 @@ func TestAccentsAreTakenOffForTheLetterOfAnArtist(t *testing.T) {
}
}
}
// ---- media, lists, search ----
type fakeLists struct {
albumQ []AlbumQuery
songQ []SongQuery
}
func (f *fakeLists) AlbumIDs(_ context.Context, q AlbumQuery) ([]int64, error) {
f.albumQ = append(f.albumQ, q)
if q.Offset > 0 {
return []int64{}, nil
}
return []int64{7}, nil
}
func (f *fakeLists) SongIDs(_ context.Context, q SongQuery) ([]int64, error) {
f.songQ = append(f.songQ, q)
return []int64{71, 70}, nil // not in the order of the catalogue
}
type fakeStreams struct{ opened []int64 }
func (f *fakeStreams) Open(_ context.Context, id int64) (*streaming.Stream, error) {
f.opened = append(f.opened, id)
switch id {
case 70:
file, err := os.Open(songFile)
if err != nil {
return nil, err
}
return &streaming.Stream{File: file, Name: "airbag.flac", ModTime: time.Unix(1_700_000_000, 0), ContentType: "audio/flac"}, nil
case 71:
return nil, streaming.ErrFileMissing
}
return nil, streaming.ErrNotFound
}
type fakeCovers struct{ sizes []images.Size }
func (f *fakeCovers) AlbumCover(_ context.Context, id int64, size images.Size) (*images.Cover, error) {
f.sizes = append(f.sizes, size)
if id != 7 {
return nil, images.ErrNoCover
}
file, err := os.Open(coverFile)
if err != nil {
return nil, err
}
return &images.Cover{File: file, ModTime: time.Unix(1_700_000_000, 0), ETag: "abc"}, nil
}
func (f *fakeCovers) ArtistImage(_ context.Context, id int64, size images.Size) (*images.Cover, error) {
f.sizes = append(f.sizes, size)
if id != 1 {
return nil, images.ErrNoImage
}
file, err := os.Open(coverFile)
if err != nil {
return nil, err
}
return &images.Cover{File: file, ModTime: time.Unix(1_700_000_000, 0), ETag: "def"}, nil
}
var songFile, coverFile string
func TestMain(m *testing.M) {
dir, err := os.MkdirTemp("", "opensubsonic")
if err != nil {
panic(err)
}
songFile, coverFile = dir+"/song.flac", dir+"/cover.jpg"
_ = os.WriteFile(songFile, []byte("0123456789"), 0o600)
_ = os.WriteFile(coverFile, []byte("JPEGDATA"), 0o600)
code := m.Run()
_ = os.RemoveAll(dir)
os.Exit(code)
}
type media struct {
h http.Handler
cat *fakeCatalog
lists *fakeLists
streams *fakeStreams
covers *fakeCovers
}
func newMediaServer() media {
gin.SetMode(gin.TestMode)
m := media{cat: &fakeCatalog{}, lists: &fakeLists{}, streams: &fakeStreams{}, covers: &fakeCovers{}}
r := gin.New()
Register(r, Deps{
Login: fakeLogin{}, Catalog: m.cat, Libraries: fakeLibraries{}, Extras: fakeExtras{}, ServerVersion: "9.9",
Lists: m.lists, Streams: m.streams, Covers: m.covers, ArtistImages: m.covers,
})
m.h = r
return m
}
func TestASongIsStreamedWithRangeAndWithoutRevealingTheToken(t *testing.T) {
m := newMediaServer()
rec := get(t, m.h, "GET", "/rest/stream", ok("id", "tr-70"))
if rec.Code != 200 || rec.Body.String() != "0123456789" || rec.Header().Get("Content-Type") != "audio/flac" {
t.Fatalf("%d %q %q", rec.Code, rec.Body.String(), rec.Header().Get("Content-Type"))
}
if rec.Header().Get("Referrer-Policy") != "no-referrer" || rec.Header().Get("X-Content-Type-Options") != "nosniff" || rec.Header().Get("Accept-Ranges") != "bytes" {
t.Fatalf("headers %v", rec.Header())
}
req := httptest.NewRequest("GET", "/rest/stream.view?"+ok("id", "tr-70").Encode(), nil)
req.Header.Set("Range", "bytes=2-5")
part := httptest.NewRecorder()
m.h.ServeHTTP(part, req)
if part.Code != http.StatusPartialContent || part.Body.String() != "2345" {
t.Fatalf("range: %d %q", part.Code, part.Body.String())
}
head := httptest.NewRecorder()
m.h.ServeHTTP(head, httptest.NewRequest("HEAD", "/rest/stream?"+ok("id", "tr-70").Encode(), nil))
if head.Code != 200 || head.Body.Len() != 0 || head.Header().Get("Content-Length") != "10" {
t.Fatalf("head: %d %q %v", head.Code, head.Body.String(), head.Header())
}
}
func TestDownloadSendsTheFileAsAnAttachment(t *testing.T) {
m := newMediaServer()
rec := get(t, m.h, "GET", "/rest/download", ok("id", "tr-70"))
if rec.Code != 200 || rec.Body.String() != "0123456789" {
t.Fatalf("%d %q", rec.Code, rec.Body.String())
}
if cd := rec.Header().Get("Content-Disposition"); !strings.HasPrefix(cd, "attachment") || !strings.Contains(cd, "airbag.flac") {
t.Fatalf("disposition %q", cd)
}
}
func TestAStreamThatCannotBeServedIsAnErrorInTheFormatAskedFor(t *testing.T) {
m := newMediaServer()
failed(t, get(t, m.h, "GET", "/rest/stream", ok("id", "tr-99")), ErrNotFound)
failed(t, get(t, m.h, "GET", "/rest/stream", ok("id", "tr-71")), ErrNotFound) // the file is gone
failed(t, get(t, m.h, "GET", "/rest/stream", ok("id", "al-7")), ErrNotFound)
failed(t, get(t, m.h, "GET", "/rest/stream", ok()), ErrMissingParam)
failed(t, get(t, m.h, "GET", "/rest/download", ok("id", "tr-99")), ErrNotFound)
// No login, no music.
failed(t, get(t, m.h, "GET", "/rest/stream", url.Values{"id": {"tr-70"}, "f": {"json"}}), ErrMissingParam)
failed(t, get(t, m.h, "GET", "/rest/stream", url.Values{"id": {"tr-70"}, "apiKey": {"nope"}, "f": {"json"}}), ErrBadAPIKey)
if len(m.streams.opened) != 3 {
t.Fatalf("files opened without a login: %v", m.streams.opened)
}
}
func TestACoverIsAnAlbumAnArtistOrTheAlbumOfASong(t *testing.T) {
m := newMediaServer()
for _, id := range []string{"al-7", "tr-70", "ar-1"} {
rec := get(t, m.h, "GET", "/rest/getCoverArt", ok("id", id))
if rec.Code != 200 || rec.Body.String() != "JPEGDATA" || rec.Header().Get("Content-Type") != "image/jpeg" {
t.Fatalf("%s: %d %q", id, rec.Code, rec.Body.String())
}
}
if rec := get(t, m.h, "GET", "/rest/getCoverArt", ok("id", "al-7")); rec.Header().Get("ETag") != `"abc"` || !strings.Contains(rec.Header().Get("Cache-Control"), "max-age") {
t.Fatalf("headers %v", rec.Header())
}
failed(t, get(t, m.h, "GET", "/rest/getCoverArt", ok("id", "al-8")), ErrNotFound)
failed(t, get(t, m.h, "GET", "/rest/getCoverArt", ok("id", "ar-2")), ErrNotFound)
failed(t, get(t, m.h, "GET", "/rest/getCoverArt", ok("id", "tr-99")), ErrNotFound)
failed(t, get(t, m.h, "GET", "/rest/getCoverArt", ok("id", "pl-1")), ErrNotFound)
failed(t, get(t, m.h, "GET", "/rest/getCoverArt", ok()), ErrMissingParam)
}
func TestACoverIsSmallUpTo300PixelsAndLargeAbove(t *testing.T) {
m := newMediaServer()
for _, size := range []string{"", "0", "150", "300", "301", "1200", "x"} {
get(t, m.h, "GET", "/rest/getCoverArt", ok("id", "al-7", "size", size))
}
want := []images.Size{images.Large, images.Large, images.Small, images.Small, images.Large, images.Large, images.Large}
if fmt.Sprint(m.covers.sizes) != fmt.Sprint(want) {
t.Fatalf("sizes %v, want %v", m.covers.sizes, want)
}
}
func TestAlbumListsAskForWhatTheAppWantsAndAnswerInTheOrderOfTheList(t *testing.T) {
m := newMediaServer()
r := good(t, get(t, m.h, "GET", "/rest/getAlbumList2", ok("type", "byYear", "fromYear", "1990", "toYear", "2000", "size", "5", "offset", "0", "musicFolderId", "2")))
al := r["albumList2"].(map[string]any)["album"].([]any)
if len(al) != 1 || al[0].(map[string]any)["id"] != "al-7" {
t.Fatalf("list %v", r)
}
q := m.lists.albumQ[0]
if q.Type != "byYear" || q.FromYear != 1990 || q.ToYear != 2000 || q.Size != 5 || q.LibraryID != 2 || q.UserID != 1 {
t.Fatalf("query %+v", q)
}
get(t, m.h, "GET", "/rest/getAlbumList2", ok("type", "newest"))
if q := m.lists.albumQ[1]; q.Size != 10 || q.Offset != 0 {
t.Fatalf("defaults %+v", q)
}
get(t, m.h, "GET", "/rest/getAlbumList2", ok("type", "newest", "size", "9000"))
if q := m.lists.albumQ[2]; q.Size != 500 {
t.Fatalf("size is not limited: %+v", q)
}
get(t, m.h, "GET", "/rest/getAlbumList2", ok("type", "byGenre", "genre", "Jazz"))
if q := m.lists.albumQ[3]; q.Genre != "Jazz" {
t.Fatalf("genre %+v", q)
}
empty := good(t, get(t, m.h, "GET", "/rest/getAlbumList2", ok("type", "random", "offset", "5")))
if _, ok := empty["albumList2"].(map[string]any); !ok {
t.Fatalf("an empty list is still a list: %v", empty)
}
}
func TestAnAlbumListThatIsAskedForBadly(t *testing.T) {
m := newMediaServer()
failed(t, get(t, m.h, "GET", "/rest/getAlbumList2", ok()), ErrMissingParam)
failed(t, get(t, m.h, "GET", "/rest/getAlbumList2", ok("type", "nope")), ErrGeneric)
failed(t, get(t, m.h, "GET", "/rest/getAlbumList2", ok("type", "byYear", "fromYear", "1990")), ErrMissingParam)
failed(t, get(t, m.h, "GET", "/rest/getAlbumList2", ok("type", "byGenre")), ErrMissingParam)
failed(t, get(t, m.h, "GET", "/rest/getAlbumList2", ok("type", "newest", "size", "many")), ErrGeneric)
failed(t, get(t, m.h, "GET", "/rest/getAlbumList2", ok("type", "newest", "offset", "-1")), ErrGeneric)
failed(t, get(t, m.h, "GET", "/rest/getAlbumList2", ok("type", "newest", "musicFolderId", "x")), ErrNotFound)
}
func TestStarredThingsAreNone(t *testing.T) {
m := newMediaServer()
good(t, get(t, m.h, "GET", "/rest/star", ok("id", "tr-70")))
good(t, get(t, m.h, "GET", "/rest/unstar", ok("id", "tr-70")))
good(t, get(t, m.h, "GET", "/rest/setRating", ok("id", "tr-70", "rating", "5")))
s := good(t, get(t, m.h, "GET", "/rest/getStarred2", ok()))["starred2"].(map[string]any)
if len(s) != 0 {
t.Fatalf("starred %v", s)
}
if r := good(t, get(t, m.h, "GET", "/rest/getAlbumList2", ok("type", "starred"))); r["albumList2"] == nil {
t.Fatalf("starred albums %v", r)
}
}
func TestSongsAtRandomAndByGenre(t *testing.T) {
m := newMediaServer()
r := good(t, get(t, m.h, "GET", "/rest/getRandomSongs", ok("size", "2", "genre", "Rock", "fromYear", "1990", "toYear", "2000", "musicFolderId", "1")))
songs := r["randomSongs"].(map[string]any)["song"].([]any)
// The songs come back in the order the list gave them.
if len(songs) != 2 || songs[0].(map[string]any)["id"] != "tr-71" || songs[1].(map[string]any)["id"] != "tr-70" {
t.Fatalf("songs %v", songs)
}
q := m.lists.songQ[0]
if !q.Random || q.Size != 2 || q.Genre != "Rock" || q.FromYear != 1990 || q.ToYear != 2000 || q.LibraryID != 1 {
t.Fatalf("query %+v", q)
}
r = good(t, get(t, m.h, "GET", "/rest/getSongsByGenre", ok("genre", "Rock", "count", "3", "offset", "4")))
if len(r["songsByGenre"].(map[string]any)["song"].([]any)) != 2 {
t.Fatalf("songs %v", r)
}
if q := m.lists.songQ[1]; q.Random || q.Size != 3 || q.Offset != 4 || q.Genre != "Rock" {
t.Fatalf("query %+v", q)
}
failed(t, get(t, m.h, "GET", "/rest/getSongsByGenre", ok()), ErrMissingParam)
if m.lists.songQ = nil; true {
get(t, m.h, "GET", "/rest/getRandomSongs", ok())
if q := m.lists.songQ[0]; q.Size != 10 {
t.Fatalf("default size %+v", q)
}
}
}
func TestSearchFindsArtistsAlbumsAndSongs(t *testing.T) {
m := newMediaServer()
r := good(t, get(t, m.h, "GET", "/rest/search3", ok("query", "", "artistCount", "2", "artistOffset", "1", "albumCount", "5", "songCount", "0")))["searchResult3"].(map[string]any)
artists := r["artist"].([]any)
if len(artists) != 2 || artists[0].(map[string]any)["name"] != "Björk" {
t.Fatalf("artists %v", artists)
}
if albums := r["album"].([]any); len(albums) != 1 || albums[0].(map[string]any)["id"] != "al-7" {
t.Fatalf("albums %v", albums)
}
if _, has := r["song"]; has {
t.Fatalf("songs were not asked for: %v", r["song"])
}
failed(t, get(t, m.h, "GET", "/rest/search3", ok()), ErrMissingParam)
}
func TestSearchReadsAsManyAsAskedEvenAboveAPageOfTheCatalogue(t *testing.T) {
m := newMediaServer()
// 500 songs asked: the answer is as many as there are, read page by page; the fake has none outside album 7.
r := good(t, get(t, m.h, "GET", "/rest/search3", ok("query", "x", "songCount", "500", "artistCount", "0", "albumCount", "0")))["searchResult3"].(map[string]any)
if _, has := r["artist"]; has {
t.Fatalf("%v", r)
}
}

View file

@ -0,0 +1,437 @@
package opensubsonic
import (
"context"
"errors"
"net/http"
"strconv"
"strings"
"git.kmalloc.org/squid/sonda/internal/catalog"
"git.kmalloc.org/squid/sonda/internal/images"
"git.kmalloc.org/squid/sonda/internal/streaming"
)
// Streams opens the audio file of a song: *streaming.Service.
type Streams interface {
Open(ctx context.Context, trackID int64) (*streaming.Stream, error)
}
// Covers builds the cover of an album: *images.Service.
type Covers interface {
AlbumCover(ctx context.Context, albumID int64, size images.Size) (*images.Cover, error)
}
// ArtistImages builds the picture of an artist: *images.Service.
type ArtistImages interface {
ArtistImage(ctx context.Context, artistID int64, size images.Size) (*images.Cover, error)
}
// served is what a call that wrote its own answer (a file, a picture) returns: there is nothing more to write.
var served = &Response{}
// stream sends the original file of a song, with Range, HEAD and conditional requests done by http.ServeContent.
// The file is sent as it is: Sonda does not transcode, so what an app asks for (format, bit rate) is ignored.
func (h *handler) stream(k *call) (*Response, *Error) { return h.send(k, false) }
// download sends the original file as an attachment.
func (h *handler) download(k *call) (*Response, *Error) { return h.send(k, true) }
func (h *handler) send(k *call, attachment bool) (*Response, *Error) {
id, bad := idParam(k, trackPrefix)
if bad != nil {
return nil, bad
}
st, err := h.Streams.Open(k.ctx, id)
switch {
case errors.Is(err, streaming.ErrNotFound), errors.Is(err, streaming.ErrFileMissing), errors.Is(err, streaming.ErrUnsafePath):
_ = k.c.Error(err)
return nil, notFound()
case err != nil:
_ = k.c.Error(err)
return nil, &Error{Code: ErrGeneric, Message: "the file could not be read"}
}
defer st.Close()
hdr := k.c.Writer.Header()
hdr.Set("Content-Type", st.ContentType)
hdr.Set("X-Content-Type-Options", "nosniff")
// The address carries the password of the device: never leak it through Referer.
hdr.Set("Referrer-Policy", "no-referrer")
hdr.Set("Cache-Control", "private, no-cache")
if attachment {
hdr.Set("Content-Disposition", `attachment; filename="`+safeName(st.Name)+`"`)
}
http.ServeContent(k.c.Writer, k.c.Request, st.Name, st.ModTime, st.File)
return served, nil
}
// safeName keeps a file name from closing the quotes of the header or adding a line to it.
func safeName(name string) string {
return strings.Map(func(r rune) rune {
if r == '"' || r == '\\' || r < ' ' || r == 0x7f {
return '_'
}
return r
}, name)
}
// smallest is the biggest size, in pixels, that is served from the small picture.
const smallest = 300
// coverArt sends the picture of an album, of an artist, or of the album of a song.
func (h *handler) coverArt(k *call) (*Response, *Error) {
raw := k.param("id")
if raw == "" {
return nil, missing("id")
}
size := images.Large
if px, err := strconv.Atoi(k.param("size")); err == nil && px > 0 && px <= smallest {
size = images.Small
}
var (
cover *images.Cover
err error
)
switch {
case strings.HasPrefix(raw, artistPrefix):
id, bad := idParam(k, artistPrefix)
if bad != nil {
return nil, bad
}
cover, err = h.ArtistImages.ArtistImage(k.ctx, id, size)
case strings.HasPrefix(raw, albumPrefix), strings.HasPrefix(raw, trackPrefix):
albumID, bad := h.albumOfCover(k, raw)
if bad != nil {
return nil, bad
}
cover, err = h.Covers.AlbumCover(k.ctx, albumID, size)
default:
return nil, notFound()
}
switch {
case err == nil:
case errors.Is(err, context.Canceled):
return served, nil // the app left: nobody is waiting
case errors.Is(err, images.ErrNoCover), errors.Is(err, images.ErrAlbumNotFound), errors.Is(err, images.ErrNoImage),
errors.Is(err, images.ErrArtistNotFound), errors.Is(err, images.ErrProviderDisabled), errors.Is(err, images.ErrNoID):
return nil, notFound()
default:
_ = k.c.Error(err)
return nil, &Error{Code: ErrGeneric, Message: "the picture could not be made"}
}
defer cover.File.Close()
hdr := k.c.Writer.Header()
hdr.Set("Content-Type", "image/jpeg")
hdr.Set("ETag", `"`+cover.ETag+`"`)
hdr.Set("Cache-Control", "private, max-age=3600") // it is the listener's own library
hdr.Set("X-Content-Type-Options", "nosniff")
hdr.Set("Referrer-Policy", "no-referrer")
http.ServeContent(k.c.Writer, k.c.Request, "cover.jpg", cover.ModTime, cover.File)
return served, nil
}
// albumOfCover is the album an id stands for: the album itself, or the album of a song.
func (h *handler) albumOfCover(k *call, raw string) (int64, *Error) {
if strings.HasPrefix(raw, albumPrefix) {
return idParam(k, albumPrefix)
}
id, bad := idParam(k, trackPrefix)
if bad != nil {
return 0, bad
}
t, err := h.Catalog.Track(k.ctx, id)
if err != nil {
return 0, failure(err)
}
if t.Album == nil {
return 0, notFound()
}
return t.Album.ID, nil
}
// ---- lists ----
const (
defaultCount = 10
maxCount = 500
defaultFind = 20
)
// count reads a whole number parameter that must be 0 or more. An absent one is the default; the answer never
// exceeds max.
func count(k *call, name string, def, max int) (int, *Error) {
raw := k.param(name)
if raw == "" {
return def, nil
}
n, err := strconv.Atoi(raw)
if err != nil || n < 0 {
return 0, &Error{Code: ErrGeneric, Message: "invalid value for " + name}
}
return min(n, max), nil
}
// folder reads musicFolderId: 0 is every library.
func folder(k *call) (int64, *Error) {
raw := k.param("musicFolderId")
if raw == "" {
return 0, nil
}
n, err := strconv.ParseInt(raw, 10, 64)
if err != nil || n < 1 {
return 0, notFound()
}
return n, nil
}
var listTypes = map[string]bool{
ListRandom: true, ListNewest: true, ListFrequent: true, ListRecent: true, ListStarred: true,
ListByName: true, ListByArtist: true, ListByYear: true, ListByGenre: true,
}
func (h *handler) albumList2(k *call) (*Response, *Error) {
kind := k.param("type")
if kind == "" {
return nil, missing("type")
}
if !listTypes[kind] {
return nil, &Error{Code: ErrGeneric, Message: "unknown list type: " + kind}
}
q := AlbumQuery{Type: kind, UserID: k.principal.UserID, Genre: k.param("genre")}
var bad *Error
if q.Size, bad = count(k, "size", defaultCount, maxCount); bad != nil {
return nil, bad
}
if q.Offset, bad = count(k, "offset", 0, 1<<30); bad != nil {
return nil, bad
}
if q.LibraryID, bad = folder(k); bad != nil {
return nil, bad
}
switch kind {
case ListByYear:
if k.param("fromYear") == "" || k.param("toYear") == "" {
return nil, missing("fromYear and toYear")
}
if q.FromYear, bad = count(k, "fromYear", 0, 9999); bad != nil {
return nil, bad
}
if q.ToYear, bad = count(k, "toYear", 0, 9999); bad != nil {
return nil, bad
}
case ListByGenre:
if q.Genre == "" {
return nil, missing("genre")
}
}
ids, err := h.Lists.AlbumIDs(k.ctx, q)
if err != nil {
return nil, failure(err)
}
albums, err := h.albumsByID(k.ctx, ids)
if err != nil {
return nil, failure(err)
}
out, err := h.albums(k.ctx, albums)
if err != nil {
return nil, failure(err)
}
return &Response{AlbumList2: &AlbumList2{Album: out}}, nil
}
func (h *handler) randomSongs(k *call) (*Response, *Error) {
q := SongQuery{Random: true, Genre: k.param("genre")}
var bad *Error
if q.Size, bad = count(k, "size", defaultCount, maxCount); bad != nil {
return nil, bad
}
if q.FromYear, bad = count(k, "fromYear", 0, 9999); bad != nil {
return nil, bad
}
if q.ToYear, bad = count(k, "toYear", 0, 9999); bad != nil {
return nil, bad
}
if q.LibraryID, bad = folder(k); bad != nil {
return nil, bad
}
songs, fail := h.songList(k, q)
if fail != nil {
return nil, fail
}
return &Response{RandomSongs: &SongList{Song: songs}}, nil
}
func (h *handler) songsByGenre(k *call) (*Response, *Error) {
q := SongQuery{Genre: k.param("genre")}
if q.Genre == "" {
return nil, missing("genre")
}
var bad *Error
if q.Size, bad = count(k, "count", defaultCount, maxCount); bad != nil {
return nil, bad
}
if q.Offset, bad = count(k, "offset", 0, 1<<30); bad != nil {
return nil, bad
}
if q.LibraryID, bad = folder(k); bad != nil {
return nil, bad
}
songs, fail := h.songList(k, q)
if fail != nil {
return nil, fail
}
return &Response{SongsByGenre: &SongList{Song: songs}}, nil
}
func (h *handler) songList(k *call, q SongQuery) ([]Child, *Error) {
ids, err := h.Lists.SongIDs(k.ctx, q)
if err != nil {
return nil, failure(err)
}
tracks, err := h.tracksByID(k.ctx, ids)
if err != nil {
return nil, failure(err)
}
songs, err := h.songs(k.ctx, tracks)
if err != nil {
return nil, failure(err)
}
return songs, nil
}
// albumsByID reads albums by their ids, in the order of the ids; an id that cannot be played is left out.
func (h *handler) albumsByID(ctx context.Context, ids []int64) ([]catalog.Album, error) {
byID := map[int64]catalog.Album{}
rest := ids
for len(rest) > 0 {
chunk := rest[:min(len(rest), catalog.MaxLimit)]
rest = rest[len(chunk):]
p, err := h.Catalog.Albums(ctx, catalog.Filter{IDs: chunk, Limit: len(chunk)})
if err != nil {
return nil, err
}
for _, a := range p.Items {
byID[a.ID] = a
}
}
return inOrder(ids, byID), nil
}
// tracksByID is the same for songs.
func (h *handler) tracksByID(ctx context.Context, ids []int64) ([]catalog.Track, error) {
byID := map[int64]catalog.Track{}
rest := ids
for len(rest) > 0 {
chunk := rest[:min(len(rest), catalog.MaxLimit)]
rest = rest[len(chunk):]
p, err := h.Catalog.Tracks(ctx, catalog.Filter{IDs: chunk, Limit: len(chunk)})
if err != nil {
return nil, err
}
for _, t := range p.Items {
byID[t.ID] = t
}
}
return inOrder(ids, byID), nil
}
func inOrder[T any](ids []int64, byID map[int64]T) []T {
out := make([]T, 0, len(ids))
for _, id := range ids {
if v, ok := byID[id]; ok {
out = append(out, v)
}
}
return out
}
// ---- search ----
func (h *handler) search3(k *call) (*Response, *Error) {
if _, given := k.c.Request.Form["query"]; !given {
return nil, missing("query")
}
query := strings.Trim(k.param("query"), `"`) // some apps send an empty search as ""
lib, bad := folder(k)
if bad != nil {
return nil, bad
}
var n [3]struct{ count, offset int }
for i, name := range []string{"artist", "album", "song"} {
if n[i].count, bad = count(k, name+"Count", defaultFind, maxCount); bad != nil {
return nil, bad
}
if n[i].offset, bad = count(k, name+"Offset", 0, 1<<30); bad != nil {
return nil, bad
}
}
filter := catalog.Filter{Query: query, LibraryID: lib}
res := &SearchResult{}
if n[0].count > 0 {
artists, err := window(n[0].count, n[0].offset, func(limit, offset int) (catalog.Page[catalog.Artist], error) {
f := filter
f.Limit, f.Offset = limit, offset
return h.Catalog.Artists(k.ctx, f)
})
if err != nil {
return nil, failure(err)
}
for _, a := range artists {
res.Artist = append(res.Artist, artistOf(a))
}
}
if n[1].count > 0 {
albums, err := window(n[1].count, n[1].offset, func(limit, offset int) (catalog.Page[catalog.Album], error) {
f := filter
f.Limit, f.Offset = limit, offset
return h.Catalog.Albums(k.ctx, f)
})
if err != nil {
return nil, failure(err)
}
if res.Album, err = h.albums(k.ctx, albums); err != nil {
return nil, failure(err)
}
}
if n[2].count > 0 {
tracks, err := window(n[2].count, n[2].offset, func(limit, offset int) (catalog.Page[catalog.Track], error) {
f := filter
f.Limit, f.Offset = limit, offset
return h.Catalog.Tracks(k.ctx, f)
})
if err != nil {
return nil, failure(err)
}
if res.Song, err = h.songs(k.ctx, tracks); err != nil {
return nil, failure(err)
}
}
return &Response{SearchResult3: res}, nil
}
// window reads n items from an offset, a page of the catalogue at a time: an app may ask for more than a page holds,
// and one that gets fewer than it asked for takes the list for ended.
func window[T any](n, offset int, fetch func(limit, offset int) (catalog.Page[T], error)) ([]T, error) {
var out []T
for len(out) < n {
p, err := fetch(min(n-len(out), catalog.MaxLimit), offset+len(out))
if err != nil {
return nil, err
}
out = append(out, p.Items...)
if len(p.Items) == 0 || offset+len(out) >= p.Total {
break
}
}
return out, nil
}
func (h *handler) starred2(*call) (*Response, *Error) {
return &Response{Starred2: &SearchResult{}}, nil
}
// nothing answers the calls that star, unstar or rate: Sonda has no stars yet, and an app should not break for it.
func nothing(*call) (*Response, *Error) { return &Response{}, nil }

View file

@ -29,6 +29,28 @@ type Response struct {
Album *AlbumWithSongs `xml:"album" json:"album,omitempty"`
Song *Child `xml:"song" json:"song,omitempty"`
Genres *Genres `xml:"genres" json:"genres,omitempty"`
AlbumList2 *AlbumList2 `xml:"albumList2" json:"albumList2,omitempty"`
RandomSongs *SongList `xml:"randomSongs" json:"randomSongs,omitempty"`
SongsByGenre *SongList `xml:"songsByGenre" json:"songsByGenre,omitempty"`
SearchResult3 *SearchResult `xml:"searchResult3" json:"searchResult3,omitempty"`
Starred2 *SearchResult `xml:"starred2" json:"starred2,omitempty"`
}
// AlbumList2 is a list of albums.
type AlbumList2 struct {
Album []AlbumID3 `xml:"album" json:"album,omitempty"`
}
// SongList is a list of songs.
type SongList struct {
Song []Child `xml:"song" json:"song,omitempty"`
}
// SearchResult is what a search found: artists, albums and songs. The starred things have the same shape.
type SearchResult struct {
Artist []ArtistID3 `xml:"artist" json:"artist,omitempty"`
Album []AlbumID3 `xml:"album" json:"album,omitempty"`
Song []Child `xml:"song" json:"song,omitempty"`
}
// Error codes of the Subsonic API.

View file

@ -38,3 +38,46 @@ type Extras interface {
// Genres returns every genre of the songs that can be played.
Genres(ctx context.Context) ([]Genre, error)
}
// The kinds of list of albums an app can ask for.
const (
ListRandom = "random"
ListNewest = "newest"
ListFrequent = "frequent"
ListRecent = "recent"
ListStarred = "starred"
ListByName = "alphabeticalByName"
ListByArtist = "alphabeticalByArtist"
ListByYear = "byYear"
ListByGenre = "byGenre"
)
// AlbumQuery asks for a list of albums.
type AlbumQuery struct {
Type string // one of the List constants
Size int
Offset int
LibraryID int64 // 0 is every library
FromYear int // byYear: from FromYear to ToYear, backwards when FromYear is the later
ToYear int
Genre string // byGenre
UserID int64 // frequent and recent: whose listens
}
// SongQuery asks for a list of songs.
type SongQuery struct {
Random bool // in any order, otherwise by album
Size int
Offset int
LibraryID int64
FromYear int // 0 is no limit
ToYear int
Genre string // "" is any genre
}
// Lists answers the calls that ask for albums and songs in an order that the catalogue does not know. They answer
// with ids, only of what can be played; the catalogue describes them.
type Lists interface {
AlbumIDs(ctx context.Context, q AlbumQuery) ([]int64, error)
SongIDs(ctx context.Context, q SongQuery) ([]int64, error)
}

View file

@ -271,6 +271,9 @@ func (r *CatalogRepo) listAlbums(ctx context.Context, f catalog.Filter, id int64
if id != 0 {
w.add("al.id = ?", id)
}
if f.IDs != nil {
w.add("al.id IN (?)", bun.In(f.IDs))
}
if f.ArtistID != 0 {
// Same meaning as an artist's album_count: albums the artist owns, plus
// albums where the artist is credited on a playable track.
@ -388,6 +391,9 @@ func (r *CatalogRepo) listTracks(ctx context.Context, f catalog.Filter, id int64
if id != 0 {
w.add("t.id = ?", id)
}
if f.IDs != nil {
w.add("t.id IN (?)", bun.In(f.IDs))
}
if f.AlbumID != 0 {
w.add("t.album_id = ?", f.AlbumID)
}

View file

@ -586,3 +586,30 @@ func TestCatalogAlbumsCanComeNewestFirst(t *testing.T) {
}
})
}
func TestAListCanBeLimitedToTheIdsOfItsItems(t *testing.T) {
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
s := seedCatalog(t, db)
ctx := context.Background()
got, err := s.repo.ListTracks(ctx, catalog.Filter{IDs: []int64{s.track["Airbag"], s.track["Karma Police"], s.track["Ghost"]}, Limit: 50})
if err != nil {
t.Fatal(err)
}
// Ghost has no file to play, so it is not there whatever the ids say.
if titles := trackTitles(got); len(titles) != 2 || got.Total != 2 {
t.Fatalf("tracks of ids = %v (%d)", titles, got.Total)
}
albums, err := s.repo.ListAlbums(ctx, catalog.Filter{Query: "", Limit: 50})
if err != nil || len(albums.Items) < 2 {
t.Fatalf("albums %v, %v", albums, err)
}
one, err := s.repo.ListAlbums(ctx, catalog.Filter{IDs: []int64{albums.Items[1].ID}, Limit: 50})
if err != nil || len(one.Items) != 1 || one.Items[0].ID != albums.Items[1].ID {
t.Fatalf("albums of an id = %+v, %v", one.Items, err)
}
none, err := s.repo.ListTracks(ctx, catalog.Filter{IDs: []int64{}, Limit: 50})
if err != nil || len(none.Items) != 0 {
t.Fatalf("an empty list of ids is no item, got %v, %v", trackTitles(none), err)
}
})
}

View file

@ -2,22 +2,31 @@ package storage
import (
"context"
"database/sql"
"errors"
"fmt"
"path"
"strings"
"time"
"github.com/uptrace/bun"
"github.com/uptrace/bun/dialect"
"git.kmalloc.org/squid/sonda/internal/opensubsonic"
)
// SubsonicRepo reads what the OpenSubsonic API needs and the catalogue does not carry. It implements
// opensubsonic.Extras. Only files that are not missing count, like everywhere else.
type SubsonicRepo struct{ db *bun.DB }
// opensubsonic.Extras and opensubsonic.Lists. Only files that are not missing count, like everywhere else.
type SubsonicRepo struct {
db *bun.DB
// minListen is how long a play must last to count as a listen.
minListen time.Duration
}
// NewSubsonicRepo builds a SubsonicRepo.
func NewSubsonicRepo(db *bun.DB) *SubsonicRepo { return &SubsonicRepo{db: db} }
// NewSubsonicRepo builds a SubsonicRepo. minListen is how long a play must last to count as a listen.
func NewSubsonicRepo(db *bun.DB, minListen time.Duration) *SubsonicRepo {
return &SubsonicRepo{db: db, minListen: minListen}
}
// Tracks returns the extras of the songs that can be played, with three queries whatever the number of songs.
func (r *SubsonicRepo) Tracks(ctx context.Context, ids []int64) (map[int64]opensubsonic.TrackExtra, error) {
@ -147,3 +156,113 @@ func (r *SubsonicRepo) Genres(ctx context.Context) ([]opensubsonic.Genre, error)
}
return out, rows.Err()
}
// ErrUnknownList is a kind of list of albums that is not known.
var ErrUnknownList = errors.New("unknown kind of list")
// albumYear is the earliest year of the songs of an album, NULL when none has one.
const albumYear = "(SELECT MIN(ty.year) FROM tracks ty WHERE ty.album_id = al.id AND ty.year > 0)"
// AlbumIDs returns the ids of a page of the albums that can be played, in the order asked for.
func (r *SubsonicRepo) AlbumIDs(ctx context.Context, q opensubsonic.AlbumQuery) ([]int64, error) {
vis, visArgs := visible("t", q.LibraryID)
var w where
w.add("EXISTS (SELECT 1 FROM tracks t WHERE t.album_id = al.id AND "+vis+")", visArgs...)
join, order := "", ""
var joinArgs []any
switch q.Type {
case opensubsonic.ListRandom:
order = "RANDOM()"
case opensubsonic.ListByName:
order = r.binary("al.title_key") + ", al.id"
case opensubsonic.ListByArtist:
join = "LEFT JOIN artists ar ON ar.id = al.artist_id"
order = r.binary("COALESCE(ar.name_key, '')") + ", " + r.binary("al.title_key") + ", al.id"
case opensubsonic.ListNewest:
order = `COALESCE((SELECT MAX(af.mtime_unix) FROM audio_files af JOIN tracks tt ON tt.id = af.track_id
WHERE tt.album_id = al.id AND af.missing_at IS NULL), 0) DESC, al.id DESC`
case opensubsonic.ListByYear:
from, to := q.FromYear, q.ToYear
dir := "ASC"
if from > to {
from, to, dir = to, from, "DESC"
}
w.add(albumYear+" BETWEEN ? AND ?", from, to)
order = albumYear + " " + dir + ", " + r.binary("al.title_key") + ", al.id"
case opensubsonic.ListByGenre:
w.add("EXISTS (SELECT 1 FROM tracks tg JOIN track_genres g ON g.track_id = tg.id WHERE tg.album_id = al.id AND g.genre = ?)", strings.ToLower(q.Genre))
order = r.binary("al.title_key") + ", al.id"
case opensubsonic.ListFrequent, opensubsonic.ListRecent:
// Only the albums the listener listened to, by how many listens or by the last one.
measure, dir := "COUNT(*)", "DESC"
if q.Type == opensubsonic.ListRecent {
measure = "MAX(e.occurred_at)"
}
join = `JOIN (SELECT tt.album_id AS album_id, ` + measure + ` AS score FROM listening_events e JOIN tracks tt ON tt.id = e.track_id
WHERE e.user_id = ? AND ` + counted + ` AND tt.album_id IS NOT NULL GROUP BY tt.album_id) lis ON lis.album_id = al.id`
joinArgs = []any{q.UserID, r.minListen.Milliseconds()}
order = "lis.score " + dir + ", al.id DESC"
case opensubsonic.ListStarred:
return []int64{}, nil // nothing is starred: there are no stars yet
default:
return nil, fmt.Errorf("%w: %q", ErrUnknownList, q.Type)
}
args := append(append([]any{}, joinArgs...), w.args...)
args = append(args, q.Size, q.Offset)
rows, err := r.db.QueryContext(ctx,
"SELECT al.id FROM albums al "+join+" WHERE "+w.sql()+" ORDER BY "+order+" LIMIT ? OFFSET ?", args...)
if err != nil {
return nil, fmt.Errorf("list albums: %w", err)
}
return scanIDs(rows)
}
// SongIDs returns the ids of a page of the songs that can be played: by album, or in any order.
func (r *SubsonicRepo) SongIDs(ctx context.Context, q opensubsonic.SongQuery) ([]int64, error) {
vis, visArgs := visible("t", q.LibraryID)
var w where
w.add(vis, visArgs...)
if q.Genre != "" {
w.add("EXISTS (SELECT 1 FROM track_genres g WHERE g.track_id = t.id AND g.genre = ?)", strings.ToLower(q.Genre))
}
if q.FromYear > 0 {
w.add("t.year >= ?", q.FromYear)
}
if q.ToYear > 0 {
w.add("t.year <= ?", q.ToYear)
}
order := r.binary("COALESCE(al.title_key, '')") + ", COALESCE(t.album_id, 0), COALESCE(t.disc_no, 0), COALESCE(t.track_no, 0), t.id"
if q.Random {
order = "RANDOM()"
}
rows, err := r.db.QueryContext(ctx,
"SELECT t.id FROM tracks t LEFT JOIN albums al ON al.id = t.album_id WHERE "+w.sql()+" ORDER BY "+order+" LIMIT ? OFFSET ?",
append(w.args, q.Size, q.Offset)...)
if err != nil {
return nil, fmt.Errorf("list songs: %w", err)
}
return scanIDs(rows)
}
func scanIDs(rows *sql.Rows) ([]int64, error) {
defer rows.Close()
out := []int64{}
for rows.Next() {
var id int64
if err := rows.Scan(&id); err != nil {
return nil, err
}
out = append(out, id)
}
return out, rows.Err()
}
// binary orders by plain byte value, so that SQLite and PostgreSQL order alike (see CatalogRepo.binary).
func (r *SubsonicRepo) binary(expr string) string {
if r.db.Dialect().Name() == dialect.PG {
return expr + ` COLLATE "C"`
}
return expr
}

View file

@ -0,0 +1,191 @@
package storage
import (
"context"
"reflect"
"testing"
"time"
"github.com/uptrace/bun"
"git.kmalloc.org/squid/sonda/internal/opensubsonic"
)
type albumWorld struct {
repo *SubsonicRepo
album map[string]int64 // album id by title
user int64
ctx context.Context
s seeded
db *bun.DB
}
func newAlbumWorld(t *testing.T, db *bun.DB) albumWorld {
t.Helper()
w := albumWorld{ctx: context.Background(), s: seedCatalog(t, db), repo: NewSubsonicRepo(db, 20*time.Second), album: map[string]int64{}, db: db}
rows, err := db.Query("SELECT id, title FROM albums")
if err != nil {
t.Fatal(err)
}
for rows.Next() {
var id int64
var title string
if err := rows.Scan(&id, &title); err != nil {
t.Fatal(err)
}
w.album[title] = id
}
rows.Close()
w.user = seedUser(t, db, "l@example.org")
w.exec("UPDATE tracks SET year = 1997 WHERE album_id = ?", w.album["OK Computer"])
w.exec("UPDATE tracks SET year = 1995 WHERE album_id = ?", w.album["Post"])
w.exec("UPDATE tracks SET year = 1959 WHERE album_id = ?", w.album["Kind of Blue"])
w.exec("UPDATE audio_files SET mtime_unix = 100 WHERE track_id IN (SELECT id FROM tracks WHERE album_id = ?)", w.album["OK Computer"])
w.exec("UPDATE audio_files SET mtime_unix = 400 WHERE track_id IN (SELECT id FROM tracks WHERE album_id = ?)", w.album["Post"])
w.exec("UPDATE audio_files SET mtime_unix = 300 WHERE track_id IN (SELECT id FROM tracks WHERE album_id = ?)", w.album["Kind of Blue"])
w.exec("UPDATE audio_files SET mtime_unix = 200 WHERE track_id IN (SELECT id FROM tracks WHERE album_id = ?)", w.album["Various Hits"])
w.exec("INSERT INTO track_genres (track_id, genre) SELECT id, 'jazz' FROM tracks WHERE album_id = ?", w.album["Kind of Blue"])
w.exec("INSERT INTO track_genres (track_id, genre) SELECT id, 'rock' FROM tracks WHERE album_id = ?", w.album["OK Computer"])
return w
}
func (w albumWorld) exec(q string, args ...any) {
if _, err := w.db.ExecContext(w.ctx, q, args...); err != nil {
panic(err)
}
}
func (w albumWorld) listen(track string, at int64, kind string, ms int64) {
w.exec(`INSERT INTO listening_events (user_id, track_id, event_type, occurred_at, duration_played_ms, idempotency_key)
VALUES (?, ?, ?, ?, ?, ?)`, w.user, w.s.track[track], kind, at, ms, kind+track+time.Unix(at, 0).String())
}
func (w albumWorld) titles(t *testing.T, ids []int64, err error) []string {
t.Helper()
if err != nil {
t.Fatal(err)
}
byID := map[int64]string{}
for title, id := range w.album {
byID[id] = title
}
out := []string{}
for _, id := range ids {
out = append(out, byID[id])
}
return out
}
func TestAlbumListsComeInTheOrderAskedFor(t *testing.T) {
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
w := newAlbumWorld(t, db)
ask := func(q opensubsonic.AlbumQuery) []string {
t.Helper()
if q.Size == 0 {
q.Size = 50
}
ids, err := w.repo.AlbumIDs(w.ctx, q)
return w.titles(t, ids, err)
}
check := func(name string, got []string, want ...string) {
t.Helper()
if len(got) == 0 && len(want) == 0 {
return
}
if !reflect.DeepEqual(got, want) {
t.Errorf("%s = %v, want %v", name, got, want)
}
}
// The album of files that are all gone is never in a list.
check("by name", ask(opensubsonic.AlbumQuery{Type: opensubsonic.ListByName}), "Kind of Blue", "OK Computer", "Post", "Various Hits")
check("by artist", ask(opensubsonic.AlbumQuery{Type: opensubsonic.ListByArtist}), "Post", "Kind of Blue", "OK Computer", "Various Hits")
check("newest", ask(opensubsonic.AlbumQuery{Type: opensubsonic.ListNewest}), "Post", "Kind of Blue", "Various Hits", "OK Computer")
check("by year", ask(opensubsonic.AlbumQuery{Type: opensubsonic.ListByYear, FromYear: 1990, ToYear: 2000}), "Post", "OK Computer")
check("by year backwards", ask(opensubsonic.AlbumQuery{Type: opensubsonic.ListByYear, FromYear: 2000, ToYear: 1990}), "OK Computer", "Post")
check("by genre", ask(opensubsonic.AlbumQuery{Type: opensubsonic.ListByGenre, Genre: "Jazz"}), "Kind of Blue")
check("by an unknown genre", ask(opensubsonic.AlbumQuery{Type: opensubsonic.ListByGenre, Genre: "polka"}))
check("paged", ask(opensubsonic.AlbumQuery{Type: opensubsonic.ListByName, Size: 2, Offset: 1}), "OK Computer", "Post")
check("past the end", ask(opensubsonic.AlbumQuery{Type: opensubsonic.ListByName, Offset: 10}))
check("in a library", ask(opensubsonic.AlbumQuery{Type: opensubsonic.ListByName, LibraryID: w.s.jazz}), "Kind of Blue", "OK Computer", "Various Hits") // a second encoding of Airbag is in it
check("starred", ask(opensubsonic.AlbumQuery{Type: opensubsonic.ListStarred}))
random := ask(opensubsonic.AlbumQuery{Type: opensubsonic.ListRandom, Size: 3})
seen := map[string]bool{}
for _, r := range random {
seen[r] = true
}
if len(random) != 3 || len(seen) != 3 {
t.Errorf("random = %v", random)
}
if _, err := w.repo.AlbumIDs(w.ctx, opensubsonic.AlbumQuery{Type: "nope", Size: 5}); err == nil {
t.Error("an unknown kind of list was answered")
}
})
}
func TestFrequentAndRecentAlbumsAreOfTheListenerAndOfListensThatCount(t *testing.T) {
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
w := newAlbumWorld(t, db)
other := seedUser(t, db, "o@example.org")
w.listen("So What", 1000, "complete", 1000)
w.listen("So What", 2000, "complete", 1000)
w.listen("Freddie Freeloader", 3000, "play", 30_000) // long enough to count
w.listen("Airbag", 4000, "complete", 1000)
w.listen("Karma Police", 5000, "skip", 2000) // too short: not a listen
w.exec(`INSERT INTO listening_events (user_id, track_id, event_type, occurred_at, duration_played_ms, idempotency_key)
VALUES (?, ?, 'complete', 9000, 1000, 'x')`, other, w.s.track["Army of Me"])
freq, err := w.repo.AlbumIDs(w.ctx, opensubsonic.AlbumQuery{Type: opensubsonic.ListFrequent, Size: 10, UserID: w.user})
if got := w.titles(t, freq, err); !reflect.DeepEqual(got, []string{"Kind of Blue", "OK Computer"}) {
t.Errorf("frequent = %v", got)
}
recent, err := w.repo.AlbumIDs(w.ctx, opensubsonic.AlbumQuery{Type: opensubsonic.ListRecent, Size: 10, UserID: w.user})
if got := w.titles(t, recent, err); !reflect.DeepEqual(got, []string{"OK Computer", "Kind of Blue"}) {
t.Errorf("recent = %v", got)
}
})
}
func TestSongListsAreByGenreAndRandom(t *testing.T) {
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
w := newAlbumWorld(t, db)
ids, err := w.repo.SongIDs(w.ctx, opensubsonic.SongQuery{Genre: "JAZZ", Size: 10})
if err != nil || len(ids) != 3 {
t.Fatalf("jazz songs = %v, %v", ids, err)
}
// In the order of the album: So What (1), Freddie Freeloader (2), Blue in Green (3).
if ids[0] != w.s.track["So What"] || ids[2] != w.s.track["Blue in Green"] {
t.Errorf("jazz songs in the wrong order: %v", ids)
}
page, _ := w.repo.SongIDs(w.ctx, opensubsonic.SongQuery{Genre: "jazz", Size: 1, Offset: 1})
if len(page) != 1 || page[0] != w.s.track["Freddie Freeloader"] {
t.Errorf("second jazz song = %v", page)
}
years, _ := w.repo.SongIDs(w.ctx, opensubsonic.SongQuery{Random: true, FromYear: 1990, ToYear: 2000, Size: 50})
if len(years) != 4 { // 3 of OK Computer that can be played (Ghost cannot), 1 of Post
t.Errorf("songs of the nineties = %d", len(years))
}
some, _ := w.repo.SongIDs(w.ctx, opensubsonic.SongQuery{Random: true, Size: 5})
seen := map[int64]bool{}
for _, id := range some {
seen[id] = true
}
if len(some) != 5 || len(seen) != 5 {
t.Errorf("random songs = %v", some)
}
if ghost, _ := w.repo.SongIDs(w.ctx, opensubsonic.SongQuery{Random: true, Size: 500}); contains(ghost, w.s.track["Ghost"]) || contains(ghost, w.s.track["Hidden Song"]) {
t.Error("a song with no file to play is in a list")
}
})
}
func contains(ids []int64, id int64) bool {
for _, x := range ids {
if x == id {
return true
}
}
return false
}

View file

@ -3,6 +3,7 @@ package storage
import (
"context"
"testing"
"time"
"github.com/uptrace/bun"
)
@ -11,7 +12,7 @@ func TestTheExtrasOfSongsAndAlbumsComeFromTheirTagsAndFiles(t *testing.T) {
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
ctx := context.Background()
s := seedCatalog(t, db)
repo := NewSubsonicRepo(db)
repo := NewSubsonicRepo(db, 20*time.Second)
exec := func(q string, args ...any) {
t.Helper()
@ -72,7 +73,7 @@ func TestTheExtrasOfSongsAndAlbumsComeFromTheirTagsAndFiles(t *testing.T) {
func TestNoIdsNoExtras(t *testing.T) {
forEachBackend(t, func(t *testing.T, db *bun.DB, _ string) {
repo := NewSubsonicRepo(db)
repo := NewSubsonicRepo(db, 20*time.Second)
if m, err := repo.Tracks(context.Background(), nil); err != nil || len(m) != 0 {
t.Fatalf("%v, %v", m, err)
}