fix: force full rescan to enable search by album artist

Bumps [@testing-library/react](https://github.com/testing-library/react-testing-library) from 9.4.1 to 9.5.0.
- [Release notes](https://github.com/testing-library/react-testing-library/releases)
- [Changelog](https://github.com/testing-library/react-testing-library/blob/master/CHANGELOG.md)
- [Commits](https://github.com/testing-library/react-testing-library/compare/v9.4.1...v9.5.0)

Signed-off-by: dependabot-preview[bot] <support@dependabot.com>

.github/workflows/build.yml

@@ -11,10 +11,10 @@ jobs:
         os: [macOS-latest, ubuntu-latest]
 
     steps:
-      - name: Set up Go 1.13
+      - name: Set up Go 1.14
         uses: actions/setup-go@v1
         with:
-          go-version: 1.13
+          go-version: 1.14
         id: go
 
       - name: Check out code into the Go module directory

.github/workflows/release.yml

@@ -15,7 +15,7 @@ jobs:
           fetch-depth: 0
       - uses: actions/setup-node@v1
         with:
-          node-version: 13
+          node-version: 13.10
       - name: Build UI
         run: |
           cd ui
@@ -24,7 +24,7 @@ jobs:
       - name: Fetch tags
         run: git fetch --depth=1 origin +refs/tags/*:refs/tags/*
       - name: Run GoReleaser
-        uses: docker://bepsays/ci-goreleaser:latest
+        uses: docker://bepsays/ci-goreleaser:1.14-1
 
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.nvmrc

@@ -1 +1 @@
-v13.7.0
+v13.10.1

API_COMPATIBILITY.md

@@ -10,7 +10,7 @@ Navidrome and Subsonic:
 * Right now, Navidrome only works with a single Music Library (Music Folder)
 * Navidrome does not mark songs as played by calls to `stream`, only when 
  `scrobble` is called with `submission=true`
-* Next features to be implemented: Playlists (WIP), MultiUser (WIP), Jukebox, Sharing, Podcasts, Bookmarks, Internet Radio. 
+* Next features to be implemented: Last.FM integration, Jukebox, Sharing, Bookmarks, Podcasts, Internet Radio. 
 
 Navidrome is actively being tested with:
 [DSub](http://www.subsonic.org/pages/apps.jsp#dsub),
@@ -54,7 +54,7 @@ Navidrome is actively being tested with:
 | `deletePlaylist`       | |
 | ||
 | _MEDIA RETRIEVAL_      ||
-| `stream`               | No Transcoding/Downsampling support (for now)|
+| `stream`               | Experimental Transcoding/Downsampling support available |
 | `download`             | |
 | `getCoverArt`          | Only gets embedded artwork |
 | `getAvatar`            | Always returns the same image |
@@ -62,7 +62,7 @@ Navidrome is actively being tested with:
 | _MEDIA ANNOTATION_     ||
 | `star`                 | |
 | `unstar`               | |
-| `setRating`            | Doesn't work with artists |
+| `setRating`            | |
 | `scrobble`             | No Last.FM support yet. It is used to update play count and last played |
 | ||
 | _USER MANAGEMENT_      ||

Dockerfile

@@ -1,6 +1,6 @@
 #####################################################
 ### Build UI bundles
-FROM node:13.7-alpine AS jsbuilder
+FROM node:13.10-alpine AS jsbuilder
 WORKDIR /src
 COPY ui/package.json ui/package-lock.json ./
 RUN npm ci
@@ -10,7 +10,7 @@ RUN npm run build
 
 #####################################################
 ### Build executable
-FROM golang:1.13-alpine AS gobuilder
+FROM golang:1.14-alpine AS gobuilder
 
 # Download build tools
 RUN mkdir -p /src/ui/build

Makefile

@@ -1,5 +1,5 @@
-GO_VERSION=1.13
-NODE_VERSION=v13.7.0
+GO_VERSION=$(shell grep -e "^go " go.mod | cut -f 2 -d ' ')
+NODE_VERSION=$(shell cat .nvmrc)
 
 GIT_SHA=$(shell git rev-parse --short HEAD)
 
@@ -51,7 +51,7 @@ check_env: check_go_env check_node_env
 .PHONY: check_go_env
 check_go_env:
 	@(hash go) || (echo "\nERROR: GO environment not setup properly!\n"; exit 1)
-	@go version | grep -q $(GO_VERSION) || (echo "\nERROR: Please upgrade your GO version\n"; exit 1)
+	@go version | grep -q $(GO_VERSION) || (echo "\nERROR: Please upgrade your GO version\nThis project requires version $(GO_VERSION)"; exit 1)
 
 .PHONY: check_node_env
 check_node_env:
@@ -79,4 +79,4 @@ release:
 
 .PHONY: dist
 dist:
-	 docker run -it -v $(PWD):/github/workspace -w /github/workspace bepsays/ci-goreleaser:1.13-4 goreleaser release --rm-dist --skip-publish --snapshot
+	 docker run -it -v $(PWD):/github/workspace -w /github/workspace bepsays/ci-goreleaser:1.14-1 goreleaser release --rm-dist --skip-publish --snapshot

README.md

@@ -86,7 +86,7 @@ To get the cutting-edge, latest version from master, use the image `deluan/navid
 
 ### Build from source
 
-You will need to install [Go 1.13](https://golang.org/dl/) and [Node 13.7.0](http://nodejs.org).
+You will need to install [Go 1.14](https://golang.org/dl/) and [Node 13.10.1](http://nodejs.org).
 You'll also need [ffmpeg](https://ffmpeg.org) installed in your system. The setup is very strict, and 
 the steps bellow only work with these specific versions (enforced in the Makefile) 
 

conf/configuration.go

@@ -25,7 +25,7 @@ type nd struct {
 
 	EnableDownsampling      bool   `default:"false"`
 	MaxBitRate              int    `default:"0"`
-	MaxTranscodingCacheSize int64  `default:"100000000"` // 100MB
+	MaxTranscodingCacheSize int64  `default:"100"` // in MB
 	DownsampleCommand       string `default:"ffmpeg -i %s -map 0:0 -b:a %bk -v 0 -f mp3 -"`
 	ProbeCommand            string `default:"ffmpeg -i %s -f ffmetadata"`
 
@@ -83,7 +83,7 @@ func LoadFromFile(confFile string, skipFlags ...bool) {
 		os.Exit(2)
 	}
 	if Server.DbPath == "" {
-		Server.DbPath = filepath.Join(Server.DataFolder, "navidrome.db")
+		Server.DbPath = filepath.Join(Server.DataFolder, consts.DefaultDbPath)
 	}
 	if os.Getenv("PORT") != "" {
 		Server.Port = os.Getenv("PORT")

consts/consts.go

@@ -6,6 +6,7 @@ const (
 	AppName = "navidrome"
 
 	LocalConfigFile     = "./navidrome.toml"
+	DefaultDbPath       = "navidrome.db?cache=shared&_busy_timeout=15000&_journal_mode=WAL"
 	InitialSetupFlagKey = "InitialSetup"
 
 	JWTSecretKey       = "JWTSecret"

consts/mime_types.go

@@ -8,7 +8,6 @@ func init() {
 		".ogg":  "audio/ogg",
 		".oga":  "audio/ogg",
 		".opus": "audio/ogg",
-		".ogx":  "application/ogg",
 		".aac":  "audio/mp4",
 		".m4a":  "audio/mp4",
 		".m4b":  "audio/mp4",
@@ -18,20 +17,8 @@ func init() {
 		".ape":  "audio/x-monkeys-audio",
 		".mpc":  "audio/x-musepack",
 		".shn":  "audio/x-shn",
-		".flv":  "video/x-flv",
-		".avi":  "video/avi",
-		".mpg":  "video/mpeg",
-		".mpeg": "video/mpeg",
-		".mp4":  "video/mp4",
-		".m4v":  "video/x-m4v",
-		".mkv":  "video/x-matroska",
-		".mov":  "video/quicktime",
-		".wmv":  "video/x-ms-wmv",
-		".ogv":  "video/ogg",
-		".divx": "video/divx",
-		".m2ts": "video/MP2T",
-		".ts":   "video/MP2T",
-		".webm": "video/webm",
+		".aif":  "audio/x-aiff",
+		".aiff": "audio/x-aiff",
 		".gif":  "image/gif",
 		".jpg":  "image/jpeg",
 		".jpeg": "image/jpeg",

db/db.go

@@ -13,32 +13,36 @@ import (
 )
 
 var (
-	once   sync.Once
 	Driver = "sqlite3"
 	Path   string
 )
 
-func Init() {
+var (
+	once sync.Once
+	db   *sql.DB
+)
+
+func Db() *sql.DB {
 	once.Do(func() {
+		var err error
 		Path = conf.Server.DbPath
 		if Path == ":memory:" {
 			Path = "file::memory:?cache=shared"
 			conf.Server.DbPath = Path
 		}
 		log.Debug("Opening DataBase", "dbPath", Path, "driver", Driver)
+		db, err = sql.Open(Driver, Path)
+		if err != nil {
+			panic(err)
+		}
 	})
+	return db
 }
 
 func EnsureLatestVersion() {
-	Init()
-	db, err := sql.Open(Driver, Path)
-	defer db.Close()
-	if err != nil {
-		log.Error("Failed to open DB", err)
-		os.Exit(1)
-	}
+	db := Db()
 
-	err = goose.SetDialect(Driver)
+	err := goose.SetDialect(Driver)
 	if err != nil {
 		log.Error("Invalid DB driver", "driver", Driver, err)
 		os.Exit(1)

db/migration/20200220143731_change_duration_to_float.go

@@ -2,7 +2,7 @@ package migration
 
 import (
 	"database/sql"
-	"github.com/deluan/navidrome/log"
+
 	"github.com/pressly/goose"
 )
 
@@ -11,7 +11,7 @@ func init() {
 }
 
 func Up20200220143731(tx *sql.Tx) error {
-	log.Warn("This migration will force the next scan to be a full rescan!")
+	notice(tx, "This migration will force the next scan to be a full rescan!")
 	_, err := tx.Exec(`
 create table media_file_dg_tmp
 (

db/migration/20200310171621_enable_search_by_albumartist.go

@@ -0,0 +1,21 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200310171621, Down20200310171621)
+}
+
+func Up20200310171621(tx *sql.Tx) error {
+	notice(tx, "A full rescan will be performed to enable search by Album Artist!")
+	return forceFullRescan(tx)
+}
+
+func Down20200310171621(tx *sql.Tx) error {
+	// This code is executed when the migration is rolled back.
+	return nil
+}

db/migration/migration.go

@@ -0,0 +1,55 @@
+package migration
+
+import (
+	"database/sql"
+	"fmt"
+	"sync"
+
+	"github.com/deluan/navidrome/consts"
+)
+
+// Use this in migrations that need to communicate something important (braking changes, forced reindexes, etc...)
+func notice(tx *sql.Tx, msg string) {
+	if isDBInitialized(tx) {
+		fmt.Printf(`
+*************************************************************************************
+NOTICE: %s
+*************************************************************************************
+
+`, msg)
+	}
+}
+
+// Call this in migrations that requires a full rescan
+func forceFullRescan(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+delete from property where id like 'LastScan%';
+update media_file set updated_at = '0001-01-01';
+`)
+	return err
+}
+
+var once sync.Once
+
+func isDBInitialized(tx *sql.Tx) (initialized bool) {
+	once.Do(func() {
+		rows, err := tx.Query("select count(*) from property where id='" + consts.InitialSetupFlagKey + "'")
+		checkErr(err)
+		initialized = checkCount(rows) > 0
+	})
+	return initialized
+}
+
+func checkCount(rows *sql.Rows) (count int) {
+	for rows.Next() {
+		err := rows.Scan(&count)
+		checkErr(err)
+	}
+	return count
+}
+
+func checkErr(err error) {
+	if err != nil {
+		panic(err)
+	}
+}

engine/browser.go

@@ -165,10 +165,13 @@ func (b *browser) buildAlbumDir(al *model.Album, tracks model.MediaFiles) *Direc
 		Genre:      al.Genre,
 		CoverArt:   al.CoverArtId,
 		PlayCount:  int32(al.PlayCount),
-		Starred:    al.StarredAt,
 		UserRating: al.Rating,
 	}
 
+	if al.Starred {
+		dir.Starred = al.StarredAt
+	}
+
 	dir.Entries = FromMediaFiles(tracks)
 	return dir
 }

engine/common.go

@@ -51,7 +51,9 @@ func FromArtist(ar *model.Artist) Entry {
 	e.Title = ar.Name
 	e.AlbumCount = ar.AlbumCount
 	e.IsDir = true
-	e.Starred = ar.StarredAt
+	if ar.Starred {
+		e.Starred = ar.StarredAt
+	}
 	return e
 }
 
@@ -71,7 +73,9 @@ func FromAlbum(al *model.Album) Entry {
 	e.ArtistId = al.ArtistID
 	e.Duration = int(al.Duration)
 	e.SongCount = al.SongCount
-	e.Starred = al.StarredAt
+	if al.Starred {
+		e.Starred = al.StarredAt
+	}
 	e.PlayCount = int32(al.PlayCount)
 	e.UserRating = al.Rating
 	return e
@@ -105,9 +109,11 @@ func FromMediaFile(mf *model.MediaFile) Entry {
 	e.Created = mf.CreatedAt
 	e.AlbumId = mf.AlbumID
 	e.ArtistId = mf.ArtistID
-	e.Type = "music" // TODO Hardcoded for now
+	e.Type = "music"
 	e.PlayCount = int32(mf.PlayCount)
-	e.Starred = mf.StarredAt
+	if mf.Starred {
+		e.Starred = mf.StarredAt
+	}
 	e.UserRating = mf.Rating
 	return e
 }

engine/media_streamer.go

@@ -4,59 +4,143 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"net/http"
+	"mime"
 	"os"
 	"path/filepath"
-	"strings"
 	"time"
 
 	"github.com/deluan/navidrome/conf"
 	"github.com/deluan/navidrome/consts"
-	"github.com/deluan/navidrome/engine/ffmpeg"
+	"github.com/deluan/navidrome/engine/transcoder"
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
 	"github.com/deluan/navidrome/utils"
-	"gopkg.in/djherbis/fscache.v0"
+	"github.com/djherbis/fscache"
 )
 
 type MediaStreamer interface {
-	NewFileSystem(ctx context.Context, maxBitRate int, format string) (http.FileSystem, error)
+	NewStream(ctx context.Context, id string, maxBitRate int, format string) (*Stream, error)
 }
 
-func NewMediaStreamer(ds model.DataStore, ffm ffmpeg.FFmpeg, cache fscache.Cache) MediaStreamer {
+func NewMediaStreamer(ds model.DataStore, ffm transcoder.Transcoder, cache fscache.Cache) MediaStreamer {
 	return &mediaStreamer{ds: ds, ffm: ffm, cache: cache}
 }
 
 type mediaStreamer struct {
 	ds    model.DataStore
-	ffm   ffmpeg.FFmpeg
+	ffm   transcoder.Transcoder
 	cache fscache.Cache
 }
 
-func (ms *mediaStreamer) NewFileSystem(ctx context.Context, maxBitRate int, format string) (http.FileSystem, error) {
-	return &mediaFileSystem{ctx: ctx, ds: ms.ds, ffm: ms.ffm, cache: ms.cache, maxBitRate: maxBitRate, format: format}, nil
+func (ms *mediaStreamer) NewStream(ctx context.Context, id string, maxBitRate int, reqFormat string) (*Stream, error) {
+	mf, err := ms.ds.MediaFile(ctx).Get(id)
+	if err != nil {
+		return nil, err
+	}
+
+	bitRate, format := selectTranscodingOptions(mf, maxBitRate, reqFormat)
+	s := &Stream{ctx: ctx, mf: mf, format: format, bitRate: bitRate}
+
+	if format == "raw" {
+		log.Debug(ctx, "Streaming raw file", "id", mf.ID, "path", mf.Path,
+			"requestBitrate", maxBitRate, "requestFormat", reqFormat,
+			"originalBitrate", mf.BitRate, "originalFormat", mf.Suffix)
+		f, err := os.Open(mf.Path)
+		if err != nil {
+			return nil, err
+		}
+		s.Reader = f
+		s.Closer = f
+		s.Seeker = f
+		s.format = mf.Suffix
+		return s, nil
+	}
+
+	key := cacheKey(id, bitRate, format)
+	r, w, err := ms.cache.Get(key)
+	if err != nil {
+		log.Error(ctx, "Error creating stream caching buffer", "id", mf.ID, err)
+		return nil, err
+	}
+
+	// If this is a brand new transcoding request, not in the cache, start transcoding
+	if w != nil {
+		log.Trace(ctx, "Cache miss. Starting new transcoding session", "id", mf.ID)
+		out, err := ms.ffm.Start(ctx, mf.Path, bitRate, format)
+		if err != nil {
+			log.Error(ctx, "Error starting transcoder", "id", mf.ID, err)
+			return nil, os.ErrInvalid
+		}
+		go copyAndClose(ctx, w, out)
+	}
+
+	// If it is in the cache, check if the stream is done being written. If so, return a ReaderSeeker
+	if w == nil {
+		size := getFinalCachedSize(r)
+		if size > 0 {
+			log.Debug(ctx, "Streaming cached file", "id", mf.ID, "path", mf.Path,
+				"requestBitrate", maxBitRate, "requestFormat", reqFormat,
+				"originalBitrate", mf.BitRate, "originalFormat", mf.Suffix, "size", size)
+			sr := io.NewSectionReader(r, 0, size)
+			s.Reader = sr
+			s.Closer = r
+			s.Seeker = sr
+			s.format = format
+			return s, nil
+		}
+	}
+
+	log.Debug(ctx, "Streaming transcoded file", "id", mf.ID, "path", mf.Path,
+		"requestBitrate", maxBitRate, "requestFormat", reqFormat,
+		"originalBitrate", mf.BitRate, "originalFormat", mf.Suffix)
+	// All other cases, just return a ReadCloser, without Seek capabilities
+	s.Reader = r
+	s.Closer = r
+	s.format = format
+	return s, nil
 }
 
-type mediaFileSystem struct {
-	ctx        context.Context
-	ds         model.DataStore
-	maxBitRate int
-	format     string
-	ffm        ffmpeg.FFmpeg
-	cache      fscache.Cache
+func copyAndClose(ctx context.Context, w io.WriteCloser, r io.ReadCloser) {
+	_, err := io.Copy(w, r)
+	if err != nil {
+		log.Error(ctx, "Error copying data to cache", err)
+	}
+	err = r.Close()
+	if err != nil {
+		log.Error(ctx, "Error closing transcode output", err)
+	}
+	err = w.Close()
+	if err != nil {
+		log.Error(ctx, "Error closing cache", err)
+	}
 }
 
-func (fs *mediaFileSystem) selectTranscodingOptions(mf *model.MediaFile) (string, int) {
+type Stream struct {
+	ctx     context.Context
+	mf      *model.MediaFile
+	bitRate int
+	format  string
+	io.Reader
+	io.Closer
+	io.Seeker
+}
+
+func (s *Stream) Seekable() bool      { return s.Seeker != nil }
+func (s *Stream) Duration() float32   { return s.mf.Duration }
+func (s *Stream) ContentType() string { return mime.TypeByExtension("." + s.format) }
+func (s *Stream) Name() string        { return s.mf.Path }
+func (s *Stream) ModTime() time.Time  { return s.mf.UpdatedAt }
+
+func selectTranscodingOptions(mf *model.MediaFile, maxBitRate int, format string) (int, string) {
 	var bitRate int
-	var format string
 
-	if fs.format == "raw" || !conf.Server.EnableDownsampling {
-		return "raw", bitRate
+	if format == "raw" || !conf.Server.EnableDownsampling {
+		return bitRate, "raw"
 	} else {
-		if fs.maxBitRate == 0 {
+		if maxBitRate == 0 {
 			bitRate = mf.BitRate
 		} else {
-			bitRate = utils.MinInt(mf.BitRate, fs.maxBitRate)
+			bitRate = utils.MinInt(mf.BitRate, maxBitRate)
 		}
 		format = "mp3" //mf.Suffix
 	}
@@ -65,117 +149,28 @@ func (fs *mediaFileSystem) selectTranscodingOptions(mf *model.MediaFile) (string
 	}
 
 	if bitRate == mf.BitRate {
-		return "raw", bitRate
+		return bitRate, "raw"
 	}
-	return format, bitRate
+	return bitRate, format
 }
 
-func (fs *mediaFileSystem) Open(name string) (http.File, error) {
-	id := strings.Trim(name, "/")
-	mf, err := fs.ds.MediaFile(fs.ctx).Get(id)
-	if err == model.ErrNotFound {
-		return nil, os.ErrNotExist
-	}
-	if err != nil {
-		log.Error("Error opening mediaFile", "id", id, err)
-		return nil, os.ErrInvalid
-	}
-
-	format, bitRate := fs.selectTranscodingOptions(mf)
-	if format == "raw" {
-		log.Debug(fs.ctx, "Streaming raw file", "id", mf.ID, "path", mf.Path,
-			"requestBitrate", bitRate, "requestFormat", format,
-			"originalBitrate", mf.BitRate, "originalFormat", mf.Suffix)
-		return os.Open(mf.Path)
-	}
-
-	log.Debug(fs.ctx, "Streaming transcoded file", "id", mf.ID, "path", mf.Path,
-		"requestBitrate", bitRate, "requestFormat", format,
-		"originalBitrate", mf.BitRate, "originalFormat", mf.Suffix)
-
-	return fs.transcodeFile(mf, bitRate, format)
+func cacheKey(id string, bitRate int, format string) string {
+	return fmt.Sprintf("%s.%d.%s", id, bitRate, format)
 }
 
-func (fs *mediaFileSystem) transcodeFile(mf *model.MediaFile, bitRate int, format string) (*transcodingFile, error) {
-	key := fmt.Sprintf("%s.%d.%s", mf.ID, bitRate, format)
-	r, w, err := fs.cache.Get(key)
-	if err != nil {
-		log.Error("Error creating stream caching buffer", "id", mf.ID, err)
-		return nil, os.ErrInvalid
-	}
-
-	// If it is a new file (not found in the cached), start a new transcoding session
-	if w != nil {
-		log.Debug("File not found in cache. Starting new transcoding session", "id", mf.ID)
-		out, err := fs.ffm.StartTranscoding(fs.ctx, mf.Path, bitRate, format)
-		if err != nil {
-			log.Error("Error starting transcoder", "id", mf.ID, err)
-			return nil, os.ErrInvalid
+func getFinalCachedSize(r fscache.ReadAtCloser) int64 {
+	cr, ok := r.(*fscache.CacheReader)
+	if ok {
+		size, final, err := cr.Size()
+		if final && err == nil {
+			return size
 		}
-		go func() {
-			io.Copy(w, out)
-			out.Close()
-			w.Close()
-		}()
-	} else {
-		log.Debug("Reading transcoded file from cache", "id", mf.ID)
 	}
-
-	return newTranscodingFile(fs.ctx, r, mf, bitRate), nil
+	return -1
 }
 
-// transcodingFile Implements http.File interface, required for the FileSystem. It needs a Closer, a Reader and
-// a Seeker for the same stream. Because the fscache package only provides a ReaderAtCloser (without the Seek()
-// method), we wrap that reader with a SectionReader, which provides a Seek(). But we still need the original
-// reader, as we need to close the stream when the transfer is complete
-func newTranscodingFile(ctx context.Context, reader fscache.ReadAtCloser,
-	mf *model.MediaFile, bitRate int) *transcodingFile {
-
-	size := int64(mf.Duration*float32(bitRate*1000)) / 8
-	return &transcodingFile{
-		ctx:        ctx,
-		mf:         mf,
-		bitRate:    bitRate,
-		size:       size,
-		closer:     reader,
-		ReadSeeker: io.NewSectionReader(reader, 0, size),
-	}
-}
-
-type transcodingFile struct {
-	ctx     context.Context
-	mf      *model.MediaFile
-	bitRate int
-	size    int64
-	closer  io.Closer
-	io.ReadSeeker
-}
-
-func (tf *transcodingFile) Stat() (os.FileInfo, error) {
-	return &streamHandlerFileInfo{f: tf}, nil
-}
-
-func (tf *transcodingFile) Close() error {
-	return tf.closer.Close()
-}
-
-func (tf *transcodingFile) Readdir(count int) ([]os.FileInfo, error) {
-	return nil, nil
-}
-
-type streamHandlerFileInfo struct {
-	f *transcodingFile
-}
-
-func (fi *streamHandlerFileInfo) Name() string       { return fi.f.mf.Title }
-func (fi *streamHandlerFileInfo) ModTime() time.Time { return fi.f.mf.UpdatedAt }
-func (fi *streamHandlerFileInfo) Size() int64        { return fi.f.size }
-func (fi *streamHandlerFileInfo) Mode() os.FileMode  { return os.FileMode(0777) }
-func (fi *streamHandlerFileInfo) IsDir() bool        { return false }
-func (fi *streamHandlerFileInfo) Sys() interface{}   { return nil }
-
 func NewTranscodingCache() (fscache.Cache, error) {
-	lru := fscache.NewLRUHaunter(0, conf.Server.MaxTranscodingCacheSize, 10*time.Minute)
+	lru := fscache.NewLRUHaunter(0, conf.Server.MaxTranscodingCacheSize*1024*1024, 10*time.Minute)
 	h := fscache.NewLRUHaunterStrategy(lru)
 	cacheFolder := filepath.Join(conf.Server.DataFolder, consts.CacheDir)
 	fs, err := fscache.NewFs(cacheFolder, 0755)

engine/media_streamer_test.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"io"
 	"io/ioutil"
-	"net/http"
 	"os"
 	"strings"
 
@@ -12,53 +11,83 @@ import (
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
 	"github.com/deluan/navidrome/persistence"
+	"github.com/djherbis/fscache"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
-	"gopkg.in/djherbis/fscache.v0"
 )
 
 var _ = Describe("MediaStreamer", func() {
-
 	var streamer MediaStreamer
 	var ds model.DataStore
+	var cache fscache.Cache
+	var tempDir string
+	ffmpeg := &fakeFFmpeg{Data: "fake data"}
 	ctx := log.NewContext(nil)
 
+	BeforeSuite(func() {
+		tempDir, _ = ioutil.TempDir("", "stream_tests")
+		fs, _ := fscache.NewFs(tempDir, 0755)
+		cache, _ = fscache.NewCache(fs, nil)
+	})
+
 	BeforeEach(func() {
 		conf.Server.EnableDownsampling = true
-		fs := fscache.NewMemFs()
-		cache, _ := fscache.NewCache(fs, nil)
 		ds = &persistence.MockDataStore{}
-		ds.MediaFile(ctx).(*persistence.MockMediaFile).SetData(`[{"id": "123", "path": "tests/fixtures/test.mp3", "bitRate": 128}]`, 1)
-		streamer = NewMediaStreamer(ds, &fakeFFmpeg{}, cache)
+		ds.MediaFile(ctx).(*persistence.MockMediaFile).SetData(`[{"id": "123", "path": "tests/fixtures/test.mp3", "bitRate": 128, "duration": 257.0}]`, 1)
+		streamer = NewMediaStreamer(ds, ffmpeg, cache)
 	})
 
-	getFile := func(id string, maxBitRate int, format string) (http.File, error) {
-		fs, _ := streamer.NewFileSystem(ctx, maxBitRate, format)
-		return fs.Open(id)
-	}
+	AfterSuite(func() {
+		os.RemoveAll(tempDir)
+	})
 
-	Context("NewFileSystem", func() {
-		It("returns a File if format is 'raw'", func() {
-			Expect(getFile("123", 0, "raw")).To(BeAssignableToTypeOf(&os.File{}))
+	Context("NewStream", func() {
+		It("returns a seekable stream if format is 'raw'", func() {
+			s, err := streamer.NewStream(ctx, "123", 0, "raw")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(s.Seekable()).To(BeTrue())
 		})
-		It("returns a File if maxBitRate is 0", func() {
-			Expect(getFile("123", 0, "mp3")).To(BeAssignableToTypeOf(&os.File{}))
+		It("returns a seekable stream if maxBitRate is 0", func() {
+			s, err := streamer.NewStream(ctx, "123", 0, "mp3")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(s.Seekable()).To(BeTrue())
 		})
-		It("returns a File if maxBitRate is higher than file bitRate", func() {
-			Expect(getFile("123", 256, "mp3")).To(BeAssignableToTypeOf(&os.File{}))
+		It("returns a seekable stream if maxBitRate is higher than file bitRate", func() {
+			s, err := streamer.NewStream(ctx, "123", 320, "mp3")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(s.Seekable()).To(BeTrue())
 		})
-		It("returns a transcodingFile if maxBitRate is lower than file bitRate", func() {
-			s, err := getFile("123", 64, "mp3")
+		It("returns a NON seekable stream if transcode is required", func() {
+			s, err := streamer.NewStream(ctx, "123", 64, "mp3")
 			Expect(err).To(BeNil())
-			Expect(s).To(BeAssignableToTypeOf(&transcodingFile{}))
-			Expect(s.(*transcodingFile).bitRate).To(Equal(64))
+			Expect(s.Seekable()).To(BeFalse())
+			Expect(s.Duration()).To(Equal(float32(257.0)))
+		})
+		It("returns a seekable stream if the file is complete in the cache", func() {
+			Eventually(func() bool { return ffmpeg.closed }).Should(BeTrue())
+			s, err := streamer.NewStream(ctx, "123", 64, "mp3")
+			Expect(err).To(BeNil())
+			Expect(s.Seekable()).To(BeTrue())
 		})
 	})
 })
 
 type fakeFFmpeg struct {
+	Data   string
+	r      io.Reader
+	closed bool
 }
 
-func (ff *fakeFFmpeg) StartTranscoding(ctx context.Context, path string, maxBitRate int, format string) (f io.ReadCloser, err error) {
-	return ioutil.NopCloser(strings.NewReader("fake data")), nil
+func (ff *fakeFFmpeg) Start(ctx context.Context, path string, maxBitRate int, format string) (f io.ReadCloser, err error) {
+	ff.r = strings.NewReader(ff.Data)
+	return ff, nil
+}
+
+func (ff *fakeFFmpeg) Read(p []byte) (n int, err error) {
+	return ff.r.Read(p)
+}
+
+func (ff *fakeFFmpeg) Close() error {
+	ff.closed = true
+	return nil
 }

engine/transcoder/ffmpeg.go

@@ -1,4 +1,4 @@
-package ffmpeg
+package transcoder
 
 import (
 	"context"
@@ -12,30 +12,30 @@ import (
 	"github.com/deluan/navidrome/log"
 )
 
-type FFmpeg interface {
-	StartTranscoding(ctx context.Context, path string, maxBitRate int, format string) (f io.ReadCloser, err error)
+type Transcoder interface {
+	Start(ctx context.Context, path string, maxBitRate int, format string) (f io.ReadCloser, err error)
 }
 
-func New() FFmpeg {
+func New() Transcoder {
 	return &ffmpeg{}
 }
 
 type ffmpeg struct{}
 
-func (ff *ffmpeg) StartTranscoding(ctx context.Context, path string, maxBitRate int, format string) (f io.ReadCloser, err error) {
-	cmdLine, args := createTranscodeCommand(path, maxBitRate, format)
+func (ff *ffmpeg) Start(ctx context.Context, path string, maxBitRate int, format string) (f io.ReadCloser, err error) {
+	arg0, args := createTranscodeCommand(path, maxBitRate, format)
 
-	log.Trace(ctx, "Executing ffmpeg command", "arg0", cmdLine, "args", args)
-	cmd := exec.Command(cmdLine, args...)
+	log.Trace(ctx, "Executing ffmpeg command", "cmd", arg0, "args", args)
+	cmd := exec.Command(arg0, args...)
 	cmd.Stderr = os.Stderr
 	if f, err = cmd.StdoutPipe(); err != nil {
-		return f, err
+		return
 	}
 	if err = cmd.Start(); err != nil {
-		return f, err
+		return
 	}
 	go cmd.Wait() // prevent zombies
-	return f, err
+	return
 }
 
 func createTranscodeCommand(path string, maxBitRate int, format string) (string, []string) {

engine/transcoder/ffmpeg_test.go

@@ -1,4 +1,4 @@
-package ffmpeg
+package transcoder
 
 import (
 	"testing"
@@ -10,11 +10,11 @@ import (
 	. "github.com/onsi/gomega"
 )
 
-func TestFFmpeg(t *testing.T) {
+func TestTranscoder(t *testing.T) {
 	tests.Init(t, false)
 	log.SetLevel(log.LevelCritical)
 	RegisterFailHandler(Fail)
-	RunSpecs(t, "FFmpeg Suite")
+	RunSpecs(t, "Transcoder Suite")
 }
 
 var _ = Describe("createTranscodeCommand", func() {

engine/wire_providers.go

@@ -1,7 +1,7 @@
 package engine
 
 import (
-	"github.com/deluan/navidrome/engine/ffmpeg"
+	"github.com/deluan/navidrome/engine/transcoder"
 	"github.com/google/wire"
 )
 
@@ -16,6 +16,6 @@ var Set = wire.NewSet(
 	NewNowPlayingRepository,
 	NewUsers,
 	NewMediaStreamer,
-	ffmpeg.New,
+	transcoder.New,
 	NewTranscodingCache,
 )

go.mod

@@ -1,6 +1,6 @@
 module github.com/deluan/navidrome
 
-go 1.13
+go 1.14
 
 require (
 	github.com/BurntSushi/toml v0.3.1 // indirect
@@ -10,6 +10,7 @@ require (
 	github.com/deluan/rest v0.0.0-20200114062534-0653ffe9eab4
 	github.com/dgrijalva/jwt-go v3.2.0+incompatible
 	github.com/dhowden/tag v0.0.0-20191122115059-7e5c04feccd8
+	github.com/djherbis/fscache v0.10.0
 	github.com/fatih/camelcase v0.0.0-20160318181535-f6a740d52f96 // indirect
 	github.com/fatih/structs v1.0.0 // indirect
 	github.com/go-chi/chi v4.0.3+incompatible
@@ -39,7 +40,6 @@ require (
 	golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 // indirect
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 	gopkg.in/djherbis/atime.v1 v1.0.0 // indirect
-	gopkg.in/djherbis/fscache.v0 v0.9.0
 	gopkg.in/djherbis/stream.v1 v1.2.0 // indirect
 	gopkg.in/yaml.v2 v2.2.8 // indirect
 )

go.sum

@@ -28,6 +28,8 @@ github.com/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumC
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dhowden/tag v0.0.0-20191122115059-7e5c04feccd8 h1:nmFnmD8VZXkjDHIb1Gnfz50cgzUvGN72zLjPRXBW/hU=
 github.com/dhowden/tag v0.0.0-20191122115059-7e5c04feccd8/go.mod h1:SniNVYuaD1jmdEEvi+7ywb1QFR7agjeTdGKyFb0p7Rw=
+github.com/djherbis/fscache v0.10.0 h1:+O3s3LwKL1Jfz7txRHpgKOz8/krh9w+NzfzxtFdbsQg=
+github.com/djherbis/fscache v0.10.0/go.mod h1:yyPYtkNnnPXsW+81lAcQS6yab3G2CRfnPLotBvtbf0c=
 github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712 h1:aaQcKT9WumO6JEJcRyTqFVq4XUZiUcKR2/GI31TOcz8=
 github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
 github.com/elazarl/go-bindata-assetfs v1.0.0/go.mod h1:v+YaWX3bdea5J/mo8dSETolEo7R71Vk1u8bnjau5yw4=
@@ -174,8 +176,6 @@ gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/djherbis/atime.v1 v1.0.0 h1:eMRqB/JrLKocla2PBPKgQYg/p5UG4L6AUAs92aP7F60=
 gopkg.in/djherbis/atime.v1 v1.0.0/go.mod h1:hQIUStKmJfvf7xdh/wtK84qe+DsTV5LnA9lzxxtPpJ8=
-gopkg.in/djherbis/fscache.v0 v0.9.0 h1:CBmOlHQKg99q0xATpQpSNAR970UN4vECB5SjzkuyLe0=
-gopkg.in/djherbis/fscache.v0 v0.9.0/go.mod h1:izqJMuO+STCEMBEGFiwW5zPlamuiUOxMRpNzHT5cQHc=
 gopkg.in/djherbis/stream.v1 v1.2.0 h1:3tZuXO+RK8opjw8/BJr780h+eAPwOFfLHCKRKyYxk3s=
 gopkg.in/djherbis/stream.v1 v1.2.0/go.mod h1:aEV8CBVRmSpLamVJfM903Npic1IKmb2qS30VAZ+sssg=
 gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=

model/user.go

@@ -22,6 +22,7 @@ type UserRepository interface {
 	CountAll(...QueryOptions) (int64, error)
 	Get(id string) (*User, error)
 	Put(*User) error
+	// FindByUsername must be case-insensitive
 	FindByUsername(username string) (*User, error)
 	UpdateLastLoginAt(id string) error
 	UpdateLastAccessAt(id string) error

persistence/album_repository.go

@@ -9,7 +9,6 @@ import (
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
 	"github.com/deluan/rest"
-	"github.com/dhowden/tag/mbz"
 )
 
 type albumRepository struct {
@@ -37,11 +36,11 @@ func (r *albumRepository) Put(a *model.Album) error {
 	if err != nil {
 		return err
 	}
-	return r.index(a.ID, a.Name, a.Artist, mbz.AlbumArtist)
+	return r.index(a.ID, a.Name, a.Artist, a.AlbumArtist)
 }
 
 func (r *albumRepository) selectAlbum(options ...model.QueryOptions) SelectBuilder {
-	return r.newSelectWithAnnotation("id", options...).Columns("*")
+	return r.newSelectWithAnnotation("album.id", options...).Columns("*")
 }
 
 func (r *albumRepository) Get(id string) (*model.Album, error) {
@@ -71,12 +70,7 @@ func (r *albumRepository) GetAll(options ...model.QueryOptions) (model.Albums, e
 // TODO Keep order when paginating
 func (r *albumRepository) GetRandom(options ...model.QueryOptions) (model.Albums, error) {
 	sq := r.selectAlbum(options...)
-	switch r.ormer.Driver().Type() {
-	case orm.DRMySQL:
-		sq = sq.OrderBy("RAND()")
-	default:
-		sq = sq.OrderBy("RANDOM()")
-	}
+	sq = sq.OrderBy("RANDOM()")
 	results := model.Albums{}
 	err := r.queryAll(sq, &results)
 	return results, err

persistence/artist_repository.go

@@ -29,7 +29,7 @@ func NewArtistRepository(ctx context.Context, o orm.Ormer) model.ArtistRepositor
 }
 
 func (r *artistRepository) selectArtist(options ...model.QueryOptions) SelectBuilder {
-	return r.newSelectWithAnnotation("id", options...).Columns("*")
+	return r.newSelectWithAnnotation("artist.id", options...).Columns("*")
 }
 
 func (r *artistRepository) CountAll(options ...model.QueryOptions) (int64, error) {

persistence/mediafile_repository.go

@@ -100,12 +100,7 @@ func (r mediaFileRepository) GetStarred(options ...model.QueryOptions) (model.Me
 // TODO Keep order when paginating
 func (r mediaFileRepository) GetRandom(options ...model.QueryOptions) (model.MediaFiles, error) {
 	sq := r.selectMediaFile(options...)
-	switch r.ormer.Driver().Type() {
-	case orm.DRMySQL:
-		sq = sq.OrderBy("RAND()")
-	default:
-		sq = sq.OrderBy("RANDOM()")
-	}
+	sq = sq.OrderBy("RANDOM()")
 	results := model.MediaFiles{}
 	err := r.queryAll(sq, &results)
 	return results, err

persistence/persistence.go

@@ -20,65 +20,62 @@ type SQLStore struct {
 }
 
 func New() model.DataStore {
-	once.Do(func() {
-		err := orm.RegisterDataBase("default", db.Driver, db.Path)
-		if err != nil {
-			panic(err)
-		}
-	})
 	return &SQLStore{}
 }
 
-func (db *SQLStore) Album(ctx context.Context) model.AlbumRepository {
-	return NewAlbumRepository(ctx, db.getOrmer())
+func (s *SQLStore) Album(ctx context.Context) model.AlbumRepository {
+	return NewAlbumRepository(ctx, s.getOrmer())
 }
 
-func (db *SQLStore) Artist(ctx context.Context) model.ArtistRepository {
-	return NewArtistRepository(ctx, db.getOrmer())
+func (s *SQLStore) Artist(ctx context.Context) model.ArtistRepository {
+	return NewArtistRepository(ctx, s.getOrmer())
 }
 
-func (db *SQLStore) MediaFile(ctx context.Context) model.MediaFileRepository {
-	return NewMediaFileRepository(ctx, db.getOrmer())
+func (s *SQLStore) MediaFile(ctx context.Context) model.MediaFileRepository {
+	return NewMediaFileRepository(ctx, s.getOrmer())
 }
 
-func (db *SQLStore) MediaFolder(ctx context.Context) model.MediaFolderRepository {
-	return NewMediaFolderRepository(ctx, db.getOrmer())
+func (s *SQLStore) MediaFolder(ctx context.Context) model.MediaFolderRepository {
+	return NewMediaFolderRepository(ctx, s.getOrmer())
 }
 
-func (db *SQLStore) Genre(ctx context.Context) model.GenreRepository {
-	return NewGenreRepository(ctx, db.getOrmer())
+func (s *SQLStore) Genre(ctx context.Context) model.GenreRepository {
+	return NewGenreRepository(ctx, s.getOrmer())
 }
 
-func (db *SQLStore) Playlist(ctx context.Context) model.PlaylistRepository {
-	return NewPlaylistRepository(ctx, db.getOrmer())
+func (s *SQLStore) Playlist(ctx context.Context) model.PlaylistRepository {
+	return NewPlaylistRepository(ctx, s.getOrmer())
 }
 
-func (db *SQLStore) Property(ctx context.Context) model.PropertyRepository {
-	return NewPropertyRepository(ctx, db.getOrmer())
+func (s *SQLStore) Property(ctx context.Context) model.PropertyRepository {
+	return NewPropertyRepository(ctx, s.getOrmer())
 }
 
-func (db *SQLStore) User(ctx context.Context) model.UserRepository {
-	return NewUserRepository(ctx, db.getOrmer())
+func (s *SQLStore) User(ctx context.Context) model.UserRepository {
+	return NewUserRepository(ctx, s.getOrmer())
 }
 
-func (db *SQLStore) Resource(ctx context.Context, m interface{}) model.ResourceRepository {
+func (s *SQLStore) Resource(ctx context.Context, m interface{}) model.ResourceRepository {
 	switch m.(type) {
 	case model.User:
-		return db.User(ctx).(model.ResourceRepository)
+		return s.User(ctx).(model.ResourceRepository)
 	case model.Artist:
-		return db.Artist(ctx).(model.ResourceRepository)
+		return s.Artist(ctx).(model.ResourceRepository)
 	case model.Album:
-		return db.Album(ctx).(model.ResourceRepository)
+		return s.Album(ctx).(model.ResourceRepository)
 	case model.MediaFile:
-		return db.MediaFile(ctx).(model.ResourceRepository)
+		return s.MediaFile(ctx).(model.ResourceRepository)
 	}
 	log.Error("Resource no implemented", "model", reflect.TypeOf(m).Name())
 	return nil
 }
 
-func (db *SQLStore) WithTx(block func(tx model.DataStore) error) error {
-	o := orm.NewOrm()
-	err := o.Begin()
+func (s *SQLStore) WithTx(block func(tx model.DataStore) error) error {
+	o, err := orm.NewOrmWithDB(db.Driver, "default", db.Db())
+	if err != nil {
+		return err
+	}
+	err = o.Begin()
 	if err != nil {
 		return err
 	}
@@ -101,41 +98,45 @@ func (db *SQLStore) WithTx(block func(tx model.DataStore) error) error {
 	return nil
 }
 
-func (db *SQLStore) GC(ctx context.Context) error {
-	err := db.Album(ctx).PurgeEmpty()
+func (s *SQLStore) GC(ctx context.Context) error {
+	err := s.Album(ctx).PurgeEmpty()
 	if err != nil {
 		return err
 	}
-	err = db.Artist(ctx).PurgeEmpty()
+	err = s.Artist(ctx).PurgeEmpty()
 	if err != nil {
 		return err
 	}
-	err = db.MediaFile(ctx).(*mediaFileRepository).cleanSearchIndex()
+	err = s.MediaFile(ctx).(*mediaFileRepository).cleanSearchIndex()
 	if err != nil {
 		return err
 	}
-	err = db.Album(ctx).(*albumRepository).cleanSearchIndex()
+	err = s.Album(ctx).(*albumRepository).cleanSearchIndex()
 	if err != nil {
 		return err
 	}
-	err = db.Artist(ctx).(*artistRepository).cleanSearchIndex()
+	err = s.Artist(ctx).(*artistRepository).cleanSearchIndex()
 	if err != nil {
 		return err
 	}
-	err = db.MediaFile(ctx).(*mediaFileRepository).cleanAnnotations()
+	err = s.MediaFile(ctx).(*mediaFileRepository).cleanAnnotations()
 	if err != nil {
 		return err
 	}
-	err = db.Album(ctx).(*albumRepository).cleanAnnotations()
+	err = s.Album(ctx).(*albumRepository).cleanAnnotations()
 	if err != nil {
 		return err
 	}
-	return db.Artist(ctx).(*artistRepository).cleanAnnotations()
+	return s.Artist(ctx).(*artistRepository).cleanAnnotations()
 }
 
-func (db *SQLStore) getOrmer() orm.Ormer {
-	if db.orm == nil {
-		return orm.NewOrm()
+func (s *SQLStore) getOrmer() orm.Ormer {
+	if s.orm == nil {
+		o, err := orm.NewOrmWithDB(db.Driver, "default", db.Db())
+		if err != nil {
+			log.Error("Error obtaining new orm instance", err)
+		}
+		return o
 	}
-	return db.orm
+	return s.orm
 }

persistence/persistence_suite_test.go

@@ -21,8 +21,8 @@ func TestPersistence(t *testing.T) {
 
 	//os.Remove("./test-123.db")
 	//conf.Server.Path = "./test-123.db"
-	conf.Server.DbPath = ":memory:"
-	db.Init()
+	conf.Server.DbPath = "file::memory:?cache=shared"
+	orm.RegisterDataBase("default", db.Driver, conf.Server.DbPath)
 	New()
 	db.EnsureLatestVersion()
 	log.SetLevel(log.LevelCritical)

persistence/sql_base_repository.go

@@ -99,8 +99,11 @@ func (r sqlRepository) executeSQL(sq Sqlizer) (int64, error) {
 		return 0, err
 	}
 	start := time.Now()
+	var c int64
 	res, err := r.ormer.Raw(query, args...).Exec()
-	c, _ := res.RowsAffected()
+	if res != nil {
+		c, _ = res.RowsAffected()
+	}
 	r.logSQL(query, args, err, c, start)
 	if err != nil {
 		if err.Error() != "LastInsertId is not supported by this driver" {
@@ -157,6 +160,8 @@ func (r sqlRepository) count(countQuery SelectBuilder, options ...model.QueryOpt
 
 func (r sqlRepository) put(id string, m interface{}) (newId string, err error) {
 	values, _ := toSqlArgs(m)
+	createdAt := values["created_at"]
+	delete(values, "created_at")
 	if id != "" {
 		update := Update(r.tableName).Where(Eq{"id": id}).SetMap(values)
 		count, err := r.executeSQL(update)
@@ -173,6 +178,9 @@ func (r sqlRepository) put(id string, m interface{}) (newId string, err error) {
 		id = rand.String()
 		values["id"] = id
 	}
+	if createdAt != nil {
+		values["created_at"] = createdAt
+	}
 	insert := Insert(r.tableName).SetMap(values)
 	_, err = r.executeSQL(insert)
 	return id, err
@@ -188,7 +196,7 @@ func (r sqlRepository) delete(cond Sqlizer) error {
 }
 
 func (r sqlRepository) logSQL(sql string, args []interface{}, err error, rowsAffected int64, start time.Time) {
-	lapsed := time.Since(start)
+	elapsed := time.Since(start)
 	var fmtArgs []string
 	for i := range args {
 		var f string
@@ -201,9 +209,9 @@ func (r sqlRepository) logSQL(sql string, args []interface{}, err error, rowsAff
 		fmtArgs = append(fmtArgs, f)
 	}
 	if err != nil {
-		log.Error(r.ctx, "SQL: `"+sql+"`", "args", `[`+strings.Join(fmtArgs, ",")+`]`, "rowsAffected", rowsAffected, "lapsedTime", lapsed, err)
+		log.Error(r.ctx, "SQL: `"+sql+"`", "args", `[`+strings.Join(fmtArgs, ",")+`]`, "rowsAffected", rowsAffected, "elapsedTime", elapsed, err)
 	} else {
-		log.Trace(r.ctx, "SQL: `"+sql+"`", "args", `[`+strings.Join(fmtArgs, ",")+`]`, "rowsAffected", rowsAffected, "lapsedTime", lapsed)
+		log.Trace(r.ctx, "SQL: `"+sql+"`", "args", `[`+strings.Join(fmtArgs, ",")+`]`, "rowsAffected", rowsAffected, "elapsedTime", elapsed)
 	}
 }
 

persistence/sql_search.go

@@ -39,7 +39,7 @@ func (r sqlRepository) doSearch(q string, offset, size int, results interface{},
 	if len(q) < 2 {
 		return nil
 	}
-	sq := Select("*").From(r.tableName)
+	sq := r.newSelectWithAnnotation(r.tableName + ".id").Columns("*")
 	sq = sq.Limit(uint64(size)).Offset(uint64(offset))
 	if len(orderBys) > 0 {
 		sq = sq.OrderBy(orderBys...)

persistence/user_repository.go

@@ -65,6 +65,7 @@ func (r *userRepository) Put(u *model.User) error {
 }
 
 func (r *userRepository) FindByUsername(username string) (*model.User, error) {
+	username = strings.ToLower(username)
 	sel := r.newSelect().Columns("*").Where(Eq{"user_name": username})
 	var usr model.User
 	err := r.queryOne(sel, &usr)

persistence/user_repository_test.go

@@ -0,0 +1,41 @@
+package persistence
+
+import (
+	"github.com/astaxie/beego/orm"
+	"github.com/deluan/navidrome/log"
+	"github.com/deluan/navidrome/model"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("UserRepository", func() {
+	var repo model.UserRepository
+
+	BeforeEach(func() {
+		repo = NewUserRepository(log.NewContext(nil), orm.NewOrm())
+	})
+
+	Describe("Put/Get/FindByUsername", func() {
+		usr := model.User{
+			ID:       "123",
+			UserName: "AdMiN",
+			Name:     "Admin",
+			Email:    "admin@admin.com",
+			Password: "wordpass",
+			IsAdmin:  true,
+		}
+		It("saves the user to the DB", func() {
+			Expect(repo.Put(&usr)).To(BeNil())
+		})
+		It("returns the newly created user", func() {
+			actual, err := repo.Get("123")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(actual.Name).To(Equal("Admin"))
+		})
+		It("find the user by case-insensitive username", func() {
+			actual, err := repo.FindByUsername("aDmIn")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(actual.Name).To(Equal("Admin"))
+		})
+	})
+})

server/middlewares.go

@@ -26,7 +26,7 @@ func RequestLogger(next http.Handler) http.Handler {
 			r.Context(),
 			message,
 			"remoteAddr", r.RemoteAddr,
-			"lapsedTime", time.Since(start),
+			"elapsedTime", time.Since(start),
 			"httpStatus", ww.Status(),
 			"responseSize", ww.BytesWritten(),
 		}

server/subsonic/api.go

@@ -68,13 +68,12 @@ func (api *Router) routes() http.Handler {
 		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)
-		H(reqParams, "getArtistInfo", c.GetArtistInfo)
-		H(reqParams, "getArtistInfo2", c.GetArtistInfo2)
+		H(r, "getMusicDirectory", c.GetMusicDirectory)
+		H(r, "getArtist", c.GetArtist)
+		H(r, "getAlbum", c.GetAlbum)
+		H(r, "getSong", c.GetSong)
+		H(r, "getArtistInfo", c.GetArtistInfo)
+		H(r, "getArtistInfo2", c.GetArtistInfo2)
 	})
 	r.Group(func(r chi.Router) {
 		c := initAlbumListController(api)

server/subsonic/helpers.go

@@ -133,6 +133,7 @@ func ToChild(entry engine.Entry) responses.Child {
 	child.AlbumId = entry.AlbumId
 	child.ArtistId = entry.ArtistId
 	child.Type = entry.Type
+	child.IsVideo = false
 	child.UserRating = entry.UserRating
 	child.SongCount = entry.SongCount
 	// TODO Must be dynamic, based on player/transcoding config

server/subsonic/middlewares.go

@@ -89,18 +89,3 @@ func authenticate(users engine.Users) func(next http.Handler) http.Handler {
 		})
 	}
 }
-
-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)
-		})
-	}
-}

server/subsonic/responses/.snapshots/responses-snapshotMatcher-Match-Responses AlbumList with data should match .JSON

@@ -1 +1 @@
-{"status":"ok","version":"1.8.0","type":"navidrome","serverVersion":"v0.0.0","albumList":{"album":[{"id":"1","isDir":false,"title":"title"}]}}
+{"status":"ok","version":"1.8.0","type":"navidrome","serverVersion":"v0.0.0","albumList":{"album":[{"id":"1","isDir":false,"title":"title","isVideo":false}]}}

server/subsonic/responses/.snapshots/responses-snapshotMatcher-Match-Responses AlbumList with data should match .XML

@@ -1 +1 @@
-<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0" type="navidrome" serverVersion="v0.0.0"><albumList><album id="1" isDir="false" title="title"></album></albumList></subsonic-response>
+<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0" type="navidrome" serverVersion="v0.0.0"><albumList><album id="1" isDir="false" title="title" isVideo="false"></album></albumList></subsonic-response>

server/subsonic/responses/.snapshots/responses-snapshotMatcher-Match-Responses Child with data should match .JSON

@@ -1 +1 @@
-{"status":"ok","version":"1.8.0","type":"navidrome","serverVersion":"v0.0.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"}}
+{"status":"ok","version":"1.8.0","type":"navidrome","serverVersion":"v0.0.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,"isVideo":false}],"id":"1","name":"N"}}

server/subsonic/responses/.snapshots/responses-snapshotMatcher-Match-Responses Child with data should match .XML

@@ -1 +1 @@
-<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0" type="navidrome" serverVersion="v0.0.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>
+<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0" type="navidrome" serverVersion="v0.0.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" isVideo="false"></child></directory></subsonic-response>

server/subsonic/responses/.snapshots/responses-snapshotMatcher-Match-Responses Directory with data should match .JSON

@@ -1 +1 @@
-{"status":"ok","version":"1.8.0","type":"navidrome","serverVersion":"v0.0.0","directory":{"child":[{"id":"1","isDir":false,"title":"title"}],"id":"1","name":"N"}}
+{"status":"ok","version":"1.8.0","type":"navidrome","serverVersion":"v0.0.0","directory":{"child":[{"id":"1","isDir":false,"title":"title","isVideo":false}],"id":"1","name":"N"}}

server/subsonic/responses/.snapshots/responses-snapshotMatcher-Match-Responses Directory with data should match .XML

@@ -1 +1 @@
-<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0" type="navidrome" serverVersion="v0.0.0"><directory id="1" name="N"><child id="1" isDir="false" title="title"></child></directory></subsonic-response>
+<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.8.0" type="navidrome" serverVersion="v0.0.0"><directory id="1" name="N"><child id="1" isDir="false" title="title" isVideo="false"></child></directory></subsonic-response>

server/subsonic/responses/responses.go

@@ -112,8 +112,8 @@ type Child struct {
 	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"`
+	IsVideo               bool       `xml:"isVideo,attr"                            json:"isVideo"`
 	/*
-	   <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 -->

server/subsonic/stream.go

@@ -1,9 +1,12 @@
 package subsonic
 
 import (
+	"io"
 	"net/http"
+	"strconv"
 
 	"github.com/deluan/navidrome/engine"
+	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/server/subsonic/responses"
 	"github.com/deluan/navidrome/utils"
 )
@@ -24,15 +27,32 @@ func (c *StreamController) Stream(w http.ResponseWriter, r *http.Request) (*resp
 	maxBitRate := utils.ParamInt(r, "maxBitRate", 0)
 	format := utils.ParamString(r, "format")
 
-	fs, err := c.streamer.NewFileSystem(r.Context(), maxBitRate, format)
+	stream, err := c.streamer.NewStream(r.Context(), id, maxBitRate, format)
 	if err != nil {
 		return nil, err
 	}
+	defer func() {
+		if err := stream.Close(); err != nil {
+			log.Error("Error closing stream", "id", id, "file", stream.Name(), err)
+		}
+	}()
 
-	// To be able to use a http.FileSystem, we need to change the URL structure
-	r.URL.Path = id
+	w.Header().Set("X-Content-Type-Options", "nosniff")
+	w.Header().Set("X-Content-Duration", strconv.FormatFloat(float64(stream.Duration()), 'G', -1, 32))
+
+	if stream.Seekable() {
+		http.ServeContent(w, r, stream.Name(), stream.ModTime(), stream)
+	} else {
+		// If the stream doesn't provide a size (i.e. is not seekable), we can't support ranges/content-length
+		w.Header().Set("Accept-Ranges", "none")
+		w.Header().Set("Content-Type", stream.ContentType())
+		if c, err := io.Copy(w, stream); err != nil {
+			log.Error(r.Context(), "Error sending transcoded file", "id", id, err)
+		} else {
+			log.Trace(r.Context(), "Success sending transcode file", "id", id, "size", c)
+		}
+	}
 
-	http.FileServer(fs).ServeHTTP(w, r)
 	return nil, nil
 }
 
@@ -42,14 +62,11 @@ func (c *StreamController) Download(w http.ResponseWriter, r *http.Request) (*re
 		return nil, err
 	}
 
-	fs, err := c.streamer.NewFileSystem(r.Context(), 0, "raw")
+	stream, err := c.streamer.NewStream(r.Context(), id, 0, "raw")
 	if err != nil {
 		return nil, err
 	}
 
-	// To be able to use a http.FileSystem, we need to change the URL structure
-	r.URL.Path = id
-
-	http.FileServer(fs).ServeHTTP(w, r)
+	http.ServeContent(w, r, stream.Name(), stream.ModTime(), stream)
 	return nil, nil
 }

tests/navidrome-test.toml

@@ -1,6 +1,6 @@
 DevDisableAuthentication = false
 User = "deluan"
 Password = "wordpass"
-DbPath = ":memory:"
+DbPath = "file::memory:?cache=shared"
 MusicFolder = "./tests/itunes-library.xml"
 DownsampleCommand = "ffmpeg -i %s -b:a %bk mp3 -"

ui/package.json

@@ -3,20 +3,20 @@
   "version": "0.1.0",
   "private": true,
   "dependencies": {
-    "@testing-library/jest-dom": "^5.0.2",
-    "@testing-library/react": "^9.3.2",
-    "@testing-library/user-event": "^8.0.4",
+    "@testing-library/jest-dom": "^5.1.1",
+    "@testing-library/react": "^9.5.0",
+    "@testing-library/user-event": "^10.0.0",
     "deepmerge": "^4.2.2",
     "jwt-decode": "^2.2.0",
     "md5-hex": "^3.0.1",
     "prop-types": "^15.7.2",
-    "ra-data-json-server": "^3.1.2",
-    "react": "^16.12.0",
-    "react-admin": "^3.1.2",
-    "react-dom": "^16.12.0",
-    "react-jinke-music-player": "^4.7.2",
-    "react-redux": "^7.1.0",
-    "react-scripts": "3.3.0"
+    "ra-data-json-server": "^3.2.3",
+    "react": "^16.13.0",
+    "react-admin": "^3.2.3",
+    "react-dom": "^16.13.0",
+    "react-jinke-music-player": "^4.10.1",
+    "react-redux": "^7.2.0",
+    "react-scripts": "^3.4.0"
   },
   "scripts": {
     "start": "react-scripts start",

ui/src/album/AlbumActions.js

@@ -21,6 +21,13 @@ export const AlbumActions = ({
   const dispatch = useDispatch()
   const translate = useTranslate()
 
+  // TODO Not sure why data is accumulating tracks from previous plays... Needs investigation. For now, filter out
+  // the unwanted tracks
+  const filteredData = ids.reduce((acc, id) => {
+    acc[id] = data[id]
+    return acc
+  }, {})
+
   const shuffle = (data) => {
     const ids = Object.keys(data)
     for (let i = ids.length - 1; i > 0; i--) {
@@ -37,7 +44,7 @@ export const AlbumActions = ({
       <Button
         color={'secondary'}
         onClick={() => {
-          dispatch(playAlbum(ids[0], data))
+          dispatch(playAlbum(ids[0], filteredData))
         }}
         label={translate('resources.album.actions.playAll')}
       >
@@ -46,7 +53,7 @@ export const AlbumActions = ({
       <Button
         color={'secondary'}
         onClick={() => {
-          const shuffled = shuffle(data)
+          const shuffled = shuffle(filteredData)
           const firstId = Object.keys(shuffled)[0]
           dispatch(playAlbum(firstId, shuffled))
         }}

ui/src/layout/Themes.js

@@ -2,6 +2,9 @@ import blue from '@material-ui/core/colors/blue'
 
 export const DarkTheme = {
   palette: {
+    primary: {
+      main: '#90caf9'
+    },
     secondary: blue,
     type: 'dark'
   }

ui/src/player/Player.js

@@ -20,6 +20,7 @@ const Player = () => {
     preload: true,
     autoPlayInitLoadPlayList: true,
     clearPriorAudioLists: false,
+    showDestroy: false,
     showDownload: false,
     showReload: false,
     glassBg: false,

ui/src/player/queue.js

@@ -8,6 +8,7 @@ const PLAYER_SCROBBLE = 'PLAYER_SCROBBLE'
 const PLAYER_PLAY_ALBUM = 'PLAYER_PLAY_ALBUM'
 
 const mapToAudioLists = (item) => ({
+  id: item.id,
   name: item.title,
   singer: item.artist,
   cover: subsonicUrl('getCoverArt', item.id, { size: 300 }),

wire_gen.go

@@ -7,7 +7,7 @@ package main
 
 import (
 	"github.com/deluan/navidrome/engine"
-	"github.com/deluan/navidrome/engine/ffmpeg"
+	"github.com/deluan/navidrome/engine/transcoder"
 	"github.com/deluan/navidrome/persistence"
 	"github.com/deluan/navidrome/scanner"
 	"github.com/deluan/navidrome/server"
@@ -42,12 +42,12 @@ func CreateSubsonicAPIRouter() (*subsonic.Router, error) {
 	ratings := engine.NewRatings(dataStore)
 	scrobbler := engine.NewScrobbler(dataStore, nowPlayingRepository)
 	search := engine.NewSearch(dataStore)
-	fFmpeg := ffmpeg.New()
+	transcoderTranscoder := transcoder.New()
 	cache, err := engine.NewTranscodingCache()
 	if err != nil {
 		return nil, err
 	}
-	mediaStreamer := engine.NewMediaStreamer(dataStore, fFmpeg, cache)
+	mediaStreamer := engine.NewMediaStreamer(dataStore, transcoderTranscoder, cache)
 	router := subsonic.New(browser, cover, listGenerator, users, playlists, ratings, scrobbler, search, mediaStreamer)
 	return router, nil
 }