feat: transcoding and player datastores and configuration

server/app/app.go

@@ -43,6 +43,8 @@ func (app *Router) routes() http.Handler {
 		app.R(r, "/song", model.MediaFile{})
 		app.R(r, "/album", model.Album{})
 		app.R(r, "/artist", model.Artist{})
+		app.R(r, "/transcoding", model.Transcoding{})
+		app.R(r, "/player", model.Player{})
 
 		// Keepalive endpoint to be used to keep the session valid (ex: while playing songs)
 		r.Get("/keepalive/*", func(w http.ResponseWriter, r *http.Request) { w.Write([]byte(`{"response":"ok"}`)) })

server/app/auth.go

@@ -149,7 +149,7 @@ func validateLogin(userRepo model.UserRepository, userName, password string) (*m
 func contextWithUser(ctx context.Context, ds model.DataStore, claims jwt.MapClaims) context.Context {
 	userName := claims["sub"].(string)
 	user, _ := ds.User(ctx).FindByUsername(userName)
-	return context.WithValue(ctx, "user", user)
+	return context.WithValue(ctx, "user", *user)
 }
 
 func getToken(ds model.DataStore, ctx context.Context) (*jwt.Token, error) {

server/initial_setup.go

@@ -1,7 +1,7 @@
 package server
 
 import (
-	"context"
+	"encoding/json"
 	"fmt"
 	"time"
 
@@ -29,14 +29,17 @@ func initialSetup(ds model.DataStore) {
 			}
 		}
 
+		if err = createDefaultTranscodings(ds); err != nil {
+			return err
+		}
+
 		err = ds.Property(nil).Put(consts.InitialSetupFlagKey, time.Now().String())
 		return err
 	})
 }
 
 func createInitialAdminUser(ds model.DataStore) error {
-	ctx := context.Background()
-	c, err := ds.User(ctx).CountAll()
+	c, err := ds.User(nil).CountAll()
 	if err != nil {
 		panic(fmt.Sprintf("Could not access User table: %s", err))
 	}
@@ -56,7 +59,7 @@ func createInitialAdminUser(ds model.DataStore) error {
 			Password: initialPassword,
 			IsAdmin:  true,
 		}
-		err := ds.User(ctx).Put(&initialUser)
+		err := ds.User(nil).Put(&initialUser)
 		if err != nil {
 			log.Error("Could not create initial admin user", "user", initialUser, err)
 		}
@@ -77,3 +80,23 @@ func createJWTSecret(ds model.DataStore) error {
 	}
 	return err
 }
+
+func createDefaultTranscodings(ds model.DataStore) error {
+	repo := ds.Transcoding(nil)
+	for _, d := range consts.DefaultTranscodings {
+		var j []byte
+		var err error
+		if j, err = json.Marshal(d); err != nil {
+			return err
+		}
+		var t model.Transcoding
+		if err = json.Unmarshal(j, &t); err != nil {
+			return err
+		}
+		log.Info("Creating default transcoding config", "name", t.Name)
+		if err = repo.Put(&t); err != nil {
+			return err
+		}
+	}
+	return nil
+}

server/subsonic/api.go

@@ -27,16 +27,17 @@ type Router struct {
 	Search        engine.Search
 	Users         engine.Users
 	Streamer      engine.MediaStreamer
+	Players       engine.Players
 
 	mux http.Handler
 }
 
 func New(browser engine.Browser, cover engine.Cover, listGenerator engine.ListGenerator, users engine.Users,
 	playlists engine.Playlists, ratings engine.Ratings, scrobbler engine.Scrobbler, search engine.Search,
-	streamer engine.MediaStreamer) *Router {
+	streamer engine.MediaStreamer, players engine.Players) *Router {
 
 	r := &Router{Browser: browser, Cover: cover, ListGenerator: listGenerator, Playlists: playlists,
-		Ratings: ratings, Scrobbler: scrobbler, Search: search, Users: users, Streamer: streamer}
+		Ratings: ratings, Scrobbler: scrobbler, Search: search, Users: users, Streamer: streamer, Players: players}
 	r.mux = r.routes()
 	return r
 }
@@ -50,6 +51,7 @@ func (api *Router) routes() http.Handler {
 
 	r.Use(postFormToQueryParams)
 	r.Use(checkRequiredParameters)
+	r.Use(getPlayer(api.Players))
 
 	// Add validation middleware
 	r.Use(authenticate(api.Users))

server/subsonic/middlewares.go

@@ -3,6 +3,7 @@ package subsonic
 import (
 	"context"
 	"fmt"
+	"net"
 	"net/http"
 	"net/url"
 	"strings"
@@ -14,6 +15,10 @@ import (
 	"github.com/deluan/navidrome/utils"
 )
 
+const (
+	cookieExpiry = 365 * 24 * 3600 // One year
+)
+
 func postFormToQueryParams(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		err := r.ParseForm()
@@ -82,10 +87,54 @@ func authenticate(users engine.Users) func(next http.Handler) http.Handler {
 			}
 
 			ctx := r.Context()
-			ctx = context.WithValue(ctx, "user", usr)
+			ctx = context.WithValue(ctx, "user", *usr)
 			r = r.WithContext(ctx)
 
 			next.ServeHTTP(w, r)
 		})
 	}
 }
+
+func getPlayer(players engine.Players) func(next http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			ctx := r.Context()
+			userName := ctx.Value("username").(string)
+			client := ctx.Value("client").(string)
+			playerId := playerIDFromCookie(r, userName)
+			ip, _, _ := net.SplitHostPort(r.RemoteAddr)
+			player, err := players.Register(ctx, playerId, client, r.Header.Get("user-agent"), ip)
+			if err != nil {
+				log.Error("Could not register player", "userName", userName, "client", client)
+			}
+
+			ctx = context.WithValue(ctx, "player", *player)
+			r = r.WithContext(ctx)
+
+			cookie := &http.Cookie{
+				Name:     playerIDCookieName(userName),
+				Value:    player.ID,
+				MaxAge:   cookieExpiry,
+				HttpOnly: true,
+				Path:     "/",
+			}
+			http.SetCookie(w, cookie)
+			next.ServeHTTP(w, r)
+		})
+	}
+}
+
+func playerIDFromCookie(r *http.Request, userName string) string {
+	cookieName := playerIDCookieName(userName)
+	var playerId string
+	if c, err := r.Cookie(cookieName); err == nil {
+		playerId = c.Value
+		log.Trace(r, "playerId found in cookies", "playerId", playerId)
+	}
+	return playerId
+}
+
+func playerIDCookieName(userName string) string {
+	cookieName := fmt.Sprintf("nd-player-%x", userName)
+	return cookieName
+}

server/subsonic/middlewares_test.go

@@ -107,35 +107,80 @@ var _ = Describe("Middlewares", func() {
 	})
 
 	Describe("Authenticate", func() {
-		var mockedUser *mockUsers
+		var mockedUsers *mockUsers
 		BeforeEach(func() {
-			mockedUser = &mockUsers{}
+			mockedUsers = &mockUsers{}
 		})
 
 		It("passes all parameters to users.Authenticate ", func() {
 			r := newGetRequest("u=valid", "p=password", "t=token", "s=salt", "jwt=jwt")
-			cp := authenticate(mockedUser)(next)
+			cp := authenticate(mockedUsers)(next)
 			cp.ServeHTTP(w, r)
 
-			Expect(mockedUser.username).To(Equal("valid"))
-			Expect(mockedUser.password).To(Equal("password"))
-			Expect(mockedUser.token).To(Equal("token"))
-			Expect(mockedUser.salt).To(Equal("salt"))
-			Expect(mockedUser.jwt).To(Equal("jwt"))
+			Expect(mockedUsers.username).To(Equal("valid"))
+			Expect(mockedUsers.password).To(Equal("password"))
+			Expect(mockedUsers.token).To(Equal("token"))
+			Expect(mockedUsers.salt).To(Equal("salt"))
+			Expect(mockedUsers.jwt).To(Equal("jwt"))
 			Expect(next.called).To(BeTrue())
-			user := next.req.Context().Value("user").(*model.User)
+			user := next.req.Context().Value("user").(model.User)
 			Expect(user.UserName).To(Equal("valid"))
 		})
 
 		It("fails authentication with wrong password", func() {
 			r := newGetRequest("u=invalid", "", "", "")
-			cp := authenticate(mockedUser)(next)
+			cp := authenticate(mockedUsers)(next)
 			cp.ServeHTTP(w, r)
 
 			Expect(w.Body.String()).To(ContainSubstring(`code="40"`))
 			Expect(next.called).To(BeFalse())
 		})
 	})
+
+	Describe("GetPlayer", func() {
+		var mockedPlayers *mockPlayers
+		var r *http.Request
+		BeforeEach(func() {
+			mockedPlayers = &mockPlayers{}
+			r = newGetRequest()
+			ctx := context.WithValue(r.Context(), "username", "someone")
+			ctx = context.WithValue(ctx, "client", "client")
+			r = r.WithContext(ctx)
+		})
+
+		It("returns a new player in the cookies when none is specified", func() {
+			gp := getPlayer(mockedPlayers)(next)
+			gp.ServeHTTP(w, r)
+
+			cookieStr := w.Header().Get("Set-Cookie")
+			Expect(cookieStr).To(ContainSubstring(playerIDCookieName("someone")))
+		})
+
+		Context("PlayerId specified in Cookies", func() {
+			BeforeEach(func() {
+				cookie := &http.Cookie{
+					Name:   playerIDCookieName("someone"),
+					Value:  "123",
+					MaxAge: cookieExpiry,
+				}
+				r.AddCookie(cookie)
+
+				gp := getPlayer(mockedPlayers)(next)
+				gp.ServeHTTP(w, r)
+			})
+
+			It("stores the player in the context", func() {
+				Expect(next.called).To(BeTrue())
+				player := next.req.Context().Value("player").(model.Player)
+				Expect(player.ID).To(Equal("123"))
+			})
+
+			It("returns the playerId in the cookie", func() {
+				cookieStr := w.Header().Get("Set-Cookie")
+				Expect(cookieStr).To(ContainSubstring(playerIDCookieName("someone") + "=123"))
+			})
+		})
+	})
 })
 
 type mockHandler struct {
@@ -164,3 +209,15 @@ func (m *mockUsers) Authenticate(ctx context.Context, username, password, token,
 	}
 	return nil, model.ErrInvalidAuth
 }
+
+type mockPlayers struct {
+	engine.Players
+}
+
+func (mp *mockPlayers) Get(ctx context.Context, playerId string) (*model.Player, error) {
+	return &model.Player{ID: playerId}, nil
+}
+
+func (mp *mockPlayers) Register(ctx context.Context, id, client, typ, ip string) (*model.Player, error) {
+	return &model.Player{ID: id}, nil
+}