2020-01-20 00:21:44 +01:00
|
|
|
package subsonic
|
2020-01-07 20:56:26 +01:00
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
|
|
|
"encoding/xml"
|
2022-10-01 00:54:25 +02:00
|
|
|
"errors"
|
2020-01-07 20:56:26 +01:00
|
|
|
"fmt"
|
|
|
|
"net/http"
|
2020-04-21 07:32:34 +02:00
|
|
|
"runtime"
|
2020-01-07 20:56:26 +01:00
|
|
|
|
2021-05-11 23:21:18 +02:00
|
|
|
"github.com/go-chi/chi/v5"
|
|
|
|
"github.com/go-chi/chi/v5/middleware"
|
2020-04-21 14:41:04 +02:00
|
|
|
"github.com/navidrome/navidrome/consts"
|
2020-07-10 19:11:02 +02:00
|
|
|
"github.com/navidrome/navidrome/core"
|
2021-06-20 02:56:56 +02:00
|
|
|
"github.com/navidrome/navidrome/core/scrobbler"
|
2020-02-02 02:07:15 +01:00
|
|
|
"github.com/navidrome/navidrome/log"
|
2020-07-31 19:07:39 +02:00
|
|
|
"github.com/navidrome/navidrome/model"
|
2020-10-27 23:19:56 +01:00
|
|
|
"github.com/navidrome/navidrome/scanner"
|
2021-06-10 18:20:52 +02:00
|
|
|
"github.com/navidrome/navidrome/server/events"
|
2020-01-24 01:44:08 +01:00
|
|
|
"github.com/navidrome/navidrome/server/subsonic/responses"
|
2020-02-07 00:55:38 +01:00
|
|
|
"github.com/navidrome/navidrome/utils"
|
2022-12-19 17:00:20 +01:00
|
|
|
"github.com/navidrome/navidrome/utils/number"
|
2020-01-07 20:56:26 +01:00
|
|
|
)
|
|
|
|
|
2020-11-01 23:04:53 +01:00
|
|
|
const Version = "1.16.1"
|
2020-01-07 20:56:26 +01:00
|
|
|
|
2022-11-21 18:57:56 +01:00
|
|
|
type handler = func(*http.Request) (*responses.Subsonic, error)
|
|
|
|
type handlerRaw = func(http.ResponseWriter, *http.Request) (*responses.Subsonic, error)
|
2020-01-07 20:56:26 +01:00
|
|
|
|
2020-01-11 18:37:05 +01:00
|
|
|
type Router struct {
|
2021-06-13 18:46:36 +02:00
|
|
|
http.Handler
|
2022-11-21 18:57:56 +01:00
|
|
|
ds model.DataStore
|
|
|
|
artwork core.Artwork
|
|
|
|
streamer core.MediaStreamer
|
|
|
|
archiver core.Archiver
|
|
|
|
players core.Players
|
|
|
|
externalMetadata core.ExternalMetadata
|
|
|
|
playlists core.Playlists
|
|
|
|
scanner scanner.Scanner
|
|
|
|
broker events.Broker
|
|
|
|
scrobbler scrobbler.PlayTracker
|
2020-01-11 18:37:05 +01:00
|
|
|
}
|
|
|
|
|
2021-10-26 16:35:58 +02:00
|
|
|
func New(ds model.DataStore, artwork core.Artwork, streamer core.MediaStreamer, archiver core.Archiver,
|
|
|
|
players core.Players, externalMetadata core.ExternalMetadata, scanner scanner.Scanner, broker events.Broker,
|
|
|
|
playlists core.Playlists, scrobbler scrobbler.PlayTracker) *Router {
|
2020-10-27 18:52:01 +01:00
|
|
|
r := &Router{
|
2022-11-21 18:57:56 +01:00
|
|
|
ds: ds,
|
|
|
|
artwork: artwork,
|
|
|
|
streamer: streamer,
|
|
|
|
archiver: archiver,
|
|
|
|
players: players,
|
|
|
|
externalMetadata: externalMetadata,
|
|
|
|
playlists: playlists,
|
|
|
|
scanner: scanner,
|
|
|
|
broker: broker,
|
|
|
|
scrobbler: scrobbler,
|
2020-10-27 18:52:01 +01:00
|
|
|
}
|
2021-06-13 18:46:36 +02:00
|
|
|
r.Handler = r.routes()
|
2020-01-11 19:21:43 +01:00
|
|
|
return r
|
|
|
|
}
|
|
|
|
|
|
|
|
func (api *Router) routes() http.Handler {
|
2020-01-07 20:56:26 +01:00
|
|
|
r := chi.NewRouter()
|
|
|
|
|
2020-01-27 21:10:46 +01:00
|
|
|
r.Use(postFormToQueryParams)
|
2020-01-09 16:35:00 +01:00
|
|
|
r.Use(checkRequiredParameters)
|
2022-11-21 18:57:56 +01:00
|
|
|
r.Use(authenticate(api.ds))
|
2020-01-31 14:35:33 +01:00
|
|
|
// TODO Validate version
|
2020-01-07 20:56:26 +01:00
|
|
|
|
2020-01-14 02:45:38 +01:00
|
|
|
// Subsonic endpoints, grouped by controller
|
2020-01-07 20:56:26 +01:00
|
|
|
r.Group(func(r chi.Router) {
|
2022-11-21 18:57:56 +01:00
|
|
|
r.Use(getPlayer(api.players))
|
|
|
|
h(r, "ping", api.Ping)
|
|
|
|
h(r, "getLicense", api.GetLicense)
|
2020-01-07 20:56:26 +01:00
|
|
|
})
|
|
|
|
r.Group(func(r chi.Router) {
|
2022-11-21 18:57:56 +01:00
|
|
|
r.Use(getPlayer(api.players))
|
|
|
|
h(r, "getMusicFolders", api.GetMusicFolders)
|
|
|
|
h(r, "getIndexes", api.GetIndexes)
|
|
|
|
h(r, "getArtists", api.GetArtists)
|
|
|
|
h(r, "getGenres", api.GetGenres)
|
|
|
|
h(r, "getMusicDirectory", api.GetMusicDirectory)
|
|
|
|
h(r, "getArtist", api.GetArtist)
|
|
|
|
h(r, "getAlbum", api.GetAlbum)
|
|
|
|
h(r, "getSong", api.GetSong)
|
|
|
|
h(r, "getArtistInfo", api.GetArtistInfo)
|
|
|
|
h(r, "getArtistInfo2", api.GetArtistInfo2)
|
|
|
|
h(r, "getTopSongs", api.GetTopSongs)
|
|
|
|
h(r, "getSimilarSongs", api.GetSimilarSongs)
|
|
|
|
h(r, "getSimilarSongs2", api.GetSimilarSongs2)
|
2020-01-07 20:56:26 +01:00
|
|
|
})
|
|
|
|
r.Group(func(r chi.Router) {
|
2022-11-21 18:57:56 +01:00
|
|
|
r.Use(getPlayer(api.players))
|
|
|
|
hr(r, "getAlbumList", api.GetAlbumList)
|
|
|
|
hr(r, "getAlbumList2", api.GetAlbumList2)
|
|
|
|
h(r, "getStarred", api.GetStarred)
|
|
|
|
h(r, "getStarred2", api.GetStarred2)
|
|
|
|
h(r, "getNowPlaying", api.GetNowPlaying)
|
|
|
|
h(r, "getRandomSongs", api.GetRandomSongs)
|
|
|
|
h(r, "getSongsByGenre", api.GetSongsByGenre)
|
2020-01-07 20:56:26 +01:00
|
|
|
})
|
|
|
|
r.Group(func(r chi.Router) {
|
2022-11-21 18:57:56 +01:00
|
|
|
r.Use(getPlayer(api.players))
|
|
|
|
h(r, "setRating", api.SetRating)
|
|
|
|
h(r, "star", api.Star)
|
|
|
|
h(r, "unstar", api.Unstar)
|
|
|
|
h(r, "scrobble", api.Scrobble)
|
2020-01-07 20:56:26 +01:00
|
|
|
})
|
|
|
|
r.Group(func(r chi.Router) {
|
2022-11-21 18:57:56 +01:00
|
|
|
r.Use(getPlayer(api.players))
|
|
|
|
h(r, "getPlaylists", api.GetPlaylists)
|
|
|
|
h(r, "getPlaylist", api.GetPlaylist)
|
|
|
|
h(r, "createPlaylist", api.CreatePlaylist)
|
|
|
|
h(r, "deletePlaylist", api.DeletePlaylist)
|
|
|
|
h(r, "updatePlaylist", api.UpdatePlaylist)
|
2020-01-07 20:56:26 +01:00
|
|
|
})
|
2020-07-31 19:07:39 +02:00
|
|
|
r.Group(func(r chi.Router) {
|
2022-11-21 18:57:56 +01:00
|
|
|
r.Use(getPlayer(api.players))
|
|
|
|
h(r, "getBookmarks", api.GetBookmarks)
|
|
|
|
h(r, "createBookmark", api.CreateBookmark)
|
|
|
|
h(r, "deleteBookmark", api.DeleteBookmark)
|
|
|
|
h(r, "getPlayQueue", api.GetPlayQueue)
|
|
|
|
h(r, "savePlayQueue", api.SavePlayQueue)
|
2020-07-31 19:07:39 +02:00
|
|
|
})
|
2020-01-07 20:56:26 +01:00
|
|
|
r.Group(func(r chi.Router) {
|
2022-11-21 18:57:56 +01:00
|
|
|
r.Use(getPlayer(api.players))
|
|
|
|
h(r, "search2", api.Search2)
|
|
|
|
h(r, "search3", api.Search3)
|
2020-01-07 20:56:26 +01:00
|
|
|
})
|
|
|
|
r.Group(func(r chi.Router) {
|
2022-11-21 18:57:56 +01:00
|
|
|
h(r, "getUser", api.GetUser)
|
|
|
|
h(r, "getUsers", api.GetUsers)
|
2020-10-27 23:19:56 +01:00
|
|
|
})
|
|
|
|
r.Group(func(r chi.Router) {
|
2022-11-21 18:57:56 +01:00
|
|
|
h(r, "getScanStatus", api.GetScanStatus)
|
|
|
|
h(r, "startScan", api.StartScan)
|
2020-01-07 20:56:26 +01:00
|
|
|
})
|
|
|
|
r.Group(func(r chi.Router) {
|
2020-04-21 07:32:34 +02:00
|
|
|
// configure request throttling
|
2022-12-19 17:00:20 +01:00
|
|
|
maxRequests := number.Max(2, runtime.NumCPU())
|
2022-11-21 18:57:56 +01:00
|
|
|
r.Use(middleware.ThrottleBacklog(maxRequests, consts.RequestThrottleBacklogLimit, consts.RequestThrottleBacklogTimeout))
|
|
|
|
hr(r, "getAvatar", api.GetAvatar)
|
|
|
|
hr(r, "getCoverArt", api.GetCoverArt)
|
|
|
|
h(r, "getLyrics", api.GetLyrics)
|
2020-01-07 20:56:26 +01:00
|
|
|
})
|
|
|
|
r.Group(func(r chi.Router) {
|
2022-11-21 18:57:56 +01:00
|
|
|
r.Use(getPlayer(api.players))
|
|
|
|
hr(r, "stream", api.Stream)
|
|
|
|
hr(r, "download", api.Download)
|
2020-01-07 20:56:26 +01:00
|
|
|
})
|
2020-01-14 02:45:38 +01:00
|
|
|
|
2021-02-10 03:25:14 +01:00
|
|
|
// Not Implemented (yet?)
|
|
|
|
h501(r, "jukeboxControl")
|
|
|
|
h501(r, "getAlbumInfo", "getAlbumInfo2")
|
|
|
|
h501(r, "getShares", "createShare", "updateShare", "deleteShare")
|
|
|
|
h501(r, "getPodcasts", "getNewestPodcasts", "refreshPodcasts", "createPodcastChannel", "deletePodcastChannel",
|
|
|
|
"deletePodcastEpisode", "downloadPodcastEpisode")
|
|
|
|
h501(r, "getInternetRadioStations", "createInternetRadioStation", "updateInternetRadioStation",
|
|
|
|
"deleteInternetRadioStation")
|
|
|
|
h501(r, "createUser", "updateUser", "deleteUser", "changePassword")
|
|
|
|
|
|
|
|
// Deprecated/Won't implement/Out of scope endpoints
|
|
|
|
h410(r, "search")
|
|
|
|
h410(r, "getChatMessages", "addChatMessage")
|
|
|
|
h410(r, "getVideos", "getVideoInfo", "getCaptions", "hls")
|
2020-01-07 20:56:26 +01:00
|
|
|
return r
|
|
|
|
}
|
|
|
|
|
2022-11-26 19:13:05 +01:00
|
|
|
// Add a Subsonic handler
|
|
|
|
func h(r chi.Router, path string, f handler) {
|
|
|
|
hr(r, path, func(_ http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
|
|
|
|
return f(r)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add a Subsonic handler that requires a http.ResponseWriter (ex: stream, getCoverArt...)
|
2022-11-21 18:57:56 +01:00
|
|
|
func hr(r chi.Router, path string, f handlerRaw) {
|
2020-01-08 18:52:57 +01:00
|
|
|
handle := func(w http.ResponseWriter, r *http.Request) {
|
|
|
|
res, err := f(w, r)
|
2020-01-07 20:56:26 +01:00
|
|
|
if err != nil {
|
2020-10-27 20:23:29 +01:00
|
|
|
// If it is not a Subsonic error, convert it to an ErrorGeneric
|
2022-10-01 01:33:39 +02:00
|
|
|
var subErr subError
|
|
|
|
if !errors.As(err, &subErr) {
|
2022-10-01 00:54:25 +02:00
|
|
|
if errors.Is(err, model.ErrNotFound) {
|
2020-11-13 20:57:49 +01:00
|
|
|
err = newError(responses.ErrorDataNotFound, "data not found")
|
|
|
|
} else {
|
|
|
|
err = newError(responses.ErrorGeneric, "Internal Error")
|
|
|
|
}
|
2020-10-27 20:23:29 +01:00
|
|
|
}
|
|
|
|
sendError(w, r, err)
|
2020-01-07 20:56:26 +01:00
|
|
|
return
|
|
|
|
}
|
2022-07-27 20:27:18 +02:00
|
|
|
if r.Context().Err() != nil {
|
2022-11-03 17:38:05 +01:00
|
|
|
if log.CurrentLevel() >= log.LevelDebug {
|
2022-12-14 16:52:46 +01:00
|
|
|
log.Warn(r.Context(), "Request was interrupted", "endpoint", r.URL.Path, r.Context().Err())
|
2022-11-03 17:38:05 +01:00
|
|
|
}
|
2022-07-27 20:27:18 +02:00
|
|
|
return
|
|
|
|
}
|
2020-01-07 20:56:26 +01:00
|
|
|
if res != nil {
|
2020-10-27 20:23:29 +01:00
|
|
|
sendResponse(w, r, res)
|
2020-01-07 20:56:26 +01:00
|
|
|
}
|
|
|
|
}
|
2022-11-26 19:13:05 +01:00
|
|
|
addHandler(r, path, handle)
|
2022-11-21 18:57:56 +01:00
|
|
|
}
|
|
|
|
|
2022-07-26 19:18:08 +02:00
|
|
|
// Add a handler that returns 501 - Not implemented. Used to signal that an endpoint is not implemented yet
|
2022-11-26 19:13:05 +01:00
|
|
|
func h501(r chi.Router, paths ...string) {
|
2021-02-10 03:25:14 +01:00
|
|
|
for _, path := range paths {
|
|
|
|
handle := func(w http.ResponseWriter, r *http.Request) {
|
|
|
|
w.Header().Add("Cache-Control", "no-cache")
|
2022-07-26 19:18:08 +02:00
|
|
|
w.WriteHeader(501)
|
2021-02-10 03:25:14 +01:00
|
|
|
_, _ = w.Write([]byte("This endpoint is not implemented, but may be in future releases"))
|
|
|
|
}
|
2022-11-26 19:13:05 +01:00
|
|
|
addHandler(r, path, handle)
|
2021-02-10 03:25:14 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-01-14 02:45:38 +01:00
|
|
|
// Add a handler that returns 410 - Gone. Used to signal that an endpoint will not be implemented
|
2021-02-10 03:25:14 +01:00
|
|
|
func h410(r chi.Router, paths ...string) {
|
|
|
|
for _, path := range paths {
|
|
|
|
handle := func(w http.ResponseWriter, r *http.Request) {
|
|
|
|
w.WriteHeader(410)
|
|
|
|
_, _ = w.Write([]byte("This endpoint will not be implemented"))
|
|
|
|
}
|
2022-11-26 19:13:05 +01:00
|
|
|
addHandler(r, path, handle)
|
2020-01-14 02:45:38 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-26 19:13:05 +01:00
|
|
|
func addHandler(r chi.Router, path string, handle func(w http.ResponseWriter, r *http.Request)) {
|
|
|
|
r.HandleFunc("/"+path, handle)
|
|
|
|
r.HandleFunc("/"+path+".view", handle)
|
|
|
|
}
|
|
|
|
|
2020-10-27 20:23:29 +01:00
|
|
|
func sendError(w http.ResponseWriter, r *http.Request, err error) {
|
2020-08-14 04:11:18 +02:00
|
|
|
response := newResponse()
|
2020-01-07 20:56:26 +01:00
|
|
|
code := responses.ErrorGeneric
|
2022-10-01 01:33:39 +02:00
|
|
|
var subErr subError
|
|
|
|
if errors.As(err, &subErr) {
|
|
|
|
code = subErr.code
|
2020-01-07 20:56:26 +01:00
|
|
|
}
|
2021-01-07 14:24:13 +01:00
|
|
|
response.Status = "failed"
|
2020-01-07 20:56:26 +01:00
|
|
|
response.Error = &responses.Error{Code: code, Message: err.Error()}
|
|
|
|
|
2020-10-27 20:23:29 +01:00
|
|
|
sendResponse(w, r, response)
|
2020-01-07 20:56:26 +01:00
|
|
|
}
|
|
|
|
|
2020-10-27 20:23:29 +01:00
|
|
|
func sendResponse(w http.ResponseWriter, r *http.Request, payload *responses.Subsonic) {
|
2020-02-07 00:55:38 +01:00
|
|
|
f := utils.ParamString(r, "f")
|
2020-01-07 20:56:26 +01:00
|
|
|
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":
|
2020-01-09 06:18:55 +01:00
|
|
|
w.Header().Set("Content-Type", "application/javascript")
|
2020-02-07 00:55:38 +01:00
|
|
|
callback := utils.ParamString(r, "callback")
|
2020-01-07 20:56:26 +01:00
|
|
|
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)
|
|
|
|
}
|
2020-02-02 02:07:15 +01:00
|
|
|
if payload.Status == "ok" {
|
|
|
|
if log.CurrentLevel() >= log.LevelTrace {
|
2022-12-14 16:52:46 +01:00
|
|
|
log.Debug(r.Context(), "API: Successful response", "endpoint", r.URL.Path, "status", "OK", "body", string(response))
|
2020-02-02 02:07:15 +01:00
|
|
|
} else {
|
2022-12-14 16:52:46 +01:00
|
|
|
log.Debug(r.Context(), "API: Successful response", "endpoint", r.URL.Path, "status", "OK")
|
2020-02-02 02:07:15 +01:00
|
|
|
}
|
|
|
|
} else {
|
2022-12-14 16:52:46 +01:00
|
|
|
log.Warn(r.Context(), "API: Failed response", "endpoint", r.URL.Path, "error", payload.Error.Code, "message", payload.Error.Message)
|
2020-02-02 02:07:15 +01:00
|
|
|
}
|
2020-04-26 18:35:26 +02:00
|
|
|
if _, err := w.Write(response); err != nil {
|
2022-12-14 16:52:46 +01:00
|
|
|
log.Error(r, "Error sending response to client", "endpoint", r.URL.Path, "payload", string(response), err)
|
2020-04-26 18:35:26 +02:00
|
|
|
}
|
2020-01-07 20:56:26 +01:00
|
|
|
}
|