mirror of
https://github.com/navidrome/navidrome.git
synced 2025-04-04 04:57:37 +03:00
Moved package api to subsonic under server
This commit is contained in:
Deluan
parent
67eeb218c4
commit
7610b42f4b
59 changed files with 41 additions and 41 deletions
149
server/subsonic/album_lists.go
Normal file
149
server/subsonic/album_lists.go
Normal file
|
|
@ -0,0 +1,149 @@
|
|||
package subsonic
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http"
|
||||
|
||||
"github.com/cloudsonic/sonic-server/engine"
|
||||
"github.com/cloudsonic/sonic-server/log"
|
||||
"github.com/cloudsonic/sonic-server/server/subsonic/responses"
|
||||
"github.com/cloudsonic/sonic-server/utils"
|
||||
)
|
||||
|
||||
type AlbumListController struct {
|
||||
listGen engine.ListGenerator
|
||||
listFunctions map[string]strategy
|
||||
}
|
||||
|
||||
func NewAlbumListController(listGen engine.ListGenerator) *AlbumListController {
|
||||
c := &AlbumListController{
|
||||
listGen: listGen,
|
||||
}
|
||||
c.listFunctions = map[string]strategy{
|
||||
"random": c.listGen.GetRandom,
|
||||
"newest": c.listGen.GetNewest,
|
||||
"recent": c.listGen.GetRecent,
|
||||
"frequent": c.listGen.GetFrequent,
|
||||
"highest": c.listGen.GetHighest,
|
||||
"alphabeticalByName": c.listGen.GetByName,
|
||||
"alphabeticalByArtist": c.listGen.GetByArtist,
|
||||
"starred": c.listGen.GetStarred,
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
type strategy func(offset int, size int) (engine.Entries, error)
|
||||
|
||||
func (c *AlbumListController) getAlbumList(r *http.Request) (engine.Entries, error) {
|
||||
typ, err := RequiredParamString(r, "type", "Required string parameter 'type' is not present")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
listFunc, found := c.listFunctions[typ]
|
||||
|
||||
if !found {
|
||||
log.Error(r, "albumList type not implemented", "type", typ)
|
||||
return nil, errors.New("Not implemented!")
|
||||
}
|
||||
|
||||
offset := ParamInt(r, "offset", 0)
|
||||
size := utils.MinInt(ParamInt(r, "size", 10), 500)
|
||||
|
||||
albums, err := listFunc(offset, size)
|
||||
if err != nil {
|
||||
log.Error(r, "Error retrieving albums", "error", err)
|
||||
return nil, errors.New("Internal Error")
|
||||
}
|
||||
|
||||
return albums, nil
|
||||
}
|
||||
|
||||
func (c *AlbumListController) GetAlbumList(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
albums, err := c.getAlbumList(r)
|
||||
if err != nil {
|
||||
return nil, NewError(responses.ErrorGeneric, err.Error())
|
||||
}
|
||||
|
||||
response := NewResponse()
|
||||
response.AlbumList = &responses.AlbumList{Album: ToChildren(albums)}
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (c *AlbumListController) GetAlbumList2(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
albums, err := c.getAlbumList(r)
|
||||
if err != nil {
|
||||
return nil, NewError(responses.ErrorGeneric, err.Error())
|
||||
}
|
||||
|
||||
response := NewResponse()
|
||||
response.AlbumList2 = &responses.AlbumList{Album: ToAlbums(albums)}
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (c *AlbumListController) GetStarred(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
artists, albums, mediaFiles, err := c.listGen.GetAllStarred()
|
||||
if err != nil {
|
||||
log.Error(r, "Error retrieving starred media", "error", err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
|
||||
response := NewResponse()
|
||||
response.Starred = &responses.Starred{}
|
||||
response.Starred.Artist = ToArtists(artists)
|
||||
response.Starred.Album = ToChildren(albums)
|
||||
response.Starred.Song = ToChildren(mediaFiles)
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (c *AlbumListController) GetStarred2(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
artists, albums, mediaFiles, err := c.listGen.GetAllStarred()
|
||||
if err != nil {
|
||||
log.Error(r, "Error retrieving starred media", "error", err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
|
||||
response := NewResponse()
|
||||
response.Starred2 = &responses.Starred{}
|
||||
response.Starred2.Artist = ToArtists(artists)
|
||||
response.Starred2.Album = ToAlbums(albums)
|
||||
response.Starred2.Song = ToChildren(mediaFiles)
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (c *AlbumListController) GetNowPlaying(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
npInfos, err := c.listGen.GetNowPlaying()
|
||||
if err != nil {
|
||||
log.Error(r, "Error retrieving now playing list", "error", err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
|
||||
response := NewResponse()
|
||||
response.NowPlaying = &responses.NowPlaying{}
|
||||
response.NowPlaying.Entry = make([]responses.NowPlayingEntry, len(npInfos))
|
||||
for i, entry := range npInfos {
|
||||
response.NowPlaying.Entry[i].Child = ToChild(entry)
|
||||
response.NowPlaying.Entry[i].UserName = entry.UserName
|
||||
response.NowPlaying.Entry[i].MinutesAgo = entry.MinutesAgo
|
||||
response.NowPlaying.Entry[i].PlayerId = entry.PlayerId
|
||||
response.NowPlaying.Entry[i].PlayerName = entry.PlayerName
|
||||
}
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (c *AlbumListController) GetRandomSongs(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
size := utils.MinInt(ParamInt(r, "size", 10), 500)
|
||||
|
||||
songs, err := c.listGen.GetRandomSongs(size)
|
||||
if err != nil {
|
||||
log.Error(r, "Error retrieving random songs", "error", err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
|
||||
response := NewResponse()
|
||||
response.RandomSongs = &responses.Songs{}
|
||||
response.RandomSongs.Songs = make([]responses.Child, len(songs))
|
||||
for i, entry := range songs {
|
||||
response.RandomSongs.Songs[i] = ToChild(entry)
|
||||
}
|
||||
return response, nil
|
||||
}
|
||||
103
server/subsonic/album_lists_test.go
Normal file
103
server/subsonic/album_lists_test.go
Normal file
|
|
@ -0,0 +1,103 @@
|
|||
package subsonic
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http/httptest"
|
||||
|
||||
"github.com/cloudsonic/sonic-server/engine"
|
||||
. "github.com/onsi/ginkgo"
|
||||
. "github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
type fakeListGen struct {
|
||||
engine.ListGenerator
|
||||
data engine.Entries
|
||||
err error
|
||||
recvOffset int
|
||||
recvSize int
|
||||
}
|
||||
|
||||
func (lg *fakeListGen) GetNewest(offset int, size int) (engine.Entries, error) {
|
||||
if lg.err != nil {
|
||||
return nil, lg.err
|
||||
}
|
||||
lg.recvOffset = offset
|
||||
lg.recvSize = size
|
||||
return lg.data, nil
|
||||
}
|
||||
|
||||
var _ = Describe("AlbumListController", func() {
|
||||
var controller *AlbumListController
|
||||
var listGen *fakeListGen
|
||||
var w *httptest.ResponseRecorder
|
||||
|
||||
BeforeEach(func() {
|
||||
listGen = &fakeListGen{}
|
||||
controller = NewAlbumListController(listGen)
|
||||
w = httptest.NewRecorder()
|
||||
})
|
||||
|
||||
Describe("GetAlbumList", func() {
|
||||
It("should return list of the type specified", func() {
|
||||
r := newTestRequest("type=newest", "offset=10", "size=20")
|
||||
listGen.data = engine.Entries{
|
||||
{Id: "1"}, {Id: "2"},
|
||||
}
|
||||
resp, err := controller.GetAlbumList(w, r)
|
||||
|
||||
Expect(err).To(BeNil())
|
||||
Expect(resp.AlbumList.Album[0].Id).To(Equal("1"))
|
||||
Expect(resp.AlbumList.Album[1].Id).To(Equal("2"))
|
||||
Expect(listGen.recvOffset).To(Equal(10))
|
||||
Expect(listGen.recvSize).To(Equal(20))
|
||||
})
|
||||
|
||||
It("should fail if missing type parameter", func() {
|
||||
r := newTestRequest()
|
||||
_, err := controller.GetAlbumList(w, r)
|
||||
|
||||
Expect(err).To(MatchError("Required string parameter 'type' is not present"))
|
||||
})
|
||||
|
||||
It("should return error if call fails", func() {
|
||||
listGen.err = errors.New("some issue")
|
||||
r := newTestRequest("type=newest")
|
||||
|
||||
_, err := controller.GetAlbumList(w, r)
|
||||
|
||||
Expect(err).To(MatchError("Internal Error"))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("GetAlbumList2", func() {
|
||||
It("should return list of the type specified", func() {
|
||||
r := newTestRequest("type=newest", "offset=10", "size=20")
|
||||
listGen.data = engine.Entries{
|
||||
{Id: "1"}, {Id: "2"},
|
||||
}
|
||||
resp, err := controller.GetAlbumList2(w, r)
|
||||
|
||||
Expect(err).To(BeNil())
|
||||
Expect(resp.AlbumList2.Album[0].Id).To(Equal("1"))
|
||||
Expect(resp.AlbumList2.Album[1].Id).To(Equal("2"))
|
||||
Expect(listGen.recvOffset).To(Equal(10))
|
||||
Expect(listGen.recvSize).To(Equal(20))
|
||||
})
|
||||
|
||||
It("should fail if missing type parameter", func() {
|
||||
r := newTestRequest()
|
||||
_, err := controller.GetAlbumList2(w, r)
|
||||
|
||||
Expect(err).To(MatchError("Required string parameter 'type' is not present"))
|
||||
})
|
||||
|
||||
It("should return error if call fails", func() {
|
||||
listGen.err = errors.New("some issue")
|
||||
r := newTestRequest("type=newest")
|
||||
|
||||
_, err := controller.GetAlbumList2(w, r)
|
||||
|
||||
Expect(err).To(MatchError("Internal Error"))
|
||||
})
|
||||
})
|
||||
})
|
||||
181
server/subsonic/api.go
Normal file
181
server/subsonic/api.go
Normal file
|
|
@ -0,0 +1,181 @@
|
|||
package subsonic
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"encoding/xml"
|
||||
"fmt"
|
||||
"net/http"
|
||||
|
||||
"github.com/cloudsonic/sonic-server/conf"
|
||||
"github.com/cloudsonic/sonic-server/engine"
|
||||
"github.com/cloudsonic/sonic-server/server/subsonic/responses"
|
||||
"github.com/go-chi/chi"
|
||||
)
|
||||
|
||||
const Version = "1.8.0"
|
||||
|
||||
type Handler = func(http.ResponseWriter, *http.Request) (*responses.Subsonic, error)
|
||||
|
||||
type Router struct {
|
||||
Browser engine.Browser
|
||||
Cover engine.Cover
|
||||
ListGenerator engine.ListGenerator
|
||||
Playlists engine.Playlists
|
||||
Ratings engine.Ratings
|
||||
Scrobbler engine.Scrobbler
|
||||
Search engine.Search
|
||||
|
||||
mux http.Handler
|
||||
}
|
||||
|
||||
func NewRouter(browser engine.Browser, cover engine.Cover, listGenerator engine.ListGenerator,
|
||||
playlists engine.Playlists, ratings engine.Ratings, scrobbler engine.Scrobbler, search engine.Search) *Router {
|
||||
|
||||
r := &Router{Browser: browser, Cover: cover, ListGenerator: listGenerator, Playlists: playlists,
|
||||
Ratings: ratings, Scrobbler: scrobbler, Search: search}
|
||||
r.mux = r.routes()
|
||||
return r
|
||||
}
|
||||
|
||||
func (api *Router) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
api.mux.ServeHTTP(w, r)
|
||||
}
|
||||
|
||||
func (api *Router) routes() http.Handler {
|
||||
r := chi.NewRouter()
|
||||
|
||||
r.Use(checkRequiredParameters)
|
||||
|
||||
// Add validation middleware if not disabled
|
||||
if !conf.Sonic.DevDisableAuthentication {
|
||||
r.Use(authenticate)
|
||||
// TODO Validate version
|
||||
}
|
||||
|
||||
// Subsonic endpoints, grouped by controller
|
||||
r.Group(func(r chi.Router) {
|
||||
c := initSystemController(api)
|
||||
H(r, "ping", c.Ping)
|
||||
H(r, "getLicense", c.GetLicense)
|
||||
})
|
||||
r.Group(func(r chi.Router) {
|
||||
c := initBrowsingController(api)
|
||||
H(r, "getMusicFolders", c.GetMusicFolders)
|
||||
H(r, "getMusicFolders", c.GetMusicFolders)
|
||||
H(r, "getIndexes", c.GetIndexes)
|
||||
H(r, "getArtists", c.GetArtists)
|
||||
H(r, "getGenres", c.GetGenres)
|
||||
reqParams := r.With(requiredParams("id"))
|
||||
H(reqParams, "getMusicDirectory", c.GetMusicDirectory)
|
||||
H(reqParams, "getArtist", c.GetArtist)
|
||||
H(reqParams, "getAlbum", c.GetAlbum)
|
||||
H(reqParams, "getSong", c.GetSong)
|
||||
})
|
||||
r.Group(func(r chi.Router) {
|
||||
c := initAlbumListController(api)
|
||||
H(r, "getAlbumList", c.GetAlbumList)
|
||||
H(r, "getAlbumList2", c.GetAlbumList2)
|
||||
H(r, "getStarred", c.GetStarred)
|
||||
H(r, "getStarred2", c.GetStarred2)
|
||||
H(r, "getNowPlaying", c.GetNowPlaying)
|
||||
H(r, "getRandomSongs", c.GetRandomSongs)
|
||||
})
|
||||
r.Group(func(r chi.Router) {
|
||||
c := initMediaAnnotationController(api)
|
||||
H(r, "setRating", c.SetRating)
|
||||
H(r, "star", c.Star)
|
||||
H(r, "unstar", c.Unstar)
|
||||
H(r, "scrobble", c.Scrobble)
|
||||
})
|
||||
r.Group(func(r chi.Router) {
|
||||
c := initPlaylistsController(api)
|
||||
H(r, "getPlaylists", c.GetPlaylists)
|
||||
H(r, "getPlaylist", c.GetPlaylist)
|
||||
H(r, "createPlaylist", c.CreatePlaylist)
|
||||
H(r, "deletePlaylist", c.DeletePlaylist)
|
||||
H(r, "updatePlaylist", c.UpdatePlaylist)
|
||||
})
|
||||
r.Group(func(r chi.Router) {
|
||||
c := initSearchingController(api)
|
||||
H(r, "search2", c.Search2)
|
||||
H(r, "search3", c.Search3)
|
||||
})
|
||||
r.Group(func(r chi.Router) {
|
||||
c := initUsersController(api)
|
||||
H(r, "getUser", c.GetUser)
|
||||
})
|
||||
r.Group(func(r chi.Router) {
|
||||
c := initMediaRetrievalController(api)
|
||||
H(r, "getAvatar", c.GetAvatar)
|
||||
H(r, "getCoverArt", c.GetCoverArt)
|
||||
})
|
||||
r.Group(func(r chi.Router) {
|
||||
c := initStreamController(api)
|
||||
H(r, "stream", c.Stream)
|
||||
H(r, "download", c.Download)
|
||||
})
|
||||
|
||||
// Deprecated/Out of scope endpoints
|
||||
HGone(r, "getChatMessages")
|
||||
HGone(r, "addChatMessage")
|
||||
return r
|
||||
}
|
||||
|
||||
// Add the Subsonic handler, with and without `.view` extension
|
||||
// Ex: if path = `ping` it will create the routes `/ping` and `/ping.view`
|
||||
func H(r chi.Router, path string, f Handler) {
|
||||
handle := func(w http.ResponseWriter, r *http.Request) {
|
||||
res, err := f(w, r)
|
||||
if err != nil {
|
||||
SendError(w, r, err)
|
||||
return
|
||||
}
|
||||
if res != nil {
|
||||
SendResponse(w, r, res)
|
||||
}
|
||||
}
|
||||
r.HandleFunc("/"+path, handle)
|
||||
r.HandleFunc("/"+path+".view", handle)
|
||||
}
|
||||
|
||||
// Add a handler that returns 410 - Gone. Used to signal that an endpoint will not be implemented
|
||||
func HGone(r chi.Router, path string) {
|
||||
handle := func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(410)
|
||||
w.Write([]byte("This endpoint will not be implemented"))
|
||||
}
|
||||
r.HandleFunc("/"+path, handle)
|
||||
r.HandleFunc("/"+path+".view", handle)
|
||||
}
|
||||
|
||||
func SendError(w http.ResponseWriter, r *http.Request, err error) {
|
||||
response := &responses.Subsonic{Version: Version, Status: "fail"}
|
||||
code := responses.ErrorGeneric
|
||||
if e, ok := err.(SubsonicError); ok {
|
||||
code = e.code
|
||||
}
|
||||
response.Error = &responses.Error{Code: code, Message: err.Error()}
|
||||
|
||||
SendResponse(w, r, response)
|
||||
}
|
||||
|
||||
func SendResponse(w http.ResponseWriter, r *http.Request, payload *responses.Subsonic) {
|
||||
f := ParamString(r, "f")
|
||||
var response []byte
|
||||
switch f {
|
||||
case "json":
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
wrapper := &responses.JsonWrapper{Subsonic: *payload}
|
||||
response, _ = json.Marshal(wrapper)
|
||||
case "jsonp":
|
||||
w.Header().Set("Content-Type", "application/javascript")
|
||||
callback := ParamString(r, "callback")
|
||||
wrapper := &responses.JsonWrapper{Subsonic: *payload}
|
||||
data, _ := json.Marshal(wrapper)
|
||||
response = []byte(fmt.Sprintf("%s(%s)", callback, data))
|
||||
default:
|
||||
w.Header().Set("Content-Type", "application/xml")
|
||||
response, _ = xml.Marshal(payload)
|
||||
}
|
||||
w.Write(response)
|
||||
}
|
||||
15
server/subsonic/api_suite_test.go
Normal file
15
server/subsonic/api_suite_test.go
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
package subsonic
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/cloudsonic/sonic-server/log"
|
||||
. "github.com/onsi/ginkgo"
|
||||
. "github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
func TestSubsonicApi(t *testing.T) {
|
||||
log.SetLevel(log.LevelCritical)
|
||||
RegisterFailHandler(Fail)
|
||||
RunSpecs(t, "Subsonic API Suite")
|
||||
}
|
||||
218
server/subsonic/browsing.go
Normal file
218
server/subsonic/browsing.go
Normal file
|
|
@ -0,0 +1,218 @@
|
|||
package subsonic
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"github.com/cloudsonic/sonic-server/conf"
|
||||
"github.com/cloudsonic/sonic-server/engine"
|
||||
"github.com/cloudsonic/sonic-server/log"
|
||||
"github.com/cloudsonic/sonic-server/model"
|
||||
"github.com/cloudsonic/sonic-server/server/subsonic/responses"
|
||||
"github.com/cloudsonic/sonic-server/utils"
|
||||
)
|
||||
|
||||
type BrowsingController struct {
|
||||
browser engine.Browser
|
||||
}
|
||||
|
||||
func NewBrowsingController(browser engine.Browser) *BrowsingController {
|
||||
return &BrowsingController{browser: browser}
|
||||
}
|
||||
|
||||
func (c *BrowsingController) GetMusicFolders(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
mediaFolderList, _ := c.browser.MediaFolders()
|
||||
folders := make([]responses.MusicFolder, len(mediaFolderList))
|
||||
for i, f := range mediaFolderList {
|
||||
folders[i].Id = f.ID
|
||||
folders[i].Name = f.Name
|
||||
}
|
||||
response := NewResponse()
|
||||
response.MusicFolders = &responses.MusicFolders{Folders: folders}
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (c *BrowsingController) getArtistIndex(r *http.Request, ifModifiedSince time.Time) (*responses.Indexes, error) {
|
||||
indexes, lastModified, err := c.browser.Indexes(ifModifiedSince)
|
||||
if err != nil {
|
||||
log.Error(r, "Error retrieving Indexes", "error", err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
|
||||
res := &responses.Indexes{
|
||||
IgnoredArticles: conf.Sonic.IgnoredArticles,
|
||||
LastModified: fmt.Sprint(utils.ToMillis(lastModified)),
|
||||
}
|
||||
|
||||
res.Index = make([]responses.Index, len(indexes))
|
||||
for i, idx := range indexes {
|
||||
res.Index[i].Name = idx.ID
|
||||
res.Index[i].Artists = make([]responses.Artist, len(idx.Artists))
|
||||
for j, a := range idx.Artists {
|
||||
res.Index[i].Artists[j].Id = a.ID
|
||||
res.Index[i].Artists[j].Name = a.Name
|
||||
res.Index[i].Artists[j].AlbumCount = a.AlbumCount
|
||||
}
|
||||
}
|
||||
return res, nil
|
||||
}
|
||||
|
||||
func (c *BrowsingController) GetIndexes(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
ifModifiedSince := ParamTime(r, "ifModifiedSince", time.Time{})
|
||||
|
||||
res, err := c.getArtistIndex(r, ifModifiedSince)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
response := NewResponse()
|
||||
response.Indexes = res
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (c *BrowsingController) GetArtists(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
res, err := c.getArtistIndex(r, time.Time{})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
response := NewResponse()
|
||||
response.Artist = res
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (c *BrowsingController) GetMusicDirectory(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
id := ParamString(r, "id")
|
||||
dir, err := c.browser.Directory(r.Context(), id)
|
||||
switch {
|
||||
case err == model.ErrNotFound:
|
||||
log.Error(r, "Requested ID not found ", "id", id)
|
||||
return nil, NewError(responses.ErrorDataNotFound, "Directory not found")
|
||||
case err != nil:
|
||||
log.Error(err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
|
||||
response := NewResponse()
|
||||
response.Directory = c.buildDirectory(dir)
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (c *BrowsingController) GetArtist(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
id := ParamString(r, "id")
|
||||
dir, err := c.browser.Artist(r.Context(), id)
|
||||
switch {
|
||||
case err == model.ErrNotFound:
|
||||
log.Error(r, "Requested ArtistID not found ", "id", id)
|
||||
return nil, NewError(responses.ErrorDataNotFound, "Artist not found")
|
||||
case err != nil:
|
||||
log.Error(r, err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
|
||||
response := NewResponse()
|
||||
response.ArtistWithAlbumsID3 = c.buildArtist(dir)
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (c *BrowsingController) GetAlbum(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
id := ParamString(r, "id")
|
||||
dir, err := c.browser.Album(r.Context(), id)
|
||||
switch {
|
||||
case err == model.ErrNotFound:
|
||||
log.Error(r, "Requested ID not found ", "id", id)
|
||||
return nil, NewError(responses.ErrorDataNotFound, "Album not found")
|
||||
case err != nil:
|
||||
log.Error(r, err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
|
||||
response := NewResponse()
|
||||
response.AlbumWithSongsID3 = c.buildAlbum(dir)
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (c *BrowsingController) GetSong(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
id := ParamString(r, "id")
|
||||
song, err := c.browser.GetSong(id)
|
||||
switch {
|
||||
case err == model.ErrNotFound:
|
||||
log.Error(r, "Requested ID not found ", "id", id)
|
||||
return nil, NewError(responses.ErrorDataNotFound, "Song not found")
|
||||
case err != nil:
|
||||
log.Error(r, err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
|
||||
response := NewResponse()
|
||||
child := ToChild(*song)
|
||||
response.Song = &child
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (c *BrowsingController) GetGenres(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
genres, err := c.browser.GetGenres()
|
||||
if err != nil {
|
||||
log.Error(r, err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
|
||||
response := NewResponse()
|
||||
response.Genres = ToGenres(genres)
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (c *BrowsingController) buildDirectory(d *engine.DirectoryInfo) *responses.Directory {
|
||||
dir := &responses.Directory{
|
||||
Id: d.Id,
|
||||
Name: d.Name,
|
||||
Parent: d.Parent,
|
||||
PlayCount: d.PlayCount,
|
||||
AlbumCount: d.AlbumCount,
|
||||
UserRating: d.UserRating,
|
||||
}
|
||||
if !d.Starred.IsZero() {
|
||||
dir.Starred = &d.Starred
|
||||
}
|
||||
|
||||
dir.Child = ToChildren(d.Entries)
|
||||
return dir
|
||||
}
|
||||
|
||||
func (c *BrowsingController) buildArtist(d *engine.DirectoryInfo) *responses.ArtistWithAlbumsID3 {
|
||||
dir := &responses.ArtistWithAlbumsID3{}
|
||||
dir.Id = d.Id
|
||||
dir.Name = d.Name
|
||||
dir.AlbumCount = d.AlbumCount
|
||||
dir.CoverArt = d.CoverArt
|
||||
if !d.Starred.IsZero() {
|
||||
dir.Starred = &d.Starred
|
||||
}
|
||||
|
||||
dir.Album = ToAlbums(d.Entries)
|
||||
return dir
|
||||
}
|
||||
|
||||
func (c *BrowsingController) buildAlbum(d *engine.DirectoryInfo) *responses.AlbumWithSongsID3 {
|
||||
dir := &responses.AlbumWithSongsID3{}
|
||||
dir.Id = d.Id
|
||||
dir.Name = d.Name
|
||||
dir.Artist = d.Artist
|
||||
dir.ArtistId = d.ArtistId
|
||||
dir.CoverArt = d.CoverArt
|
||||
dir.SongCount = d.SongCount
|
||||
dir.Duration = d.Duration
|
||||
dir.PlayCount = d.PlayCount
|
||||
dir.Year = d.Year
|
||||
dir.Genre = d.Genre
|
||||
if !d.Created.IsZero() {
|
||||
dir.Created = &d.Created
|
||||
}
|
||||
if !d.Starred.IsZero() {
|
||||
dir.Starred = &d.Starred
|
||||
}
|
||||
|
||||
dir.Song = ToChildren(d.Entries)
|
||||
return dir
|
||||
}
|
||||
211
server/subsonic/helpers.go
Normal file
211
server/subsonic/helpers.go
Normal file
|
|
@ -0,0 +1,211 @@
|
|||
package subsonic
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/cloudsonic/sonic-server/engine"
|
||||
"github.com/cloudsonic/sonic-server/model"
|
||||
"github.com/cloudsonic/sonic-server/server/subsonic/responses"
|
||||
"github.com/cloudsonic/sonic-server/utils"
|
||||
)
|
||||
|
||||
func NewResponse() *responses.Subsonic {
|
||||
return &responses.Subsonic{Status: "ok", Version: Version}
|
||||
}
|
||||
|
||||
func RequiredParamString(r *http.Request, param string, msg string) (string, error) {
|
||||
p := ParamString(r, param)
|
||||
if p == "" {
|
||||
return "", NewError(responses.ErrorMissingParameter, msg)
|
||||
}
|
||||
return p, nil
|
||||
}
|
||||
|
||||
func RequiredParamStrings(r *http.Request, param string, msg string) ([]string, error) {
|
||||
ps := ParamStrings(r, param)
|
||||
if len(ps) == 0 {
|
||||
return nil, NewError(responses.ErrorMissingParameter, msg)
|
||||
}
|
||||
return ps, nil
|
||||
}
|
||||
|
||||
func ParamString(r *http.Request, param string) string {
|
||||
return r.URL.Query().Get(param)
|
||||
}
|
||||
|
||||
func ParamStrings(r *http.Request, param string) []string {
|
||||
return r.URL.Query()[param]
|
||||
}
|
||||
|
||||
func ParamTimes(r *http.Request, param string) []time.Time {
|
||||
pStr := ParamStrings(r, param)
|
||||
times := make([]time.Time, len(pStr))
|
||||
for i, t := range pStr {
|
||||
ti, err := strconv.ParseInt(t, 10, 64)
|
||||
if err == nil {
|
||||
times[i] = utils.ToTime(ti)
|
||||
}
|
||||
}
|
||||
return times
|
||||
}
|
||||
|
||||
func ParamTime(r *http.Request, param string, def time.Time) time.Time {
|
||||
v := ParamString(r, param)
|
||||
if v == "" {
|
||||
return def
|
||||
}
|
||||
value, err := strconv.ParseInt(v, 10, 64)
|
||||
if err != nil {
|
||||
return def
|
||||
}
|
||||
return utils.ToTime(value)
|
||||
}
|
||||
|
||||
func RequiredParamInt(r *http.Request, param string, msg string) (int, error) {
|
||||
p := ParamString(r, param)
|
||||
if p == "" {
|
||||
return 0, NewError(responses.ErrorMissingParameter, msg)
|
||||
}
|
||||
return ParamInt(r, param, 0), nil
|
||||
}
|
||||
|
||||
func ParamInt(r *http.Request, param string, def int) int {
|
||||
v := ParamString(r, param)
|
||||
if v == "" {
|
||||
return def
|
||||
}
|
||||
value, err := strconv.ParseInt(v, 10, 32)
|
||||
if err != nil {
|
||||
return def
|
||||
}
|
||||
return int(value)
|
||||
}
|
||||
|
||||
func ParamInts(r *http.Request, param string) []int {
|
||||
pStr := ParamStrings(r, param)
|
||||
ints := make([]int, 0, len(pStr))
|
||||
for _, s := range pStr {
|
||||
i, err := strconv.ParseInt(s, 10, 32)
|
||||
if err == nil {
|
||||
ints = append(ints, int(i))
|
||||
}
|
||||
}
|
||||
return ints
|
||||
}
|
||||
|
||||
func ParamBool(r *http.Request, param string, def bool) bool {
|
||||
p := ParamString(r, param)
|
||||
if p == "" {
|
||||
return def
|
||||
}
|
||||
return strings.Index("/true/on/1/", "/"+p+"/") != -1
|
||||
}
|
||||
|
||||
type SubsonicError struct {
|
||||
code int
|
||||
messages []interface{}
|
||||
}
|
||||
|
||||
func NewError(code int, message ...interface{}) error {
|
||||
return SubsonicError{
|
||||
code: code,
|
||||
messages: message,
|
||||
}
|
||||
}
|
||||
|
||||
func (e SubsonicError) Error() string {
|
||||
var msg string
|
||||
if len(e.messages) == 0 {
|
||||
msg = responses.ErrorMsg(e.code)
|
||||
} else {
|
||||
msg = fmt.Sprintf(e.messages[0].(string), e.messages[1:]...)
|
||||
}
|
||||
return msg
|
||||
}
|
||||
|
||||
func ToAlbums(entries engine.Entries) []responses.Child {
|
||||
children := make([]responses.Child, len(entries))
|
||||
for i, entry := range entries {
|
||||
children[i] = ToAlbum(entry)
|
||||
}
|
||||
return children
|
||||
}
|
||||
|
||||
func ToAlbum(entry engine.Entry) responses.Child {
|
||||
album := ToChild(entry)
|
||||
album.Name = album.Title
|
||||
album.Title = ""
|
||||
album.Parent = ""
|
||||
album.Album = ""
|
||||
album.AlbumId = ""
|
||||
return album
|
||||
}
|
||||
|
||||
func ToArtists(entries engine.Entries) []responses.Artist {
|
||||
artists := make([]responses.Artist, len(entries))
|
||||
for i, entry := range entries {
|
||||
artists[i] = responses.Artist{
|
||||
Id: entry.Id,
|
||||
Name: entry.Title,
|
||||
AlbumCount: entry.AlbumCount,
|
||||
}
|
||||
if !entry.Starred.IsZero() {
|
||||
artists[i].Starred = &entry.Starred
|
||||
}
|
||||
}
|
||||
return artists
|
||||
}
|
||||
|
||||
func ToChildren(entries engine.Entries) []responses.Child {
|
||||
children := make([]responses.Child, len(entries))
|
||||
for i, entry := range entries {
|
||||
children[i] = ToChild(entry)
|
||||
}
|
||||
return children
|
||||
}
|
||||
|
||||
func ToChild(entry engine.Entry) responses.Child {
|
||||
child := responses.Child{}
|
||||
child.Id = entry.Id
|
||||
child.Title = entry.Title
|
||||
child.IsDir = entry.IsDir
|
||||
child.Parent = entry.Parent
|
||||
child.Album = entry.Album
|
||||
child.Year = entry.Year
|
||||
child.Artist = entry.Artist
|
||||
child.Genre = entry.Genre
|
||||
child.CoverArt = entry.CoverArt
|
||||
child.Track = entry.Track
|
||||
child.Duration = entry.Duration
|
||||
child.Size = entry.Size
|
||||
child.Suffix = entry.Suffix
|
||||
child.BitRate = entry.BitRate
|
||||
child.ContentType = entry.ContentType
|
||||
if !entry.Starred.IsZero() {
|
||||
child.Starred = &entry.Starred
|
||||
}
|
||||
child.Path = entry.Path
|
||||
child.PlayCount = entry.PlayCount
|
||||
child.DiscNumber = entry.DiscNumber
|
||||
if !entry.Created.IsZero() {
|
||||
child.Created = &entry.Created
|
||||
}
|
||||
child.AlbumId = entry.AlbumId
|
||||
child.ArtistId = entry.ArtistId
|
||||
child.Type = entry.Type
|
||||
child.UserRating = entry.UserRating
|
||||
child.SongCount = entry.SongCount
|
||||
return child
|
||||
}
|
||||
|
||||
func ToGenres(genres model.Genres) *responses.Genres {
|
||||
response := make([]responses.Genre, len(genres))
|
||||
for i, g := range genres {
|
||||
response[i] = responses.Genre(g)
|
||||
}
|
||||
return &responses.Genres{Genre: response}
|
||||
}
|
||||
141
server/subsonic/media_annotation.go
Normal file
141
server/subsonic/media_annotation.go
Normal file
|
|
@ -0,0 +1,141 @@
|
|||
package subsonic
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"github.com/cloudsonic/sonic-server/engine"
|
||||
"github.com/cloudsonic/sonic-server/log"
|
||||
"github.com/cloudsonic/sonic-server/model"
|
||||
"github.com/cloudsonic/sonic-server/server/subsonic/responses"
|
||||
)
|
||||
|
||||
type MediaAnnotationController struct {
|
||||
scrobbler engine.Scrobbler
|
||||
ratings engine.Ratings
|
||||
}
|
||||
|
||||
func NewMediaAnnotationController(scrobbler engine.Scrobbler, ratings engine.Ratings) *MediaAnnotationController {
|
||||
return &MediaAnnotationController{
|
||||
scrobbler: scrobbler,
|
||||
ratings: ratings,
|
||||
}
|
||||
}
|
||||
|
||||
func (c *MediaAnnotationController) SetRating(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
id, err := RequiredParamString(r, "id", "Required id parameter is missing")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
rating, err := RequiredParamInt(r, "rating", "Required rating parameter is missing")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
log.Debug(r, "Setting rating", "rating", rating, "id", id)
|
||||
err = c.ratings.SetRating(r.Context(), id, rating)
|
||||
|
||||
switch {
|
||||
case err == model.ErrNotFound:
|
||||
log.Error(r, err)
|
||||
return nil, NewError(responses.ErrorDataNotFound, "ID not found")
|
||||
case err != nil:
|
||||
log.Error(r, err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
|
||||
return NewResponse(), nil
|
||||
}
|
||||
|
||||
func (c *MediaAnnotationController) getIds(r *http.Request) ([]string, error) {
|
||||
ids := ParamStrings(r, "id")
|
||||
albumIds := ParamStrings(r, "albumId")
|
||||
artistIds := ParamStrings(r, "artistId")
|
||||
|
||||
if len(ids)+len(albumIds)+len(artistIds) == 0 {
|
||||
return nil, NewError(responses.ErrorMissingParameter, "Required id parameter is missing")
|
||||
}
|
||||
|
||||
ids = append(ids, albumIds...)
|
||||
ids = append(ids, artistIds...)
|
||||
return ids, nil
|
||||
}
|
||||
|
||||
func (c *MediaAnnotationController) Star(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
ids, err := c.getIds(r)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
log.Debug(r, "Starring items", "ids", ids)
|
||||
err = c.ratings.SetStar(r.Context(), true, ids...)
|
||||
switch {
|
||||
case err == model.ErrNotFound:
|
||||
log.Error(r, err)
|
||||
return nil, NewError(responses.ErrorDataNotFound, "ID not found")
|
||||
case err != nil:
|
||||
log.Error(r, err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
|
||||
return NewResponse(), nil
|
||||
}
|
||||
|
||||
func (c *MediaAnnotationController) Unstar(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
ids, err := c.getIds(r)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
log.Debug(r, "Unstarring items", "ids", ids)
|
||||
err = c.ratings.SetStar(r.Context(), false, ids...)
|
||||
switch {
|
||||
case err == model.ErrNotFound:
|
||||
log.Error(r, err)
|
||||
return nil, NewError(responses.ErrorDataNotFound, "Directory not found")
|
||||
case err != nil:
|
||||
log.Error(r, err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
|
||||
return NewResponse(), nil
|
||||
}
|
||||
|
||||
func (c *MediaAnnotationController) Scrobble(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
ids, err := RequiredParamStrings(r, "id", "Required id parameter is missing")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
times := ParamTimes(r, "time")
|
||||
if len(times) > 0 && len(times) != len(ids) {
|
||||
return nil, NewError(responses.ErrorGeneric, "Wrong number of timestamps: %d, should be %d", len(times), len(ids))
|
||||
}
|
||||
submission := ParamBool(r, "submission", true)
|
||||
playerId := 1 // TODO Multiple players, based on playerName/username/clientIP(?)
|
||||
playerName := ParamString(r, "c")
|
||||
username := ParamString(r, "u")
|
||||
|
||||
log.Debug(r, "Scrobbling tracks", "ids", ids, "times", times, "submission", submission)
|
||||
for i, id := range ids {
|
||||
var t time.Time
|
||||
if len(times) > 0 {
|
||||
t = times[i]
|
||||
} else {
|
||||
t = time.Now()
|
||||
}
|
||||
if submission {
|
||||
mf, err := c.scrobbler.Register(r.Context(), playerId, id, t)
|
||||
if err != nil {
|
||||
log.Error(r, "Error scrobbling track", "id", id, err)
|
||||
continue
|
||||
}
|
||||
log.Info(r, "Scrobbled", "id", id, "title", mf.Title, "timestamp", t)
|
||||
} else {
|
||||
mf, err := c.scrobbler.NowPlaying(r.Context(), playerId, playerName, id, username)
|
||||
if err != nil {
|
||||
log.Error(r, "Error setting current song", "id", id, err)
|
||||
continue
|
||||
}
|
||||
log.Info(r, "Now Playing", "id", id, "title", mf.Title, "timestamp", t)
|
||||
}
|
||||
}
|
||||
return NewResponse(), nil
|
||||
}
|
||||
54
server/subsonic/media_retrieval.go
Normal file
54
server/subsonic/media_retrieval.go
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
package subsonic
|
||||
|
||||
import (
|
||||
"io"
|
||||
"net/http"
|
||||
"os"
|
||||
|
||||
"github.com/cloudsonic/sonic-server/engine"
|
||||
"github.com/cloudsonic/sonic-server/log"
|
||||
"github.com/cloudsonic/sonic-server/model"
|
||||
"github.com/cloudsonic/sonic-server/server/subsonic/responses"
|
||||
)
|
||||
|
||||
type MediaRetrievalController struct {
|
||||
cover engine.Cover
|
||||
}
|
||||
|
||||
func NewMediaRetrievalController(cover engine.Cover) *MediaRetrievalController {
|
||||
return &MediaRetrievalController{cover: cover}
|
||||
}
|
||||
|
||||
func (c *MediaRetrievalController) GetAvatar(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
var f *os.File
|
||||
f, err := os.Open("static/itunes.png")
|
||||
if err != nil {
|
||||
log.Error(r, "Image not found", err)
|
||||
return nil, NewError(responses.ErrorDataNotFound, "Avatar image not found")
|
||||
}
|
||||
defer f.Close()
|
||||
io.Copy(w, f)
|
||||
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
func (c *MediaRetrievalController) GetCoverArt(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
id, err := RequiredParamString(r, "id", "id parameter required")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
size := ParamInt(r, "size", 0)
|
||||
|
||||
err = c.cover.Get(id, size, w)
|
||||
|
||||
switch {
|
||||
case err == model.ErrNotFound:
|
||||
log.Error(r, err.Error(), "id", id)
|
||||
return nil, NewError(responses.ErrorDataNotFound, "Cover not found")
|
||||
case err != nil:
|
||||
log.Error(r, err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
|
||||
return nil, nil
|
||||
}
|
||||
76
server/subsonic/media_retrieval_test.go
Normal file
76
server/subsonic/media_retrieval_test.go
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
package subsonic
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"io"
|
||||
"net/http/httptest"
|
||||
|
||||
"github.com/cloudsonic/sonic-server/model"
|
||||
. "github.com/onsi/ginkgo"
|
||||
. "github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
type fakeCover struct {
|
||||
data string
|
||||
err error
|
||||
recvId string
|
||||
recvSize int
|
||||
}
|
||||
|
||||
func (c *fakeCover) Get(id string, size int, out io.Writer) error {
|
||||
if c.err != nil {
|
||||
return c.err
|
||||
}
|
||||
c.recvId = id
|
||||
c.recvSize = size
|
||||
out.Write([]byte(c.data))
|
||||
return nil
|
||||
}
|
||||
|
||||
var _ = Describe("MediaRetrievalController", func() {
|
||||
var controller *MediaRetrievalController
|
||||
var cover *fakeCover
|
||||
var w *httptest.ResponseRecorder
|
||||
|
||||
BeforeEach(func() {
|
||||
cover = &fakeCover{}
|
||||
controller = NewMediaRetrievalController(cover)
|
||||
w = httptest.NewRecorder()
|
||||
})
|
||||
|
||||
Describe("GetCoverArt", func() {
|
||||
It("should return data for that id", func() {
|
||||
cover.data = "image data"
|
||||
r := newTestRequest("id=34", "size=128")
|
||||
_, err := controller.GetCoverArt(w, r)
|
||||
|
||||
Expect(err).To(BeNil())
|
||||
Expect(cover.recvId).To(Equal("34"))
|
||||
Expect(cover.recvSize).To(Equal(128))
|
||||
Expect(w.Body.String()).To(Equal(cover.data))
|
||||
})
|
||||
|
||||
It("should fail if missing id parameter", func() {
|
||||
r := newTestRequest()
|
||||
_, err := controller.GetCoverArt(w, r)
|
||||
|
||||
Expect(err).To(MatchError("id parameter required"))
|
||||
})
|
||||
|
||||
It("should fail when the file is not found", func() {
|
||||
cover.err = model.ErrNotFound
|
||||
r := newTestRequest("id=34", "size=128")
|
||||
_, err := controller.GetCoverArt(w, r)
|
||||
|
||||
Expect(err).To(MatchError("Cover not found"))
|
||||
})
|
||||
|
||||
It("should fail when there is an unknown error", func() {
|
||||
cover.err = errors.New("weird error")
|
||||
r := newTestRequest("id=34", "size=128")
|
||||
_, err := controller.GetCoverArt(w, r)
|
||||
|
||||
Expect(err).To(MatchError("Internal Error"))
|
||||
})
|
||||
})
|
||||
})
|
||||
92
server/subsonic/middlewares.go
Normal file
92
server/subsonic/middlewares.go
Normal file
|
|
@ -0,0 +1,92 @@
|
|||
package subsonic
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/md5"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"strings"
|
||||
|
||||
"github.com/cloudsonic/sonic-server/conf"
|
||||
"github.com/cloudsonic/sonic-server/log"
|
||||
"github.com/cloudsonic/sonic-server/server/subsonic/responses"
|
||||
)
|
||||
|
||||
func checkRequiredParameters(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
requiredParameters := []string{"u", "v", "c"}
|
||||
|
||||
for _, p := range requiredParameters {
|
||||
if ParamString(r, p) == "" {
|
||||
msg := fmt.Sprintf(`Missing required parameter "%s"`, p)
|
||||
log.Warn(r, msg)
|
||||
SendError(w, r, NewError(responses.ErrorMissingParameter, msg))
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if ParamString(r, "p") == "" && (ParamString(r, "s") == "" || ParamString(r, "t") == "") {
|
||||
log.Warn(r, "Missing authentication information")
|
||||
}
|
||||
|
||||
user := ParamString(r, "u")
|
||||
client := ParamString(r, "c")
|
||||
version := ParamString(r, "v")
|
||||
ctx := r.Context()
|
||||
ctx = context.WithValue(ctx, "user", user)
|
||||
ctx = context.WithValue(ctx, "client", client)
|
||||
ctx = context.WithValue(ctx, "version", version)
|
||||
log.Info(ctx, "New Subsonic API request", "user", user, "client", client, "version", version, "path", r.URL.Path)
|
||||
|
||||
r = r.WithContext(ctx)
|
||||
next.ServeHTTP(w, r)
|
||||
})
|
||||
}
|
||||
|
||||
func authenticate(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
password := conf.Sonic.Password
|
||||
user := ParamString(r, "u")
|
||||
pass := ParamString(r, "p")
|
||||
salt := ParamString(r, "s")
|
||||
token := ParamString(r, "t")
|
||||
valid := false
|
||||
|
||||
switch {
|
||||
case pass != "":
|
||||
if strings.HasPrefix(pass, "enc:") {
|
||||
if dec, err := hex.DecodeString(pass[4:]); err == nil {
|
||||
pass = string(dec)
|
||||
}
|
||||
}
|
||||
valid = pass == password
|
||||
case token != "":
|
||||
t := fmt.Sprintf("%x", md5.Sum([]byte(password+salt)))
|
||||
valid = t == token
|
||||
}
|
||||
|
||||
if user != conf.Sonic.User || !valid {
|
||||
log.Warn(r, "Invalid login", "user", user)
|
||||
SendError(w, r, NewError(responses.ErrorAuthenticationFail))
|
||||
return
|
||||
}
|
||||
|
||||
next.ServeHTTP(w, r)
|
||||
})
|
||||
}
|
||||
|
||||
func requiredParams(params ...string) func(next http.Handler) http.Handler {
|
||||
return func(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
for _, p := range params {
|
||||
_, err := RequiredParamString(r, p, fmt.Sprintf("%s parameter is required", p))
|
||||
if err != nil {
|
||||
SendError(w, r, err)
|
||||
return
|
||||
}
|
||||
}
|
||||
next.ServeHTTP(w, r)
|
||||
})
|
||||
}
|
||||
}
|
||||
135
server/subsonic/middlewares_test.go
Normal file
135
server/subsonic/middlewares_test.go
Normal file
|
|
@ -0,0 +1,135 @@
|
|||
package subsonic
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
|
||||
"github.com/cloudsonic/sonic-server/conf"
|
||||
"github.com/cloudsonic/sonic-server/log"
|
||||
. "github.com/onsi/ginkgo"
|
||||
. "github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
func newTestRequest(queryParams ...string) *http.Request {
|
||||
r := httptest.NewRequest("get", "/ping?"+strings.Join(queryParams, "&"), nil)
|
||||
ctx := r.Context()
|
||||
return r.WithContext(log.NewContext(ctx))
|
||||
}
|
||||
|
||||
var _ = Describe("Middlewares", func() {
|
||||
var next *mockHandler
|
||||
var w *httptest.ResponseRecorder
|
||||
|
||||
BeforeEach(func() {
|
||||
next = &mockHandler{}
|
||||
w = httptest.NewRecorder()
|
||||
})
|
||||
|
||||
Describe("CheckParams", func() {
|
||||
It("passes when all required params are available", func() {
|
||||
r := newTestRequest("u=user", "v=1.15", "c=test")
|
||||
cp := checkRequiredParameters(next)
|
||||
cp.ServeHTTP(w, r)
|
||||
|
||||
Expect(next.req.Context().Value("user")).To(Equal("user"))
|
||||
Expect(next.req.Context().Value("version")).To(Equal("1.15"))
|
||||
Expect(next.req.Context().Value("client")).To(Equal("test"))
|
||||
Expect(next.called).To(BeTrue())
|
||||
})
|
||||
|
||||
It("fails when user is missing", func() {
|
||||
r := newTestRequest("v=1.15", "c=test")
|
||||
cp := checkRequiredParameters(next)
|
||||
cp.ServeHTTP(w, r)
|
||||
|
||||
Expect(w.Body.String()).To(ContainSubstring(`code="10"`))
|
||||
Expect(next.called).To(BeFalse())
|
||||
})
|
||||
|
||||
It("fails when version is missing", func() {
|
||||
r := newTestRequest("u=user", "c=test")
|
||||
cp := checkRequiredParameters(next)
|
||||
cp.ServeHTTP(w, r)
|
||||
|
||||
Expect(w.Body.String()).To(ContainSubstring(`code="10"`))
|
||||
Expect(next.called).To(BeFalse())
|
||||
})
|
||||
|
||||
It("fails when client is missing", func() {
|
||||
r := newTestRequest("u=user", "v=1.15")
|
||||
cp := checkRequiredParameters(next)
|
||||
cp.ServeHTTP(w, r)
|
||||
|
||||
Expect(w.Body.String()).To(ContainSubstring(`code="10"`))
|
||||
Expect(next.called).To(BeFalse())
|
||||
})
|
||||
})
|
||||
|
||||
Describe("Authenticate", func() {
|
||||
BeforeEach(func() {
|
||||
conf.Sonic.User = "admin"
|
||||
conf.Sonic.Password = "wordpass"
|
||||
conf.Sonic.DevDisableAuthentication = false
|
||||
})
|
||||
|
||||
Context("Plaintext password", func() {
|
||||
It("authenticates with plaintext password ", func() {
|
||||
r := newTestRequest("u=admin", "p=wordpass")
|
||||
cp := authenticate(next)
|
||||
cp.ServeHTTP(w, r)
|
||||
|
||||
Expect(next.called).To(BeTrue())
|
||||
})
|
||||
|
||||
It("fails authentication with wrong password", func() {
|
||||
r := newTestRequest("u=admin", "p=INVALID")
|
||||
cp := authenticate(next)
|
||||
cp.ServeHTTP(w, r)
|
||||
|
||||
Expect(w.Body.String()).To(ContainSubstring(`code="40"`))
|
||||
Expect(next.called).To(BeFalse())
|
||||
})
|
||||
})
|
||||
|
||||
Context("Encoded password", func() {
|
||||
It("authenticates with simple encoded password ", func() {
|
||||
r := newTestRequest("u=admin", "p=enc:776f726470617373")
|
||||
cp := authenticate(next)
|
||||
cp.ServeHTTP(w, r)
|
||||
|
||||
Expect(next.called).To(BeTrue())
|
||||
})
|
||||
})
|
||||
|
||||
Context("Token based authentication", func() {
|
||||
It("authenticates with token based authentication", func() {
|
||||
r := newTestRequest("u=admin", "t=23b342970e25c7928831c3317edd0b67", "s=retnlmjetrymazgkt")
|
||||
cp := authenticate(next)
|
||||
cp.ServeHTTP(w, r)
|
||||
|
||||
Expect(next.called).To(BeTrue())
|
||||
})
|
||||
|
||||
It("fails if salt is missing", func() {
|
||||
r := newTestRequest("u=admin", "t=23b342970e25c7928831c3317edd0b67")
|
||||
cp := authenticate(next)
|
||||
cp.ServeHTTP(w, r)
|
||||
|
||||
Expect(w.Body.String()).To(ContainSubstring(`code="40"`))
|
||||
Expect(next.called).To(BeFalse())
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
})
|
||||
|
||||
type mockHandler struct {
|
||||
req *http.Request
|
||||
called bool
|
||||
}
|
||||
|
||||
func (mh *mockHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
mh.req = r
|
||||
mh.called = true
|
||||
}
|
||||
132
server/subsonic/playlists.go
Normal file
132
server/subsonic/playlists.go
Normal file
|
|
@ -0,0 +1,132 @@
|
|||
package subsonic
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
|
||||
"github.com/cloudsonic/sonic-server/engine"
|
||||
"github.com/cloudsonic/sonic-server/log"
|
||||
"github.com/cloudsonic/sonic-server/model"
|
||||
"github.com/cloudsonic/sonic-server/server/subsonic/responses"
|
||||
)
|
||||
|
||||
type PlaylistsController struct {
|
||||
pls engine.Playlists
|
||||
}
|
||||
|
||||
func NewPlaylistsController(pls engine.Playlists) *PlaylistsController {
|
||||
return &PlaylistsController{pls: pls}
|
||||
}
|
||||
|
||||
func (c *PlaylistsController) GetPlaylists(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
allPls, err := c.pls.GetAll()
|
||||
if err != nil {
|
||||
log.Error(r, err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal error")
|
||||
}
|
||||
playlists := make([]responses.Playlist, len(allPls))
|
||||
for i, p := range allPls {
|
||||
playlists[i].Id = p.ID
|
||||
playlists[i].Name = p.Name
|
||||
playlists[i].Comment = p.Comment
|
||||
playlists[i].SongCount = len(p.Tracks)
|
||||
playlists[i].Duration = p.Duration
|
||||
playlists[i].Owner = p.Owner
|
||||
playlists[i].Public = p.Public
|
||||
}
|
||||
response := NewResponse()
|
||||
response.Playlists = &responses.Playlists{Playlist: playlists}
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (c *PlaylistsController) GetPlaylist(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
id, err := RequiredParamString(r, "id", "id parameter required")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
pinfo, err := c.pls.Get(id)
|
||||
switch {
|
||||
case err == model.ErrNotFound:
|
||||
log.Error(r, err.Error(), "id", id)
|
||||
return nil, NewError(responses.ErrorDataNotFound, "Directory not found")
|
||||
case err != nil:
|
||||
log.Error(r, err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
|
||||
response := NewResponse()
|
||||
response.Playlist = c.buildPlaylist(pinfo)
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (c *PlaylistsController) CreatePlaylist(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
songIds, err := RequiredParamStrings(r, "songId", "Required parameter songId is missing")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
name, err := RequiredParamString(r, "name", "Required parameter name is missing")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
err = c.pls.Create(r.Context(), name, songIds)
|
||||
if err != nil {
|
||||
log.Error(r, err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
return NewResponse(), nil
|
||||
}
|
||||
|
||||
func (c *PlaylistsController) DeletePlaylist(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
id, err := RequiredParamString(r, "id", "Required parameter id is missing")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
err = c.pls.Delete(r.Context(), id)
|
||||
if err != nil {
|
||||
log.Error(r, err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
return NewResponse(), nil
|
||||
}
|
||||
|
||||
func (c *PlaylistsController) UpdatePlaylist(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
playlistId, err := RequiredParamString(r, "playlistId", "Required parameter playlistId is missing")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
songsToAdd := ParamStrings(r, "songIdToAdd")
|
||||
songIndexesToRemove := ParamInts(r, "songIndexToRemove")
|
||||
|
||||
var pname *string
|
||||
if len(r.URL.Query()["name"]) > 0 {
|
||||
s := r.URL.Query()["name"][0]
|
||||
pname = &s
|
||||
}
|
||||
|
||||
log.Info(r, "Updating playlist", "id", playlistId)
|
||||
if pname != nil {
|
||||
log.Debug(r, fmt.Sprintf("-- New Name: '%s'", *pname))
|
||||
}
|
||||
log.Debug(r, fmt.Sprintf("-- Adding: '%v'", songsToAdd))
|
||||
log.Debug(r, fmt.Sprintf("-- Removing: '%v'", songIndexesToRemove))
|
||||
|
||||
err = c.pls.Update(playlistId, pname, songsToAdd, songIndexesToRemove)
|
||||
if err != nil {
|
||||
log.Error(r, err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal Error")
|
||||
}
|
||||
return NewResponse(), nil
|
||||
}
|
||||
|
||||
func (c *PlaylistsController) buildPlaylist(d *engine.PlaylistInfo) *responses.PlaylistWithSongs {
|
||||
pls := &responses.PlaylistWithSongs{}
|
||||
pls.Id = d.Id
|
||||
pls.Name = d.Name
|
||||
pls.SongCount = d.SongCount
|
||||
pls.Owner = d.Owner
|
||||
pls.Duration = d.Duration
|
||||
pls.Public = d.Public
|
||||
|
||||
pls.Entry = ToChildren(d.Entries)
|
||||
return pls
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"status":"ok","version":"1.8.0","albumList":{"album":[{"id":"1","isDir":false,"title":"title"}]}}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0"><albumList><album id="1" isDir="false" title="title"></album></albumList></subsonic-response>
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"status":"ok","version":"1.8.0","albumList":{}}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0"><albumList></albumList></subsonic-response>
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"status":"ok","version":"1.8.0","directory":{"child":[{"id":"1","isDir":true,"title":"title","album":"album","artist":"artist","track":1,"year":1985,"genre":"Rock","coverArt":"1","size":"8421341","contentType":"audio/flac","suffix":"flac","starred":"2016-03-02T20:30:00Z","transcodedContentType":"audio/mpeg","transcodedSuffix":"mp3","duration":146,"bitRate":320}],"id":"1","name":"N"}}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0"><directory id="1" name="N"><child id="1" isDir="true" title="title" album="album" artist="artist" track="1" year="1985" genre="Rock" coverArt="1" size="8421341" contentType="audio/flac" suffix="flac" starred="2016-03-02T20:30:00Z" transcodedContentType="audio/mpeg" transcodedSuffix="mp3" duration="146" bitRate="320"></child></directory></subsonic-response>
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"status":"ok","version":"1.8.0","directory":{"child":[{"id":"1","isDir":false,"title":"title"}],"id":"1","name":"N"}}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0"><directory id="1" name="N"><child id="1" isDir="false" title="title"></child></directory></subsonic-response>
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"status":"ok","version":"1.8.0","directory":{"id":"1","name":"N"}}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0"><directory id="1" name="N"></directory></subsonic-response>
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"status":"ok","version":"1.8.0"}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0"></subsonic-response>
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"status":"ok","version":"1.8.0","genres":{"genre":[{"value":"Rock","songCount":1000,"albumCount":100},{"value":"Reggae","songCount":500,"albumCount":50},{"value":"Pop","songCount":0,"albumCount":0}]}}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0"><genres><genre songCount="1000" albumCount="100">Rock</genre><genre songCount="500" albumCount="50">Reggae</genre><genre songCount="0" albumCount="0">Pop</genre></genres></subsonic-response>
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"status":"ok","version":"1.8.0","genres":{}}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0"><genres></genres></subsonic-response>
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"status":"ok","version":"1.8.0","indexes":{"index":[{"name":"A","artist":[{"id":"111","name":"aaa","starred":"2016-03-02T20:30:00Z"}]}],"lastModified":"1","ignoredArticles":"A"}}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0"><indexes lastModified="1" ignoredArticles="A"><index name="A"><artist id="111" name="aaa" starred="2016-03-02T20:30:00Z"></artist></index></indexes></subsonic-response>
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"status":"ok","version":"1.8.0","indexes":{"lastModified":"1","ignoredArticles":"A"}}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0"><indexes lastModified="1" ignoredArticles="A"></indexes></subsonic-response>
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"status":"ok","version":"1.8.0","license":{"valid":true}}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0"><license valid="true"></license></subsonic-response>
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"status":"ok","version":"1.8.0","musicFolders":{"musicFolder":[{"id":"111","name":"aaa"},{"id":"222","name":"bbb"}]}}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0"><musicFolders><musicFolder id="111" name="aaa"></musicFolder><musicFolder id="222" name="bbb"></musicFolder></musicFolders></subsonic-response>
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"status":"ok","version":"1.8.0","musicFolders":{}}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0"><musicFolders></musicFolders></subsonic-response>
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"status":"ok","version":"1.8.0","playlists":{"playlist":[{"id":"111","name":"aaa"},{"id":"222","name":"bbb"}]}}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0"><playlists><playlist id="111" name="aaa"></playlist><playlist id="222" name="bbb"></playlist></playlists></subsonic-response>
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"status":"ok","version":"1.8.0","playlists":{}}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0"><playlists></playlists></subsonic-response>
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"status":"ok","version":"1.8.0","user":{"username":"deluan","email":"cloudsonic@deluan.com","scrobblingEnabled":false,"adminRole":false,"settingsRole":false,"downloadRole":false,"uploadRole":false,"playlistRole":false,"coverArtRole":false,"commentRole":false,"podcastRole":false,"streamRole":false,"jukeboxRole":false,"shareRole":false,"videoConversionRole":false,"folder":[1]}}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0"><user username="deluan" email="cloudsonic@deluan.com" scrobblingEnabled="false" adminRole="false" settingsRole="false" downloadRole="false" uploadRole="false" playlistRole="false" coverArtRole="false" commentRole="false" podcastRole="false" streamRole="false" jukeboxRole="false" shareRole="false" videoConversionRole="false"><folder>1</folder></user></subsonic-response>
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"status":"ok","version":"1.8.0","user":{"username":"deluan","scrobblingEnabled":false,"adminRole":false,"settingsRole":false,"downloadRole":false,"uploadRole":false,"playlistRole":false,"coverArtRole":false,"commentRole":false,"podcastRole":false,"streamRole":false,"jukeboxRole":false,"shareRole":false,"videoConversionRole":false}}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0"><user username="deluan" scrobblingEnabled="false" adminRole="false" settingsRole="false" downloadRole="false" uploadRole="false" playlistRole="false" coverArtRole="false" commentRole="false" podcastRole="false" streamRole="false" jukeboxRole="false" shareRole="false" videoConversionRole="false"></user></subsonic-response>
|
||||
30
server/subsonic/responses/errors.go
Normal file
30
server/subsonic/responses/errors.go
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
package responses
|
||||
|
||||
const (
|
||||
ErrorGeneric = iota * 10
|
||||
ErrorMissingParameter
|
||||
ErrorClientTooOld
|
||||
ErrorServerTooOld
|
||||
ErrorAuthenticationFail
|
||||
ErrorAuthorizationFail
|
||||
ErrorTrialExpired
|
||||
ErrorDataNotFound
|
||||
)
|
||||
|
||||
var errors = map[int]string{
|
||||
ErrorGeneric: "A generic error",
|
||||
ErrorMissingParameter: "Required parameter is missing",
|
||||
ErrorClientTooOld: "Incompatible Subsonic REST protocol version. Client must upgrade",
|
||||
ErrorServerTooOld: "Incompatible Subsonic REST protocol version. Server must upgrade",
|
||||
ErrorAuthenticationFail: "Wrong username or password",
|
||||
ErrorAuthorizationFail: "User is not authorized for the given operation",
|
||||
ErrorTrialExpired: "The trial period for the Subsonic server is over. Please upgrade to Subsonic Premium. Visit subsonic.org for details",
|
||||
ErrorDataNotFound: "The requested data was not found",
|
||||
}
|
||||
|
||||
func ErrorMsg(code int) string {
|
||||
if v, found := errors[code]; found {
|
||||
return v
|
||||
}
|
||||
return errors[ErrorGeneric]
|
||||
}
|
||||
272
server/subsonic/responses/responses.go
Normal file
272
server/subsonic/responses/responses.go
Normal file
|
|
@ -0,0 +1,272 @@
|
|||
package responses
|
||||
|
||||
import (
|
||||
"encoding/xml"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Subsonic struct {
|
||||
XMLName xml.Name `xml:"http://subsonic.org/restapi subsonic-response" json:"-"`
|
||||
Status string `xml:"status,attr" json:"status"`
|
||||
Version string `xml:"version,attr" json:"version"`
|
||||
Error *Error `xml:"error,omitempty" json:"error,omitempty"`
|
||||
License *License `xml:"license,omitempty" json:"license,omitempty"`
|
||||
MusicFolders *MusicFolders `xml:"musicFolders,omitempty" json:"musicFolders,omitempty"`
|
||||
Indexes *Indexes `xml:"indexes,omitempty" json:"indexes,omitempty"`
|
||||
Directory *Directory `xml:"directory,omitempty" json:"directory,omitempty"`
|
||||
User *User `xml:"user,omitempty" json:"user,omitempty"`
|
||||
AlbumList *AlbumList `xml:"albumList,omitempty" json:"albumList,omitempty"`
|
||||
AlbumList2 *AlbumList `xml:"albumList2,omitempty" json:"albumList2,omitempty"`
|
||||
Playlists *Playlists `xml:"playlists,omitempty" json:"playlists,omitempty"`
|
||||
Playlist *PlaylistWithSongs `xml:"playlist,omitempty" json:"playlist,omitempty"`
|
||||
SearchResult2 *SearchResult2 `xml:"searchResult2,omitempty" json:"searchResult2,omitempty"`
|
||||
SearchResult3 *SearchResult3 `xml:"searchResult3,omitempty" json:"searchResult3,omitempty"`
|
||||
Starred *Starred `xml:"starred,omitempty" json:"starred,omitempty"`
|
||||
Starred2 *Starred `xml:"starred2,omitempty" json:"starred2,omitempty"`
|
||||
NowPlaying *NowPlaying `xml:"nowPlaying,omitempty" json:"nowPlaying,omitempty"`
|
||||
Song *Child `xml:"song,omitempty" json:"song,omitempty"`
|
||||
RandomSongs *Songs `xml:"randomSongs,omitempty" json:"randomSongs,omitempty"`
|
||||
Genres *Genres `xml:"genres,omitempty" json:"genres,omitempty"`
|
||||
|
||||
// ID3
|
||||
Artist *Indexes `xml:"artists,omitempty" json:"artists,omitempty"`
|
||||
ArtistWithAlbumsID3 *ArtistWithAlbumsID3 `xml:"artist,omitempty" json:"artist,omitempty"`
|
||||
AlbumWithSongsID3 *AlbumWithSongsID3 `xml:"album,omitempty" json:"album,omitempty"`
|
||||
}
|
||||
|
||||
type JsonWrapper struct {
|
||||
Subsonic Subsonic `json:"subsonic-response"`
|
||||
}
|
||||
|
||||
type Error struct {
|
||||
Code int `xml:"code,attr" json:"code"`
|
||||
Message string `xml:"message,attr" json:"message"`
|
||||
}
|
||||
|
||||
type License struct {
|
||||
Valid bool `xml:"valid,attr" json:"valid"`
|
||||
}
|
||||
|
||||
type MusicFolder struct {
|
||||
Id string `xml:"id,attr" json:"id"`
|
||||
Name string `xml:"name,attr" json:"name"`
|
||||
}
|
||||
|
||||
type MusicFolders struct {
|
||||
Folders []MusicFolder `xml:"musicFolder" json:"musicFolder,omitempty"`
|
||||
}
|
||||
|
||||
type Artist struct {
|
||||
Id string `xml:"id,attr" json:"id"`
|
||||
Name string `xml:"name,attr" json:"name"`
|
||||
AlbumCount int `xml:"albumCount,attr,omitempty" json:"albumCount,omitempty"`
|
||||
Starred *time.Time `xml:"starred,attr,omitempty" json:"starred,omitempty"`
|
||||
/*
|
||||
<xs:attribute name="userRating" type="sub:UserRating" use="optional"/> <!-- Added in 1.13.0 -->
|
||||
<xs:attribute name="averageRating" type="sub:AverageRating" use="optional"/> <!-- Added in 1.13.0 -->
|
||||
*/
|
||||
}
|
||||
|
||||
type Index struct {
|
||||
Name string `xml:"name,attr" json:"name"`
|
||||
Artists []Artist `xml:"artist" json:"artist"`
|
||||
}
|
||||
|
||||
type Indexes struct {
|
||||
Index []Index `xml:"index" json:"index,omitempty"`
|
||||
LastModified string `xml:"lastModified,attr" json:"lastModified"`
|
||||
IgnoredArticles string `xml:"ignoredArticles,attr" json:"ignoredArticles"`
|
||||
}
|
||||
|
||||
type Child struct {
|
||||
Id string `xml:"id,attr" json:"id"`
|
||||
Parent string `xml:"parent,attr,omitempty" json:"parent,omitempty"`
|
||||
IsDir bool `xml:"isDir,attr" json:"isDir"`
|
||||
Title string `xml:"title,attr,omitempty" json:"title,omitempty"`
|
||||
Name string `xml:"name,attr,omitempty" json:"name,omitempty"`
|
||||
Album string `xml:"album,attr,omitempty" json:"album,omitempty"`
|
||||
Artist string `xml:"artist,attr,omitempty" json:"artist,omitempty"`
|
||||
Track int `xml:"track,attr,omitempty" json:"track,omitempty"`
|
||||
Year int `xml:"year,attr,omitempty" json:"year,omitempty"`
|
||||
Genre string `xml:"genre,attr,omitempty" json:"genre,omitempty"`
|
||||
CoverArt string `xml:"coverArt,attr,omitempty" json:"coverArt,omitempty"`
|
||||
Size string `xml:"size,attr,omitempty" json:"size,omitempty"`
|
||||
ContentType string `xml:"contentType,attr,omitempty" json:"contentType,omitempty"`
|
||||
Suffix string `xml:"suffix,attr,omitempty" json:"suffix,omitempty"`
|
||||
Starred *time.Time `xml:"starred,attr,omitempty" json:"starred,omitempty"`
|
||||
TranscodedContentType string `xml:"transcodedContentType,attr,omitempty" json:"transcodedContentType,omitempty"`
|
||||
TranscodedSuffix string `xml:"transcodedSuffix,attr,omitempty" json:"transcodedSuffix,omitempty"`
|
||||
Duration int `xml:"duration,attr,omitempty" json:"duration,omitempty"`
|
||||
BitRate int `xml:"bitRate,attr,omitempty" json:"bitRate,omitempty"`
|
||||
Path string `xml:"path,attr,omitempty" json:"path,omitempty"`
|
||||
PlayCount int32 `xml:"playCount,attr,omitempty" json:"playcount,omitempty"`
|
||||
DiscNumber int `xml:"discNumber,attr,omitempty" json:"discNumber,omitempty"`
|
||||
Created *time.Time `xml:"created,attr,omitempty" json:"created,omitempty"`
|
||||
AlbumId string `xml:"albumId,attr,omitempty" json:"albumId,omitempty"`
|
||||
ArtistId string `xml:"artistId,attr,omitempty" json:"artistId,omitempty"`
|
||||
Type string `xml:"type,attr,omitempty" json:"type,omitempty"`
|
||||
UserRating int `xml:"userRating,attr,omitempty" json:"userRating,omitempty"`
|
||||
SongCount int `xml:"songCount,attr,omitempty" json:"songCount,omitempty"`
|
||||
/*
|
||||
<xs:attribute name="isVideo" type="xs:boolean" use="optional"/> <!-- Added in 1.4.1 -->
|
||||
<xs:attribute name="averageRating" type="sub:AverageRating" use="optional"/> <!-- Added in 1.6.0 -->
|
||||
<xs:attribute name="bookmarkPosition" type="xs:long" use="optional"/> <!-- In millis. Added in 1.10.1 -->
|
||||
<xs:attribute name="originalWidth" type="xs:int" use="optional"/> <!-- Added in 1.13.0 -->
|
||||
<xs:attribute name="originalHeight" type="xs:int" use="optional"/> <!-- Added in 1.13.0 -->
|
||||
*/
|
||||
}
|
||||
|
||||
type Songs struct {
|
||||
Songs []Child `xml:"song" json:"song,omitempty"`
|
||||
}
|
||||
|
||||
type Directory struct {
|
||||
Child []Child `xml:"child" json:"child,omitempty"`
|
||||
Id string `xml:"id,attr" json:"id"`
|
||||
Name string `xml:"name,attr" json:"name"`
|
||||
Parent string `xml:"parent,attr,omitempty" json:"parent,omitempty"`
|
||||
Starred *time.Time `xml:"starred,attr,omitempty" json:"starred,omitempty"`
|
||||
PlayCount int32 `xml:"playCount,attr,omitempty" json:"playcount,omitempty"`
|
||||
UserRating int `xml:"userRating,attr,omitempty" json:"userRating,omitempty"`
|
||||
|
||||
// ID3
|
||||
Artist string `xml:"artist,attr,omitempty" json:"artist,omitempty"`
|
||||
ArtistId string `xml:"artistId,attr,omitempty" json:"artistId,omitempty"`
|
||||
CoverArt string `xml:"coverArt,attr,omitempty" json:"coverArt,omitempty"`
|
||||
SongCount int `xml:"songCount,attr,omitempty" json:"songCount,omitempty"`
|
||||
AlbumCount int `xml:"albumCount,attr,omitempty" json:"albumCount,omitempty"`
|
||||
Duration int `xml:"duration,attr,omitempty" json:"duration,omitempty"`
|
||||
Created *time.Time `xml:"created,attr,omitempty" json:"created,omitempty"`
|
||||
Year int `xml:"year,attr,omitempty" json:"year,omitempty"`
|
||||
Genre string `xml:"genre,attr,omitempty" json:"genre,omitempty"`
|
||||
|
||||
/*
|
||||
<xs:attribute name="averageRating" type="sub:AverageRating" use="optional"/> <!-- Added in 1.13.0 -->
|
||||
*/
|
||||
}
|
||||
|
||||
type ArtistID3 struct {
|
||||
Id string `xml:"id,attr" json:"id"`
|
||||
Name string `xml:"name,attr" json:"name"`
|
||||
CoverArt string `xml:"coverArt,attr,omitempty" json:"coverArt,omitempty"`
|
||||
AlbumCount int `xml:"albumCount,attr,omitempty" json:"albumCount,omitempty"`
|
||||
Starred *time.Time `xml:"starred,attr,omitempty" json:"starred,omitempty"`
|
||||
}
|
||||
|
||||
type AlbumID3 struct {
|
||||
Id string `xml:"id,attr" json:"id"`
|
||||
Name string `xml:"name,attr" json:"name"`
|
||||
Artist string `xml:"artist,attr,omitempty" json:"artist,omitempty"`
|
||||
ArtistId string `xml:"artistId,attr,omitempty" json:"artistId,omitempty"`
|
||||
CoverArt string `xml:"coverArt,attr,omitempty" json:"coverArt,omitempty"`
|
||||
SongCount int `xml:"songCount,attr,omitempty" json:"songCount,omitempty"`
|
||||
Duration int `xml:"duration,attr,omitempty" json:"duration,omitempty"`
|
||||
PlayCount int32 `xml:"playCount,attr,omitempty" json:"playcount,omitempty"`
|
||||
Created *time.Time `xml:"created,attr,omitempty" json:"created,omitempty"`
|
||||
Starred *time.Time `xml:"starred,attr,omitempty" json:"starred,omitempty"`
|
||||
Year int `xml:"year,attr,omitempty" json:"year,omitempty"`
|
||||
Genre string `xml:"genre,attr,omitempty" json:"genre,omitempty"`
|
||||
}
|
||||
|
||||
type ArtistWithAlbumsID3 struct {
|
||||
ArtistID3
|
||||
Album []Child `xml:"album" json:"album,omitempty"`
|
||||
}
|
||||
|
||||
type AlbumWithSongsID3 struct {
|
||||
AlbumID3
|
||||
Song []Child `xml:"song" json:"song,omitempty"`
|
||||
}
|
||||
|
||||
type AlbumList struct {
|
||||
Album []Child `xml:"album" json:"album,omitempty"`
|
||||
}
|
||||
|
||||
type Playlist struct {
|
||||
Id string `xml:"id,attr" json:"id"`
|
||||
Name string `xml:"name,attr" json:"name"`
|
||||
Comment string `xml:"comment,attr,omitempty" json:"comment,omitempty"`
|
||||
SongCount int `xml:"songCount,attr,omitempty" json:"songCount,omitempty"`
|
||||
Duration int `xml:"duration,attr,omitempty" json:"duration,omitempty"`
|
||||
Public bool `xml:"public,attr,omitempty" json:"public,omitempty"`
|
||||
Owner string `xml:"owner,attr,omitempty" json:"owner,omitempty"`
|
||||
/*
|
||||
<xs:sequence>
|
||||
<xs:element name="allowedUser" type="xs:string" minOccurs="0" maxOccurs="unbounded"/> <!--Added in 1.8.0-->
|
||||
</xs:sequence>
|
||||
<xs:attribute name="comment" type="xs:string" use="optional"/> <!--Added in 1.8.0-->
|
||||
<xs:attribute name="created" type="xs:dateTime" use="required"/> <!--Added in 1.8.0-->
|
||||
<xs:attribute name="changed" type="xs:dateTime" use="required"/> <!--Added in 1.13.0-->
|
||||
<xs:attribute name="coverArt" type="xs:string" use="optional"/> <!--Added in 1.11.0-->
|
||||
|
||||
*/
|
||||
}
|
||||
|
||||
type Playlists struct {
|
||||
Playlist []Playlist `xml:"playlist" json:"playlist,omitempty"`
|
||||
}
|
||||
|
||||
type PlaylistWithSongs struct {
|
||||
Playlist
|
||||
Entry []Child `xml:"entry" json:"entry,omitempty"`
|
||||
}
|
||||
|
||||
type SearchResult2 struct {
|
||||
Artist []Artist `xml:"artist" json:"artist,omitempty"`
|
||||
Album []Child `xml:"album" json:"album,omitempty"`
|
||||
Song []Child `xml:"song" json:"song,omitempty"`
|
||||
}
|
||||
|
||||
type SearchResult3 struct {
|
||||
Artist []ArtistID3 `xml:"artist" json:"artist,omitempty"`
|
||||
Album []Child `xml:"album" json:"album,omitempty"`
|
||||
Song []Child `xml:"song" json:"song,omitempty"`
|
||||
}
|
||||
|
||||
type Starred struct {
|
||||
Artist []Artist `xml:"artist" json:"artist,omitempty"`
|
||||
Album []Child `xml:"album" json:"album,omitempty"`
|
||||
Song []Child `xml:"song" json:"song,omitempty"`
|
||||
}
|
||||
|
||||
type NowPlayingEntry struct {
|
||||
Child
|
||||
UserName string `xml:"username,attr" json:"username,omitempty"`
|
||||
MinutesAgo int `xml:"minutesAgo,attr" json:"minutesAgo,omitempty"`
|
||||
PlayerId int `xml:"playerId,attr" json:"playerId,omitempty"`
|
||||
PlayerName string `xml:"playerName,attr" json:"playerName,omitempty"`
|
||||
}
|
||||
|
||||
type NowPlaying struct {
|
||||
Entry []NowPlayingEntry `xml:"entry" json:"entry,omitempty"`
|
||||
}
|
||||
|
||||
type User struct {
|
||||
Username string `xml:"username,attr" json:"username"`
|
||||
Email string `xml:"email,attr,omitempty" json:"email,omitempty"`
|
||||
ScrobblingEnabled bool `xml:"scrobblingEnabled,attr" json:"scrobblingEnabled"`
|
||||
MaxBitRate int `xml:"maxBitRate,attr,omitempty" json:"maxBitRate,omitempty"`
|
||||
AdminRole bool `xml:"adminRole,attr" json:"adminRole"`
|
||||
SettingsRole bool `xml:"settingsRole,attr" json:"settingsRole"`
|
||||
DownloadRole bool `xml:"downloadRole,attr" json:"downloadRole"`
|
||||
UploadRole bool `xml:"uploadRole,attr" json:"uploadRole"`
|
||||
PlaylistRole bool `xml:"playlistRole,attr" json:"playlistRole"`
|
||||
CoverArtRole bool `xml:"coverArtRole,attr" json:"coverArtRole"`
|
||||
CommentRole bool `xml:"commentRole,attr" json:"commentRole"`
|
||||
PodcastRole bool `xml:"podcastRole,attr" json:"podcastRole"`
|
||||
StreamRole bool `xml:"streamRole,attr" json:"streamRole"`
|
||||
JukeboxRole bool `xml:"jukeboxRole,attr" json:"jukeboxRole"`
|
||||
ShareRole bool `xml:"shareRole,attr" json:"shareRole"`
|
||||
VideoConversionRole bool `xml:"videoConversionRole,attr" json:"videoConversionRole"`
|
||||
Folder []int `xml:"folder,omitempty" json:"folder,omitempty"`
|
||||
}
|
||||
|
||||
type Genre struct {
|
||||
Name string `xml:",chardata" json:"value,omitempty"`
|
||||
SongCount int `xml:"songCount,attr" json:"songCount"`
|
||||
AlbumCount int `xml:"albumCount,attr" json:"albumCount"`
|
||||
}
|
||||
|
||||
type Genres struct {
|
||||
Genre []Genre `xml:"genre,omitempty" json:"genre,omitempty"`
|
||||
}
|
||||
41
server/subsonic/responses/responses_suite_test.go
Normal file
41
server/subsonic/responses/responses_suite_test.go
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
package responses
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"testing"
|
||||
|
||||
"github.com/bradleyjkemp/cupaloy"
|
||||
"github.com/cloudsonic/sonic-server/log"
|
||||
"github.com/onsi/ginkgo"
|
||||
"github.com/onsi/gomega"
|
||||
"github.com/onsi/gomega/types"
|
||||
)
|
||||
|
||||
func TestSubsonicApiResponses(t *testing.T) {
|
||||
log.SetLevel(log.LevelError)
|
||||
gomega.RegisterFailHandler(ginkgo.Fail)
|
||||
ginkgo.RunSpecs(t, "Subsonic API Responses Suite")
|
||||
}
|
||||
|
||||
func MatchSnapshot() types.GomegaMatcher {
|
||||
c := cupaloy.New(cupaloy.FailOnUpdate(false))
|
||||
return &snapshotMatcher{c}
|
||||
}
|
||||
|
||||
type snapshotMatcher struct {
|
||||
c *cupaloy.Config
|
||||
}
|
||||
|
||||
func (matcher snapshotMatcher) Match(actual interface{}) (success bool, err error) {
|
||||
err = matcher.c.SnapshotMulti(ginkgo.CurrentGinkgoTestDescription().FullTestText, actual)
|
||||
success = err == nil
|
||||
return
|
||||
}
|
||||
|
||||
func (matcher snapshotMatcher) FailureMessage(actual interface{}) (message string) {
|
||||
return fmt.Sprintf("Expected to match saved snapshot\n")
|
||||
}
|
||||
|
||||
func (matcher snapshotMatcher) NegatedFailureMessage(actual interface{}) (message string) {
|
||||
return fmt.Sprintf("Expected to not match saved snapshot\n")
|
||||
}
|
||||
284
server/subsonic/responses/responses_test.go
Normal file
284
server/subsonic/responses/responses_test.go
Normal file
|
|
@ -0,0 +1,284 @@
|
|||
//+build linux darwin
|
||||
|
||||
// TODO Fix snapshot tests in Windows
|
||||
// Response Snapshot tests. Only run in Linux and macOS, as they fail in Windows
|
||||
// Probably because of EOL char differences
|
||||
package responses_test
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"encoding/xml"
|
||||
"time"
|
||||
|
||||
. "github.com/cloudsonic/sonic-server/server/subsonic/responses"
|
||||
. "github.com/onsi/ginkgo"
|
||||
. "github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
var _ = Describe("Responses", func() {
|
||||
var response *Subsonic
|
||||
BeforeEach(func() {
|
||||
response = &Subsonic{Status: "ok", Version: "1.8.0"}
|
||||
})
|
||||
|
||||
Describe("EmptyResponse", func() {
|
||||
It("should match .XML", func() {
|
||||
Expect(xml.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
It("should match .JSON", func() {
|
||||
Expect(json.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
})
|
||||
|
||||
Describe("License", func() {
|
||||
BeforeEach(func() {
|
||||
response.License = &License{Valid: true}
|
||||
})
|
||||
It("should match .XML", func() {
|
||||
Expect(xml.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
It("should match .JSON", func() {
|
||||
Expect(json.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
})
|
||||
|
||||
Describe("MusicFolders", func() {
|
||||
BeforeEach(func() {
|
||||
response.MusicFolders = &MusicFolders{}
|
||||
})
|
||||
|
||||
Context("without data", func() {
|
||||
It("should match .XML", func() {
|
||||
Expect(xml.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
It("should match .JSON", func() {
|
||||
Expect(json.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
})
|
||||
|
||||
Context("with data", func() {
|
||||
BeforeEach(func() {
|
||||
folders := make([]MusicFolder, 2)
|
||||
folders[0] = MusicFolder{Id: "111", Name: "aaa"}
|
||||
folders[1] = MusicFolder{Id: "222", Name: "bbb"}
|
||||
response.MusicFolders.Folders = folders
|
||||
})
|
||||
|
||||
It("should match .XML", func() {
|
||||
Expect(xml.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
It("should match .JSON", func() {
|
||||
Expect(json.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("Indexes", func() {
|
||||
BeforeEach(func() {
|
||||
response.Indexes = &Indexes{LastModified: "1", IgnoredArticles: "A"}
|
||||
})
|
||||
|
||||
Context("without data", func() {
|
||||
It("should match .XML", func() {
|
||||
Expect(xml.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
It("should match .JSON", func() {
|
||||
Expect(json.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
})
|
||||
|
||||
Context("with data", func() {
|
||||
BeforeEach(func() {
|
||||
artists := make([]Artist, 1)
|
||||
t := time.Date(2016, 03, 2, 20, 30, 0, 0, time.UTC)
|
||||
artists[0] = Artist{Id: "111", Name: "aaa", Starred: &t}
|
||||
index := make([]Index, 1)
|
||||
index[0] = Index{Name: "A", Artists: artists}
|
||||
response.Indexes.Index = index
|
||||
})
|
||||
|
||||
It("should match .XML", func() {
|
||||
Expect(xml.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
It("should match .JSON", func() {
|
||||
Expect(json.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("Child", func() {
|
||||
Context("with data", func() {
|
||||
BeforeEach(func() {
|
||||
response.Directory = &Directory{Id: "1", Name: "N"}
|
||||
child := make([]Child, 1)
|
||||
t := time.Date(2016, 03, 2, 20, 30, 0, 0, time.UTC)
|
||||
child[0] = Child{
|
||||
Id: "1", IsDir: true, Title: "title", Album: "album", Artist: "artist", Track: 1,
|
||||
Year: 1985, Genre: "Rock", CoverArt: "1", Size: "8421341", ContentType: "audio/flac",
|
||||
Suffix: "flac", TranscodedContentType: "audio/mpeg", TranscodedSuffix: "mp3",
|
||||
Duration: 146, BitRate: 320, Starred: &t,
|
||||
}
|
||||
response.Directory.Child = child
|
||||
})
|
||||
|
||||
It("should match .XML", func() {
|
||||
Expect(xml.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
It("should match .JSON", func() {
|
||||
Expect(json.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("Directory", func() {
|
||||
BeforeEach(func() {
|
||||
response.Directory = &Directory{Id: "1", Name: "N"}
|
||||
})
|
||||
|
||||
Context("without data", func() {
|
||||
It("should match .XML", func() {
|
||||
Expect(xml.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
It("should match .JSON", func() {
|
||||
Expect(json.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
})
|
||||
|
||||
Context("with data", func() {
|
||||
BeforeEach(func() {
|
||||
child := make([]Child, 1)
|
||||
child[0] = Child{Id: "1", Title: "title", IsDir: false}
|
||||
response.Directory.Child = child
|
||||
})
|
||||
|
||||
It("should match .XML", func() {
|
||||
Expect(xml.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
It("should match .JSON", func() {
|
||||
Expect(json.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("AlbumList", func() {
|
||||
BeforeEach(func() {
|
||||
response.AlbumList = &AlbumList{}
|
||||
})
|
||||
|
||||
Context("without data", func() {
|
||||
It("should match .XML", func() {
|
||||
Expect(xml.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
It("should match .JSON", func() {
|
||||
Expect(json.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
})
|
||||
|
||||
Context("with data", func() {
|
||||
BeforeEach(func() {
|
||||
child := make([]Child, 1)
|
||||
child[0] = Child{Id: "1", Title: "title", IsDir: false}
|
||||
response.AlbumList.Album = child
|
||||
})
|
||||
|
||||
It("should match .XML", func() {
|
||||
Expect(xml.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
It("should match .JSON", func() {
|
||||
Expect(json.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("User", func() {
|
||||
BeforeEach(func() {
|
||||
response.User = &User{Username: "deluan"}
|
||||
})
|
||||
|
||||
Context("without data", func() {
|
||||
It("should match .XML", func() {
|
||||
Expect(xml.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
It("should match .JSON", func() {
|
||||
Expect(json.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
})
|
||||
|
||||
Context("with data", func() {
|
||||
BeforeEach(func() {
|
||||
response.User.Email = "cloudsonic@deluan.com"
|
||||
response.User.Folder = []int{1}
|
||||
})
|
||||
|
||||
It("should match .XML", func() {
|
||||
Expect(xml.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
It("should match .JSON", func() {
|
||||
Expect(json.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("Playlists", func() {
|
||||
BeforeEach(func() {
|
||||
response.Playlists = &Playlists{}
|
||||
})
|
||||
|
||||
Context("without data", func() {
|
||||
It("should match .XML", func() {
|
||||
Expect(xml.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
It("should match .JSON", func() {
|
||||
Expect(json.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
})
|
||||
|
||||
Context("with data", func() {
|
||||
BeforeEach(func() {
|
||||
pls := make([]Playlist, 2)
|
||||
pls[0] = Playlist{Id: "111", Name: "aaa"}
|
||||
pls[1] = Playlist{Id: "222", Name: "bbb"}
|
||||
response.Playlists.Playlist = pls
|
||||
})
|
||||
|
||||
It("should match .XML", func() {
|
||||
Expect(xml.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
It("should match .JSON", func() {
|
||||
Expect(json.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Describe("Genres", func() {
|
||||
BeforeEach(func() {
|
||||
response.Genres = &Genres{}
|
||||
})
|
||||
|
||||
Context("without data", func() {
|
||||
It("should match .XML", func() {
|
||||
Expect(xml.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
It("should match .JSON", func() {
|
||||
Expect(json.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
})
|
||||
|
||||
Context("with data", func() {
|
||||
BeforeEach(func() {
|
||||
genres := make([]Genre, 3)
|
||||
genres[0] = Genre{SongCount: 1000, AlbumCount: 100, Name: "Rock"}
|
||||
genres[1] = Genre{SongCount: 500, AlbumCount: 50, Name: "Reggae"}
|
||||
genres[2] = Genre{SongCount: 0, AlbumCount: 0, Name: "Pop"}
|
||||
response.Genres.Genre = genres
|
||||
})
|
||||
|
||||
It("should match .XML", func() {
|
||||
Expect(xml.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
It("should match .JSON", func() {
|
||||
Expect(json.Marshal(response)).To(MatchSnapshot())
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
105
server/subsonic/searching.go
Normal file
105
server/subsonic/searching.go
Normal file
|
|
@ -0,0 +1,105 @@
|
|||
package subsonic
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
|
||||
"github.com/cloudsonic/sonic-server/engine"
|
||||
"github.com/cloudsonic/sonic-server/log"
|
||||
"github.com/cloudsonic/sonic-server/server/subsonic/responses"
|
||||
)
|
||||
|
||||
type SearchingController struct {
|
||||
search engine.Search
|
||||
}
|
||||
|
||||
type searchParams struct {
|
||||
query string
|
||||
artistCount int
|
||||
artistOffset int
|
||||
albumCount int
|
||||
albumOffset int
|
||||
songCount int
|
||||
songOffset int
|
||||
}
|
||||
|
||||
func NewSearchingController(search engine.Search) *SearchingController {
|
||||
return &SearchingController{search: search}
|
||||
}
|
||||
|
||||
func (c *SearchingController) getParams(r *http.Request) (*searchParams, error) {
|
||||
var err error
|
||||
sp := &searchParams{}
|
||||
sp.query, err = RequiredParamString(r, "query", "Parameter query required")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
sp.artistCount = ParamInt(r, "artistCount", 20)
|
||||
sp.artistOffset = ParamInt(r, "artistOffset", 0)
|
||||
sp.albumCount = ParamInt(r, "albumCount", 20)
|
||||
sp.albumOffset = ParamInt(r, "albumOffset", 0)
|
||||
sp.songCount = ParamInt(r, "songCount", 20)
|
||||
sp.songOffset = ParamInt(r, "songOffset", 0)
|
||||
return sp, nil
|
||||
}
|
||||
|
||||
func (c *SearchingController) searchAll(r *http.Request, sp *searchParams) (engine.Entries, engine.Entries, engine.Entries) {
|
||||
as, err := c.search.SearchArtist(r.Context(), sp.query, sp.artistOffset, sp.artistCount)
|
||||
if err != nil {
|
||||
log.Error(r, "Error searching for Artists", err)
|
||||
}
|
||||
als, err := c.search.SearchAlbum(r.Context(), sp.query, sp.albumOffset, sp.albumCount)
|
||||
if err != nil {
|
||||
log.Error(r, "Error searching for Albums", err)
|
||||
}
|
||||
mfs, err := c.search.SearchSong(r.Context(), sp.query, sp.songOffset, sp.songCount)
|
||||
if err != nil {
|
||||
log.Error(r, "Error searching for MediaFiles", err)
|
||||
}
|
||||
|
||||
log.Debug(r, fmt.Sprintf("Search resulted in %d songs, %d albums and %d artists", len(mfs), len(als), len(as)), "query", sp.query)
|
||||
return mfs, als, as
|
||||
}
|
||||
|
||||
func (c *SearchingController) Search2(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
sp, err := c.getParams(r)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
mfs, als, as := c.searchAll(r, sp)
|
||||
|
||||
response := NewResponse()
|
||||
searchResult2 := &responses.SearchResult2{}
|
||||
searchResult2.Artist = ToArtists(as)
|
||||
searchResult2.Album = ToChildren(als)
|
||||
searchResult2.Song = ToChildren(mfs)
|
||||
response.SearchResult2 = searchResult2
|
||||
return response, nil
|
||||
}
|
||||
|
||||
func (c *SearchingController) Search3(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
sp, err := c.getParams(r)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
mfs, als, as := c.searchAll(r, sp)
|
||||
|
||||
response := NewResponse()
|
||||
searchResult3 := &responses.SearchResult3{}
|
||||
searchResult3.Artist = make([]responses.ArtistID3, len(as))
|
||||
for i, e := range as {
|
||||
searchResult3.Artist[i] = responses.ArtistID3{
|
||||
Id: e.Id,
|
||||
Name: e.Title,
|
||||
CoverArt: e.CoverArt,
|
||||
AlbumCount: e.AlbumCount,
|
||||
}
|
||||
if !e.Starred.IsZero() {
|
||||
searchResult3.Artist[i].Starred = &e.Starred
|
||||
}
|
||||
}
|
||||
searchResult3.Album = ToAlbums(als)
|
||||
searchResult3.Song = ToChildren(mfs)
|
||||
response.SearchResult3 = searchResult3
|
||||
return response, nil
|
||||
}
|
||||
92
server/subsonic/stream.go
Normal file
92
server/subsonic/stream.go
Normal file
|
|
@ -0,0 +1,92 @@
|
|||
package subsonic
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
|
||||
"github.com/cloudsonic/sonic-server/engine"
|
||||
"github.com/cloudsonic/sonic-server/log"
|
||||
"github.com/cloudsonic/sonic-server/model"
|
||||
"github.com/cloudsonic/sonic-server/server/subsonic/responses"
|
||||
"github.com/cloudsonic/sonic-server/utils"
|
||||
)
|
||||
|
||||
type StreamController struct {
|
||||
browser engine.Browser
|
||||
}
|
||||
|
||||
func NewStreamController(browser engine.Browser) *StreamController {
|
||||
return &StreamController{browser: browser}
|
||||
}
|
||||
|
||||
func (c *StreamController) getMediaFile(r *http.Request) (mf *engine.Entry, err error) {
|
||||
id, err := RequiredParamString(r, "id", "id parameter required")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
mf, err = c.browser.GetSong(id)
|
||||
switch {
|
||||
case err == model.ErrNotFound:
|
||||
log.Error(r, "Mediafile not found", "id", id)
|
||||
return nil, NewError(responses.ErrorDataNotFound)
|
||||
case err != nil:
|
||||
log.Error(r, "Error reading mediafile from DB", "id", id, err)
|
||||
return nil, NewError(responses.ErrorGeneric, "Internal error")
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// TODO Still getting the "Conn.Write wrote more than the declared Content-Length" error.
|
||||
// Don't know if this causes any issues
|
||||
func (c *StreamController) Stream(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
mf, err := c.getMediaFile(r)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
maxBitRate := ParamInt(r, "maxBitRate", 0)
|
||||
maxBitRate = utils.MinInt(mf.BitRate, maxBitRate)
|
||||
|
||||
log.Debug(r, "Streaming file", "id", mf.Id, "path", mf.AbsolutePath, "bitrate", mf.BitRate, "maxBitRate", maxBitRate)
|
||||
|
||||
// TODO Send proper estimated content-length
|
||||
//contentLength := mf.Size
|
||||
//if maxBitRate > 0 {
|
||||
// contentLength = strconv.Itoa((mf.Duration + 1) * maxBitRate * 1000 / 8)
|
||||
//}
|
||||
h := w.Header()
|
||||
h.Set("Content-Length", mf.Size)
|
||||
h.Set("Content-Type", "audio/mpeg")
|
||||
h.Set("Expires", "0")
|
||||
h.Set("Cache-Control", "must-revalidate")
|
||||
h.Set("Pragma", "public")
|
||||
|
||||
if r.Method == "HEAD" {
|
||||
log.Debug(r, "Just a HEAD. Not streaming", "path", mf.AbsolutePath)
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
err = engine.Stream(r.Context(), mf.AbsolutePath, mf.BitRate, maxBitRate, w)
|
||||
if err != nil {
|
||||
log.Error(r, "Error streaming file", "id", mf.Id, err)
|
||||
}
|
||||
|
||||
log.Debug(r, "Finished streaming", "path", mf.AbsolutePath)
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
func (c *StreamController) Download(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
mf, err := c.getMediaFile(r)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
log.Debug(r, "Sending file", "path", mf.AbsolutePath)
|
||||
|
||||
err = engine.Stream(r.Context(), mf.AbsolutePath, 0, 0, w)
|
||||
if err != nil {
|
||||
log.Error(r, "Error downloading file", "path", mf.AbsolutePath, err)
|
||||
}
|
||||
|
||||
log.Debug(r, "Finished sending", "path", mf.AbsolutePath)
|
||||
|
||||
return nil, nil
|
||||
}
|
||||
23
server/subsonic/system.go
Normal file
23
server/subsonic/system.go
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
package subsonic
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
|
||||
"github.com/cloudsonic/sonic-server/server/subsonic/responses"
|
||||
)
|
||||
|
||||
type SystemController struct{}
|
||||
|
||||
func NewSystemController() *SystemController {
|
||||
return &SystemController{}
|
||||
}
|
||||
|
||||
func (c *SystemController) Ping(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
return NewResponse(), nil
|
||||
}
|
||||
|
||||
func (c *SystemController) GetLicense(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
response := NewResponse()
|
||||
response.License = &responses.License{Valid: true}
|
||||
return response, nil
|
||||
}
|
||||
28
server/subsonic/users.go
Normal file
28
server/subsonic/users.go
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
package subsonic
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
|
||||
"github.com/cloudsonic/sonic-server/server/subsonic/responses"
|
||||
)
|
||||
|
||||
type UsersController struct{}
|
||||
|
||||
func NewUsersController() *UsersController {
|
||||
return &UsersController{}
|
||||
}
|
||||
|
||||
// TODO This is a placeholder. The real one has to read this info from a config file or the database
|
||||
func (c *UsersController) GetUser(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
||||
user, err := RequiredParamString(r, "username", "Required string parameter 'username' is not present")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
response := NewResponse()
|
||||
response.User = &responses.User{}
|
||||
response.User.Username = user
|
||||
response.User.StreamRole = true
|
||||
response.User.DownloadRole = true
|
||||
response.User.ScrobblingEnabled = true
|
||||
return response, nil
|
||||
}
|
||||
79
server/subsonic/wire_gen.go
Normal file
79
server/subsonic/wire_gen.go
Normal file
|
|
@ -0,0 +1,79 @@
|
|||
// Code generated by Wire. DO NOT EDIT.
|
||||
|
||||
//go:generate wire
|
||||
//+build !wireinject
|
||||
|
||||
package subsonic
|
||||
|
||||
import (
|
||||
"github.com/google/wire"
|
||||
)
|
||||
|
||||
// Injectors from wire_injectors.go:
|
||||
|
||||
func initSystemController(router *Router) *SystemController {
|
||||
systemController := NewSystemController()
|
||||
return systemController
|
||||
}
|
||||
|
||||
func initBrowsingController(router *Router) *BrowsingController {
|
||||
browser := router.Browser
|
||||
browsingController := NewBrowsingController(browser)
|
||||
return browsingController
|
||||
}
|
||||
|
||||
func initAlbumListController(router *Router) *AlbumListController {
|
||||
listGenerator := router.ListGenerator
|
||||
albumListController := NewAlbumListController(listGenerator)
|
||||
return albumListController
|
||||
}
|
||||
|
||||
func initMediaAnnotationController(router *Router) *MediaAnnotationController {
|
||||
scrobbler := router.Scrobbler
|
||||
ratings := router.Ratings
|
||||
mediaAnnotationController := NewMediaAnnotationController(scrobbler, ratings)
|
||||
return mediaAnnotationController
|
||||
}
|
||||
|
||||
func initPlaylistsController(router *Router) *PlaylistsController {
|
||||
playlists := router.Playlists
|
||||
playlistsController := NewPlaylistsController(playlists)
|
||||
return playlistsController
|
||||
}
|
||||
|
||||
func initSearchingController(router *Router) *SearchingController {
|
||||
search := router.Search
|
||||
searchingController := NewSearchingController(search)
|
||||
return searchingController
|
||||
}
|
||||
|
||||
func initUsersController(router *Router) *UsersController {
|
||||
usersController := NewUsersController()
|
||||
return usersController
|
||||
}
|
||||
|
||||
func initMediaRetrievalController(router *Router) *MediaRetrievalController {
|
||||
cover := router.Cover
|
||||
mediaRetrievalController := NewMediaRetrievalController(cover)
|
||||
return mediaRetrievalController
|
||||
}
|
||||
|
||||
func initStreamController(router *Router) *StreamController {
|
||||
browser := router.Browser
|
||||
streamController := NewStreamController(browser)
|
||||
return streamController
|
||||
}
|
||||
|
||||
// wire_injectors.go:
|
||||
|
||||
var allProviders = wire.NewSet(
|
||||
NewSystemController,
|
||||
NewBrowsingController,
|
||||
NewAlbumListController,
|
||||
NewMediaAnnotationController,
|
||||
NewPlaylistsController,
|
||||
NewSearchingController,
|
||||
NewUsersController,
|
||||
NewMediaRetrievalController,
|
||||
NewStreamController, wire.FieldsOf(new(*Router), "Browser", "Cover", "ListGenerator", "Playlists", "Ratings", "Scrobbler", "Search"),
|
||||
)
|
||||
56
server/subsonic/wire_injectors.go
Normal file
56
server/subsonic/wire_injectors.go
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
//+build wireinject
|
||||
|
||||
package subsonic
|
||||
|
||||
import (
|
||||
"github.com/google/wire"
|
||||
)
|
||||
|
||||
var allProviders = wire.NewSet(
|
||||
NewSystemController,
|
||||
NewBrowsingController,
|
||||
NewAlbumListController,
|
||||
NewMediaAnnotationController,
|
||||
NewPlaylistsController,
|
||||
NewSearchingController,
|
||||
NewUsersController,
|
||||
NewMediaRetrievalController,
|
||||
NewStreamController,
|
||||
wire.FieldsOf(new(*Router), "Browser", "Cover", "ListGenerator", "Playlists", "Ratings", "Scrobbler", "Search"),
|
||||
)
|
||||
|
||||
func initSystemController(router *Router) *SystemController {
|
||||
panic(wire.Build(allProviders))
|
||||
}
|
||||
|
||||
func initBrowsingController(router *Router) *BrowsingController {
|
||||
panic(wire.Build(allProviders))
|
||||
}
|
||||
|
||||
func initAlbumListController(router *Router) *AlbumListController {
|
||||
panic(wire.Build(allProviders))
|
||||
}
|
||||
|
||||
func initMediaAnnotationController(router *Router) *MediaAnnotationController {
|
||||
panic(wire.Build(allProviders))
|
||||
}
|
||||
|
||||
func initPlaylistsController(router *Router) *PlaylistsController {
|
||||
panic(wire.Build(allProviders))
|
||||
}
|
||||
|
||||
func initSearchingController(router *Router) *SearchingController {
|
||||
panic(wire.Build(allProviders))
|
||||
}
|
||||
|
||||
func initUsersController(router *Router) *UsersController {
|
||||
panic(wire.Build(allProviders))
|
||||
}
|
||||
|
||||
func initMediaRetrievalController(router *Router) *MediaRetrievalController {
|
||||
panic(wire.Build(allProviders))
|
||||
}
|
||||
|
||||
func initStreamController(router *Router) *StreamController {
|
||||
panic(wire.Build(allProviders))
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue