diff --git a/.github/workflows/pipeline.yml b/.github/workflows/pipeline.yml
index 232171c6d..0767346fa 100644
--- a/.github/workflows/pipeline.yml
+++ b/.github/workflows/pipeline.yml
@@ -217,7 +217,7 @@ jobs:
CROSS_TAGLIB_VERSION=${{ env.CROSS_TAGLIB_VERSION }}
- name: Upload Binaries
- uses: actions/upload-artifact@v4
+ uses: actions/upload-artifact@v5
with:
name: navidrome-${{ env.PLATFORM }}
path: ./output
@@ -248,7 +248,7 @@ jobs:
touch "/tmp/digests/${digest#sha256:}"
- name: Upload digest
- uses: actions/upload-artifact@v4
+ uses: actions/upload-artifact@v5
if: env.IS_LINUX == 'true' && env.IS_DOCKER_PUSH_CONFIGURED == 'true' && env.IS_ARMV5 == 'false'
with:
name: digests-${{ env.PLATFORM }}
@@ -267,7 +267,7 @@ jobs:
- uses: actions/checkout@v5
- name: Download digests
- uses: actions/download-artifact@v5
+ uses: actions/download-artifact@v6
with:
path: /tmp/digests
pattern: digests-*
@@ -320,7 +320,7 @@ jobs:
steps:
- uses: actions/checkout@v5
- - uses: actions/download-artifact@v5
+ - uses: actions/download-artifact@v6
with:
path: ./binaries
pattern: navidrome-windows*
@@ -339,7 +339,7 @@ jobs:
du -h binaries/msi/*.msi
- name: Upload MSI files
- uses: actions/upload-artifact@v4
+ uses: actions/upload-artifact@v5
with:
name: navidrome-windows-installers
path: binaries/msi/*.msi
@@ -357,7 +357,7 @@ jobs:
fetch-depth: 0
fetch-tags: true
- - uses: actions/download-artifact@v5
+ - uses: actions/download-artifact@v6
with:
path: ./binaries
pattern: navidrome-*
@@ -383,7 +383,7 @@ jobs:
rm ./dist/*.tar.gz ./dist/*.zip
- name: Upload all-packages artifact
- uses: actions/upload-artifact@v4
+ uses: actions/upload-artifact@v5
with:
name: packages
path: dist/navidrome_0*
@@ -406,13 +406,13 @@ jobs:
item: ${{ fromJson(needs.release.outputs.package_list) }}
steps:
- name: Download all-packages artifact
- uses: actions/download-artifact@v5
+ uses: actions/download-artifact@v6
with:
name: packages
path: ./dist
- name: Upload all-packages artifact
- uses: actions/upload-artifact@v4
+ uses: actions/upload-artifact@v5
with:
name: navidrome_linux_${{ matrix.item }}
path: dist/navidrome_0*_linux_${{ matrix.item }}
diff --git a/Makefile b/Makefile
index df8155f56..1de789c11 100644
--- a/Makefile
+++ b/Makefile
@@ -16,7 +16,7 @@ DOCKER_TAG ?= deluan/navidrome:develop
# Taglib version to use in cross-compilation, from https://github.com/navidrome/cross-taglib
CROSS_TAGLIB_VERSION ?= 2.1.1-1
-GOLANGCI_LINT_VERSION ?= v2.5.0
+GOLANGCI_LINT_VERSION ?= v2.6.2
UI_SRC_FILES := $(shell find ui -type f -not -path "ui/build/*" -not -path "ui/node_modules/*")
@@ -54,7 +54,7 @@ testall: test-race test-i18n test-js ##@Development Run Go and JS tests
.PHONY: testall
test-race: ##@Development Run Go tests with race detector
- go test -tags netgo -race -shuffle=on ./...
+ go test -tags netgo -race -shuffle=on $(PKG)
.PHONY: test-race
test-js: ##@Development Run JS tests
diff --git a/cmd/scan.go b/cmd/scan.go
index d37ccd69f..41d281070 100644
--- a/cmd/scan.go
+++ b/cmd/scan.go
@@ -4,10 +4,12 @@ import (
"context"
"encoding/gob"
"os"
+ "strings"
"github.com/navidrome/navidrome/core"
"github.com/navidrome/navidrome/db"
"github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/persistence"
"github.com/navidrome/navidrome/scanner"
"github.com/navidrome/navidrome/utils/pl"
@@ -17,11 +19,13 @@ import (
var (
fullScan bool
subprocess bool
+ targets string
)
func init() {
scanCmd.Flags().BoolVarP(&fullScan, "full", "f", false, "check all subfolders, ignoring timestamps")
scanCmd.Flags().BoolVarP(&subprocess, "subprocess", "", false, "run as subprocess (internal use)")
+ scanCmd.Flags().StringVarP(&targets, "targets", "t", "", "comma-separated list of libraryID:folderPath pairs (e.g., \"1:Music/Rock,1:Music/Jazz,2:Classical\")")
rootCmd.AddCommand(scanCmd)
}
@@ -68,7 +72,18 @@ func runScanner(ctx context.Context) {
ds := persistence.New(sqlDB)
pls := core.NewPlaylists(ds)
- progress, err := scanner.CallScan(ctx, ds, pls, fullScan)
+ // Parse targets if provided
+ var scanTargets []model.ScanTarget
+ if targets != "" {
+ var err error
+ scanTargets, err = model.ParseTargets(strings.Split(targets, ","))
+ if err != nil {
+ log.Fatal(ctx, "Failed to parse targets", err)
+ }
+ log.Info(ctx, "Scanning specific folders", "numTargets", len(scanTargets))
+ }
+
+ progress, err := scanner.CallScan(ctx, ds, pls, fullScan, scanTargets)
if err != nil {
log.Fatal(ctx, "Failed to scan", err)
}
diff --git a/cmd/wire_gen.go b/cmd/wire_gen.go
index 187ab488d..d7b6a3ad2 100644
--- a/cmd/wire_gen.go
+++ b/cmd/wire_gen.go
@@ -69,10 +69,11 @@ func CreateNativeAPIRouter(ctx context.Context) *nativeapi.Router {
artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
broker := events.GetBroker()
- scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
- watcher := scanner.GetWatcher(dataStore, scannerScanner)
- library := core.NewLibrary(dataStore, scannerScanner, watcher, broker)
- router := nativeapi.New(dataStore, share, playlists, insights, library)
+ modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
+ watcher := scanner.GetWatcher(dataStore, modelScanner)
+ library := core.NewLibrary(dataStore, modelScanner, watcher, broker)
+ maintenance := core.NewMaintenance(dataStore)
+ router := nativeapi.New(dataStore, share, playlists, insights, library, maintenance)
return router
}
@@ -94,10 +95,10 @@ func CreateSubsonicAPIRouter(ctx context.Context) *subsonic.Router {
cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
broker := events.GetBroker()
playlists := core.NewPlaylists(dataStore)
- scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
+ modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
playTracker := scrobbler.GetPlayTracker(dataStore, broker, manager)
playbackServer := playback.GetInstance(dataStore)
- router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, provider, scannerScanner, broker, playlists, playTracker, share, playbackServer, metricsMetrics)
+ router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, provider, modelScanner, broker, playlists, playTracker, share, playbackServer, metricsMetrics)
return router
}
@@ -149,7 +150,7 @@ func CreatePrometheus() metrics.Metrics {
return metricsMetrics
}
-func CreateScanner(ctx context.Context) scanner.Scanner {
+func CreateScanner(ctx context.Context) model.Scanner {
sqlDB := db.Db()
dataStore := persistence.New(sqlDB)
fileCache := artwork.GetImageCache()
@@ -162,8 +163,8 @@ func CreateScanner(ctx context.Context) scanner.Scanner {
cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
broker := events.GetBroker()
playlists := core.NewPlaylists(dataStore)
- scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
- return scannerScanner
+ modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
+ return modelScanner
}
func CreateScanWatcher(ctx context.Context) scanner.Watcher {
@@ -179,8 +180,8 @@ func CreateScanWatcher(ctx context.Context) scanner.Watcher {
cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
broker := events.GetBroker()
playlists := core.NewPlaylists(dataStore)
- scannerScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
- watcher := scanner.GetWatcher(dataStore, scannerScanner)
+ modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
+ watcher := scanner.GetWatcher(dataStore, modelScanner)
return watcher
}
@@ -201,7 +202,7 @@ func getPluginManager() plugins.Manager {
// wire_injectors.go:
-var allProviders = wire.NewSet(core.Set, artwork.Set, server.New, subsonic.New, nativeapi.New, public.New, persistence.New, lastfm.NewRouter, listenbrainz.NewRouter, events.GetBroker, scanner.New, scanner.GetWatcher, plugins.GetManager, metrics.GetPrometheusInstance, db.Db, wire.Bind(new(agents.PluginLoader), new(plugins.Manager)), wire.Bind(new(scrobbler.PluginLoader), new(plugins.Manager)), wire.Bind(new(metrics.PluginLoader), new(plugins.Manager)), wire.Bind(new(core.Scanner), new(scanner.Scanner)), wire.Bind(new(core.Watcher), new(scanner.Watcher)))
+var allProviders = wire.NewSet(core.Set, artwork.Set, server.New, subsonic.New, nativeapi.New, public.New, persistence.New, lastfm.NewRouter, listenbrainz.NewRouter, events.GetBroker, scanner.New, scanner.GetWatcher, plugins.GetManager, metrics.GetPrometheusInstance, db.Db, wire.Bind(new(agents.PluginLoader), new(plugins.Manager)), wire.Bind(new(scrobbler.PluginLoader), new(plugins.Manager)), wire.Bind(new(metrics.PluginLoader), new(plugins.Manager)), wire.Bind(new(core.Watcher), new(scanner.Watcher)))
func GetPluginManager(ctx context.Context) plugins.Manager {
manager := getPluginManager()
diff --git a/cmd/wire_injectors.go b/cmd/wire_injectors.go
index e8759ac53..595d406b9 100644
--- a/cmd/wire_injectors.go
+++ b/cmd/wire_injectors.go
@@ -45,7 +45,6 @@ var allProviders = wire.NewSet(
wire.Bind(new(agents.PluginLoader), new(plugins.Manager)),
wire.Bind(new(scrobbler.PluginLoader), new(plugins.Manager)),
wire.Bind(new(metrics.PluginLoader), new(plugins.Manager)),
- wire.Bind(new(core.Scanner), new(scanner.Scanner)),
wire.Bind(new(core.Watcher), new(scanner.Watcher)),
)
@@ -103,7 +102,7 @@ func CreatePrometheus() metrics.Metrics {
))
}
-func CreateScanner(ctx context.Context) scanner.Scanner {
+func CreateScanner(ctx context.Context) model.Scanner {
panic(wire.Build(
allProviders,
))
diff --git a/conf/configuration.go b/conf/configuration.go
index 7292c7dfe..a9fee00e4 100644
--- a/conf/configuration.go
+++ b/conf/configuration.go
@@ -125,6 +125,7 @@ type configOptions struct {
DevAlbumInfoTimeToLive time.Duration
DevExternalScanner bool
DevScannerThreads uint
+ DevSelectiveWatcher bool
DevInsightsInitialDelay time.Duration
DevEnablePlayerInsights bool
DevEnablePluginsInsights bool
@@ -600,6 +601,7 @@ func setViperDefaults() {
viper.SetDefault("devalbuminfotimetolive", consts.AlbumInfoTimeToLive)
viper.SetDefault("devexternalscanner", true)
viper.SetDefault("devscannerthreads", 5)
+ viper.SetDefault("devselectivewatcher", true)
viper.SetDefault("devinsightsinitialdelay", consts.InsightsInitialDelay)
viper.SetDefault("devenableplayerinsights", true)
viper.SetDefault("devenablepluginsinsights", true)
diff --git a/core/agents/lastfm/agent.go b/core/agents/lastfm/agent.go
index d01b496ec..fafa6afec 100644
--- a/core/agents/lastfm/agent.go
+++ b/core/agents/lastfm/agent.go
@@ -38,6 +38,7 @@ type lastfmAgent struct {
secret string
lang string
client *client
+ httpClient httpDoer
getInfoMutex sync.Mutex
}
@@ -56,6 +57,7 @@ func lastFMConstructor(ds model.DataStore) *lastfmAgent {
Timeout: consts.DefaultHttpClientTimeOut,
}
chc := cache.NewHTTPClient(hc, consts.DefaultHttpClientTimeOut)
+ l.httpClient = chc
l.client = newClient(l.apiKey, l.secret, l.lang, chc)
return l
}
@@ -190,13 +192,13 @@ func (l *lastfmAgent) GetArtistTopSongs(ctx context.Context, id, artistName, mbi
return res, nil
}
-var artistOpenGraphQuery = cascadia.MustCompile(`html > head > meta[property="og:image"]`)
+var (
+ artistOpenGraphQuery = cascadia.MustCompile(`html > head > meta[property="og:image"]`)
+ artistIgnoredImage = "2a96cbd8b46e442fc41c2b86b821562f" // Last.fm artist placeholder image name
+)
func (l *lastfmAgent) GetArtistImages(ctx context.Context, _, name, mbid string) ([]agents.ExternalImage, error) {
log.Debug(ctx, "Getting artist images from Last.fm", "name", name)
- hc := http.Client{
- Timeout: consts.DefaultHttpClientTimeOut,
- }
a, err := l.callArtistGetInfo(ctx, name)
if err != nil {
return nil, fmt.Errorf("get artist info: %w", err)
@@ -205,7 +207,7 @@ func (l *lastfmAgent) GetArtistImages(ctx context.Context, _, name, mbid string)
if err != nil {
return nil, fmt.Errorf("create artist image request: %w", err)
}
- resp, err := hc.Do(req)
+ resp, err := l.httpClient.Do(req)
if err != nil {
return nil, fmt.Errorf("get artist url: %w", err)
}
@@ -222,11 +224,16 @@ func (l *lastfmAgent) GetArtistImages(ctx context.Context, _, name, mbid string)
return res, nil
}
for _, attr := range n.Attr {
- if attr.Key == "content" {
- res = []agents.ExternalImage{
- {URL: attr.Val},
- }
- break
+ if attr.Key != "content" {
+ continue
+ }
+ if strings.Contains(attr.Val, artistIgnoredImage) {
+ log.Debug(ctx, "Artist image is ignored default image", "name", name, "url", attr.Val)
+ return res, nil
+ }
+
+ res = []agents.ExternalImage{
+ {URL: attr.Val},
}
}
return res, nil
diff --git a/core/agents/lastfm/agent_test.go b/core/agents/lastfm/agent_test.go
index 4476d592f..18e7facf2 100644
--- a/core/agents/lastfm/agent_test.go
+++ b/core/agents/lastfm/agent_test.go
@@ -393,4 +393,73 @@ var _ = Describe("lastfmAgent", func() {
})
})
})
+
+ Describe("GetArtistImages", func() {
+ var agent *lastfmAgent
+ var apiClient *tests.FakeHttpClient
+ var httpClient *tests.FakeHttpClient
+
+ BeforeEach(func() {
+ apiClient = &tests.FakeHttpClient{}
+ httpClient = &tests.FakeHttpClient{}
+ client := newClient("API_KEY", "SECRET", "pt", apiClient)
+ agent = lastFMConstructor(ds)
+ agent.client = client
+ agent.httpClient = httpClient
+ })
+
+ It("returns the artist image from the page", func() {
+ fApi, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
+ apiClient.Res = http.Response{Body: fApi, StatusCode: 200}
+
+ fScraper, _ := os.Open("tests/fixtures/lastfm.artist.page.html")
+ httpClient.Res = http.Response{Body: fScraper, StatusCode: 200}
+
+ images, err := agent.GetArtistImages(ctx, "123", "U2", "")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(images).To(HaveLen(1))
+ Expect(images[0].URL).To(Equal("https://lastfm.freetls.fastly.net/i/u/ar0/818148bf682d429dc21b59a73ef6f68e.png"))
+ })
+
+ It("returns empty list if image is the ignored default image", func() {
+ fApi, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
+ apiClient.Res = http.Response{Body: fApi, StatusCode: 200}
+
+ fScraper, _ := os.Open("tests/fixtures/lastfm.artist.page.ignored.html")
+ httpClient.Res = http.Response{Body: fScraper, StatusCode: 200}
+
+ images, err := agent.GetArtistImages(ctx, "123", "U2", "")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(images).To(BeEmpty())
+ })
+
+ It("returns empty list if page has no meta tags", func() {
+ fApi, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
+ apiClient.Res = http.Response{Body: fApi, StatusCode: 200}
+
+ fScraper, _ := os.Open("tests/fixtures/lastfm.artist.page.no_meta.html")
+ httpClient.Res = http.Response{Body: fScraper, StatusCode: 200}
+
+ images, err := agent.GetArtistImages(ctx, "123", "U2", "")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(images).To(BeEmpty())
+ })
+
+ It("returns error if API call fails", func() {
+ apiClient.Err = errors.New("api error")
+ _, err := agent.GetArtistImages(ctx, "123", "U2", "")
+ Expect(err).To(HaveOccurred())
+ Expect(err.Error()).To(ContainSubstring("get artist info"))
+ })
+
+ It("returns error if scraper call fails", func() {
+ fApi, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
+ apiClient.Res = http.Response{Body: fApi, StatusCode: 200}
+
+ httpClient.Err = errors.New("scraper error")
+ _, err := agent.GetArtistImages(ctx, "123", "U2", "")
+ Expect(err).To(HaveOccurred())
+ Expect(err.Error()).To(ContainSubstring("get artist url"))
+ })
+ })
})
diff --git a/core/artwork/cache_warmer_test.go b/core/artwork/cache_warmer_test.go
index 4125d6de0..7ae3a16e0 100644
--- a/core/artwork/cache_warmer_test.go
+++ b/core/artwork/cache_warmer_test.go
@@ -90,6 +90,7 @@ var _ = Describe("CacheWarmer", func() {
})
It("deduplicates items in buffer", func() {
+ fc.SetReady(false) // Make cache unavailable so items stay in buffer
cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
cw.PreCache(model.MustParseArtworkID("al-1"))
cw.PreCache(model.MustParseArtworkID("al-1"))
diff --git a/core/artwork/reader_album.go b/core/artwork/reader_album.go
index 55d8b4352..cb4db97fe 100644
--- a/core/artwork/reader_album.go
+++ b/core/artwork/reader_album.go
@@ -1,6 +1,7 @@
package artwork
import (
+ "cmp"
"context"
"crypto/md5"
"fmt"
@@ -11,6 +12,7 @@ import (
"time"
"github.com/Masterminds/squirrel"
+ "github.com/maruel/natural"
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/core"
"github.com/navidrome/navidrome/core/external"
@@ -116,8 +118,30 @@ func loadAlbumFoldersPaths(ctx context.Context, ds model.DataStore, albums ...mo
}
// Sort image files to ensure consistent selection of cover art
- // This prioritizes files from lower-numbered disc folders by sorting the paths
- slices.Sort(imgFiles)
+ // This prioritizes files without numeric suffixes (e.g., cover.jpg over cover.1.jpg)
+ // by comparing base filenames without extensions
+ slices.SortFunc(imgFiles, compareImageFiles)
return paths, imgFiles, &updatedAt, nil
}
+
+// compareImageFiles compares two image file paths for sorting.
+// It extracts the base filename (without extension) and compares case-insensitively.
+// This ensures that "cover.jpg" sorts before "cover.1.jpg" since "cover" < "cover.1".
+// Note: This function is called O(n log n) times during sorting, but in practice albums
+// typically have only 1-20 image files, making the repeated string operations negligible.
+func compareImageFiles(a, b string) int {
+ // Case-insensitive comparison
+ a = strings.ToLower(a)
+ b = strings.ToLower(b)
+
+ // Extract base filenames without extensions
+ baseA := strings.TrimSuffix(filepath.Base(a), filepath.Ext(a))
+ baseB := strings.TrimSuffix(filepath.Base(b), filepath.Ext(b))
+
+ // Compare base names first, then full paths if equal
+ return cmp.Or(
+ natural.Compare(baseA, baseB),
+ natural.Compare(a, b),
+ )
+}
diff --git a/core/artwork/reader_album_test.go b/core/artwork/reader_album_test.go
index 2665632b9..fd5f8a2be 100644
--- a/core/artwork/reader_album_test.go
+++ b/core/artwork/reader_album_test.go
@@ -27,26 +27,7 @@ var _ = Describe("Album Artwork Reader", func() {
expectedAt = now.Add(5 * time.Minute)
// Set up the test folders with image files
- repo = &fakeFolderRepo{
- result: []model.Folder{
- {
- Path: "Artist/Album/Disc1",
- ImagesUpdatedAt: expectedAt,
- ImageFiles: []string{"cover.jpg", "back.jpg"},
- },
- {
- Path: "Artist/Album/Disc2",
- ImagesUpdatedAt: now,
- ImageFiles: []string{"cover.jpg"},
- },
- {
- Path: "Artist/Album/Disc10",
- ImagesUpdatedAt: now,
- ImageFiles: []string{"cover.jpg"},
- },
- },
- err: nil,
- }
+ repo = &fakeFolderRepo{}
ds = &fakeDataStore{
folderRepo: repo,
}
@@ -58,19 +39,82 @@ var _ = Describe("Album Artwork Reader", func() {
})
It("returns sorted image files", func() {
+ repo.result = []model.Folder{
+ {
+ Path: "Artist/Album/Disc1",
+ ImagesUpdatedAt: expectedAt,
+ ImageFiles: []string{"cover.jpg", "back.jpg", "cover.1.jpg"},
+ },
+ {
+ Path: "Artist/Album/Disc2",
+ ImagesUpdatedAt: now,
+ ImageFiles: []string{"cover.jpg"},
+ },
+ {
+ Path: "Artist/Album/Disc10",
+ ImagesUpdatedAt: now,
+ ImageFiles: []string{"cover.jpg"},
+ },
+ }
+
_, imgFiles, imagesUpdatedAt, err := loadAlbumFoldersPaths(ctx, ds, album)
Expect(err).ToNot(HaveOccurred())
Expect(*imagesUpdatedAt).To(Equal(expectedAt))
- // Check that image files are sorted alphabetically
- Expect(imgFiles).To(HaveLen(4))
+ // Check that image files are sorted by base name (without extension)
+ Expect(imgFiles).To(HaveLen(5))
- // The files should be sorted by full path
+ // Files should be sorted by base filename without extension, then by full path
+ // "back" < "cover", so back.jpg comes first
+ // Then all cover.jpg files, sorted by path
Expect(imgFiles[0]).To(Equal(filepath.FromSlash("Artist/Album/Disc1/back.jpg")))
Expect(imgFiles[1]).To(Equal(filepath.FromSlash("Artist/Album/Disc1/cover.jpg")))
- Expect(imgFiles[2]).To(Equal(filepath.FromSlash("Artist/Album/Disc10/cover.jpg")))
- Expect(imgFiles[3]).To(Equal(filepath.FromSlash("Artist/Album/Disc2/cover.jpg")))
+ Expect(imgFiles[2]).To(Equal(filepath.FromSlash("Artist/Album/Disc2/cover.jpg")))
+ Expect(imgFiles[3]).To(Equal(filepath.FromSlash("Artist/Album/Disc10/cover.jpg")))
+ Expect(imgFiles[4]).To(Equal(filepath.FromSlash("Artist/Album/Disc1/cover.1.jpg")))
+ })
+
+ It("prioritizes files without numeric suffixes", func() {
+ // Test case for issue #4683: cover.jpg should come before cover.1.jpg
+ repo.result = []model.Folder{
+ {
+ Path: "Artist/Album",
+ ImagesUpdatedAt: now,
+ ImageFiles: []string{"cover.1.jpg", "cover.jpg", "cover.2.jpg"},
+ },
+ }
+
+ _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(imgFiles).To(HaveLen(3))
+
+ // cover.jpg should come first because "cover" < "cover.1" < "cover.2"
+ Expect(imgFiles[0]).To(Equal(filepath.FromSlash("Artist/Album/cover.jpg")))
+ Expect(imgFiles[1]).To(Equal(filepath.FromSlash("Artist/Album/cover.1.jpg")))
+ Expect(imgFiles[2]).To(Equal(filepath.FromSlash("Artist/Album/cover.2.jpg")))
+ })
+
+ It("handles case-insensitive sorting", func() {
+ // Test that Cover.jpg and cover.jpg are treated as equivalent
+ repo.result = []model.Folder{
+ {
+ Path: "Artist/Album",
+ ImagesUpdatedAt: now,
+ ImageFiles: []string{"Folder.jpg", "cover.jpg", "BACK.jpg"},
+ },
+ }
+
+ _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(imgFiles).To(HaveLen(3))
+
+ // Files should be sorted case-insensitively: BACK, cover, Folder
+ Expect(imgFiles[0]).To(Equal(filepath.FromSlash("Artist/Album/BACK.jpg")))
+ Expect(imgFiles[1]).To(Equal(filepath.FromSlash("Artist/Album/cover.jpg")))
+ Expect(imgFiles[2]).To(Equal(filepath.FromSlash("Artist/Album/Folder.jpg")))
})
})
})
diff --git a/core/artwork/reader_artist.go b/core/artwork/reader_artist.go
index cb029a16e..da8141a2d 100644
--- a/core/artwork/reader_artist.go
+++ b/core/artwork/reader_artist.go
@@ -8,6 +8,7 @@ import (
"io/fs"
"os"
"path/filepath"
+ "slices"
"strings"
"time"
@@ -139,11 +140,22 @@ func findImageInFolder(ctx context.Context, folder, pattern string) (io.ReadClos
return nil, "", err
}
+ // Filter to valid image files
+ var imagePaths []string
for _, m := range matches {
if !model.IsImageFile(m) {
continue
}
- filePath := filepath.Join(folder, m)
+ imagePaths = append(imagePaths, m)
+ }
+
+ // Sort image files by prioritizing base filenames without numeric
+ // suffixes (e.g., artist.jpg before artist.1.jpg)
+ slices.SortFunc(imagePaths, compareImageFiles)
+
+ // Try to open files in sorted order
+ for _, p := range imagePaths {
+ filePath := filepath.Join(folder, p)
f, err := os.Open(filePath)
if err != nil {
log.Warn(ctx, "Could not open cover art file", "file", filePath, err)
diff --git a/core/artwork/reader_artist_test.go b/core/artwork/reader_artist_test.go
index 527b0849f..e6a0168f8 100644
--- a/core/artwork/reader_artist_test.go
+++ b/core/artwork/reader_artist_test.go
@@ -240,24 +240,79 @@ var _ = Describe("artistArtworkReader", func() {
Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
// Create multiple matching files
- Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("jpg image"), 0600)).To(Succeed())
+ Expect(os.WriteFile(filepath.Join(artistDir, "artist.abc"), []byte("text file"), 0600)).To(Succeed())
Expect(os.WriteFile(filepath.Join(artistDir, "artist.png"), []byte("png image"), 0600)).To(Succeed())
- Expect(os.WriteFile(filepath.Join(artistDir, "artist.txt"), []byte("text file"), 0600)).To(Succeed())
+ Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("jpg image"), 0600)).To(Succeed())
testFunc = fromArtistFolder(ctx, artistDir, "artist.*")
})
- It("returns the first valid image file", func() {
+ It("returns the first valid image file in sorted order", func() {
reader, path, err := testFunc()
Expect(err).ToNot(HaveOccurred())
Expect(reader).ToNot(BeNil())
- // Should return an image file, not the text file
- Expect(path).To(SatisfyAny(
- ContainSubstring("artist.jpg"),
- ContainSubstring("artist.png"),
- ))
- Expect(path).ToNot(ContainSubstring("artist.txt"))
+ // Should return an image file,
+ // Files are sorted: jpg comes before png alphabetically.
+ // .abc comes first, but it's not an image.
+ Expect(path).To(ContainSubstring("artist.jpg"))
+ reader.Close()
+ })
+ })
+
+ When("prioritizing files without numeric suffixes", func() {
+ BeforeEach(func() {
+ // Test case for issue #4683: artist.jpg should come before artist.1.jpg
+ artistDir := filepath.Join(tempDir, "artist")
+ Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
+
+ // Create multiple matches with and without numeric suffixes
+ Expect(os.WriteFile(filepath.Join(artistDir, "artist.1.jpg"), []byte("artist 1"), 0600)).To(Succeed())
+ Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("artist main"), 0600)).To(Succeed())
+ Expect(os.WriteFile(filepath.Join(artistDir, "artist.2.jpg"), []byte("artist 2"), 0600)).To(Succeed())
+
+ testFunc = fromArtistFolder(ctx, artistDir, "artist.*")
+ })
+
+ It("returns artist.jpg before artist.1.jpg and artist.2.jpg", func() {
+ reader, path, err := testFunc()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(reader).ToNot(BeNil())
+ Expect(path).To(ContainSubstring("artist.jpg"))
+
+ // Verify it's the main file, not a numbered variant
+ data, err := io.ReadAll(reader)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(string(data)).To(Equal("artist main"))
+ reader.Close()
+ })
+ })
+
+ When("handling case-insensitive sorting", func() {
+ BeforeEach(func() {
+ // Test case to ensure case-insensitive natural sorting
+ artistDir := filepath.Join(tempDir, "artist")
+ Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
+
+ // Create files with mixed case names
+ Expect(os.WriteFile(filepath.Join(artistDir, "Folder.jpg"), []byte("folder"), 0600)).To(Succeed())
+ Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("artist"), 0600)).To(Succeed())
+ Expect(os.WriteFile(filepath.Join(artistDir, "BACK.jpg"), []byte("back"), 0600)).To(Succeed())
+
+ testFunc = fromArtistFolder(ctx, artistDir, "*.*")
+ })
+
+ It("sorts case-insensitively", func() {
+ reader, path, err := testFunc()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(reader).ToNot(BeNil())
+
+ // Should return artist.jpg first (case-insensitive: "artist" < "back" < "folder")
+ Expect(path).To(ContainSubstring("artist.jpg"))
+
+ data, err := io.ReadAll(reader)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(string(data)).To(Equal("artist"))
reader.Close()
})
})
diff --git a/core/library.go b/core/library.go
index 7abd35c8f..f4f55ec5a 100644
--- a/core/library.go
+++ b/core/library.go
@@ -21,11 +21,6 @@ import (
"github.com/navidrome/navidrome/utils/slice"
)
-// Scanner interface for triggering scans
-type Scanner interface {
- ScanAll(ctx context.Context, fullScan bool) (warnings []string, err error)
-}
-
// Watcher interface for managing file system watchers
type Watcher interface {
Watch(ctx context.Context, lib *model.Library) error
@@ -43,13 +38,13 @@ type Library interface {
type libraryService struct {
ds model.DataStore
- scanner Scanner
+ scanner model.Scanner
watcher Watcher
broker events.Broker
}
// NewLibrary creates a new Library service
-func NewLibrary(ds model.DataStore, scanner Scanner, watcher Watcher, broker events.Broker) Library {
+func NewLibrary(ds model.DataStore, scanner model.Scanner, watcher Watcher, broker events.Broker) Library {
return &libraryService{
ds: ds,
scanner: scanner,
@@ -155,7 +150,7 @@ type libraryRepositoryWrapper struct {
model.LibraryRepository
ctx context.Context
ds model.DataStore
- scanner Scanner
+ scanner model.Scanner
watcher Watcher
broker events.Broker
}
@@ -192,7 +187,7 @@ func (r *libraryRepositoryWrapper) Save(entity interface{}) (string, error) {
return strconv.Itoa(lib.ID), nil
}
-func (r *libraryRepositoryWrapper) Update(id string, entity interface{}, cols ...string) error {
+func (r *libraryRepositoryWrapper) Update(id string, entity interface{}, _ ...string) error {
lib := entity.(*model.Library)
libID, err := strconv.Atoi(id)
if err != nil {
diff --git a/core/library_test.go b/core/library_test.go
index bfbb4300a..bf73a62b7 100644
--- a/core/library_test.go
+++ b/core/library_test.go
@@ -29,7 +29,7 @@ var _ = Describe("Library Service", func() {
var userRepo *tests.MockedUserRepo
var ctx context.Context
var tempDir string
- var scanner *mockScanner
+ var scanner *tests.MockScanner
var watcherManager *mockWatcherManager
var broker *mockEventBroker
@@ -43,7 +43,7 @@ var _ = Describe("Library Service", func() {
ds.MockedUser = userRepo
// Create a mock scanner that tracks calls
- scanner = &mockScanner{}
+ scanner = tests.NewMockScanner()
// Create a mock watcher manager
watcherManager = &mockWatcherManager{
libraryStates: make(map[int]model.Library),
@@ -616,11 +616,12 @@ var _ = Describe("Library Service", func() {
// Wait briefly for the goroutine to complete
Eventually(func() int {
- return scanner.len()
+ return scanner.GetScanAllCallCount()
}, "1s", "10ms").Should(Equal(1))
// Verify scan was called with correct parameters
- Expect(scanner.ScanCalls[0].FullScan).To(BeFalse()) // Should be quick scan
+ calls := scanner.GetScanAllCalls()
+ Expect(calls[0].FullScan).To(BeFalse()) // Should be quick scan
})
It("triggers scan when updating library path", func() {
@@ -641,11 +642,12 @@ var _ = Describe("Library Service", func() {
// Wait briefly for the goroutine to complete
Eventually(func() int {
- return scanner.len()
+ return scanner.GetScanAllCallCount()
}, "1s", "10ms").Should(Equal(1))
// Verify scan was called with correct parameters
- Expect(scanner.ScanCalls[0].FullScan).To(BeFalse()) // Should be quick scan
+ calls := scanner.GetScanAllCalls()
+ Expect(calls[0].FullScan).To(BeFalse()) // Should be quick scan
})
It("does not trigger scan when updating library without path change", func() {
@@ -661,7 +663,7 @@ var _ = Describe("Library Service", func() {
// Wait a bit to ensure no scan was triggered
Consistently(func() int {
- return scanner.len()
+ return scanner.GetScanAllCallCount()
}, "100ms", "10ms").Should(Equal(0))
})
@@ -674,7 +676,7 @@ var _ = Describe("Library Service", func() {
// Ensure no scan was triggered since creation failed
Consistently(func() int {
- return scanner.len()
+ return scanner.GetScanAllCallCount()
}, "100ms", "10ms").Should(Equal(0))
})
@@ -691,7 +693,7 @@ var _ = Describe("Library Service", func() {
// Ensure no scan was triggered since update failed
Consistently(func() int {
- return scanner.len()
+ return scanner.GetScanAllCallCount()
}, "100ms", "10ms").Should(Equal(0))
})
@@ -707,11 +709,12 @@ var _ = Describe("Library Service", func() {
// Wait briefly for the goroutine to complete
Eventually(func() int {
- return scanner.len()
+ return scanner.GetScanAllCallCount()
}, "1s", "10ms").Should(Equal(1))
// Verify scan was called with correct parameters
- Expect(scanner.ScanCalls[0].FullScan).To(BeFalse()) // Should be quick scan
+ calls := scanner.GetScanAllCalls()
+ Expect(calls[0].FullScan).To(BeFalse()) // Should be quick scan
})
It("does not trigger scan when library deletion fails", func() {
@@ -721,7 +724,7 @@ var _ = Describe("Library Service", func() {
// Ensure no scan was triggered since deletion failed
Consistently(func() int {
- return scanner.len()
+ return scanner.GetScanAllCallCount()
}, "100ms", "10ms").Should(Equal(0))
})
@@ -868,31 +871,6 @@ var _ = Describe("Library Service", func() {
})
})
-// mockScanner provides a simple mock implementation of core.Scanner for testing
-type mockScanner struct {
- ScanCalls []ScanCall
- mu sync.RWMutex
-}
-
-type ScanCall struct {
- FullScan bool
-}
-
-func (m *mockScanner) ScanAll(ctx context.Context, fullScan bool) (warnings []string, err error) {
- m.mu.Lock()
- defer m.mu.Unlock()
- m.ScanCalls = append(m.ScanCalls, ScanCall{
- FullScan: fullScan,
- })
- return []string{}, nil
-}
-
-func (m *mockScanner) len() int {
- m.mu.RLock()
- defer m.mu.RUnlock()
- return len(m.ScanCalls)
-}
-
// mockWatcherManager provides a simple mock implementation of core.Watcher for testing
type mockWatcherManager struct {
StartedWatchers []model.Library
diff --git a/core/maintenance.go b/core/maintenance.go
new file mode 100644
index 000000000..750fd3a9e
--- /dev/null
+++ b/core/maintenance.go
@@ -0,0 +1,226 @@
+package core
+
+import (
+ "context"
+ "fmt"
+ "slices"
+ "sync"
+ "time"
+
+ "github.com/Masterminds/squirrel"
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/model/request"
+ "github.com/navidrome/navidrome/utils/slice"
+)
+
+type Maintenance interface {
+ // DeleteMissingFiles deletes specific missing files by their IDs
+ DeleteMissingFiles(ctx context.Context, ids []string) error
+ // DeleteAllMissingFiles deletes all files marked as missing
+ DeleteAllMissingFiles(ctx context.Context) error
+}
+
+type maintenanceService struct {
+ ds model.DataStore
+ wg sync.WaitGroup
+}
+
+func NewMaintenance(ds model.DataStore) Maintenance {
+ return &maintenanceService{
+ ds: ds,
+ }
+}
+
+func (s *maintenanceService) DeleteMissingFiles(ctx context.Context, ids []string) error {
+ return s.deleteMissing(ctx, ids)
+}
+
+func (s *maintenanceService) DeleteAllMissingFiles(ctx context.Context) error {
+ return s.deleteMissing(ctx, nil)
+}
+
+// deleteMissing handles the deletion of missing files and triggers necessary cleanup operations
+func (s *maintenanceService) deleteMissing(ctx context.Context, ids []string) error {
+ // Track affected album IDs before deletion for refresh
+ affectedAlbumIDs, err := s.getAffectedAlbumIDs(ctx, ids)
+ if err != nil {
+ log.Warn(ctx, "Error tracking affected albums for refresh", err)
+ // Don't fail the operation, just log the warning
+ }
+
+ // Delete missing files within a transaction
+ err = s.ds.WithTx(func(tx model.DataStore) error {
+ if len(ids) == 0 {
+ _, err := tx.MediaFile(ctx).DeleteAllMissing()
+ return err
+ }
+ return tx.MediaFile(ctx).DeleteMissing(ids)
+ })
+ if err != nil {
+ log.Error(ctx, "Error deleting missing tracks from DB", "ids", ids, err)
+ return err
+ }
+
+ // Run garbage collection to clean up orphaned records
+ if err := s.ds.GC(ctx); err != nil {
+ log.Error(ctx, "Error running GC after deleting missing tracks", err)
+ return err
+ }
+
+ // Refresh statistics in background
+ s.refreshStatsAsync(ctx, affectedAlbumIDs)
+
+ return nil
+}
+
+// refreshAlbums recalculates album attributes (size, duration, song count, etc.) from media files.
+// It uses batch queries to minimize database round-trips for efficiency.
+func (s *maintenanceService) refreshAlbums(ctx context.Context, albumIDs []string) error {
+ if len(albumIDs) == 0 {
+ return nil
+ }
+
+ log.Debug(ctx, "Refreshing albums", "count", len(albumIDs))
+
+ // Process in chunks to avoid query size limits
+ const chunkSize = 100
+ for chunk := range slice.CollectChunks(slices.Values(albumIDs), chunkSize) {
+ if err := s.refreshAlbumChunk(ctx, chunk); err != nil {
+ return fmt.Errorf("refreshing album chunk: %w", err)
+ }
+ }
+
+ log.Debug(ctx, "Successfully refreshed albums", "count", len(albumIDs))
+ return nil
+}
+
+// refreshAlbumChunk processes a single chunk of album IDs
+func (s *maintenanceService) refreshAlbumChunk(ctx context.Context, albumIDs []string) error {
+ albumRepo := s.ds.Album(ctx)
+ mfRepo := s.ds.MediaFile(ctx)
+
+ // Batch load existing albums
+ albums, err := albumRepo.GetAll(model.QueryOptions{
+ Filters: squirrel.Eq{"album.id": albumIDs},
+ })
+ if err != nil {
+ return fmt.Errorf("loading albums: %w", err)
+ }
+
+ // Create a map for quick lookup
+ albumMap := make(map[string]*model.Album, len(albums))
+ for i := range albums {
+ albumMap[albums[i].ID] = &albums[i]
+ }
+
+ // Batch load all media files for these albums
+ mediaFiles, err := mfRepo.GetAll(model.QueryOptions{
+ Filters: squirrel.Eq{"album_id": albumIDs},
+ Sort: "album_id, path",
+ })
+ if err != nil {
+ return fmt.Errorf("loading media files: %w", err)
+ }
+
+ // Group media files by album ID
+ filesByAlbum := make(map[string]model.MediaFiles)
+ for i := range mediaFiles {
+ albumID := mediaFiles[i].AlbumID
+ filesByAlbum[albumID] = append(filesByAlbum[albumID], mediaFiles[i])
+ }
+
+ // Recalculate each album from its media files
+ for albumID, oldAlbum := range albumMap {
+ mfs, hasTracks := filesByAlbum[albumID]
+ if !hasTracks {
+ // Album has no tracks anymore, skip (will be cleaned up by GC)
+ log.Debug(ctx, "Skipping album with no tracks", "albumID", albumID)
+ continue
+ }
+
+ // Recalculate album from media files
+ newAlbum := mfs.ToAlbum()
+
+ // Only update if something changed (avoid unnecessary writes)
+ if !oldAlbum.Equals(newAlbum) {
+ // Preserve original timestamps
+ newAlbum.UpdatedAt = time.Now()
+ newAlbum.CreatedAt = oldAlbum.CreatedAt
+
+ if err := albumRepo.Put(&newAlbum); err != nil {
+ log.Error(ctx, "Error updating album during refresh", "albumID", albumID, err)
+ // Continue with other albums instead of failing entirely
+ continue
+ }
+ log.Trace(ctx, "Refreshed album", "albumID", albumID, "name", newAlbum.Name)
+ }
+ }
+
+ return nil
+}
+
+// getAffectedAlbumIDs returns distinct album IDs from missing media files
+func (s *maintenanceService) getAffectedAlbumIDs(ctx context.Context, ids []string) ([]string, error) {
+ var filters squirrel.Sqlizer = squirrel.Eq{"missing": true}
+ if len(ids) > 0 {
+ filters = squirrel.And{
+ squirrel.Eq{"missing": true},
+ squirrel.Eq{"media_file.id": ids},
+ }
+ }
+
+ mfs, err := s.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+ Filters: filters,
+ })
+ if err != nil {
+ return nil, err
+ }
+
+ // Extract unique album IDs
+ albumIDMap := make(map[string]struct{}, len(mfs))
+ for _, mf := range mfs {
+ if mf.AlbumID != "" {
+ albumIDMap[mf.AlbumID] = struct{}{}
+ }
+ }
+
+ albumIDs := make([]string, 0, len(albumIDMap))
+ for id := range albumIDMap {
+ albumIDs = append(albumIDs, id)
+ }
+
+ return albumIDs, nil
+}
+
+// refreshStatsAsync refreshes artist and album statistics in background goroutines
+func (s *maintenanceService) refreshStatsAsync(ctx context.Context, affectedAlbumIDs []string) {
+ // Refresh artist stats in background
+ s.wg.Add(1)
+ go func() {
+ defer s.wg.Done()
+ bgCtx := request.AddValues(context.Background(), ctx)
+ if _, err := s.ds.Artist(bgCtx).RefreshStats(true); err != nil {
+ log.Error(bgCtx, "Error refreshing artist stats after deleting missing files", err)
+ } else {
+ log.Debug(bgCtx, "Successfully refreshed artist stats after deleting missing files")
+ }
+
+ // Refresh album stats in background if we have affected albums
+ if len(affectedAlbumIDs) > 0 {
+ if err := s.refreshAlbums(bgCtx, affectedAlbumIDs); err != nil {
+ log.Error(bgCtx, "Error refreshing album stats after deleting missing files", err)
+ } else {
+ log.Debug(bgCtx, "Successfully refreshed album stats after deleting missing files", "count", len(affectedAlbumIDs))
+ }
+ }
+ }()
+}
+
+// Wait waits for all background goroutines to complete.
+// WARNING: This method is ONLY for testing. Never call this in production code.
+// Calling Wait() in production will block until ALL background operations complete
+// and may cause race conditions with new operations starting.
+func (s *maintenanceService) wait() {
+ s.wg.Wait()
+}
diff --git a/core/maintenance_test.go b/core/maintenance_test.go
new file mode 100644
index 000000000..09b442438
--- /dev/null
+++ b/core/maintenance_test.go
@@ -0,0 +1,364 @@
+package core
+
+import (
+ "context"
+ "errors"
+ "sync"
+
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/model/request"
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+ "github.com/sirupsen/logrus"
+)
+
+var _ = Describe("Maintenance", func() {
+ var ds *tests.MockDataStore
+ var mfRepo *extendedMediaFileRepo
+ var service Maintenance
+ var ctx context.Context
+
+ BeforeEach(func() {
+ ctx = context.Background()
+ ctx = request.WithUser(ctx, model.User{ID: "user1", IsAdmin: true})
+
+ ds = createTestDataStore()
+ mfRepo = ds.MockedMediaFile.(*extendedMediaFileRepo)
+ service = NewMaintenance(ds)
+ })
+
+ Describe("DeleteMissingFiles", func() {
+ Context("with specific IDs", func() {
+ It("deletes specific missing files and runs GC", func() {
+ // Setup: mock missing files with album IDs
+ mfRepo.SetData(model.MediaFiles{
+ {ID: "mf1", AlbumID: "album1", Missing: true},
+ {ID: "mf2", AlbumID: "album2", Missing: true},
+ })
+
+ err := service.DeleteMissingFiles(ctx, []string{"mf1", "mf2"})
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(mfRepo.deleteMissingCalled).To(BeTrue())
+ Expect(mfRepo.deletedIDs).To(Equal([]string{"mf1", "mf2"}))
+ Expect(ds.GCCalled).To(BeTrue(), "GC should be called after deletion")
+ })
+
+ It("triggers artist stats refresh and album refresh after deletion", func() {
+ artistRepo := ds.MockedArtist.(*extendedArtistRepo)
+ // Setup: mock missing files with albums
+ albumRepo := ds.MockedAlbum.(*extendedAlbumRepo)
+ albumRepo.SetData(model.Albums{
+ {ID: "album1", Name: "Test Album", SongCount: 5},
+ })
+ mfRepo.SetData(model.MediaFiles{
+ {ID: "mf1", AlbumID: "album1", Missing: true},
+ {ID: "mf2", AlbumID: "album1", Missing: false, Size: 1000, Duration: 180},
+ {ID: "mf3", AlbumID: "album1", Missing: false, Size: 2000, Duration: 200},
+ })
+
+ err := service.DeleteMissingFiles(ctx, []string{"mf1"})
+
+ Expect(err).ToNot(HaveOccurred())
+
+ // Wait for background goroutines to complete
+ service.(*maintenanceService).wait()
+
+ // RefreshStats should be called
+ Expect(artistRepo.IsRefreshStatsCalled()).To(BeTrue(), "Artist stats should be refreshed")
+
+ // Album should be updated with new calculated values
+ Expect(albumRepo.GetPutCallCount()).To(BeNumerically(">", 0), "Album.Put() should be called to refresh album data")
+ })
+
+ It("returns error if deletion fails", func() {
+ mfRepo.deleteMissingError = errors.New("delete failed")
+
+ err := service.DeleteMissingFiles(ctx, []string{"mf1"})
+
+ Expect(err).To(HaveOccurred())
+ Expect(err.Error()).To(ContainSubstring("delete failed"))
+ })
+
+ It("continues even if album tracking fails", func() {
+ mfRepo.SetError(true)
+
+ err := service.DeleteMissingFiles(ctx, []string{"mf1"})
+
+ // Should not fail, just log warning
+ Expect(err).ToNot(HaveOccurred())
+ Expect(mfRepo.deleteMissingCalled).To(BeTrue())
+ })
+
+ It("returns error if GC fails", func() {
+ mfRepo.SetData(model.MediaFiles{
+ {ID: "mf1", AlbumID: "album1", Missing: true},
+ })
+
+ // Set GC to return error
+ ds.GCError = errors.New("gc failed")
+
+ err := service.DeleteMissingFiles(ctx, []string{"mf1"})
+
+ Expect(err).To(HaveOccurred())
+ Expect(err.Error()).To(ContainSubstring("gc failed"))
+ })
+ })
+
+ Context("album ID extraction", func() {
+ It("extracts unique album IDs from missing files", func() {
+ mfRepo.SetData(model.MediaFiles{
+ {ID: "mf1", AlbumID: "album1", Missing: true},
+ {ID: "mf2", AlbumID: "album1", Missing: true},
+ {ID: "mf3", AlbumID: "album2", Missing: true},
+ })
+
+ err := service.DeleteMissingFiles(ctx, []string{"mf1", "mf2", "mf3"})
+
+ Expect(err).ToNot(HaveOccurred())
+ })
+
+ It("skips files without album IDs", func() {
+ mfRepo.SetData(model.MediaFiles{
+ {ID: "mf1", AlbumID: "", Missing: true},
+ {ID: "mf2", AlbumID: "album1", Missing: true},
+ })
+
+ err := service.DeleteMissingFiles(ctx, []string{"mf1", "mf2"})
+
+ Expect(err).ToNot(HaveOccurred())
+ })
+ })
+ })
+
+ Describe("DeleteAllMissingFiles", func() {
+ It("deletes all missing files and runs GC", func() {
+ mfRepo.SetData(model.MediaFiles{
+ {ID: "mf1", AlbumID: "album1", Missing: true},
+ {ID: "mf2", AlbumID: "album2", Missing: true},
+ {ID: "mf3", AlbumID: "album3", Missing: true},
+ })
+
+ err := service.DeleteAllMissingFiles(ctx)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ds.GCCalled).To(BeTrue(), "GC should be called after deletion")
+ })
+
+ It("returns error if deletion fails", func() {
+ mfRepo.SetError(true)
+
+ err := service.DeleteAllMissingFiles(ctx)
+
+ Expect(err).To(HaveOccurred())
+ })
+
+ It("handles empty result gracefully", func() {
+ mfRepo.SetData(model.MediaFiles{})
+
+ err := service.DeleteAllMissingFiles(ctx)
+
+ Expect(err).ToNot(HaveOccurred())
+ })
+ })
+
+ Describe("Album refresh logic", func() {
+ var albumRepo *extendedAlbumRepo
+
+ BeforeEach(func() {
+ albumRepo = ds.MockedAlbum.(*extendedAlbumRepo)
+ })
+
+ Context("when album has no tracks after deletion", func() {
+ It("skips the album without updating it", func() {
+ // Setup album with no remaining tracks
+ albumRepo.SetData(model.Albums{
+ {ID: "album1", Name: "Empty Album", SongCount: 1},
+ })
+ mfRepo.SetData(model.MediaFiles{
+ {ID: "mf1", AlbumID: "album1", Missing: true},
+ })
+
+ err := service.DeleteMissingFiles(ctx, []string{"mf1"})
+
+ Expect(err).ToNot(HaveOccurred())
+
+ // Wait for background goroutines to complete
+ service.(*maintenanceService).wait()
+
+ // Album should NOT be updated because it has no tracks left
+ Expect(albumRepo.GetPutCallCount()).To(Equal(0), "Album with no tracks should not be updated")
+ })
+ })
+
+ Context("when Put fails for one album", func() {
+ It("continues processing other albums", func() {
+ albumRepo.SetData(model.Albums{
+ {ID: "album1", Name: "Album 1"},
+ {ID: "album2", Name: "Album 2"},
+ })
+ mfRepo.SetData(model.MediaFiles{
+ {ID: "mf1", AlbumID: "album1", Missing: true},
+ {ID: "mf2", AlbumID: "album1", Missing: false, Size: 1000, Duration: 180},
+ {ID: "mf3", AlbumID: "album2", Missing: true},
+ {ID: "mf4", AlbumID: "album2", Missing: false, Size: 2000, Duration: 200},
+ })
+
+ // Make Put fail on first call but succeed on subsequent calls
+ albumRepo.putError = errors.New("put failed")
+ albumRepo.failOnce = true
+
+ err := service.DeleteMissingFiles(ctx, []string{"mf1", "mf3"})
+
+ // Should not fail even if one album's Put fails
+ Expect(err).ToNot(HaveOccurred())
+
+ // Wait for background goroutines to complete
+ service.(*maintenanceService).wait()
+
+ // Put should have been called multiple times
+ Expect(albumRepo.GetPutCallCount()).To(BeNumerically(">", 0), "Put should be attempted")
+ })
+ })
+
+ Context("when media file loading fails", func() {
+ It("logs warning but continues when tracking affected albums fails", func() {
+ // Set up log capturing
+ hook, cleanup := tests.LogHook()
+ defer cleanup()
+
+ albumRepo.SetData(model.Albums{
+ {ID: "album1", Name: "Album 1"},
+ })
+ mfRepo.SetData(model.MediaFiles{
+ {ID: "mf1", AlbumID: "album1", Missing: true},
+ })
+ // Make GetAll fail when loading media files
+ mfRepo.SetError(true)
+
+ err := service.DeleteMissingFiles(ctx, []string{"mf1"})
+
+ // Deletion should succeed despite the tracking error
+ Expect(err).ToNot(HaveOccurred())
+ Expect(mfRepo.deleteMissingCalled).To(BeTrue())
+
+ // Verify the warning was logged
+ Expect(hook.LastEntry()).ToNot(BeNil())
+ Expect(hook.LastEntry().Level).To(Equal(logrus.WarnLevel))
+ Expect(hook.LastEntry().Message).To(Equal("Error tracking affected albums for refresh"))
+ })
+ })
+ })
+})
+
+// Test helper to create a mock DataStore with controllable behavior
+func createTestDataStore() *tests.MockDataStore {
+ ds := &tests.MockDataStore{}
+
+ // Create extended album repo with Put tracking
+ albumRepo := &extendedAlbumRepo{
+ MockAlbumRepo: tests.CreateMockAlbumRepo(),
+ }
+ ds.MockedAlbum = albumRepo
+
+ // Create extended artist repo with RefreshStats tracking
+ artistRepo := &extendedArtistRepo{
+ MockArtistRepo: tests.CreateMockArtistRepo(),
+ }
+ ds.MockedArtist = artistRepo
+
+ // Create extended media file repo with DeleteMissing support
+ mfRepo := &extendedMediaFileRepo{
+ MockMediaFileRepo: tests.CreateMockMediaFileRepo(),
+ }
+ ds.MockedMediaFile = mfRepo
+
+ return ds
+}
+
+// Extension of MockMediaFileRepo to add DeleteMissing method
+type extendedMediaFileRepo struct {
+ *tests.MockMediaFileRepo
+ deleteMissingCalled bool
+ deletedIDs []string
+ deleteMissingError error
+}
+
+func (m *extendedMediaFileRepo) DeleteMissing(ids []string) error {
+ m.deleteMissingCalled = true
+ m.deletedIDs = ids
+ if m.deleteMissingError != nil {
+ return m.deleteMissingError
+ }
+ // Actually delete from the mock data
+ for _, id := range ids {
+ delete(m.Data, id)
+ }
+ return nil
+}
+
+// Extension of MockAlbumRepo to track Put calls
+type extendedAlbumRepo struct {
+ *tests.MockAlbumRepo
+ mu sync.RWMutex
+ putCallCount int
+ lastPutData *model.Album
+ putError error
+ failOnce bool
+}
+
+func (m *extendedAlbumRepo) Put(album *model.Album) error {
+ m.mu.Lock()
+ m.putCallCount++
+ m.lastPutData = album
+
+ // Handle failOnce behavior
+ var err error
+ if m.putError != nil {
+ if m.failOnce {
+ err = m.putError
+ m.putError = nil // Clear error after first failure
+ m.mu.Unlock()
+ return err
+ }
+ err = m.putError
+ m.mu.Unlock()
+ return err
+ }
+ m.mu.Unlock()
+
+ return m.MockAlbumRepo.Put(album)
+}
+
+func (m *extendedAlbumRepo) GetPutCallCount() int {
+ m.mu.RLock()
+ defer m.mu.RUnlock()
+ return m.putCallCount
+}
+
+// Extension of MockArtistRepo to track RefreshStats calls
+type extendedArtistRepo struct {
+ *tests.MockArtistRepo
+ mu sync.RWMutex
+ refreshStatsCalled bool
+ refreshStatsError error
+}
+
+func (m *extendedArtistRepo) RefreshStats(allArtists bool) (int64, error) {
+ m.mu.Lock()
+ m.refreshStatsCalled = true
+ err := m.refreshStatsError
+ m.mu.Unlock()
+
+ if err != nil {
+ return 0, err
+ }
+ return m.MockArtistRepo.RefreshStats(allArtists)
+}
+
+func (m *extendedArtistRepo) IsRefreshStatsCalled() bool {
+ m.mu.RLock()
+ defer m.mu.RUnlock()
+ return m.refreshStatsCalled
+}
diff --git a/core/metrics/insights.go b/core/metrics/insights.go
index f4f8738e7..010c24c28 100644
--- a/core/metrics/insights.go
+++ b/core/metrics/insights.go
@@ -6,6 +6,7 @@ import (
"encoding/json"
"math"
"net/http"
+ "os"
"path/filepath"
"runtime"
"runtime/debug"
@@ -160,6 +161,13 @@ var staticData = sync.OnceValue(func() insights.Data {
data.Build.Settings, data.Build.GoVersion = buildInfo()
data.OS.Containerized = consts.InContainer
+ // Install info
+ packageFilename := filepath.Join(conf.Server.DataFolder, ".package")
+ packageFileData, err := os.ReadFile(packageFilename)
+ if err == nil {
+ data.OS.Package = string(packageFileData)
+ }
+
// OS info
data.OS.Type = runtime.GOOS
data.OS.Arch = runtime.GOARCH
diff --git a/core/metrics/insights/data.go b/core/metrics/insights/data.go
index 105a6218e..c46eb8743 100644
--- a/core/metrics/insights/data.go
+++ b/core/metrics/insights/data.go
@@ -16,6 +16,7 @@ type Data struct {
Containerized bool `json:"containerized"`
Arch string `json:"arch"`
NumCPU int `json:"numCPU"`
+ Package string `json:"package,omitempty"`
} `json:"os"`
Mem struct {
Alloc uint64 `json:"alloc"`
diff --git a/core/share.go b/core/share.go
index 202c27d89..eb5e6679b 100644
--- a/core/share.go
+++ b/core/share.go
@@ -13,6 +13,7 @@ import (
"github.com/navidrome/navidrome/model"
. "github.com/navidrome/navidrome/utils/gg"
"github.com/navidrome/navidrome/utils/slice"
+ "github.com/navidrome/navidrome/utils/str"
)
type Share interface {
@@ -119,9 +120,8 @@ func (r *shareRepositoryWrapper) Save(entity interface{}) (string, error) {
log.Error(r.ctx, "Invalid Resource ID", "id", firstId)
return "", model.ErrNotFound
}
- if len(s.Contents) > 30 {
- s.Contents = s.Contents[:26] + "..."
- }
+
+ s.Contents = str.TruncateRunes(s.Contents, 30, "...")
id, err = r.Persistable.Save(s)
return id, err
diff --git a/core/share_test.go b/core/share_test.go
index 21069bb59..475d40ec9 100644
--- a/core/share_test.go
+++ b/core/share_test.go
@@ -38,6 +38,38 @@ var _ = Describe("Share", func() {
Expect(id).ToNot(BeEmpty())
Expect(entity.ID).To(Equal(id))
})
+
+ It("does not truncate ASCII labels shorter than 30 characters", func() {
+ _ = ds.MediaFile(ctx).Put(&model.MediaFile{ID: "456", Title: "Example Media File"})
+ entity := &model.Share{Description: "test", ResourceIDs: "456"}
+ _, err := repo.Save(entity)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(entity.Contents).To(Equal("Example Media File"))
+ })
+
+ It("truncates ASCII labels longer than 30 characters", func() {
+ _ = ds.MediaFile(ctx).Put(&model.MediaFile{ID: "789", Title: "Example Media File But The Title Is Really Long For Testing Purposes"})
+ entity := &model.Share{Description: "test", ResourceIDs: "789"}
+ _, err := repo.Save(entity)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(entity.Contents).To(Equal("Example Media File But The ..."))
+ })
+
+ It("does not truncate CJK labels shorter than 30 runes", func() {
+ _ = ds.MediaFile(ctx).Put(&model.MediaFile{ID: "456", Title: "青春コンプレックス"})
+ entity := &model.Share{Description: "test", ResourceIDs: "456"}
+ _, err := repo.Save(entity)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(entity.Contents).To(Equal("青春コンプレックス"))
+ })
+
+ It("truncates CJK labels longer than 30 runes", func() {
+ _ = ds.MediaFile(ctx).Put(&model.MediaFile{ID: "789", Title: "私の中の幻想的世界観及びその顕現を想起させたある現実での出来事に関する一考察"})
+ entity := &model.Share{Description: "test", ResourceIDs: "789"}
+ _, err := repo.Save(entity)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(entity.Contents).To(Equal("私の中の幻想的世界観及びその顕現を想起させたある現実で..."))
+ })
})
Describe("Update", func() {
diff --git a/core/wire_providers.go b/core/wire_providers.go
index ae365156a..16335645c 100644
--- a/core/wire_providers.go
+++ b/core/wire_providers.go
@@ -18,6 +18,7 @@ var Set = wire.NewSet(
NewShare,
NewPlaylists,
NewLibrary,
+ NewMaintenance,
agents.GetAgents,
external.NewProvider,
wire.Bind(new(external.Agents), new(*agents.Agents)),
diff --git a/db/migrations/20250823142158_make_playqueue_position_int.sql b/db/migrations/20250823142158_make_playqueue_position_int.sql
new file mode 100644
index 000000000..de20f0c79
--- /dev/null
+++ b/db/migrations/20250823142158_make_playqueue_position_int.sql
@@ -0,0 +1,9 @@
+-- +goose Up
+-- +goose StatementBegin
+ALTER TABLE playqueue ADD COLUMN position_int integer;
+UPDATE playqueue SET position_int = CAST(position as INTEGER) ;
+ALTER TABLE playqueue DROP COLUMN position;
+ALTER TABLE playqueue RENAME COLUMN position_int TO position;
+-- +goose StatementEnd
+
+-- +goose Down
diff --git a/go.mod b/go.mod
index 265cbfa6d..f680bda51 100644
--- a/go.mod
+++ b/go.mod
@@ -1,8 +1,8 @@
module github.com/navidrome/navidrome
-go 1.25.3
+go 1.25
-// Fork to fix https://github.com/navidrome/navidrome/pull/3254
+// Fork to fix https://github.com/navidrome/navidrome/issues/3254
replace github.com/dhowden/tag v0.0.0-20240417053706-3d75831295e8 => github.com/deluan/tag v0.0.0-20241002021117-dfe5e6ea396d
require (
@@ -39,11 +39,12 @@ require (
github.com/knqyf263/go-plugin v0.9.0
github.com/kr/pretty v0.3.1
github.com/lestrrat-go/jwx/v2 v2.1.6
+ github.com/maruel/natural v1.2.1
github.com/matoous/go-nanoid/v2 v2.1.0
github.com/mattn/go-sqlite3 v1.14.32
github.com/microcosm-cc/bluemonday v1.0.27
github.com/mileusna/useragent v1.3.5
- github.com/onsi/ginkgo/v2 v2.27.1
+ github.com/onsi/ginkgo/v2 v2.27.2
github.com/onsi/gomega v1.38.2
github.com/pelletier/go-toml/v2 v2.2.4
github.com/pocketbase/dbx v1.11.0
@@ -56,16 +57,16 @@ require (
github.com/spf13/cobra v1.10.1
github.com/spf13/viper v1.21.0
github.com/stretchr/testify v1.11.1
- github.com/tetratelabs/wazero v1.9.0
+ github.com/tetratelabs/wazero v1.10.1
github.com/unrolled/secure v1.17.0
github.com/xrash/smetrics v0.0.0-20250705151800-55b8f293f342
go.uber.org/goleak v1.3.0
- golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546
- golang.org/x/image v0.32.0
- golang.org/x/net v0.46.0
- golang.org/x/sync v0.17.0
- golang.org/x/sys v0.37.0
- golang.org/x/text v0.30.0
+ golang.org/x/exp v0.0.0-20251113190631-e25ba8c21ef6
+ golang.org/x/image v0.33.0
+ golang.org/x/net v0.47.0
+ golang.org/x/sync v0.18.0
+ golang.org/x/sys v0.38.0
+ golang.org/x/text v0.31.0
golang.org/x/time v0.14.0
google.golang.org/protobuf v1.36.10
gopkg.in/yaml.v3 v3.0.1
@@ -89,7 +90,7 @@ require (
github.com/goccy/go-json v0.10.5 // indirect
github.com/goccy/go-yaml v1.18.0 // indirect
github.com/google/go-cmp v0.7.0 // indirect
- github.com/google/pprof v0.0.0-20251007162407-5df77e3f7d1d // indirect
+ github.com/google/pprof v0.0.0-20251114195745-4902fdda35c8 // indirect
github.com/google/subcommands v1.2.0 // indirect
github.com/gorilla/css v1.0.1 // indirect
github.com/hashicorp/errwrap v1.1.0 // indirect
@@ -124,14 +125,13 @@ require (
github.com/stretchr/objx v0.5.2 // indirect
github.com/subosito/gotenv v1.6.0 // indirect
github.com/zeebo/xxh3 v1.0.2 // indirect
- go.uber.org/automaxprocs v1.6.0 // indirect
go.uber.org/multierr v1.11.0 // indirect
go.yaml.in/yaml/v2 v2.4.2 // indirect
go.yaml.in/yaml/v3 v3.0.4 // indirect
- golang.org/x/crypto v0.43.0 // indirect
- golang.org/x/mod v0.29.0 // indirect
- golang.org/x/telemetry v0.0.0-20251008203120-078029d740a8 // indirect
- golang.org/x/tools v0.38.0 // indirect
+ golang.org/x/crypto v0.45.0 // indirect
+ golang.org/x/mod v0.30.0 // indirect
+ golang.org/x/telemetry v0.0.0-20251111182119-bc8e575c7b54 // indirect
+ golang.org/x/tools v0.39.0 // indirect
gopkg.in/ini.v1 v1.67.0 // indirect
gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
)
diff --git a/go.sum b/go.sum
index f9e620fb2..77c0cbb40 100644
--- a/go.sum
+++ b/go.sum
@@ -99,8 +99,8 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/go-pipeline v0.0.0-20230411140531-6cbedfc1d3fc h1:hd+uUVsB1vdxohPneMrhGH2YfQuH5hRIK9u4/XCeUtw=
github.com/google/go-pipeline v0.0.0-20230411140531-6cbedfc1d3fc/go.mod h1:SL66SJVysrh7YbDCP9tH30b8a9o/N2HeiQNUm85EKhc=
-github.com/google/pprof v0.0.0-20251007162407-5df77e3f7d1d h1:KJIErDwbSHjnp/SGzE5ed8Aol7JsKiI5X7yWKAtzhM0=
-github.com/google/pprof v0.0.0-20251007162407-5df77e3f7d1d/go.mod h1:I6V7YzU0XDpsHqbsyrghnFZLO1gwK6NPTNvmetQIk9U=
+github.com/google/pprof v0.0.0-20251114195745-4902fdda35c8 h1:3DsUAV+VNEQa2CUVLxCY3f87278uWfIDhJnbdvDjvmE=
+github.com/google/pprof v0.0.0-20251114195745-4902fdda35c8/go.mod h1:I6V7YzU0XDpsHqbsyrghnFZLO1gwK6NPTNvmetQIk9U=
github.com/google/subcommands v1.2.0 h1:vWQspBTo2nEqTUFita5/KeEWlUL8kQObDFbub/EN9oE=
github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
@@ -162,8 +162,8 @@ github.com/lestrrat-go/jwx/v2 v2.1.6 h1:hxM1gfDILk/l5ylers6BX/Eq1m/pnxe9NBwW6lVf
github.com/lestrrat-go/jwx/v2 v2.1.6/go.mod h1:Y722kU5r/8mV7fYDifjug0r8FK8mZdw0K0GpJw/l8pU=
github.com/lestrrat-go/option v1.0.1 h1:oAzP2fvZGQKWkvHa1/SAcFolBEca1oN+mQ7eooNBEYU=
github.com/lestrrat-go/option v1.0.1/go.mod h1:5ZHFbivi4xwXxhxY9XHDe2FHo6/Z7WWmtT7T5nBBp3I=
-github.com/maruel/natural v1.1.1 h1:Hja7XhhmvEFhcByqDoHz9QZbkWey+COd9xWfCfn1ioo=
-github.com/maruel/natural v1.1.1/go.mod h1:v+Rfd79xlw1AgVBjbO0BEQmptqb5HvL/k9GRHB7ZKEg=
+github.com/maruel/natural v1.2.1 h1:G/y4pwtTA07lbQsMefvsmEO0VN0NfqpxprxXDM4R/4o=
+github.com/maruel/natural v1.2.1/go.mod h1:v+Rfd79xlw1AgVBjbO0BEQmptqb5HvL/k9GRHB7ZKEg=
github.com/matoous/go-nanoid/v2 v2.1.0 h1:P64+dmq21hhWdtvZfEAofnvJULaRR1Yib0+PnU669bE=
github.com/matoous/go-nanoid/v2 v2.1.0/go.mod h1:KlbGNQ+FhrUNIHUxZdL63t7tl4LaPkZNpUULS8H4uVM=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
@@ -186,8 +186,8 @@ github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdh
github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
github.com/ogier/pflag v0.0.1 h1:RW6JSWSu/RkSatfcLtogGfFgpim5p7ARQ10ECk5O750=
github.com/ogier/pflag v0.0.1/go.mod h1:zkFki7tvTa0tafRvTBIZTvzYyAu6kQhPZFnshFFPE+g=
-github.com/onsi/ginkgo/v2 v2.27.1 h1:0LJC8MpUSQnfnp4n/3W3GdlmJP3ENGF0ZPzjQGLPP7s=
-github.com/onsi/ginkgo/v2 v2.27.1/go.mod h1:wmy3vCqiBjirARfVhAqFpYt8uvX0yaFe+GudAqqcCqA=
+github.com/onsi/ginkgo/v2 v2.27.2 h1:LzwLj0b89qtIy6SSASkzlNvX6WktqurSHwkk2ipF/Ns=
+github.com/onsi/ginkgo/v2 v2.27.2/go.mod h1:ArE1D/XhNXBXCBkKOLkbsb2c81dQHCRcF5zwn/ykDRo=
github.com/onsi/gomega v1.38.2 h1:eZCjf2xjZAqe+LeWvKb5weQ+NcPwX84kqJ0cZNxok2A=
github.com/onsi/gomega v1.38.2/go.mod h1:W2MJcYxRGV63b418Ai34Ud0hEdTVXq9NW9+Sx6uXf3k=
github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
@@ -201,8 +201,6 @@ github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRI
github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/pocketbase/dbx v1.11.0 h1:LpZezioMfT3K4tLrqA55wWFw1EtH1pM4tzSVa7kgszU=
github.com/pocketbase/dbx v1.11.0/go.mod h1:xXRCIAKTHMgUCyCKZm55pUOdvFziJjQfXaWKhu2vhMs=
-github.com/prashantv/gostub v1.1.0 h1:BTyx3RfQjRHnUWaGF9oQos79AlQ5k8WNktv7VGvVH4g=
-github.com/prashantv/gostub v1.1.0/go.mod h1:A5zLQHz7ieHGG7is6LLXLz7I8+3LZzsrV0P1IAHhP5U=
github.com/pressly/goose/v3 v3.26.0 h1:KJakav68jdH0WDvoAcj8+n61WqOIaPGgH0bJWS6jpmM=
github.com/pressly/goose/v3 v3.26.0/go.mod h1:4hC1KrritdCxtuFsqgs1R4AU5bWtTAf+cnWvfhf2DNY=
github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o=
@@ -267,8 +265,8 @@ github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
-github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
-github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
+github.com/tetratelabs/wazero v1.10.1 h1:2DugeJf6VVk58KTPszlNfeeN8AhhpwcZqkJj2wwFuH8=
+github.com/tetratelabs/wazero v1.10.1/go.mod h1:DRm5twOQ5Gr1AoEdSi0CLjDQF1J9ZAuyqFIjl1KKfQU=
github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
@@ -286,8 +284,6 @@ github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
-go.uber.org/automaxprocs v1.6.0 h1:O3y2/QNTOdbF+e/dpXNNW7Rx2hZ4sTIPyybbxyNqTUs=
-go.uber.org/automaxprocs v1.6.0/go.mod h1:ifeIMSnPZuznNm6jmdzmU3/bfk01Fe2fotchwEFJ8r8=
go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
@@ -302,20 +298,20 @@ golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliY
golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
-golang.org/x/crypto v0.43.0 h1:dduJYIi3A3KOfdGOHX8AVZ/jGiyPa3IbBozJ5kNuE04=
-golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0=
-golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 h1:mgKeJMpvi0yx/sU5GsxQ7p6s2wtOnGAHZWCHUM4KGzY=
-golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546/go.mod h1:j/pmGrbnkbPtQfxEe5D0VQhZC6qKbfKifgD0oM7sR70=
+golang.org/x/crypto v0.45.0 h1:jMBrvKuj23MTlT0bQEOBcAE0mjg8mK9RXFhRH6nyF3Q=
+golang.org/x/crypto v0.45.0/go.mod h1:XTGrrkGJve7CYK7J8PEww4aY7gM3qMCElcJQ8n8JdX4=
+golang.org/x/exp v0.0.0-20251113190631-e25ba8c21ef6 h1:zfMcR1Cs4KNuomFFgGefv5N0czO2XZpUbxGUy8i8ug0=
+golang.org/x/exp v0.0.0-20251113190631-e25ba8c21ef6/go.mod h1:46edojNIoXTNOhySWIWdix628clX9ODXwPsQuG6hsK0=
golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.32.0 h1:6lZQWq75h7L5IWNk0r+SCpUJ6tUVd3v4ZHnbRKLkUDQ=
-golang.org/x/image v0.32.0/go.mod h1:/R37rrQmKXtO6tYXAjtDLwQgFLHmhW+V6ayXlxzP2Pc=
+golang.org/x/image v0.33.0 h1:LXRZRnv1+zGd5XBUVRFmYEphyyKJjQjCRiOuAP3sZfQ=
+golang.org/x/image v0.33.0/go.mod h1:DD3OsTYT9chzuzTQt+zMcOlBHgfoKQb1gry8p76Y1sc=
golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/mod v0.29.0 h1:HV8lRxZC4l2cr3Zq1LvtOsi/ThTgWnUk/y64QSs8GwA=
-golang.org/x/mod v0.29.0/go.mod h1:NyhrlYXJ2H4eJiRy/WDBO6HMqZQ6q9nk4JzS3NuCK+w=
+golang.org/x/mod v0.30.0 h1:fDEXFVZ/fmCKProc/yAXXUijritrDzahmwwefnjoPFk=
+golang.org/x/mod v0.30.0/go.mod h1:lAsf5O2EvJeSFMiBxXDki7sCgAxEUcZHXoXMKT4GJKc=
golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
@@ -327,8 +323,8 @@ golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
-golang.org/x/net v0.46.0 h1:giFlY12I07fugqwPuWJi68oOnpfqFnJIJzaIIm2JVV4=
-golang.org/x/net v0.46.0/go.mod h1:Q9BGdFy1y4nkUwiLvT5qtyhAnEHgnQ/zd8PfU6nc210=
+golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY=
+golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -336,8 +332,8 @@ golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
-golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sync v0.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I=
+golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20180926160741-c2ed4eda69e7/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -354,11 +350,11 @@ golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
-golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
+golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
-golang.org/x/telemetry v0.0.0-20251008203120-078029d740a8 h1:LvzTn0GQhWuvKH/kVRS3R3bVAsdQWI7hvfLHGgh9+lU=
-golang.org/x/telemetry v0.0.0-20251008203120-078029d740a8/go.mod h1:Pi4ztBfryZoJEkyFTI5/Ocsu2jXyDr6iSdgJiYE/uwE=
+golang.org/x/telemetry v0.0.0-20251111182119-bc8e575c7b54 h1:E2/AqCUMZGgd73TQkxUMcMla25GB9i/5HOdLr+uH7Vo=
+golang.org/x/telemetry v0.0.0-20251111182119-bc8e575c7b54/go.mod h1:hKdjCMrbv9skySur+Nek8Hd0uJ0GuxJIoIX2payrIdQ=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
@@ -377,8 +373,8 @@ golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
-golang.org/x/text v0.30.0 h1:yznKA/E9zq54KzlzBEAWn1NXSQ8DIp/NYMy88xJjl4k=
-golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM=
+golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
+golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI=
golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -388,8 +384,8 @@ golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc
golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
-golang.org/x/tools v0.38.0 h1:Hx2Xv8hISq8Lm16jvBZ2VQf+RLmbd7wVUsALibYI/IQ=
-golang.org/x/tools v0.38.0/go.mod h1:yEsQ/d/YK8cjh0L6rZlY8tgtlKiBNTL14pGDJPJpYQs=
+golang.org/x/tools v0.39.0 h1:ik4ho21kwuQln40uelmciQPp9SipgNDdrafrYA4TmQQ=
+golang.org/x/tools v0.39.0/go.mod h1:JnefbkDPyD8UU2kI5fuf8ZX4/yUeh9W877ZeBONxUqQ=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
diff --git a/log/log.go b/log/log.go
index 20119ab46..801fd7214 100644
--- a/log/log.go
+++ b/log/log.go
@@ -11,6 +11,7 @@ import (
"runtime"
"sort"
"strings"
+ "sync"
"time"
"github.com/sirupsen/logrus"
@@ -70,6 +71,7 @@ type levelPath struct {
var (
currentLevel Level
+ loggerMu sync.RWMutex
defaultLogger = logrus.New()
logSourceLine = false
rootPath string
@@ -78,8 +80,10 @@ var (
// SetLevel sets the global log level used by the simple logger.
func SetLevel(l Level) {
+ loggerMu.Lock()
currentLevel = l
defaultLogger.Level = logrus.TraceLevel
+ loggerMu.Unlock()
logrus.SetLevel(logrus.Level(l))
}
@@ -110,6 +114,8 @@ func levelFromString(l string) Level {
// SetLogLevels sets the log levels for specific paths in the codebase.
func SetLogLevels(levels map[string]string) {
+ loggerMu.Lock()
+ defer loggerMu.Unlock()
logLevels = nil
for k, v := range levels {
logLevels = append(logLevels, levelPath{path: k, level: levelFromString(v)})
@@ -125,6 +131,8 @@ func SetLogSourceLine(enabled bool) {
func SetRedacting(enabled bool) {
if enabled {
+ loggerMu.Lock()
+ defer loggerMu.Unlock()
defaultLogger.AddHook(redacted)
}
}
@@ -133,6 +141,8 @@ func SetOutput(w io.Writer) {
if runtime.GOOS == "windows" {
w = CRLFWriter(w)
}
+ loggerMu.Lock()
+ defer loggerMu.Unlock()
defaultLogger.SetOutput(w)
}
@@ -158,10 +168,14 @@ func NewContext(ctx context.Context, keyValuePairs ...interface{}) context.Conte
}
func SetDefaultLogger(l *logrus.Logger) {
+ loggerMu.Lock()
+ defer loggerMu.Unlock()
defaultLogger = l
}
func CurrentLevel() Level {
+ loggerMu.RLock()
+ defer loggerMu.RUnlock()
return currentLevel
}
@@ -204,14 +218,21 @@ func log(level Level, args ...interface{}) {
}
func Writer() io.Writer {
+ loggerMu.RLock()
+ defer loggerMu.RUnlock()
return defaultLogger.Writer()
}
func shouldLog(requiredLevel Level, skip int) bool {
- if currentLevel >= requiredLevel {
+ loggerMu.RLock()
+ level := currentLevel
+ levels := logLevels
+ loggerMu.RUnlock()
+
+ if level >= requiredLevel {
return true
}
- if len(logLevels) == 0 {
+ if len(levels) == 0 {
return false
}
@@ -221,7 +242,7 @@ func shouldLog(requiredLevel Level, skip int) bool {
}
file = strings.TrimPrefix(file, rootPath)
- for _, lp := range logLevels {
+ for _, lp := range levels {
if strings.HasPrefix(file, lp.path) {
return lp.level >= requiredLevel
}
@@ -314,6 +335,8 @@ func extractLogger(ctx interface{}) (*logrus.Entry, error) {
func createNewLogger() *logrus.Entry {
//logrus.SetFormatter(&logrus.TextFormatter{ForceColors: true, DisableTimestamp: false, FullTimestamp: true})
//l.Formatter = &logrus.TextFormatter{ForceColors: true, DisableTimestamp: false, FullTimestamp: true}
+ loggerMu.RLock()
+ defer loggerMu.RUnlock()
logger := logrus.NewEntry(defaultLogger)
return logger
}
diff --git a/model/datastore.go b/model/datastore.go
index 4290e2134..536a37274 100644
--- a/model/datastore.go
+++ b/model/datastore.go
@@ -43,5 +43,5 @@ type DataStore interface {
WithTx(block func(tx DataStore) error, scope ...string) error
WithTxImmediate(block func(tx DataStore) error, scope ...string) error
- GC(ctx context.Context) error
+ GC(ctx context.Context, libraryIDs ...int) error
}
diff --git a/model/folder.go b/model/folder.go
index f715f8c11..7a769735e 100644
--- a/model/folder.go
+++ b/model/folder.go
@@ -85,7 +85,7 @@ type FolderRepository interface {
GetByPath(lib Library, path string) (*Folder, error)
GetAll(...QueryOptions) ([]Folder, error)
CountAll(...QueryOptions) (int64, error)
- GetLastUpdates(lib Library) (map[string]FolderUpdateInfo, error)
+ GetFolderUpdateInfo(lib Library, targetPaths ...string) (map[string]FolderUpdateInfo, error)
Put(*Folder) error
MarkMissing(missing bool, ids ...string) error
GetTouchedWithPlaylists() (FolderCursor, error)
diff --git a/model/metadata/legacy_ids.go b/model/metadata/legacy_ids.go
index 0a3bf0bf3..18a273550 100644
--- a/model/metadata/legacy_ids.go
+++ b/model/metadata/legacy_ids.go
@@ -23,7 +23,7 @@ func legacyTrackID(mf model.MediaFile, prependLibId bool) string {
}
func legacyAlbumID(mf model.MediaFile, md Metadata, prependLibId bool) string {
- releaseDate := legacyReleaseDate(md)
+ _, _, releaseDate := md.mapDates()
albumPath := strings.ToLower(fmt.Sprintf("%s\\%s", legacyMapAlbumArtistName(md), legacyMapAlbumName(md)))
if !conf.Server.Scanner.GroupAlbumReleases {
if len(releaseDate) != 0 {
@@ -55,9 +55,3 @@ func legacyMapAlbumName(md Metadata) string {
consts.UnknownAlbum,
)
}
-
-// Keep the TaggedLikePicard logic for backwards compatibility
-func legacyReleaseDate(md Metadata) string {
- _, _, releaseDate := md.mapDates()
- return string(releaseDate)
-}
diff --git a/model/metadata/legacy_ids_test.go b/model/metadata/legacy_ids_test.go
deleted file mode 100644
index b6d096763..000000000
--- a/model/metadata/legacy_ids_test.go
+++ /dev/null
@@ -1,30 +0,0 @@
-package metadata
-
-import (
- . "github.com/onsi/ginkgo/v2"
- . "github.com/onsi/gomega"
-)
-
-var _ = Describe("legacyReleaseDate", func() {
-
- DescribeTable("legacyReleaseDate",
- func(recordingDate, originalDate, releaseDate, expected string) {
- md := New("", Info{
- Tags: map[string][]string{
- "DATE": {recordingDate},
- "ORIGINALDATE": {originalDate},
- "RELEASEDATE": {releaseDate},
- },
- })
-
- result := legacyReleaseDate(md)
- Expect(result).To(Equal(expected))
- },
- Entry("regular mapping", "2020-05-15", "2019-02-10", "2021-01-01", "2021-01-01"),
- Entry("legacy mapping", "2020-05-15", "2019-02-10", "", "2020-05-15"),
- Entry("legacy mapping, originalYear < year", "2018-05-15", "2019-02-10", "2021-01-01", "2021-01-01"),
- Entry("legacy mapping, originalYear empty", "2020-05-15", "", "2021-01-01", "2021-01-01"),
- Entry("legacy mapping, releaseYear", "2020-05-15", "2019-02-10", "2021-01-01", "2021-01-01"),
- Entry("legacy mapping, same dates", "2020-05-15", "2020-05-15", "", "2020-05-15"),
- )
-})
diff --git a/model/metadata/map_mediafile_test.go b/model/metadata/map_mediafile_test.go
index ddda39bc2..e3adf3fae 100644
--- a/model/metadata/map_mediafile_test.go
+++ b/model/metadata/map_mediafile_test.go
@@ -75,6 +75,23 @@ var _ = Describe("ToMediaFile", func() {
Expect(mf.OriginalYear).To(Equal(1966))
Expect(mf.ReleaseYear).To(Equal(2014))
})
+ DescribeTable("legacyReleaseDate (TaggedLikePicard old behavior)",
+ func(recordingDate, originalDate, releaseDate, expected string) {
+ mf := toMediaFile(model.RawTags{
+ "DATE": {recordingDate},
+ "ORIGINALDATE": {originalDate},
+ "RELEASEDATE": {releaseDate},
+ })
+
+ Expect(mf.ReleaseDate).To(Equal(expected))
+ },
+ Entry("regular mapping", "2020-05-15", "2019-02-10", "2021-01-01", "2021-01-01"),
+ Entry("legacy mapping", "2020-05-15", "2019-02-10", "", "2020-05-15"),
+ Entry("legacy mapping, originalYear < year", "2018-05-15", "2019-02-10", "2021-01-01", "2021-01-01"),
+ Entry("legacy mapping, originalYear empty", "2020-05-15", "", "2021-01-01", "2021-01-01"),
+ Entry("legacy mapping, releaseYear", "2020-05-15", "2019-02-10", "2021-01-01", "2021-01-01"),
+ Entry("legacy mapping, same dates", "2020-05-15", "2020-05-15", "", "2020-05-15"),
+ )
})
Describe("Lyrics", func() {
diff --git a/model/scanner.go b/model/scanner.go
new file mode 100644
index 000000000..389c77f87
--- /dev/null
+++ b/model/scanner.go
@@ -0,0 +1,81 @@
+package model
+
+import (
+ "context"
+ "fmt"
+ "strconv"
+ "strings"
+ "time"
+)
+
+// ScanTarget represents a specific folder within a library to be scanned.
+// NOTE: This struct is used as a map key, so it should only contain comparable types.
+type ScanTarget struct {
+ LibraryID int
+ FolderPath string // Relative path within the library, or "" for entire library
+}
+
+func (st ScanTarget) String() string {
+ return fmt.Sprintf("%d:%s", st.LibraryID, st.FolderPath)
+}
+
+// ScannerStatus holds information about the current scan status
+type ScannerStatus struct {
+ Scanning bool
+ LastScan time.Time
+ Count uint32
+ FolderCount uint32
+ LastError string
+ ScanType string
+ ElapsedTime time.Duration
+}
+
+type Scanner interface {
+ // ScanAll starts a scan of all libraries. This is a blocking operation.
+ ScanAll(ctx context.Context, fullScan bool) (warnings []string, err error)
+ // ScanFolders scans specific library/folder pairs, recursing into subdirectories.
+ // If targets is nil, it scans all libraries. This is a blocking operation.
+ ScanFolders(ctx context.Context, fullScan bool, targets []ScanTarget) (warnings []string, err error)
+ Status(context.Context) (*ScannerStatus, error)
+}
+
+// ParseTargets parses scan targets strings into ScanTarget structs.
+// Example: []string{"1:Music/Rock", "2:Classical"}
+func ParseTargets(libFolders []string) ([]ScanTarget, error) {
+ targets := make([]ScanTarget, 0, len(libFolders))
+
+ for _, part := range libFolders {
+ part = strings.TrimSpace(part)
+ if part == "" {
+ continue
+ }
+
+ // Split by the first colon
+ colonIdx := strings.Index(part, ":")
+ if colonIdx == -1 {
+ return nil, fmt.Errorf("invalid target format: %q (expected libraryID:folderPath)", part)
+ }
+
+ libIDStr := part[:colonIdx]
+ folderPath := part[colonIdx+1:]
+
+ libID, err := strconv.Atoi(libIDStr)
+ if err != nil {
+ return nil, fmt.Errorf("invalid library ID %q: %w", libIDStr, err)
+ }
+ if libID <= 0 {
+ return nil, fmt.Errorf("invalid library ID %q", libIDStr)
+ }
+
+ targets = append(targets, ScanTarget{
+ LibraryID: libID,
+ FolderPath: folderPath,
+ })
+ }
+
+ if len(targets) == 0 {
+ return nil, fmt.Errorf("no valid targets found")
+ }
+
+ return targets, nil
+}
diff --git a/model/scanner_test.go b/model/scanner_test.go
new file mode 100644
index 000000000..8ca0c53fa
--- /dev/null
+++ b/model/scanner_test.go
@@ -0,0 +1,89 @@
+package model_test
+
+import (
+ "github.com/navidrome/navidrome/model"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+var _ = Describe("ParseTargets", func() {
+ It("parses multiple entries in slice", func() {
+ targets, err := model.ParseTargets([]string{"1:Music/Rock", "1:Music/Jazz", "2:Classical"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(targets).To(HaveLen(3))
+ Expect(targets[0].LibraryID).To(Equal(1))
+ Expect(targets[0].FolderPath).To(Equal("Music/Rock"))
+ Expect(targets[1].LibraryID).To(Equal(1))
+ Expect(targets[1].FolderPath).To(Equal("Music/Jazz"))
+ Expect(targets[2].LibraryID).To(Equal(2))
+ Expect(targets[2].FolderPath).To(Equal("Classical"))
+ })
+
+ It("handles empty folder paths", func() {
+ targets, err := model.ParseTargets([]string{"1:", "2:"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(targets).To(HaveLen(2))
+ Expect(targets[0].FolderPath).To(Equal(""))
+ Expect(targets[1].FolderPath).To(Equal(""))
+ })
+
+ It("trims whitespace from entries", func() {
+ targets, err := model.ParseTargets([]string{" 1:Music/Rock", " 2:Classical "})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(targets).To(HaveLen(2))
+ Expect(targets[0].LibraryID).To(Equal(1))
+ Expect(targets[0].FolderPath).To(Equal("Music/Rock"))
+ Expect(targets[1].LibraryID).To(Equal(2))
+ Expect(targets[1].FolderPath).To(Equal("Classical"))
+ })
+
+ It("skips empty strings", func() {
+ targets, err := model.ParseTargets([]string{"1:Music/Rock", "", "2:Classical"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(targets).To(HaveLen(2))
+ })
+
+ It("handles paths with colons", func() {
+ targets, err := model.ParseTargets([]string{"1:C:/Music/Rock", "2:/path:with:colons"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(targets).To(HaveLen(2))
+ Expect(targets[0].FolderPath).To(Equal("C:/Music/Rock"))
+ Expect(targets[1].FolderPath).To(Equal("/path:with:colons"))
+ })
+
+ It("returns error for invalid format without colon", func() {
+ _, err := model.ParseTargets([]string{"1Music/Rock"})
+ Expect(err).To(HaveOccurred())
+ Expect(err.Error()).To(ContainSubstring("invalid target format"))
+ })
+
+ It("returns error for non-numeric library ID", func() {
+ _, err := model.ParseTargets([]string{"abc:Music/Rock"})
+ Expect(err).To(HaveOccurred())
+ Expect(err.Error()).To(ContainSubstring("invalid library ID"))
+ })
+
+ It("returns error for negative library ID", func() {
+ _, err := model.ParseTargets([]string{"-1:Music/Rock"})
+ Expect(err).To(HaveOccurred())
+ Expect(err.Error()).To(ContainSubstring("invalid library ID"))
+ })
+
+ It("returns error for zero library ID", func() {
+ _, err := model.ParseTargets([]string{"0:Music/Rock"})
+ Expect(err).To(HaveOccurred())
+ Expect(err.Error()).To(ContainSubstring("invalid library ID"))
+ })
+
+ It("returns error for empty input", func() {
+ _, err := model.ParseTargets([]string{})
+ Expect(err).To(HaveOccurred())
+ Expect(err.Error()).To(ContainSubstring("no valid targets found"))
+ })
+
+ It("returns error for all empty strings", func() {
+ _, err := model.ParseTargets([]string{"", " ", ""})
+ Expect(err).To(HaveOccurred())
+ Expect(err.Error()).To(ContainSubstring("no valid targets found"))
+ })
+})
diff --git a/persistence/album_repository.go b/persistence/album_repository.go
index 6f9bb3b48..b1ce23e2b 100644
--- a/persistence/album_repository.go
+++ b/persistence/album_repository.go
@@ -337,8 +337,12 @@ on conflict (user_id, item_id, item_type) do update
return r.executeSQL(query)
}
-func (r *albumRepository) purgeEmpty() error {
+func (r *albumRepository) purgeEmpty(libraryIDs ...int) error {
del := Delete(r.tableName).Where("id not in (select distinct(album_id) from media_file)")
+ // If libraryIDs are specified, only purge albums from those libraries
+ if len(libraryIDs) > 0 {
+ del = del.Where(Eq{"library_id": libraryIDs})
+ }
c, err := r.executeSQL(del)
if err != nil {
return fmt.Errorf("purging empty albums: %w", err)
diff --git a/persistence/album_repository_test.go b/persistence/album_repository_test.go
index 4be89bcb8..a062b4398 100644
--- a/persistence/album_repository_test.go
+++ b/persistence/album_repository_test.go
@@ -55,6 +55,7 @@ var _ = Describe("AlbumRepository", func() {
It("returns all records sorted", func() {
Expect(GetAll(model.QueryOptions{Sort: "name"})).To(Equal(model.Albums{
albumAbbeyRoad,
+ albumMultiDisc,
albumRadioactivity,
albumSgtPeppers,
}))
@@ -64,6 +65,7 @@ var _ = Describe("AlbumRepository", func() {
Expect(GetAll(model.QueryOptions{Sort: "name", Order: "desc"})).To(Equal(model.Albums{
albumSgtPeppers,
albumRadioactivity,
+ albumMultiDisc,
albumAbbeyRoad,
}))
})
diff --git a/persistence/folder_repository.go b/persistence/folder_repository.go
index 96a9bae82..a586746a0 100644
--- a/persistence/folder_repository.go
+++ b/persistence/folder_repository.go
@@ -4,7 +4,10 @@ import (
"context"
"encoding/json"
"fmt"
+ "os"
+ "path/filepath"
"slices"
+ "strings"
"time"
. "github.com/Masterminds/squirrel"
@@ -91,8 +94,47 @@ func (r folderRepository) CountAll(opt ...model.QueryOptions) (int64, error) {
return r.count(query)
}
-func (r folderRepository) GetLastUpdates(lib model.Library) (map[string]model.FolderUpdateInfo, error) {
- sq := r.newSelect().Columns("id", "updated_at", "hash").Where(Eq{"library_id": lib.ID, "missing": false})
+func (r folderRepository) GetFolderUpdateInfo(lib model.Library, targetPaths ...string) (map[string]model.FolderUpdateInfo, error) {
+ where := And{
+ Eq{"library_id": lib.ID},
+ Eq{"missing": false},
+ }
+
+ // If specific paths are requested, include those folders and all their descendants
+ if len(targetPaths) > 0 {
+ // Collect folder IDs for exact target folders and path conditions for descendants
+ folderIDs := make([]string, 0, len(targetPaths))
+ pathConditions := make(Or, 0, len(targetPaths)*2)
+
+ for _, targetPath := range targetPaths {
+ if targetPath == "" || targetPath == "." {
+ // Root path - include everything in this library
+ pathConditions = Or{}
+ folderIDs = nil
+ break
+ }
+ // Clean the path to normalize it. Paths stored in the folder table do not have leading/trailing slashes.
+ cleanPath := strings.TrimPrefix(targetPath, string(os.PathSeparator))
+ cleanPath = filepath.Clean(cleanPath)
+
+ // Include the target folder itself by ID
+ folderIDs = append(folderIDs, model.FolderID(lib, cleanPath))
+
+ // Include all descendants: folders whose path field equals or starts with the target path
+ // Note: Folder.Path is the directory path, so children have path = targetPath
+ pathConditions = append(pathConditions, Eq{"path": cleanPath})
+ pathConditions = append(pathConditions, Like{"path": cleanPath + "/%"})
+ }
+
+ // Combine conditions: exact folder IDs OR descendant path patterns
+ if len(folderIDs) > 0 {
+ where = append(where, Or{Eq{"id": folderIDs}, pathConditions})
+ } else if len(pathConditions) > 0 {
+ where = append(where, pathConditions)
+ }
+ }
+
+ sq := r.newSelect().Columns("id", "updated_at", "hash").Where(where)
var res []struct {
ID string
UpdatedAt time.Time
@@ -149,7 +191,7 @@ func (r folderRepository) GetTouchedWithPlaylists() (model.FolderCursor, error)
}, nil
}
-func (r folderRepository) purgeEmpty() error {
+func (r folderRepository) purgeEmpty(libraryIDs ...int) error {
sq := Delete(r.tableName).Where(And{
Eq{"num_audio_files": 0},
Eq{"num_playlists": 0},
@@ -157,6 +199,10 @@ func (r folderRepository) purgeEmpty() error {
ConcatExpr("id not in (select parent_id from folder)"),
ConcatExpr("id not in (select folder_id from media_file)"),
})
+ // If libraryIDs are specified, only purge folders from those libraries
+ if len(libraryIDs) > 0 {
+ sq = sq.Where(Eq{"library_id": libraryIDs})
+ }
c, err := r.executeSQL(sq)
if err != nil {
return fmt.Errorf("purging empty folders: %w", err)
diff --git a/persistence/folder_repository_test.go b/persistence/folder_repository_test.go
new file mode 100644
index 000000000..6c24741c9
--- /dev/null
+++ b/persistence/folder_repository_test.go
@@ -0,0 +1,213 @@
+package persistence
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/model/request"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+ "github.com/pocketbase/dbx"
+)
+
+var _ = Describe("FolderRepository", func() {
+ var repo model.FolderRepository
+ var ctx context.Context
+ var conn *dbx.DB
+ var testLib, otherLib model.Library
+
+ BeforeEach(func() {
+ ctx = request.WithUser(log.NewContext(context.TODO()), model.User{ID: "userid"})
+ conn = GetDBXBuilder()
+ repo = newFolderRepository(ctx, conn)
+
+ // Use existing library ID 1 from test fixtures
+ libRepo := NewLibraryRepository(ctx, conn)
+ lib, err := libRepo.Get(1)
+ Expect(err).ToNot(HaveOccurred())
+ testLib = *lib
+
+ // Create a second library with its own folder to verify isolation
+ otherLib = model.Library{Name: "Other Library", Path: "/other/path"}
+ Expect(libRepo.Put(&otherLib)).To(Succeed())
+ })
+
+ AfterEach(func() {
+ // Clean up only test folders created by our tests (paths starting with "Test")
+ // This prevents interference with fixture data needed by other tests
+ _, _ = conn.NewQuery("DELETE FROM folder WHERE library_id = 1 AND path LIKE 'Test%'").Execute()
+ _, _ = conn.NewQuery(fmt.Sprintf("DELETE FROM library WHERE id = %d", otherLib.ID)).Execute()
+ })
+
+ Describe("GetFolderUpdateInfo", func() {
+ Context("with no target paths", func() {
+ It("returns all folders in the library", func() {
+ // Create test folders with unique names to avoid conflicts
+ folder1 := model.NewFolder(testLib, "TestGetLastUpdates/Folder1")
+ folder2 := model.NewFolder(testLib, "TestGetLastUpdates/Folder2")
+
+ err := repo.Put(folder1)
+ Expect(err).ToNot(HaveOccurred())
+ err = repo.Put(folder2)
+ Expect(err).ToNot(HaveOccurred())
+
+ otherFolder := model.NewFolder(otherLib, "TestOtherLib/Folder")
+ err = repo.Put(otherFolder)
+ Expect(err).ToNot(HaveOccurred())
+
+ // Query all folders (no target paths) - should only return folders from testLib
+ results, err := repo.GetFolderUpdateInfo(testLib)
+ Expect(err).ToNot(HaveOccurred())
+ // Should include folders from testLib
+ Expect(results).To(HaveKey(folder1.ID))
+ Expect(results).To(HaveKey(folder2.ID))
+ // Should NOT include folders from other library
+ Expect(results).ToNot(HaveKey(otherFolder.ID))
+ })
+ })
+
+ Context("with specific target paths", func() {
+ It("returns folder info for existing folders", func() {
+ // Create test folders with unique names
+ folder1 := model.NewFolder(testLib, "TestSpecific/Rock")
+ folder2 := model.NewFolder(testLib, "TestSpecific/Jazz")
+ folder3 := model.NewFolder(testLib, "TestSpecific/Classical")
+
+ err := repo.Put(folder1)
+ Expect(err).ToNot(HaveOccurred())
+ err = repo.Put(folder2)
+ Expect(err).ToNot(HaveOccurred())
+ err = repo.Put(folder3)
+ Expect(err).ToNot(HaveOccurred())
+
+ // Query specific paths
+ results, err := repo.GetFolderUpdateInfo(testLib, "TestSpecific/Rock", "TestSpecific/Classical")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(results).To(HaveLen(2))
+
+ // Verify folder IDs are in results
+ Expect(results).To(HaveKey(folder1.ID))
+ Expect(results).To(HaveKey(folder3.ID))
+ Expect(results).ToNot(HaveKey(folder2.ID))
+
+ // Verify update info is populated
+ Expect(results[folder1.ID].UpdatedAt).ToNot(BeZero())
+ Expect(results[folder1.ID].Hash).To(Equal(folder1.Hash))
+ })
+
+ It("includes all child folders when querying parent", func() {
+ // Create a parent folder with multiple children
+ parent := model.NewFolder(testLib, "TestParent/Music")
+ child1 := model.NewFolder(testLib, "TestParent/Music/Rock/Queen")
+ child2 := model.NewFolder(testLib, "TestParent/Music/Jazz")
+ otherParent := model.NewFolder(testLib, "TestParent2/Music/Jazz")
+
+ Expect(repo.Put(parent)).To(Succeed())
+ Expect(repo.Put(child1)).To(Succeed())
+ Expect(repo.Put(child2)).To(Succeed())
+
+ // Query the parent folder - should return parent and all children
+ results, err := repo.GetFolderUpdateInfo(testLib, "TestParent/Music")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(results).To(HaveLen(3))
+ Expect(results).To(HaveKey(parent.ID))
+ Expect(results).To(HaveKey(child1.ID))
+ Expect(results).To(HaveKey(child2.ID))
+ Expect(results).ToNot(HaveKey(otherParent.ID))
+ })
+
+ It("excludes children from other libraries", func() {
+ // Create parent in testLib
+ parent := model.NewFolder(testLib, "TestIsolation/Parent")
+ child := model.NewFolder(testLib, "TestIsolation/Parent/Child")
+
+ Expect(repo.Put(parent)).To(Succeed())
+ Expect(repo.Put(child)).To(Succeed())
+
+ // Create similar path in other library
+ otherParent := model.NewFolder(otherLib, "TestIsolation/Parent")
+ otherChild := model.NewFolder(otherLib, "TestIsolation/Parent/Child")
+
+ Expect(repo.Put(otherParent)).To(Succeed())
+ Expect(repo.Put(otherChild)).To(Succeed())
+
+ // Query should only return folders from testLib
+ results, err := repo.GetFolderUpdateInfo(testLib, "TestIsolation/Parent")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(results).To(HaveLen(2))
+ Expect(results).To(HaveKey(parent.ID))
+ Expect(results).To(HaveKey(child.ID))
+ Expect(results).ToNot(HaveKey(otherParent.ID))
+ Expect(results).ToNot(HaveKey(otherChild.ID))
+ })
+
+ It("excludes missing children when querying parent", func() {
+ // Create parent and children, mark one as missing
+ parent := model.NewFolder(testLib, "TestMissingChild/Parent")
+ child1 := model.NewFolder(testLib, "TestMissingChild/Parent/Child1")
+ child2 := model.NewFolder(testLib, "TestMissingChild/Parent/Child2")
+ child2.Missing = true
+
+ Expect(repo.Put(parent)).To(Succeed())
+ Expect(repo.Put(child1)).To(Succeed())
+ Expect(repo.Put(child2)).To(Succeed())
+
+ // Query parent - should only return parent and non-missing child
+ results, err := repo.GetFolderUpdateInfo(testLib, "TestMissingChild/Parent")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(results).To(HaveLen(2))
+ Expect(results).To(HaveKey(parent.ID))
+ Expect(results).To(HaveKey(child1.ID))
+ Expect(results).ToNot(HaveKey(child2.ID))
+ })
+
+ It("handles mix of existing and non-existing target paths", func() {
+ // Create folders for one path but not the other
+ existingParent := model.NewFolder(testLib, "TestMixed/Exists")
+ existingChild := model.NewFolder(testLib, "TestMixed/Exists/Child")
+
+ Expect(repo.Put(existingParent)).To(Succeed())
+ Expect(repo.Put(existingChild)).To(Succeed())
+
+ // Query both existing and non-existing paths
+ results, err := repo.GetFolderUpdateInfo(testLib, "TestMixed/Exists", "TestMixed/DoesNotExist")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(results).To(HaveLen(2))
+ Expect(results).To(HaveKey(existingParent.ID))
+ Expect(results).To(HaveKey(existingChild.ID))
+ })
+
+ It("handles empty folder path as root", func() {
+ // Test querying for root folder without creating it (fixtures should have one)
+ rootFolderID := model.FolderID(testLib, ".")
+
+ results, err := repo.GetFolderUpdateInfo(testLib, "")
+ Expect(err).ToNot(HaveOccurred())
+ // Should return the root folder if it exists
+ if len(results) > 0 {
+ Expect(results).To(HaveKey(rootFolderID))
+ }
+ })
+
+ It("returns empty map for non-existent folders", func() {
+ results, err := repo.GetFolderUpdateInfo(testLib, "NonExistent/Path")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(results).To(BeEmpty())
+ })
+
+ It("skips missing folders", func() {
+ // Create a folder and mark it as missing
+ folder := model.NewFolder(testLib, "TestMissing/Folder")
+ folder.Missing = true
+ err := repo.Put(folder)
+ Expect(err).ToNot(HaveOccurred())
+
+ results, err := repo.GetFolderUpdateInfo(testLib, "TestMissing/Folder")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(results).To(BeEmpty())
+ })
+ })
+ })
+})
diff --git a/persistence/library_repository.go b/persistence/library_repository.go
index 314b682bb..5621e1719 100644
--- a/persistence/library_repository.go
+++ b/persistence/library_repository.go
@@ -177,7 +177,9 @@ func (r *libraryRepository) ScanEnd(id int) error {
return err
}
// https://www.sqlite.org/pragma.html#pragma_optimize
- _, err = r.executeSQL(Expr("PRAGMA optimize=0x10012;"))
+ // Use mask 0x10000 to check table sizes without running ANALYZE
+ // Running ANALYZE can cause query planner issues with expression-based collation indexes
+ _, err = r.executeSQL(Expr("PRAGMA optimize=0x10000;"))
return err
}
diff --git a/persistence/library_repository_test.go b/persistence/library_repository_test.go
index 6f4df1beb..3e3972bdb 100644
--- a/persistence/library_repository_test.go
+++ b/persistence/library_repository_test.go
@@ -142,4 +142,62 @@ var _ = Describe("LibraryRepository", func() {
Expect(libAfter.TotalSize).To(Equal(sizeRes.Sum))
Expect(libAfter.TotalDuration).To(Equal(durationRes.Sum))
})
+
+ Describe("ScanBegin and ScanEnd", func() {
+ var lib *model.Library
+
+ BeforeEach(func() {
+ lib = &model.Library{
+ ID: 0,
+ Name: "Test Scan Library",
+ Path: "/music/test-scan",
+ }
+ err := repo.Put(lib)
+ Expect(err).ToNot(HaveOccurred())
+ })
+
+ DescribeTable("ScanBegin",
+ func(fullScan bool, expectedFullScanInProgress bool) {
+ err := repo.ScanBegin(lib.ID, fullScan)
+ Expect(err).ToNot(HaveOccurred())
+
+ updatedLib, err := repo.Get(lib.ID)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(updatedLib.LastScanStartedAt).ToNot(BeZero())
+ Expect(updatedLib.FullScanInProgress).To(Equal(expectedFullScanInProgress))
+ },
+ Entry("sets FullScanInProgress to true for full scan", true, true),
+ Entry("sets FullScanInProgress to false for quick scan", false, false),
+ )
+
+ Context("ScanEnd", func() {
+ BeforeEach(func() {
+ err := repo.ScanBegin(lib.ID, true)
+ Expect(err).ToNot(HaveOccurred())
+ })
+
+ It("sets LastScanAt and clears FullScanInProgress and LastScanStartedAt", func() {
+ err := repo.ScanEnd(lib.ID)
+ Expect(err).ToNot(HaveOccurred())
+
+ updatedLib, err := repo.Get(lib.ID)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(updatedLib.LastScanAt).ToNot(BeZero())
+ Expect(updatedLib.FullScanInProgress).To(BeFalse())
+ Expect(updatedLib.LastScanStartedAt).To(BeZero())
+ })
+
+ It("sets LastScanAt to be after LastScanStartedAt", func() {
+ libBefore, err := repo.Get(lib.ID)
+ Expect(err).ToNot(HaveOccurred())
+
+ err = repo.ScanEnd(lib.ID)
+ Expect(err).ToNot(HaveOccurred())
+
+ libAfter, err := repo.Get(lib.ID)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(libAfter.LastScanAt).To(BeTemporally(">=", libBefore.LastScanStartedAt))
+ })
+ })
+ })
})
diff --git a/persistence/mediafile_repository_test.go b/persistence/mediafile_repository_test.go
index 002b82499..ab926c00d 100644
--- a/persistence/mediafile_repository_test.go
+++ b/persistence/mediafile_repository_test.go
@@ -38,7 +38,7 @@ var _ = Describe("MediaRepository", func() {
})
It("counts the number of mediafiles in the DB", func() {
- Expect(mr.CountAll()).To(Equal(int64(6)))
+ Expect(mr.CountAll()).To(Equal(int64(10)))
})
It("returns songs ordered by lyrics with a specific title/artist", func() {
diff --git a/persistence/persistence.go b/persistence/persistence.go
index ac607f85f..1de0bae61 100644
--- a/persistence/persistence.go
+++ b/persistence/persistence.go
@@ -157,7 +157,7 @@ func (s *SQLStore) WithTxImmediate(block func(tx model.DataStore) error, scope .
}, scope...)
}
-func (s *SQLStore) GC(ctx context.Context) error {
+func (s *SQLStore) GC(ctx context.Context, libraryIDs ...int) error {
trace := func(ctx context.Context, msg string, f func() error) func() error {
return func() error {
start := time.Now()
@@ -167,11 +167,17 @@ func (s *SQLStore) GC(ctx context.Context) error {
}
}
+ // If libraryIDs are provided, scope operations to those libraries where possible
+ scoped := len(libraryIDs) > 0
+ if scoped {
+ log.Debug(ctx, "GC: Running selective garbage collection", "libraryIDs", libraryIDs)
+ }
+
err := run.Sequentially(
- trace(ctx, "purge empty albums", func() error { return s.Album(ctx).(*albumRepository).purgeEmpty() }),
+ trace(ctx, "purge empty albums", func() error { return s.Album(ctx).(*albumRepository).purgeEmpty(libraryIDs...) }),
trace(ctx, "purge empty artists", func() error { return s.Artist(ctx).(*artistRepository).purgeEmpty() }),
trace(ctx, "mark missing artists", func() error { return s.Artist(ctx).(*artistRepository).markMissing() }),
- trace(ctx, "purge empty folders", func() error { return s.Folder(ctx).(*folderRepository).purgeEmpty() }),
+ trace(ctx, "purge empty folders", func() error { return s.Folder(ctx).(*folderRepository).purgeEmpty(libraryIDs...) }),
trace(ctx, "clean album annotations", func() error { return s.Album(ctx).(*albumRepository).cleanAnnotations() }),
trace(ctx, "clean artist annotations", func() error { return s.Artist(ctx).(*artistRepository).cleanAnnotations() }),
trace(ctx, "clean media file annotations", func() error { return s.MediaFile(ctx).(*mediaFileRepository).cleanAnnotations() }),
diff --git a/persistence/persistence_suite_test.go b/persistence/persistence_suite_test.go
index 1007d84fe..f3cb4f3d0 100644
--- a/persistence/persistence_suite_test.go
+++ b/persistence/persistence_suite_test.go
@@ -69,10 +69,12 @@ var (
albumSgtPeppers = al(model.Album{ID: "101", Name: "Sgt Peppers", AlbumArtist: "The Beatles", OrderAlbumName: "sgt peppers", AlbumArtistID: "3", EmbedArtPath: p("/beatles/1/sgt/a day.mp3"), SongCount: 1, MaxYear: 1967})
albumAbbeyRoad = al(model.Album{ID: "102", Name: "Abbey Road", AlbumArtist: "The Beatles", OrderAlbumName: "abbey road", AlbumArtistID: "3", EmbedArtPath: p("/beatles/1/come together.mp3"), SongCount: 1, MaxYear: 1969})
albumRadioactivity = al(model.Album{ID: "103", Name: "Radioactivity", AlbumArtist: "Kraftwerk", OrderAlbumName: "radioactivity", AlbumArtistID: "2", EmbedArtPath: p("/kraft/radio/radio.mp3"), SongCount: 2})
+ albumMultiDisc = al(model.Album{ID: "104", Name: "Multi Disc Album", AlbumArtist: "Test Artist", OrderAlbumName: "multi disc album", AlbumArtistID: "1", EmbedArtPath: p("/test/multi/disc1/track1.mp3"), SongCount: 4})
testAlbums = model.Albums{
albumSgtPeppers,
albumAbbeyRoad,
albumRadioactivity,
+ albumMultiDisc,
}
)
@@ -94,13 +96,22 @@ var (
Lyrics: `[{"lang":"xxx","line":[{"value":"This is a set of lyrics"}],"synced":false}]`,
})
songAntenna2 = mf(model.MediaFile{ID: "1006", Title: "Antenna", ArtistID: "2", Artist: "Kraftwerk", AlbumID: "103"})
- testSongs = model.MediaFiles{
+ // Multi-disc album tracks (intentionally out of order to test sorting)
+ songDisc2Track11 = mf(model.MediaFile{ID: "2001", Title: "Disc 2 Track 11", ArtistID: "1", Artist: "Test Artist", AlbumID: "104", Album: "Multi Disc Album", DiscNumber: 2, TrackNumber: 11, Path: p("/test/multi/disc2/track11.mp3"), OrderAlbumName: "multi disc album", OrderArtistName: "test artist"})
+ songDisc1Track01 = mf(model.MediaFile{ID: "2002", Title: "Disc 1 Track 1", ArtistID: "1", Artist: "Test Artist", AlbumID: "104", Album: "Multi Disc Album", DiscNumber: 1, TrackNumber: 1, Path: p("/test/multi/disc1/track1.mp3"), OrderAlbumName: "multi disc album", OrderArtistName: "test artist"})
+ songDisc2Track01 = mf(model.MediaFile{ID: "2003", Title: "Disc 2 Track 1", ArtistID: "1", Artist: "Test Artist", AlbumID: "104", Album: "Multi Disc Album", DiscNumber: 2, TrackNumber: 1, Path: p("/test/multi/disc2/track1.mp3"), OrderAlbumName: "multi disc album", OrderArtistName: "test artist"})
+ songDisc1Track02 = mf(model.MediaFile{ID: "2004", Title: "Disc 1 Track 2", ArtistID: "1", Artist: "Test Artist", AlbumID: "104", Album: "Multi Disc Album", DiscNumber: 1, TrackNumber: 2, Path: p("/test/multi/disc1/track2.mp3"), OrderAlbumName: "multi disc album", OrderArtistName: "test artist"})
+ testSongs = model.MediaFiles{
songDayInALife,
songComeTogether,
songRadioactivity,
songAntenna,
songAntennaWithLyrics,
songAntenna2,
+ songDisc2Track11,
+ songDisc1Track01,
+ songDisc2Track01,
+ songDisc1Track02,
}
)
diff --git a/persistence/playlist_repository_test.go b/persistence/playlist_repository_test.go
index 15ae438d9..7fad93b1e 100644
--- a/persistence/playlist_repository_test.go
+++ b/persistence/playlist_repository_test.go
@@ -219,4 +219,37 @@ var _ = Describe("PlaylistRepository", func() {
})
})
})
+
+ Describe("Playlist Track Sorting", func() {
+ var testPlaylistID string
+
+ AfterEach(func() {
+ if testPlaylistID != "" {
+ Expect(repo.Delete(testPlaylistID)).To(BeNil())
+ testPlaylistID = ""
+ }
+ })
+
+ It("sorts tracks correctly by album (disc and track number)", func() {
+ By("creating a playlist with multi-disc album tracks in arbitrary order")
+ newPls := model.Playlist{Name: "Multi-Disc Test", OwnerID: "userid"}
+ // Add tracks in intentionally scrambled order
+ newPls.AddMediaFilesByID([]string{"2001", "2002", "2003", "2004"})
+ Expect(repo.Put(&newPls)).To(Succeed())
+ testPlaylistID = newPls.ID
+
+ By("retrieving tracks sorted by album")
+ tracksRepo := repo.Tracks(newPls.ID, false)
+ tracks, err := tracksRepo.GetAll(model.QueryOptions{Sort: "album", Order: "asc"})
+ Expect(err).ToNot(HaveOccurred())
+
+ By("verifying tracks are sorted by disc number then track number")
+ Expect(tracks).To(HaveLen(4))
+ // Expected order: Disc 1 Track 1, Disc 1 Track 2, Disc 2 Track 1, Disc 2 Track 11
+ Expect(tracks[0].MediaFileID).To(Equal("2002")) // Disc 1, Track 1
+ Expect(tracks[1].MediaFileID).To(Equal("2004")) // Disc 1, Track 2
+ Expect(tracks[2].MediaFileID).To(Equal("2003")) // Disc 2, Track 1
+ Expect(tracks[3].MediaFileID).To(Equal("2001")) // Disc 2, Track 11
+ })
+ })
})
diff --git a/persistence/playlist_track_repository.go b/persistence/playlist_track_repository.go
index 01eec0d02..b3f9e0c07 100644
--- a/persistence/playlist_track_repository.go
+++ b/persistence/playlist_track_repository.go
@@ -55,7 +55,7 @@ func (r *playlistRepository) Tracks(playlistId string, refreshSmartPlaylist bool
"id": "playlist_tracks.id",
"artist": "order_artist_name",
"album_artist": "order_album_artist_name",
- "album": "order_album_name, order_album_artist_name",
+ "album": "order_album_name, album_id, disc_number, track_number, order_artist_name, title",
"title": "order_title",
// To make sure these fields will be whitelisted
"duration": "duration",
diff --git a/persistence/sql_annotations.go b/persistence/sql_annotations.go
index 6691b553c..98ade6e21 100644
--- a/persistence/sql_annotations.go
+++ b/persistence/sql_annotations.go
@@ -119,7 +119,7 @@ func (r sqlRepository) cleanAnnotations() error {
del := Delete(annotationTable).Where(Eq{"item_type": r.tableName}).Where("item_id not in (select id from " + r.tableName + ")")
c, err := r.executeSQL(del)
if err != nil {
- return fmt.Errorf("error cleaning up annotations: %w", err)
+ return fmt.Errorf("error cleaning up %s annotations: %w", r.tableName, err)
}
if c > 0 {
log.Debug(r.ctx, "Clean-up annotations", "table", r.tableName, "totalDeleted", c)
diff --git a/persistence/sql_bookmarks.go b/persistence/sql_bookmarks.go
index 52c4b8e9c..9164aed9d 100644
--- a/persistence/sql_bookmarks.go
+++ b/persistence/sql_bookmarks.go
@@ -148,10 +148,10 @@ func (r sqlRepository) cleanBookmarks() error {
del := Delete(bookmarkTable).Where(Eq{"item_type": r.tableName}).Where("item_id not in (select id from " + r.tableName + ")")
c, err := r.executeSQL(del)
if err != nil {
- return fmt.Errorf("error cleaning up bookmarks: %w", err)
+ return fmt.Errorf("error cleaning up %s bookmarks: %w", r.tableName, err)
}
if c > 0 {
- log.Debug(r.ctx, "Clean-up bookmarks", "totalDeleted", c)
+ log.Debug(r.ctx, "Clean-up bookmarks", "totalDeleted", c, "itemType", r.tableName)
}
return nil
}
diff --git a/persistence/tag_repository.go b/persistence/tag_repository.go
index b224450ab..5bb8b3832 100644
--- a/persistence/tag_repository.go
+++ b/persistence/tag_repository.go
@@ -88,10 +88,10 @@ func (r *tagRepository) purgeUnused() error {
`)
c, err := r.executeSQL(del)
if err != nil {
- return fmt.Errorf("error purging unused tags: %w", err)
+ return fmt.Errorf("error purging %s unused tags: %w", r.tableName, err)
}
if c > 0 {
- log.Debug(r.ctx, "Purged unused tags", "totalDeleted", c)
+ log.Debug(r.ctx, "Purged unused tags", "totalDeleted", c, "table", r.tableName)
}
return err
}
diff --git a/persistence/user_repository.go b/persistence/user_repository.go
index a7181b1a7..7baa8f6a8 100644
--- a/persistence/user_repository.go
+++ b/persistence/user_repository.go
@@ -57,6 +57,7 @@ func NewUserRepository(ctx context.Context, db dbx.Builder) model.UserRepository
r.db = db
r.tableName = "user"
r.registerModel(&model.User{}, map[string]filterFunc{
+ "id": idFilter(r.tableName),
"password": invalidFilter(ctx),
"name": r.withTableName(startsWithFilter),
})
diff --git a/persistence/user_repository_test.go b/persistence/user_repository_test.go
index 7c0707ecd..8abbf76a9 100644
--- a/persistence/user_repository_test.go
+++ b/persistence/user_repository_test.go
@@ -559,4 +559,15 @@ var _ = Describe("UserRepository", func() {
Expect(user.Libraries[0].ID).To(Equal(1))
})
})
+
+ Describe("filters", func() {
+ It("qualifies id filter with table name", func() {
+ r := repo.(*userRepository)
+ qo := r.parseRestOptions(r.ctx, rest.QueryOptions{Filters: map[string]any{"id": "123"}})
+ sel := r.selectUserWithLibraries(qo)
+ query, _, err := r.toSQL(sel)
+ Expect(err).NotTo(HaveOccurred())
+ Expect(query).To(ContainSubstring("user.id = {:p0}"))
+ })
+ })
})
diff --git a/plugins/host_subsonicapi.go b/plugins/host_subsonicapi.go
index d3008798a..937dd044f 100644
--- a/plugins/host_subsonicapi.go
+++ b/plugins/host_subsonicapi.go
@@ -93,8 +93,12 @@ func (s *subsonicAPIServiceImpl) Call(ctx context.Context, req *subsonicapi.Call
RawQuery: query.Encode(),
}
- // Create HTTP request with internal authentication
- httpReq, err := http.NewRequestWithContext(ctx, "GET", finalURL.String(), nil)
+ // Create HTTP request with a fresh context to avoid Chi RouteContext pollution.
+ // Using http.NewRequest (instead of http.NewRequestWithContext) ensures the internal
+ // SubsonicAPI call doesn't inherit routing information from the parent handler,
+ // which would cause Chi to invoke the wrong handler. Authentication context is
+ // explicitly added in the next step via request.WithInternalAuth.
+ httpReq, err := http.NewRequest("GET", finalURL.String(), nil)
if err != nil {
return &subsonicapi.CallResponse{
Error: fmt.Sprintf("failed to create HTTP request: %v", err),
diff --git a/plugins/manager_test.go b/plugins/manager_test.go
index 207908ebc..8b361f8b3 100644
--- a/plugins/manager_test.go
+++ b/plugins/manager_test.go
@@ -4,6 +4,7 @@ import (
"context"
"os"
"path/filepath"
+ "time"
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/core/agents"
@@ -22,8 +23,11 @@ var _ = Describe("Plugin Manager", func() {
// but, as this is an integration test, we can't use configtest.SetupConfig() as it causes
// data races.
originalPluginsFolder := conf.Server.Plugins.Folder
+ originalTimeout := conf.Server.DevPluginCompilationTimeout
+ conf.Server.DevPluginCompilationTimeout = 2 * time.Minute
DeferCleanup(func() {
conf.Server.Plugins.Folder = originalPluginsFolder
+ conf.Server.DevPluginCompilationTimeout = originalTimeout
})
conf.Server.Plugins.Enabled = true
conf.Server.Plugins.Folder = testDataDir
diff --git a/release/goreleaser.yml b/release/goreleaser.yml
index f71c38f31..30c0d6f3b 100644
--- a/release/goreleaser.yml
+++ b/release/goreleaser.yml
@@ -83,6 +83,15 @@ nfpms:
owner: navidrome
group: navidrome
+ - src: release/linux/.package.rpm # contents: "rpm"
+ dst: /var/lib/navidrome/.package
+ type: "config|noreplace"
+ packager: rpm
+ - src: release/linux/.package.deb # contents: "deb"
+ dst: /var/lib/navidrome/.package
+ type: "config|noreplace"
+ packager: deb
+
scripts:
preinstall: "release/linux/preinstall.sh"
postinstall: "release/linux/postinstall.sh"
diff --git a/release/linux/.package.deb b/release/linux/.package.deb
new file mode 100644
index 000000000..811c85f42
--- /dev/null
+++ b/release/linux/.package.deb
@@ -0,0 +1 @@
+deb
\ No newline at end of file
diff --git a/release/linux/.package.rpm b/release/linux/.package.rpm
new file mode 100644
index 000000000..7c88ef3c0
--- /dev/null
+++ b/release/linux/.package.rpm
@@ -0,0 +1 @@
+rpm
\ No newline at end of file
diff --git a/release/wix/build_msi.sh b/release/wix/build_msi.sh
index 9fc008446..7e595311e 100755
--- a/release/wix/build_msi.sh
+++ b/release/wix/build_msi.sh
@@ -49,6 +49,9 @@ cp "${DOWNLOAD_FOLDER}"/extracted_ffmpeg/${FFMPEG_FILE}/bin/ffmpeg.exe "$MSI_OUT
cp "$WORKSPACE"/LICENSE "$WORKSPACE"/README.md "$MSI_OUTPUT_DIR"
cp "$BINARY" "$MSI_OUTPUT_DIR"
+# package type indicator file
+echo "msi" > "$MSI_OUTPUT_DIR/.package"
+
# workaround for wixl WixVariable not working to override bmp locations
cp "$WORKSPACE"/release/wix/bmp/banner.bmp /usr/share/wixl-*/ext/ui/bitmaps/bannrbmp.bmp
cp "$WORKSPACE"/release/wix/bmp/dialogue.bmp /usr/share/wixl-*/ext/ui/bitmaps/dlgbmp.bmp
diff --git a/release/wix/navidrome.wxs b/release/wix/navidrome.wxs
index ec8b164e8..8ebba4632 100644
--- a/release/wix/navidrome.wxs
+++ b/release/wix/navidrome.wxs
@@ -69,6 +69,12 @@
+
+
+
+
+
+
@@ -81,6 +87,7 @@
+
diff --git a/resources/i18n/gl.json b/resources/i18n/gl.json
index 8cde597cc..a6c3beb05 100644
--- a/resources/i18n/gl.json
+++ b/resources/i18n/gl.json
@@ -31,8 +31,12 @@
"mood": "Estado",
"participants": "Participantes adicionais",
"tags": "Etiquetas adicionais",
- "mappedTags": "",
- "rawTags": "Etiquetas en cru"
+ "mappedTags": "Etiquetas mapeadas",
+ "rawTags": "Etiquetas en cru",
+ "bitDepth": "Calidade de Bit",
+ "sampleRate": "Taxa de mostra",
+ "missing": "Falta",
+ "libraryName": "Biblioteca"
},
"actions": {
"addToQueue": "Ao final da cola",
@@ -41,7 +45,8 @@
"shuffleAll": "Remexer todo",
"download": "Descargar",
"playNext": "A continuación",
- "info": "Obter info"
+ "info": "Obter info",
+ "showInPlaylist": "Mostrar en Lista de reprodución"
}
},
"album": {
@@ -70,7 +75,10 @@
"releaseType": "Tipo",
"grouping": "Grupos",
"media": "Multimedia",
- "mood": "Estado"
+ "mood": "Estado",
+ "date": "Data de gravación",
+ "missing": "Falta",
+ "libraryName": "Biblioteca"
},
"actions": {
"playAll": "Reproducir",
@@ -102,7 +110,8 @@
"rating": "Valoración",
"genre": "Xénero",
"size": "Tamaño",
- "role": "Rol"
+ "role": "Rol",
+ "missing": "Falta"
},
"roles": {
"albumartist": "Artista do álbum |||| Artistas do álbum",
@@ -117,7 +126,13 @@
"mixer": "Mistura |||| Mistura",
"remixer": "Remezcla |||| Remezcla",
"djmixer": "Mezcla DJs |||| Mezcla DJs",
- "performer": "Intérprete |||| Intérpretes"
+ "performer": "Intérprete |||| Intérpretes",
+ "maincredit": "Artista do álbum ou Artista |||| Artistas do álbum ou Artistas"
+ },
+ "actions": {
+ "shuffle": "Barallar",
+ "radio": "Radio",
+ "topSongs": "Cancións destacadas"
}
},
"user": {
@@ -134,10 +149,12 @@
"currentPassword": "Contrasinal actual",
"newPassword": "Novo contrasinal",
"token": "Token",
- "lastAccessAt": "Último acceso"
+ "lastAccessAt": "Último acceso",
+ "libraries": "Bibliotecas"
},
"helperTexts": {
- "name": "Os cambios no nome aplicaranse a próxima vez que accedas"
+ "name": "Os cambios no nome aplicaranse a próxima vez que accedas",
+ "libraries": "Selecciona bibliotecas específicas para esta usuaria, ou deixa baleiro para usar as bibliotecas por defecto"
},
"notifications": {
"created": "Creouse a usuaria",
@@ -146,7 +163,12 @@
},
"message": {
"listenBrainzToken": "Escribe o token de usuaria de ListenBrainz",
- "clickHereForToken": "Preme aquí para obter o token"
+ "clickHereForToken": "Preme aquí para obter o token",
+ "selectAllLibraries": "Seleccionar todas as bibliotecas",
+ "adminAutoLibraries": "As usuarias Admin teñen acceso por defecto a todas as bibliotecas"
+ },
+ "validation": {
+ "librariesRequired": "Debes seleccionar polo menos unha biblioteca para usuarias non admins"
}
},
"player": {
@@ -190,11 +212,17 @@
"addNewPlaylist": "Crear \"%{name}\"",
"export": "Exportar",
"makePublic": "Facela Pública",
- "makePrivate": "Facela Privada"
+ "makePrivate": "Facela Privada",
+ "saveQueue": "Salvar a Cola como Lista de reprodución",
+ "searchOrCreate": "Buscar listas ou escribe para crear nova…",
+ "pressEnterToCreate": "Preme Enter para crear nova lista",
+ "removeFromSelection": "Retirar da selección"
},
"message": {
"duplicate_song": "Engadir cancións duplicadas",
- "song_exist": "Hai duplicadas que serán engadidas á lista de reprodución. Desexas engadir as duplicadas ou omitilas?"
+ "song_exist": "Hai duplicadas que serán engadidas á lista de reprodución. Desexas engadir as duplicadas ou omitilas?",
+ "noPlaylistsFound": "Sen listas de reprodución",
+ "noPlaylists": "Sen listas dispoñibles"
}
},
"radio": {
@@ -232,13 +260,68 @@
"fields": {
"path": "Ruta",
"size": "Tamaño",
- "updatedAt": "Desapareceu o"
+ "updatedAt": "Desapareceu o",
+ "libraryName": "Biblioteca"
},
"actions": {
- "remove": "Retirar"
+ "remove": "Retirar",
+ "remove_all": "Retirar todo"
},
"notifications": {
"removed": "Ficheiro(s) faltantes retirados"
+ },
+ "empty": "Sen ficheiros faltantes"
+ },
+ "library": {
+ "name": "Biblioteca |||| Bibliotecas",
+ "fields": {
+ "name": "Nome",
+ "path": "Ruta",
+ "remotePath": "Ruta remota",
+ "lastScanAt": "Último escaneado",
+ "songCount": "Cancións",
+ "albumCount": "Álbums",
+ "artistCount": "Artistas",
+ "totalSongs": "Cancións",
+ "totalAlbums": "Álbums",
+ "totalArtists": "Artistas",
+ "totalFolders": "Cartafoles",
+ "totalFiles": "Ficheiros",
+ "totalMissingFiles": "Ficheiros que faltan",
+ "totalSize": "Tamaño total",
+ "totalDuration": "Duración",
+ "defaultNewUsers": "Por defecto para novas usuarias",
+ "createdAt": "Creada",
+ "updatedAt": "Actualizada"
+ },
+ "sections": {
+ "basic": "Información básica",
+ "statistics": "Estatísticas"
+ },
+ "actions": {
+ "scan": "Escanear Biblioteca",
+ "manageUsers": "Xestionar acceso das usuarias",
+ "viewDetails": "Ver detalles"
+ },
+ "notifications": {
+ "created": "Biblioteca creada correctamente",
+ "updated": "Biblioteca actualizada correctamente",
+ "deleted": "Biblioteca eliminada correctamente",
+ "scanStarted": "Comezou o escaneo da biblioteca",
+ "scanCompleted": "Completouse o escaneado da biblioteca"
+ },
+ "validation": {
+ "nameRequired": "Requírese un nome para a biblioteca",
+ "pathRequired": "Requírese unha ruta para a biblioteca",
+ "pathNotDirectory": "A ruta á biblioteca ten que ser un directorio",
+ "pathNotFound": "Non se atopa a ruta á biblioteca",
+ "pathNotAccessible": "A ruta á biblioteca non é accesible",
+ "pathInvalid": "Ruta non válida á biblioteca"
+ },
+ "messages": {
+ "deleteConfirm": "Tes certeza de querer eliminar esta biblioteca? Isto eliminará todos os datos asociados e accesos de usuarias.",
+ "scanInProgress": "Escaneo en progreso…",
+ "noLibrariesAssigned": "Sen bibliotecas asignadas a esta usuaria"
}
}
},
@@ -419,7 +502,11 @@
"downloadDialogTitle": "Descargar %{resource} '%{name}' (%{size})",
"shareCopyToClipboard": "Copiar ao portapapeis: Ctrl+C, Enter",
"remove_missing_title": "Retirar ficheiros que faltan",
- "remove_missing_content": "Tes certeza de querer retirar da base de datos os ficheiros que faltan? Isto retirará de xeito permanente todas a referencias a eles, incluíndo a conta de reproducións e valoracións."
+ "remove_missing_content": "Tes certeza de querer retirar da base de datos os ficheiros que faltan? Isto retirará de xeito permanente todas a referencias a eles, incluíndo a conta de reproducións e valoracións.",
+ "remove_all_missing_title": "Retirar todos os ficheiros que faltan",
+ "remove_all_missing_content": "Tes certeza de querer retirar da base de datos todos os ficheiros que faltan? Isto eliminará todas as referencias a eles, incluíndo o número de reproducións e valoracións.",
+ "noSimilarSongsFound": "Sen cancións parecidas",
+ "noTopSongsFound": "Sen cancións destacadas"
},
"menu": {
"library": "Biblioteca",
@@ -448,7 +535,13 @@
"albumList": "Álbums",
"about": "Acerca de",
"playlists": "Listas de reprodución",
- "sharedPlaylists": "Listas compartidas"
+ "sharedPlaylists": "Listas compartidas",
+ "librarySelector": {
+ "allLibraries": "Todas as bibliotecas (%{count})",
+ "multipleLibraries": "%{selected} de %{total} Bibliotecas",
+ "selectLibraries": "Seleccionar Bibliotecas",
+ "none": "Ningunha"
+ }
},
"player": {
"playListsText": "Reproducir cola",
@@ -485,6 +578,21 @@
"disabled": "Desactivado",
"waiting": "Agardando"
}
+ },
+ "tabs": {
+ "about": "Sobre",
+ "config": "Configuración"
+ },
+ "config": {
+ "configName": "Nome",
+ "environmentVariable": "Variable de entorno",
+ "currentValue": "Valor actual",
+ "configurationFile": "Ficheiro de configuración",
+ "exportToml": "Exportar configuración (TOML)",
+ "exportSuccess": "Configuración exportada ao portapapeis no formato TOML",
+ "exportFailed": "Fallou a copia da configuración",
+ "devFlagsHeader": "Configuracións de Desenvolvemento (suxeitas a cambio/retirada)",
+ "devFlagsComment": "Son axustes experimentais e poden retirarse en futuras versións"
}
},
"activity": {
@@ -493,7 +601,10 @@
"quickScan": "Escaneo rápido",
"fullScan": "Escaneo completo",
"serverUptime": "Servidor a funcionar",
- "serverDown": "SEN CONEXIÓN"
+ "serverDown": "SEN CONEXIÓN",
+ "scanType": "Tipo",
+ "status": "Erro de escaneado",
+ "elapsedTime": "Tempo transcurrido"
},
"help": {
"title": "Atallos de Navidrome",
@@ -508,5 +619,10 @@
"toggle_love": "Engadir canción a favoritas",
"current_song": "Ir á Canción actual "
}
+ },
+ "nowPlaying": {
+ "title": "En reprodución",
+ "empty": "Sen reprodución",
+ "minutesAgo": "hai %{smart_count} minuto |||| hai %{smart_count} minutos"
}
}
\ No newline at end of file
diff --git a/resources/i18n/it.json b/resources/i18n/it.json
index 9d1c2bb74..11fadb46b 100644
--- a/resources/i18n/it.json
+++ b/resources/i18n/it.json
@@ -400,8 +400,8 @@
},
"albumList": "Album",
"about": "Info",
- "playlists": "Scalette",
- "sharedPlaylists": "Scalette Condivise"
+ "playlists": "Playlist",
+ "sharedPlaylists": "Playlist Condivise"
},
"player": {
"playListsText": "Coda",
@@ -457,4 +457,4 @@
"current_song": ""
}
}
-}
\ No newline at end of file
+}
diff --git a/resources/i18n/ko.json b/resources/i18n/ko.json
index a8b26df6d..6b81e02d8 100644
--- a/resources/i18n/ko.json
+++ b/resources/i18n/ko.json
@@ -12,6 +12,7 @@
"artist": "아티스트",
"album": "앨범",
"path": "파일 경로",
+ "libraryName": "라이브러리",
"genre": "장르",
"compilation": "컴필레이션",
"year": "년",
@@ -34,7 +35,8 @@
"participants": "추가 참가자",
"tags": "추가 태그",
"mappedTags": "매핑된 태그",
- "rawTags": "원시 태그"
+ "rawTags": "원시 태그",
+ "missing": "누락"
},
"actions": {
"addToQueue": "나중에 재생",
@@ -56,6 +58,7 @@
"playCount": "재생 횟수",
"size": "크기",
"name": "이름",
+ "libraryName": "라이브러리",
"genre": "장르",
"compilation": "컴필레이션",
"year": "년",
@@ -73,7 +76,8 @@
"releaseType": "유형",
"grouping": "그룹",
"media": "미디어",
- "mood": "분위기"
+ "mood": "분위기",
+ "missing": "누락"
},
"actions": {
"playAll": "재생",
@@ -105,7 +109,8 @@
"playCount": "재생 횟수",
"rating": "평가",
"genre": "장르",
- "role": "역할"
+ "role": "역할",
+ "missing": "누락"
},
"roles": {
"albumartist": "앨범 아티스트 |||| 앨범 아티스트들",
@@ -120,7 +125,13 @@
"mixer": "믹서 |||| 믹서들",
"remixer": "리믹서 |||| 리믹서들",
"djmixer": "DJ 믹서 |||| DJ 믹서들",
- "performer": "공연자 |||| 공연자들"
+ "performer": "공연자 |||| 공연자들",
+ "maincredit": "앨범 아티스트 또는 아티스트 |||| 앨범 아티스트들 또는 아티스트들"
+ },
+ "actions": {
+ "topSongs": "인기곡",
+ "shuffle": "셔플",
+ "radio": "라디오"
}
},
"user": {
@@ -137,19 +148,26 @@
"changePassword": "비밀번호를 변경할까요?",
"currentPassword": "현재 비밀번호",
"newPassword": "새 비밀번호",
- "token": "토큰"
+ "token": "토큰",
+ "libraries": "라이브러리"
},
"helperTexts": {
- "name": "이름 변경 사항은 다음 로그인 시에만 반영됨"
+ "name": "이름 변경 사항은 다음 로그인 시에만 반영됨",
+ "libraries": "이 사용자에 대한 특정 라이브러리를 선택하거나 기본 라이브러리를 사용하려면 비움"
},
"notifications": {
"created": "사용자 생성됨",
"updated": "사용자 업데이트됨",
"deleted": "사용자 삭제됨"
},
+ "validation": {
+ "librariesRequired": "관리자가 아닌 사용자의 경우 최소한 하나의 라이브러리를 선택해야 함"
+ },
"message": {
"listenBrainzToken": "ListenBrainz 사용자 토큰을 입력하세요.",
- "clickHereForToken": "여기를 클릭하여 토큰을 얻으세요"
+ "clickHereForToken": "여기를 클릭하여 토큰을 얻으세요",
+ "selectAllLibraries": "모든 라이브러리 선택",
+ "adminAutoLibraries": "관리자 사용자는 자동으로 모든 라이브러리에 접속할 수 있음"
}
},
"player": {
@@ -192,12 +210,18 @@
"selectPlaylist": "재생목록 선택:",
"addNewPlaylist": "\"%{name}\" 만들기",
"export": "내보내기",
+ "saveQueue": "재생목록에 대기열 저장",
"makePublic": "공개 만들기",
- "makePrivate": "비공개 만들기"
+ "makePrivate": "비공개 만들기",
+ "searchOrCreate": "재생목록을 검색하거나 입력하여 새 재생목록을 만드세요...",
+ "pressEnterToCreate": "새 재생목록을 만드려면 Enter 키를 누름",
+ "removeFromSelection": "선택에서 제거"
},
"message": {
"duplicate_song": "중복된 노래 추가",
- "song_exist": "이미 재생목록에 존재하는 노래입니다. 중복을 추가할까요 아니면 건너뛸까요?"
+ "song_exist": "이미 재생목록에 존재하는 노래입니다. 중복을 추가할까요 아니면 건너뛸까요?",
+ "noPlaylistsFound": "재생목록을 찾을 수 없음",
+ "noPlaylists": "사용 가능한 재생 목록이 없음"
}
},
"radio": {
@@ -238,14 +262,68 @@
"fields": {
"path": "경로",
"size": "크기",
+ "libraryName": "라이브러리",
"updatedAt": "사라짐"
},
"actions": {
- "remove": "제거"
+ "remove": "제거",
+ "remove_all": "모두 제거"
},
"notifications": {
"removed": "누락된 파일이 제거되었음"
}
+ },
+ "library": {
+ "name": "라이브러리 |||| 라이브러리들",
+ "fields": {
+ "name": "이름",
+ "path": "경로",
+ "remotePath": "원격 경로",
+ "lastScanAt": "최근 스캔",
+ "songCount": "노래",
+ "albumCount": "앨범",
+ "artistCount": "아티스트",
+ "totalSongs": "노래",
+ "totalAlbums": "앨범",
+ "totalArtists": "아티스트",
+ "totalFolders": "폴더",
+ "totalFiles": "파일",
+ "totalMissingFiles": "누락된 파일",
+ "totalSize": "총 크기",
+ "totalDuration": "기간",
+ "defaultNewUsers": "신규 사용자 기본값",
+ "createdAt": "생성됨",
+ "updatedAt": "업데이트됨"
+ },
+ "sections": {
+ "basic": "기본 정보",
+ "statistics": "통계"
+ },
+ "actions": {
+ "scan": "라이브러리 스캔",
+ "manageUsers": "자용자 접속 관리",
+ "viewDetails": "상세 보기"
+ },
+ "notifications": {
+ "created": "라이브러리가 성공적으로 생성됨",
+ "updated": "라이브러리가 성공적으로 업데이트됨",
+ "deleted": "라이브러리가 성공적으로 삭제됨",
+ "scanStarted": "라이브러리 스캔 스작됨",
+ "scanCompleted": "라이브러리 스캔 완료됨"
+ },
+ "validation": {
+ "nameRequired": "라이브러리 이름이 필요함",
+ "pathRequired": "라이브러리 경로가 필요함",
+ "pathNotDirectory": "라이브러리 경로는 디렉터리여야 함",
+ "pathNotFound": "라이브러리 경로를 찾을 수 없음",
+ "pathNotAccessible": "라이브러리 경로에 접근할 수 없음",
+ "pathInvalid": "잘못된 라이브러리 경로"
+ },
+ "messages": {
+ "deleteConfirm": "이 라이브러리를 삭제할까요? 삭제하면 연결된 모든 데이터와 사용자 접속 권한이 제거됩니다.",
+ "scanInProgress": "스캔 진행 중...",
+ "noLibrariesAssigned": "이 사용자에게 할당된 라이브러리가 없음"
+ }
}
},
"ra": {
@@ -398,11 +476,15 @@
"transcodingDisabled": "웹 인터페이스를 통한 트랜스코딩 구성 변경은 보안상의 이유로 비활성화되어 있습니다. 트랜스코딩 옵션을 변경(편집 또는 추가)하려면, %{config} 구성 옵션으로 서버를 다시 시작하세요.",
"transcodingEnabled": "Navidrome은 현재 %{config}로 실행 중이므로 웹 인터페이스를 사용하여 트랜스코딩 설정에서 시스템 명령을 실행할 수 있습니다. 보안상의 이유로 비활성화하고 트랜스코딩 옵션을 구성할 때만 활성화하는 것이 좋습니다.",
"songsAddedToPlaylist": "1 개의 노래를 재생목록에 추가하였음 |||| %{smart_count} 개의 노래를 재생 목록에 추가하였음",
+ "noSimilarSongsFound": "비슷한 노래를 찾을 수 없음",
+ "noTopSongsFound": "인기곡을 찾을 수 없음",
"noPlaylistsAvailable": "사용 가능한 노래 없음",
"delete_user_title": "사용자 '%{name}' 삭제",
"delete_user_content": "이 사용자와 해당 사용자의 모든 데이터(재생 목록 및 환경 설정 포함)를 삭제할까요?",
"remove_missing_title": "누락된 파일들 제거",
"remove_missing_content": "선택한 누락된 파일을 데이터베이스에서 삭제할까요? 삭제하면 재생 횟수 및 평점을 포함하여 해당 파일에 대한 모든 참조가 영구적으로 삭제됩니다.",
+ "remove_all_missing_title": "누락된 모든 파일 제거",
+ "remove_all_missing_content": "데이터베이스에서 누락된 모든 파일을 제거할까요? 이렇게 하면 해당 게임의 플레이 횟수와 평점을 포함한 모든 참조 내용이 영구적으로 삭제됩니다.",
"notifications_blocked": "브라우저 설정에서 이 사이트의 알림을 차단하였음",
"notifications_not_available": "이 브라우저는 데스크톱 알림을 지원하지 않거나 https를 통해 Navidrome에 접속하고 있지 않음",
"lastfmLinkSuccess": "Last.fm이 성공적으로 연결되었고 스크로블링이 활성화되었음",
@@ -429,6 +511,12 @@
},
"menu": {
"library": "라이브러리",
+ "librarySelector": {
+ "allLibraries": "모든 라이브러리 (%{count})",
+ "multipleLibraries": "%{selected} / %{total} 라이브러리",
+ "selectLibraries": "라이브러리 선택",
+ "none": "없음"
+ },
"settings": "설정",
"version": "버전",
"theme": "테마",
@@ -491,6 +579,21 @@
"disabled": "비활성화",
"waiting": "대기중"
}
+ },
+ "tabs": {
+ "about": "정보",
+ "config": "구성"
+ },
+ "config": {
+ "configName": "구성 이름",
+ "environmentVariable": "환경 변수",
+ "currentValue": "현재 값",
+ "configurationFile": "구성 파일",
+ "exportToml": "구성 내보내기 (TOML)",
+ "exportSuccess": "TOML 형식으로 클립보드로 내보낸 구성",
+ "exportFailed": "구성 복사 실패",
+ "devFlagsHeader": "개발 플래그 (변경/삭제 가능)",
+ "devFlagsComment": "이는 실험적 설정이므로 향후 버전에서 제거될 수 있음"
}
},
"activity": {
@@ -499,7 +602,15 @@
"quickScan": "빠른 스캔",
"fullScan": "전체 스캔",
"serverUptime": "서버 가동 시간",
- "serverDown": "오프라인"
+ "serverDown": "오프라인",
+ "scanType": "유형",
+ "status": "스캔 오류",
+ "elapsedTime": "경과 시간"
+ },
+ "nowPlaying": {
+ "title": "현재 재생 중",
+ "empty": "재생 중인 콘텐츠 없음",
+ "minutesAgo": "%{smart_count} 분 전"
},
"help": {
"title": "Navidrome 단축키",
diff --git a/resources/i18n/nl.json b/resources/i18n/nl.json
index 4737cb33a..b6da47380 100644
--- a/resources/i18n/nl.json
+++ b/resources/i18n/nl.json
@@ -5,7 +5,7 @@
"name": "Nummer |||| Nummers",
"fields": {
"albumArtist": "Album Artiest",
- "duration": "Lengte",
+ "duration": "Afspeelduur",
"trackNumber": "Nummer #",
"playCount": "Aantal keren afgespeeld",
"title": "Titel",
@@ -35,7 +35,8 @@
"rawTags": "Onbewerkte tags",
"bitDepth": "Bit diepte",
"sampleRate": "Sample waarde",
- "missing": "Ontbrekend"
+ "missing": "Ontbrekend",
+ "libraryName": "Bibliotheek"
},
"actions": {
"addToQueue": "Voeg toe aan wachtrij",
@@ -44,7 +45,8 @@
"shuffleAll": "Shuffle alles",
"download": "Downloaden",
"playNext": "Volgende",
- "info": "Meer info"
+ "info": "Meer info",
+ "showInPlaylist": "Toon in afspeellijst"
}
},
"album": {
@@ -55,7 +57,7 @@
"duration": "Afspeelduur",
"songCount": "Nummers",
"playCount": "Aantal keren afgespeeld",
- "name": "Naam",
+ "name": "Titel",
"genre": "Genre",
"compilation": "Compilatie",
"year": "Jaar",
@@ -65,9 +67,9 @@
"createdAt": "Datum toegevoegd",
"size": "Grootte",
"originalDate": "Origineel",
- "releaseDate": "Uitgegeven",
+ "releaseDate": "Uitgave",
"releases": "Uitgave |||| Uitgaven",
- "released": "Uitgegeven",
+ "released": "Uitgave",
"recordLabel": "Label",
"catalogNum": "Catalogus nummer",
"releaseType": "Type",
@@ -75,7 +77,8 @@
"media": "Media",
"mood": "Sfeer",
"date": "Opnamedatum",
- "missing": "Ontbrekend"
+ "missing": "Ontbrekend",
+ "libraryName": "Bibliotheek"
},
"actions": {
"playAll": "Afspelen",
@@ -123,7 +126,13 @@
"mixer": "Mixer |||| Mixers",
"remixer": "Remixer |||| Remixers",
"djmixer": "DJ Mixer |||| DJ Mixers",
- "performer": "Performer |||| Performers"
+ "performer": "Performer |||| Performers",
+ "maincredit": "Album Artiest of Artiest |||| Album Artiesten or Artiesten"
+ },
+ "actions": {
+ "shuffle": "Shuffle",
+ "radio": "Radio",
+ "topSongs": "Beste nummers"
}
},
"user": {
@@ -132,7 +141,7 @@
"userName": "Gebruikersnaam",
"isAdmin": "Is beheerder",
"lastLoginAt": "Laatst ingelogd op",
- "updatedAt": "Laatst gewijzigd op",
+ "updatedAt": "Laatst bijgewerkt op",
"name": "Naam",
"password": "Wachtwoord",
"createdAt": "Aangemaakt op",
@@ -140,19 +149,26 @@
"currentPassword": "Huidig wachtwoord",
"newPassword": "Nieuw wachtwoord",
"token": "Token",
- "lastAccessAt": "Meest recente toegang"
+ "lastAccessAt": "Meest recente toegang",
+ "libraries": "Bibliotheken"
},
"helperTexts": {
- "name": "Naamswijziging wordt pas zichtbaar bij de volgende login"
+ "name": "Naamswijziging wordt pas zichtbaar bij de volgende login",
+ "libraries": "Selecteer specifieke bibliotheken voor deze gebruiker, of laat leeg om de standaardbiblliotheken te gebruiken"
},
"notifications": {
"created": "Aangemaakt door gebruiker",
- "updated": "Gewijzigd door gebruiker",
- "deleted": "Gewist door gebruiker"
+ "updated": "Bijgewerkt door gebruiker",
+ "deleted": "Gebruiker verwijderd"
},
"message": {
"listenBrainzToken": "Vul je ListenBrainz gebruikers-token in.",
- "clickHereForToken": "Klik hier voor je token"
+ "clickHereForToken": "Klik hier voor je token",
+ "selectAllLibraries": "Selecteer alle bibliotheken",
+ "adminAutoLibraries": "Admin gebruikers hebben automatisch toegang tot alle bibliotheken"
+ },
+ "validation": {
+ "librariesRequired": "Minstens één bibliotheek moet geselecteerd worden voor niet-admin gebruikers"
}
},
"player": {
@@ -181,10 +197,10 @@
"name": "Afspeellijst |||| Afspeellijsten",
"fields": {
"name": "Titel",
- "duration": "Lengte",
+ "duration": "Afspeelduur",
"ownerName": "Eigenaar",
"public": "Publiek",
- "updatedAt": "Laatst gewijzigd op",
+ "updatedAt": "Laatst bijgewerkt op",
"createdAt": "Aangemaakt op",
"songCount": "Nummers",
"comment": "Commentaar",
@@ -197,11 +213,16 @@
"export": "Exporteer",
"makePublic": "Openbaar maken",
"makePrivate": "Privé maken",
- "saveQueue": "Bewaar wachtrij als playlist"
+ "saveQueue": "Bewaar wachtrij als playlist",
+ "searchOrCreate": "Zoek afspeellijsten of typ om een nieuwe te starten...",
+ "pressEnterToCreate": "Druk Enter om nieuwe afspeellijst te maken",
+ "removeFromSelection": "Verwijder van selectie"
},
"message": {
"duplicate_song": "Dubbele nummers toevoegen",
- "song_exist": "Er komen nummers dubbel in de afspeellijst. Wil je de dubbele nummers toevoegen of overslaan?"
+ "song_exist": "Er komen nummers dubbel in de afspeellijst. Wil je de dubbele nummers toevoegen of overslaan?",
+ "noPlaylistsFound": "Geen playlists gevonden",
+ "noPlaylists": "Geen playlists beschikbaar"
}
},
"radio": {
@@ -210,8 +231,8 @@
"name": "Naam",
"streamUrl": "Stream URL",
"homePageUrl": "Hoofdpagina URL",
- "updatedAt": "Geüpdate op",
- "createdAt": "Gecreëerd op"
+ "updatedAt": "Bijgewerkt op",
+ "createdAt": "Aangemaakt op"
},
"actions": {
"playNow": "Speel nu"
@@ -229,8 +250,8 @@
"visitCount": "Bezocht",
"format": "Formaat",
"maxBitRate": "Max. bitrate",
- "updatedAt": "Geüpdatet op",
- "createdAt": "Gecreëerd op",
+ "updatedAt": "Bijgewerkt op",
+ "createdAt": "Aangemaakt op",
"downloadable": "Downloads toestaan?"
}
},
@@ -239,7 +260,8 @@
"fields": {
"path": "Pad",
"size": "Grootte",
- "updatedAt": "Verdwenen op"
+ "updatedAt": "Verdwenen op",
+ "libraryName": "Bibliotheek"
},
"actions": {
"remove": "Verwijder",
@@ -249,6 +271,58 @@
"removed": "Ontbrekende bestanden verwijderd"
},
"empty": "Geen ontbrekende bestanden"
+ },
+ "library": {
+ "name": "Bibliotheek |||| Bibliotheken",
+ "fields": {
+ "name": "Naam",
+ "path": "Pad",
+ "remotePath": "Extern pad",
+ "lastScanAt": "Laatste scan",
+ "songCount": "Nummers",
+ "albumCount": "Albums",
+ "artistCount": "Artiesten",
+ "totalSongs": "Nummers",
+ "totalAlbums": "Albums",
+ "totalArtists": "Artiesten",
+ "totalFolders": "Mappen",
+ "totalFiles": "Bestanden",
+ "totalMissingFiles": "Ontbrekende bestanden",
+ "totalSize": "Totale bestandsgrootte",
+ "totalDuration": "Afspeelduur",
+ "defaultNewUsers": "Standaard voor nieuwe gebruikers",
+ "createdAt": "Aangemaakt",
+ "updatedAt": "Bijgewerkt"
+ },
+ "sections": {
+ "basic": "Basisinformatie",
+ "statistics": "Statistieken"
+ },
+ "actions": {
+ "scan": "Scan bibliotheek",
+ "manageUsers": "Beheer gebruikerstoegang",
+ "viewDetails": "Bekijk details"
+ },
+ "notifications": {
+ "created": "Bibliotheek succesvol aangemaakt",
+ "updated": "Bibliotheek succesvol bijgewerkt",
+ "deleted": "Bibliotheek succesvol verwijderd",
+ "scanStarted": "Bibliotheekscan is gestart",
+ "scanCompleted": "Bibliotheekscan is voltooid"
+ },
+ "validation": {
+ "nameRequired": "Bibliotheek naam is vereist",
+ "pathRequired": "Pad naar bibliotheek is vereist",
+ "pathNotDirectory": "Pad naar bibliotheek moet een map zijn",
+ "pathNotFound": "Pad naar bibliotheek niet gevonden",
+ "pathNotAccessible": "Pad naar bibliotheek is niet toegankelijk",
+ "pathInvalid": "Ongeldig pad naar bibliotheek"
+ },
+ "messages": {
+ "deleteConfirm": "Weet je zeker dat je deze bibliotheek wil verwijderen? Dit verwijdert ook alle gerelateerde data en gebruikerstoegang.",
+ "scanInProgress": "Scan is bezig...",
+ "noLibrariesAssigned": "Geen bibliotheken aan deze gebruiker toegewezen"
+ }
}
},
"ra": {
@@ -430,7 +504,9 @@
"remove_missing_title": "Verwijder ontbrekende bestanden",
"remove_missing_content": "Weet je zeker dat je alle ontbrekende bestanden van de database wil verwijderen? Dit wist permanent al hun referenties inclusief afspeel tellers en beoordelingen.",
"remove_all_missing_title": "Verwijder alle ontbrekende bestanden",
- "remove_all_missing_content": "Weet je zeker dat je alle ontbrekende bestanden van de database wil verwijderen? Dit wist permanent al hun referenties inclusief afspeel tellers en beoordelingen."
+ "remove_all_missing_content": "Weet je zeker dat je alle ontbrekende bestanden van de database wil verwijderen? Dit wist permanent al hun referenties inclusief afspeel tellers en beoordelingen.",
+ "noSimilarSongsFound": "Geen vergelijkbare nummers gevonden",
+ "noTopSongsFound": "Geen beste nummers gevonden"
},
"menu": {
"library": "Bibliotheek",
@@ -459,7 +535,13 @@
"albumList": "Albums",
"about": "Over",
"playlists": "Afspeellijsten",
- "sharedPlaylists": "Gedeelde afspeellijsten"
+ "sharedPlaylists": "Gedeelde afspeellijsten",
+ "librarySelector": {
+ "allLibraries": "Alle bibliotheken (%{count})",
+ "multipleLibraries": "%{selected} van %{total} bibliotheken",
+ "selectLibraries": "Selecteer bibliotheken",
+ "none": "Geen"
+ }
},
"player": {
"playListsText": "Wachtrij",
@@ -468,7 +550,7 @@
"notContentText": "Geen muziek",
"clickToPlayText": "Klik om af te spelen",
"clickToPauseText": "Klik om te pauzeren",
- "nextTrackText": "Volgende",
+ "nextTrackText": "Volgend nummer",
"previousTrackText": "Vorige",
"reloadText": "Herladen",
"volumeText": "Volume",
@@ -496,11 +578,26 @@
"disabled": "Uitgeschakeld",
"waiting": "Wachten"
}
+ },
+ "tabs": {
+ "about": "Over",
+ "config": "Configuratie"
+ },
+ "config": {
+ "configName": "Config Naam",
+ "environmentVariable": "Omgevingsvariabele",
+ "currentValue": "Huidige waarde",
+ "configurationFile": "Configuratiebestand",
+ "exportToml": "Exporteer configuratie (TOML)",
+ "exportSuccess": "Configuratie geëxporteerd naar klembord in TOML formaat",
+ "exportFailed": "Kopiëren van configuratie mislukt",
+ "devFlagsHeader": "Ontwikkelaarsinstellingen (onder voorbehoud)",
+ "devFlagsComment": "Dit zijn experimentele instellingen en worden mogelijk in latere versies verwijderd"
}
},
"activity": {
"title": "Activiteit",
- "totalScanned": "Totaal gescande folders",
+ "totalScanned": "Totaal gescande mappen",
"quickScan": "Snelle scan",
"fullScan": "Volledige scan",
"serverUptime": "Server uptime",
@@ -522,5 +619,10 @@
"toggle_love": "Voeg toe aan favorieten",
"current_song": "Ga naar huidig nummer"
}
+ },
+ "nowPlaying": {
+ "title": "Speelt nu",
+ "empty": "Er wordt niets afgespeed",
+ "minutesAgo": "%{smart_count} minuut geleden |||| %{smart_count} minuten geleden"
}
}
\ No newline at end of file
diff --git a/resources/i18n/pt-br.json b/resources/i18n/pt-br.json
index 9c22d509f..3f095b025 100644
--- a/resources/i18n/pt-br.json
+++ b/resources/i18n/pt-br.json
@@ -300,6 +300,8 @@
},
"actions": {
"scan": "Scanear Biblioteca",
+ "quickScan": "Scan Rápido",
+ "fullScan": "Scan Completo",
"manageUsers": "Gerenciar Acesso do Usuário",
"viewDetails": "Ver Detalhes"
},
@@ -308,6 +310,9 @@
"updated": "Biblioteca atualizada com sucesso",
"deleted": "Biblioteca excluída com sucesso",
"scanStarted": "Scan da biblioteca iniciada",
+ "quickScanStarted": "Scan rápido iniciado",
+ "fullScanStarted": "Scan completo iniciado",
+ "scanError": "Erro ao iniciar o scan. Verifique os logs",
"scanCompleted": "Scan da biblioteca concluída"
},
"validation": {
@@ -598,11 +603,12 @@
"activity": {
"title": "Atividade",
"totalScanned": "Total de pastas scaneadas",
- "quickScan": "Scan rápido",
- "fullScan": "Scan completo",
+ "quickScan": "Rápido",
+ "fullScan": "Completo",
+ "selectiveScan": "Seletivo",
"serverUptime": "Uptime do servidor",
"serverDown": "DESCONECTADO",
- "scanType": "Tipo",
+ "scanType": "Último Scan",
"status": "Erro",
"elapsedTime": "Duração"
},
diff --git a/resources/i18n/th.json b/resources/i18n/th.json
index 2f96f4958..65d51860f 100644
--- a/resources/i18n/th.json
+++ b/resources/i18n/th.json
@@ -26,7 +26,17 @@
"bpm": "BPM",
"playDate": "เล่นล่าสุด",
"channels": "ช่อง",
- "createdAt": "เพิ่มเมื่อ"
+ "createdAt": "เพิ่มเมื่อ",
+ "grouping": "จัดกลุ่ม",
+ "mood": "อารมณ์",
+ "participants": "ผู้มีส่วนร่วม",
+ "tags": "แทกเพิ่มเติม",
+ "mappedTags": "แมพแทก",
+ "rawTags": "แทกเริ่มต้น",
+ "bitDepth": "Bit depth",
+ "sampleRate": "แซมเปิ้ลเรต",
+ "missing": "หายไป",
+ "libraryName": "ห้องสมุด"
},
"actions": {
"addToQueue": "เพิ่มในคิว",
@@ -35,7 +45,8 @@
"shuffleAll": "สุ่มทั้งหมด",
"download": "ดาวน์โหลด",
"playNext": "เล่นถัดไป",
- "info": "ดูรายละเอียด"
+ "info": "ดูรายละเอียด",
+ "showInPlaylist": "แสดงในเพลย์ลิสต์"
}
},
"album": {
@@ -58,7 +69,16 @@
"originalDate": "วันที่เริ่ม",
"releaseDate": "เผยแพร่เมื่อ",
"releases": "เผยแพร่ |||| เผยแพร่",
- "released": "เผยแพร่เมื่อ"
+ "released": "เผยแพร่เมื่อ",
+ "recordLabel": "ป้าย",
+ "catalogNum": "หมายเลขแคตาล็อก",
+ "releaseType": "ประเภท",
+ "grouping": "จัดกลุ่ม",
+ "media": "มีเดีย",
+ "mood": "อารมณ์",
+ "date": "บันทึกเมื่อ",
+ "missing": "หายไป",
+ "libraryName": "ห้องสมุด"
},
"actions": {
"playAll": "เล่นทั้งหมด",
@@ -89,7 +109,30 @@
"playCount": "เล่นแล้ว",
"rating": "ความนิยม",
"genre": "ประเภท",
- "size": "ขนาด"
+ "size": "ขนาด",
+ "role": "Role",
+ "missing": "หายไป"
+ },
+ "roles": {
+ "albumartist": "ศิลปินอัลบั้ม |||| ศิลปินอัลบั้ม",
+ "artist": "ศิลปิน |||| ศิลปิน",
+ "composer": "ผู้แต่ง |||| ผู้แต่ง",
+ "conductor": "คอนดักเตอร์ |||| คอนดักเตอร์",
+ "lyricist": "เนื้อเพลง |||| เนื้อเพลง",
+ "arranger": "ผู้ดำเนินการ |||| ผู้ดำเนินการ",
+ "producer": "ผู้จัด |||| ผู้จัด",
+ "director": "ไดเรกเตอร์ |||| ไดเรกเตอร์",
+ "engineer": "วิศวกร |||| วิศวกร",
+ "mixer": "มิกเซอร์ |||| มิกเซอร์",
+ "remixer": "รีมิกเซอร์ |||| รีมิกเซอร์",
+ "djmixer": "ดีเจมิกเซอร์ |||| ดีเจมิกเซอร์",
+ "performer": "ผู้เล่น |||| ผู้เล่น",
+ "maincredit": "ศิลปิน |||| ศิลปิน"
+ },
+ "actions": {
+ "shuffle": "เล่นสุ่ม",
+ "radio": "วิทยุ",
+ "topSongs": "เพลงยอดนิยม"
}
},
"user": {
@@ -106,10 +149,12 @@
"currentPassword": "รหัสผ่านปัจจุบัน",
"newPassword": "รหัสผ่านใหม่",
"token": "โทเคน",
- "lastAccessAt": "เข้าใช้ล่าสุด"
+ "lastAccessAt": "เข้าใช้ล่าสุด",
+ "libraries": "ห้องสมุด"
},
"helperTexts": {
- "name": "การเปลี่ยนชื่อจะมีผลในการล็อกอินครั้งถัดไป"
+ "name": "การเปลี่ยนชื่อจะมีผลในการล็อกอินครั้งถัดไป",
+ "libraries": "เลือกห้องสมุดสำหรับผู้ใช้นี้หรือปล่อยว่างเพื่อใช้ห้องสมุดเริ่มต้น"
},
"notifications": {
"created": "สร้างชื่อผู้ใช้",
@@ -118,7 +163,12 @@
},
"message": {
"listenBrainzToken": "ใส่โทเคน ListenBrainz ของคุณ",
- "clickHereForToken": "กดที่นี่เพื่อรับโทเคนของคุณ"
+ "clickHereForToken": "กดที่นี่เพื่อรับโทเคนของคุณ",
+ "selectAllLibraries": "เลือกห้องสมุดทั้งหมด",
+ "adminAutoLibraries": "ผู้ดูแลเข้าถึงห้องสมุดทั้งหมดโดยอัตโนมัติ"
+ },
+ "validation": {
+ "librariesRequired": "ต้องเลือกห้องสมุด 1 ห้อง สำหรับผู้ใช้ที่ไม่ใช่ผู้ดูแล"
}
},
"player": {
@@ -162,11 +212,17 @@
"addNewPlaylist": "สร้าง \"%{name}\"",
"export": "ส่งออก",
"makePublic": "ทำเป็นสาธารณะ",
- "makePrivate": "ทำเป็นส่วนตัว"
+ "makePrivate": "ทำเป็นส่วนตัว",
+ "saveQueue": "บันทึกคิวลงเพลย์ลิสต์",
+ "searchOrCreate": "ค้นหาเพลย์ลิสต์หรือพิมพ์เพื่อสร้างใหม่",
+ "pressEnterToCreate": "กด Enter เพื่อสร้างเพลย์ลิสต์",
+ "removeFromSelection": "เอาออกจากที่เลือกไว้"
},
"message": {
"duplicate_song": "เพิ่มเพลงซ้ำ",
- "song_exist": "เพิ่มเพลงซ้ำกันในเพลย์ลิสต์ คุณจะเพิ่มเพลงต่อหรือข้าม"
+ "song_exist": "เพิ่มเพลงซ้ำกันในเพลย์ลิสต์ คุณจะเพิ่มเพลงต่อหรือข้าม",
+ "noPlaylistsFound": "ไม่พบเพลย์ลิสต์",
+ "noPlaylists": "ไม่มีเพลย์ลิสต์อยู่"
}
},
"radio": {
@@ -198,6 +254,75 @@
"createdAt": "สร้างเมื่อ",
"downloadable": "อนุญาตให้ดาวโหลด?"
}
+ },
+ "missing": {
+ "name": "ไฟล์ที่หายไป |||| ไฟล์ที่หายไป",
+ "fields": {
+ "path": "พาร์ท",
+ "size": "ขนาด",
+ "updatedAt": "หายไปจาก",
+ "libraryName": "ห้องสมุด"
+ },
+ "actions": {
+ "remove": "เอาออก",
+ "remove_all": "เอาออกทั้งหมด"
+ },
+ "notifications": {
+ "removed": "เอาไฟล์ที่หายไปออกแล้ว"
+ },
+ "empty": "ไม่มีไฟล์หาย"
+ },
+ "library": {
+ "name": "ห้องสมุด |||| ห้องสมุด",
+ "fields": {
+ "name": "ชื่อ",
+ "path": "พาร์ท",
+ "remotePath": "รีโมทพาร์ท",
+ "lastScanAt": "สแกนล่าสุด",
+ "songCount": "เพลง",
+ "albumCount": "อัลบัม",
+ "artistCount": "ศิลปิน",
+ "totalSongs": "เพลง",
+ "totalAlbums": "อัลบัม",
+ "totalArtists": "ศิลปิน",
+ "totalFolders": "แฟ้ม",
+ "totalFiles": "ไฟล์",
+ "totalMissingFiles": "ไฟล์ที่หายไป",
+ "totalSize": "ขนาดทั้งหมด",
+ "totalDuration": "ความยาว",
+ "defaultNewUsers": "ค่าเริ่มต้นผู้ใช้ใหม่",
+ "createdAt": "สร้าง",
+ "updatedAt": "อัพเดท"
+ },
+ "sections": {
+ "basic": "ข้อมูลเบื้องต้น",
+ "statistics": "สถิติ"
+ },
+ "actions": {
+ "scan": "สแกนห้องสมุด",
+ "manageUsers": "ตั้งค่าการเข้าถึง",
+ "viewDetails": "ดูรายละเอียด"
+ },
+ "notifications": {
+ "created": "สร้างห้องสมุดเรียบร้อย",
+ "updated": "อัพเดทห้องสมุดเรียบร้อย",
+ "deleted": "ลบห้องสมุดเพลงเรียบร้อยแล้ว",
+ "scanStarted": "เริ่มสแกนห้องสมุด",
+ "scanCompleted": "สแกนห้องสมุดเสร็จแล้ว"
+ },
+ "validation": {
+ "nameRequired": "ต้องใส่ชื่อห้องสมุดเพลง",
+ "pathRequired": "ต้องใส่พาร์ทของห้องสมุด",
+ "pathNotDirectory": "พาร์ทของห้องสมุดต้องเป็นแฟ้ม",
+ "pathNotFound": "ไม่เจอพาร์ทของห้องสมุด",
+ "pathNotAccessible": "ไม่สามารถเข้าพาร์ทของห้องสมุด",
+ "pathInvalid": "พาร์ทห้องสมุดไม่ถูก"
+ },
+ "messages": {
+ "deleteConfirm": "คุณแน่ใจว่าจะลบห้องสมุดนี้? นี่จะลบข้อมูลและการเข้าถึงของผู้ใช้ที่เกี่ยวข้องทั้งหมด",
+ "scanInProgress": "กำลังสแกน...",
+ "noLibrariesAssigned": "ไม่มีห้องสมุดสำหรับผู้ใช้นี้"
+ }
}
},
"ra": {
@@ -375,7 +500,13 @@
"shareSuccess": "คัดลอก URL ไปคลิปบอร์ด: %{url}",
"shareFailure": "คัดลอก URL %{url} ไปคลิปบอร์ดผิดพลาด",
"downloadDialogTitle": "ดาวโหลด %{resource} '%{name}' (%{size})",
- "shareCopyToClipboard": "คัดลอกไปคลิปบอร์ด: Ctrl+C, Enter"
+ "shareCopyToClipboard": "คัดลอกไปคลิปบอร์ด: Ctrl+C, Enter",
+ "remove_missing_title": "ลบรายการไฟล์ที่หายไป",
+ "remove_missing_content": "คุณแน่ใจว่าจะเอารายการไฟล์ที่หายไปออกจากดาต้าเบส นี่จะเป็นการลบข้อมูลอ้างอิงทั้งหมดของไฟล์ออกอย่างถาวร",
+ "remove_all_missing_title": "เอารายการไฟล์ที่หายไปออกทั้งหมด",
+ "remove_all_missing_content": "คุณแน่ใจว่าจะเอารายการไฟล์ที่หายไปออกจากดาต้าเบส นี่จะเป็นการลบข้อมูลอ้างอิงทั้งหมดของไฟล์ออกอย่างถาวร",
+ "noSimilarSongsFound": "ไม่มีเพลงคล้ายกัน",
+ "noTopSongsFound": "ไม่พบเพลงยอดนิยม"
},
"menu": {
"library": "ห้องสมุดเพลง",
@@ -404,7 +535,13 @@
"albumList": "อัลบั้ม",
"about": "เกี่ยวกับ",
"playlists": "เพลย์ลิสต์",
- "sharedPlaylists": "เพลย์ลิสต์ที่แบ่งปัน"
+ "sharedPlaylists": "เพลย์ลิสต์ที่แบ่งปัน",
+ "librarySelector": {
+ "allLibraries": "ห้องสมุด (%{count}) ห้อง",
+ "multipleLibraries": "%{selected} ของ %{total} ห้องสมุด",
+ "selectLibraries": "เลือกห้องสมุด",
+ "none": "ไม่มี"
+ }
},
"player": {
"playListsText": "คิวเล่น",
@@ -441,6 +578,21 @@
"disabled": "ปิดการทำงาน",
"waiting": "รอ"
}
+ },
+ "tabs": {
+ "about": "เกี่ยวกับ",
+ "config": "การตั้งค่า"
+ },
+ "config": {
+ "configName": "ชื่อการตั้งค่า",
+ "environmentVariable": "ค่าทั่วไป",
+ "currentValue": "ค่าปัจจุบัน",
+ "configurationFile": "ไฟล์การตั้งค่า",
+ "exportToml": "นำออกการตั้งค่า (TOML)",
+ "exportSuccess": "นำออกการตั้งค่าไปยังคลิปบอร์ดในรูปแบบ TOML แล้ว",
+ "exportFailed": "คัดลอกการตั้งค่าล้มเหลว",
+ "devFlagsHeader": "ปักธงการพัฒนา (อาจมีการเปลี่ยน/เอาออก)",
+ "devFlagsComment": "การตั้งค่านี้อยู่ในช่วงทดลองและอาจจะมีการเอาออกในเวอร์ชั่นหลัง"
}
},
"activity": {
@@ -449,7 +601,10 @@
"quickScan": "สแกนแบบเร็ว",
"fullScan": "สแกนทั้งหมด",
"serverUptime": "เซิร์ฟเวอร์ออนไลน์นาน",
- "serverDown": "ออฟไลน์"
+ "serverDown": "ออฟไลน์",
+ "scanType": "ประเภท",
+ "status": "สแกนผิดพลาด",
+ "elapsedTime": "เวลาที่ใช้"
},
"help": {
"title": "คีย์ลัด Navidrome",
@@ -464,5 +619,10 @@
"toggle_love": "เพิ่มเพลงนี้ไปยังรายการโปรด",
"current_song": "ไปยังเพลงปัจจุบัน"
}
+ },
+ "nowPlaying": {
+ "title": "กำลังเล่น",
+ "empty": "ไม่มีเพลงเล่น",
+ "minutesAgo": "%{smart_count} นาทีที่แล้ว |||| %{smart_count} นาทีที่แล้ว"
}
}
\ No newline at end of file
diff --git a/resources/i18n/zh-Hant.json b/resources/i18n/zh-Hant.json
index 3d6bbd268..7d8ce2872 100644
--- a/resources/i18n/zh-Hant.json
+++ b/resources/i18n/zh-Hant.json
@@ -1,463 +1,630 @@
{
- "languageName": "繁體中文",
- "resources": {
- "song": {
- "name": "歌曲 |||| 歌曲",
- "fields": {
- "albumArtist": "專輯藝人",
- "duration": "長度",
- "trackNumber": "#",
- "playCount": "播放次數",
- "title": "標題",
- "artist": "藝人",
- "album": "專輯",
- "path": "文件路徑",
- "genre": "類型",
- "compilation": "合輯",
- "year": "發行年份",
- "size": "檔案大小",
- "updatedAt": "更新於",
- "bitRate": "位元率",
- "discSubtitle": "字幕",
- "starred": "收藏",
- "comment": "註解",
- "rating": "評分",
- "quality": "品質",
- "bpm": "BPM",
- "playDate": "上次播放",
- "channels": "聲道",
- "createdAt": "創建於"
- },
- "actions": {
- "addToQueue": "加入至播放佇列",
- "playNow": "立即播放",
- "addToPlaylist": "加入至播放清單",
- "shuffleAll": "全部隨機播放",
- "download": "下載",
- "playNext": "下一首播放",
- "info": "取得資訊"
- }
- },
- "album": {
- "name": "專輯 |||| 專輯",
- "fields": {
- "albumArtist": "專輯藝人",
- "artist": "藝人",
- "duration": "長度",
- "songCount": "歌曲數量",
- "playCount": "播放次數",
- "name": "名稱",
- "genre": "類型",
- "compilation": "合輯",
- "year": "發行年份",
- "updatedAt": "更新於",
- "comment": "註解",
- "rating": "評分",
- "createdAt": "創建於",
- "size": "檔案大小",
- "originalDate": "原始日期",
- "releaseDate": "發行日期",
- "releases": "發行",
- "released": "已發行"
- },
- "actions": {
- "playAll": "立即播放",
- "playNext": "下首播放",
- "addToQueue": "加入至播放佇列",
- "shuffle": "隨機播放",
- "addToPlaylist": "加入播放清單",
- "download": "下載",
- "info": "取得資訊",
- "share": "分享"
- },
- "lists": {
- "all": "所有",
- "random": "隨機",
- "recentlyAdded": "最近加入",
- "recentlyPlayed": "最近播放",
- "mostPlayed": "最多播放的",
- "starred": "收藏",
- "topRated": "最高評分"
- }
- },
- "artist": {
- "name": "藝人 |||| 藝人",
- "fields": {
- "name": "名稱",
- "albumCount": "專輯數",
- "songCount": "歌曲數",
- "playCount": "播放次數",
- "rating": "評分",
- "genre": "類型",
- "size": "檔案大小"
- }
- },
- "user": {
- "name": "使用者 |||| 使用者",
- "fields": {
- "userName": "使用者名稱",
- "isAdmin": "是否管理員",
- "lastLoginAt": "上次登入",
- "lastAccessAt": "上此訪問",
- "updatedAt": "更新於",
- "name": "名稱",
- "password": "密碼",
- "createdAt": "創建於",
- "changePassword": "變更密碼？",
- "currentPassword": "現在的密碼",
- "newPassword": "新密碼",
- "token": "權杖"
- },
- "helperTexts": {
- "name": "你的名稱會在下次登入時生效"
- },
- "notifications": {
- "created": "使用者已創建",
- "updated": "使用者已更新",
- "deleted": "使用者已刪除"
- },
- "message": {
- "listenBrainzToken": "輸入您的 ListenBrainz 使用者權杖",
- "clickHereForToken": "點擊此處來獲得你的 ListenBrainz 權杖"
- }
- },
- "player": {
- "name": "用戶端 |||| 用戶端",
- "fields": {
- "name": "名稱",
- "transcodingId": "轉碼",
- "maxBitRate": "最大位元率",
- "client": "用戶端",
- "userName": "使用者名稱",
- "lastSeen": "上次瀏覽",
- "reportRealPath": "回報實際路徑",
- "scrobbleEnabled": "傳送音樂記錄至外部服務"
- }
- },
- "transcoding": {
- "name": "轉碼 |||| 轉碼",
- "fields": {
- "name": "名稱",
- "targetFormat": "目標格式",
- "defaultBitRate": "預設位元率",
- "command": "命令"
- }
- },
- "playlist": {
- "name": "播放清單 |||| 播放清單",
- "fields": {
- "name": "名稱",
- "duration": "長度",
- "ownerName": "擁有者",
- "public": "公開",
- "updatedAt": "更新於",
- "createdAt": "創建於",
- "songCount": "歌曲數",
- "comment": "註解",
- "sync": "自動導入",
- "path": "導入"
- },
- "actions": {
- "selectPlaylist": "選擇播放清單",
- "addNewPlaylist": "創建 %{name}",
- "export": "導出",
- "makePublic": "設為公開",
- "makePrivate": "設為私人"
- },
- "message": {
- "duplicate_song": "加入重複的歌曲",
- "song_exist": "有重複歌曲正在播放清單裡，您要加入或略過重複歌曲？"
- }
- },
- "radio": {
- "name": "電台",
- "fields": {
- "name": "名稱",
- "streamUrl": "串流網址",
- "homePageUrl": "首頁網址",
- "updatedAt": "更新於",
- "createdAt": "創建於"
- },
- "actions": {
- "playNow": "立即播放"
- }
- },
- "share": {
- "name": "分享",
- "fields": {
- "username": "使用者名稱",
- "url": "網址",
- "description": "描述",
- "contents": "內容",
- "expiresAt": "過期時間",
- "lastVisitedAt": "上次訪問時間",
- "visitCount": "訪問次數",
- "format": "格式",
- "maxBitRate": "最大位元率",
- "updatedAt": "更新於",
- "createdAt": "創建於",
- "downloadable": "可下載"
- },
- "notifications": {},
- "actions": {}
- }
+ "languageName": "繁體中文",
+ "resources": {
+ "song": {
+ "name": "歌曲 |||| 歌曲",
+ "fields": {
+ "albumArtist": "專輯藝人",
+ "duration": "長度",
+ "trackNumber": "#",
+ "playCount": "播放次數",
+ "title": "標題",
+ "artist": "藝人",
+ "album": "專輯",
+ "path": "檔案路徑",
+ "libraryName": "媒體庫",
+ "genre": "曲風",
+ "compilation": "合輯",
+ "year": "發行年份",
+ "size": "檔案大小",
+ "updatedAt": "更新於",
+ "bitRate": "位元率",
+ "bitDepth": "位元深度",
+ "sampleRate": "取樣率",
+ "channels": "聲道",
+ "discSubtitle": "光碟副標題",
+ "starred": "收藏",
+ "comment": "註解",
+ "rating": "評分",
+ "quality": "品質",
+ "bpm": "BPM",
+ "playDate": "上次播放",
+ "createdAt": "建立於",
+ "grouping": "分組",
+ "mood": "情緒",
+ "participants": "其他參與人員",
+ "tags": "額外標籤",
+ "mappedTags": "分類後標籤",
+ "rawTags": "原始標籤",
+ "missing": "遺失"
+ },
+ "actions": {
+ "addToQueue": "加入至播放佇列",
+ "playNow": "立即播放",
+ "addToPlaylist": "加入至播放清單",
+ "showInPlaylist": "在播放清單中顯示",
+ "shuffleAll": "全部隨機播放",
+ "download": "下載",
+ "playNext": "下一首播放",
+ "info": "取得資訊"
+ }
},
- "ra": {
- "auth": {
- "welcome1": "感謝您安裝 Navidrome！",
- "welcome2": "開始前，請創建一個管理員帳戶",
- "confirmPassword": "確認密碼",
- "buttonCreateAdmin": "創建管理員",
- "auth_check_error": "請登入以訪問更多內容",
- "user_menu": "配置",
- "username": "使用者名稱",
- "password": "密碼",
- "sign_in": "登入",
- "sign_in_error": "驗證失敗，請重試",
- "logout": "登出"
- },
- "validation": {
- "invalidChars": "請使用字母和數字",
- "passwordDoesNotMatch": "密碼不相符",
- "required": "必填",
- "minLength": "必須不少於 %{min} 個字元",
- "maxLength": "必須不多於 %{max} 個字元",
- "minValue": "必須不小於 %{min}",
- "maxValue": "必須不大於 %{max}",
- "number": "必須為數字",
- "email": "必須是有效的電子郵件",
- "oneOf": "必須為: %{options}其中一項",
- "regex": "必須符合指定的格式（正規表達式）：%{pattern}",
- "unique": "必須是唯一的",
- "url": "網址"
- },
- "action": {
- "add_filter": "加入篩選",
- "add": "加入",
- "back": "返回",
- "bulk_actions": "選中 %{smart_count} 項",
- "cancel": "取消",
- "clear_input_value": "清除",
- "clone": "複製",
- "confirm": "確認",
- "create": "創建",
- "delete": "刪除",
- "edit": "編輯",
- "export": "匯出",
- "list": "列表",
- "refresh": "重新整理",
- "remove_filter": "清除此條件",
- "remove": "清除",
- "save": "保存",
- "search": "搜尋",
- "show": "顯示",
- "sort": "排序",
- "undo": "撤銷",
- "expand": "展開",
- "close": "關閉",
- "open_menu": "打開選單",
- "close_menu": "關閉選單",
- "unselect": "未選擇",
- "skip": "略過",
- "bulk_actions_mobile": "%{smart_count}",
- "share": "分享",
- "download": "下載"
- },
- "boolean": {
- "true": "是",
- "false": "否"
- },
- "page": {
- "create": "創建 %{name}",
- "dashboard": "儀表板",
- "edit": "%{name} #%{id}",
- "error": "發生錯誤",
- "list": "%{name}",
- "loading": "載入中",
- "not_found": "未發現",
- "show": "%{name} #%{id}",
- "empty": "還沒有 %{name}。",
- "invite": "你要創建一個嗎？"
- },
- "input": {
- "file": {
- "upload_several": "拖拽多個文件上傳或點擊選擇一個",
- "upload_single": "拖拽單個文件上傳或點擊選擇一個"
- },
- "image": {
- "upload_several": "拖拽多個圖片上傳或點擊選擇一個",
- "upload_single": "拖拽單個圖片上傳或點擊選擇一個"
- },
- "references": {
- "all_missing": "未找到參考數據",
- "many_missing": "至少有一條參考數據不再可用",
- "single_missing": "關聯的參考數據不再可用"
- },
- "password": {
- "toggle_visible": "隱藏密碼",
- "toggle_hidden": "顯示密碼"
- }
- },
- "message": {
- "about": "關於",
- "are_you_sure": "確定進行此操作？",
- "bulk_delete_content": "您確定要刪除 %{name}？ |||| 您確定要刪除 %{smart_count} 項？",
- "bulk_delete_title": "刪除 %{name} |||| 刪除 %{smart_count} 項 %{name}",
- "delete_content": "您確定要刪除該項目？",
- "delete_title": "刪除 %{name} #%{id}",
- "details": "詳細資訊",
- "error": "發生一個用戶端錯誤，您的請求無法完成",
- "invalid_form": "提交內容無效，請檢查錯誤",
- "loading": "正在載入頁面，請稍候",
- "no": "否",
- "not_found": "您輸入的連結格式不對或連結遺失",
- "yes": "是",
- "unsaved_changes": "某些更改尚未保存，您確定要離開此頁面嗎？"
- },
- "navigation": {
- "no_results": "無內容",
- "no_more_results": "頁碼 %{page} 超出邊界，嘗試返回上一頁",
- "page_out_of_boundaries": "頁碼 %{page} 超出邊界",
- "page_out_from_end": "已經最後一頁",
- "page_out_from_begin": "已經是第一頁",
- "page_range_info": "%{offsetBegin}-%{offsetEnd} / %{total}",
- "page_rows_per_page": "每頁行數：",
- "next": "下一頁",
- "prev": "上一頁",
- "skip_nav": "跳過"
- },
- "notification": {
- "updated": "項已更新 |||| %{smart_count} 項已更新",
- "created": "項已創建",
- "deleted": "項已刪除 |||| %{smart_count} 項已刪除",
- "bad_item": "不確定的項",
- "item_doesnt_exist": "項不存在",
- "http_error": "伺服器通訊錯誤",
- "data_provider_error": "資料來源錯誤，請檢查控制台的詳細資訊",
- "i18n_error": "無法載入所選語言",
- "canceled": "操作已取消",
- "logged_out": "您的會話已結束，請重新登入",
- "new_version": "發現新版本！請重新整理視窗"
- },
- "toggleFieldsMenu": {
- "columnsToDisplay": "顯示欄目",
- "layout": "版面",
- "grid": "框格",
- "table": "表格"
- }
+ "album": {
+ "name": "專輯 |||| 專輯",
+ "fields": {
+ "albumArtist": "專輯藝人",
+ "artist": "藝人",
+ "duration": "長度",
+ "songCount": "歌曲數",
+ "playCount": "播放次數",
+ "size": "檔案大小",
+ "name": "名稱",
+ "libraryName": "媒體庫",
+ "genre": "曲風",
+ "compilation": "合輯",
+ "year": "發行年份",
+ "date": "錄製日期",
+ "originalDate": "原始日期",
+ "releaseDate": "發行日期",
+ "releases": "發行",
+ "released": "已發行",
+ "updatedAt": "更新於",
+ "comment": "註解",
+ "rating": "評分",
+ "createdAt": "建立於",
+ "recordLabel": "唱片公司",
+ "catalogNum": "目錄編號",
+ "releaseType": "發行類型",
+ "grouping": "分組",
+ "media": "媒體類型",
+ "mood": "情緒",
+ "missing": "遺失"
+ },
+ "actions": {
+ "playAll": "播放全部",
+ "playNext": "下一首播放",
+ "addToQueue": "加入至播放佇列",
+ "share": "分享",
+ "shuffle": "隨機播放",
+ "addToPlaylist": "加入至播放清單",
+ "download": "下載",
+ "info": "取得資訊"
+ },
+ "lists": {
+ "all": "所有",
+ "random": "隨機",
+ "recentlyAdded": "最近加入",
+ "recentlyPlayed": "最近播放",
+ "mostPlayed": "最常播放",
+ "starred": "收藏",
+ "topRated": "最高評分"
+ }
},
- "message": {
- "note": "註解",
- "transcodingDisabled": "出於安全原因，禁用了從 Web 介面更改參數。要更改（編輯或新增）轉檔選項，請在啟用 %{config} 選項的情況下重新啟動伺服器。",
- "transcodingEnabled": "Navidrome 當前與 %{config} 一起使用，可以通過配置轉檔參數執行任意命令，建議僅在配置轉檔選項時啟用此功能。",
- "songsAddedToPlaylist": "已加入一首歌到播放清單 |||| 已添加 %{smart_count} 首歌到播放清單",
- "noPlaylistsAvailable": "沒有可用的播放清單",
- "delete_user_title": "刪除使用者 %{name}",
- "delete_user_content": "您確定要刪除該使用者及其相關數據（包括播放清單和使用者配置）嗎？",
- "notifications_blocked": "您已在瀏覽器的設置中封鎖了此網站的通知",
- "notifications_not_available": "此瀏覽器不支援桌面通知",
- "lastfmLinkSuccess": "Last.fm 成功連接並開啟音樂記錄",
- "lastfmLinkFailure": "Last.fm 無法連接",
- "lastfmUnlinkSuccess": "Last.fm 已無連接並停用音樂記錄",
- "lastfmUnlinkFailure": "Last.fm 無法取消連接",
- "openIn": {
- "lastfm": "在 Last.fm 打開",
- "musicbrainz": "在 MusicBrainz 打開"
- },
- "lastfmLink": "繼續閱讀…",
- "listenBrainzLinkSuccess": "ListenBrainz 成功連接並開啟音樂記錄",
- "listenBrainzLinkFailure": "ListenBrainz 無法連接：%{error}",
- "listenBrainzUnlinkSuccess": "ListenBrainz 已無連接並停用音樂記錄",
- "listenBrainzUnlinkFailure": "ListenBrainz 無法取消連接",
- "downloadOriginalFormat": "下載原始格式",
- "shareOriginalFormat": "分享原始格式",
- "shareDialogTitle": "分享",
- "shareBatchDialogTitle": "批次分享",
- "shareSuccess": "分享成功",
- "shareFailure": "分享失敗",
- "downloadDialogTitle": "下載",
- "shareCopyToClipboard": "複製到剪貼簿"
+ "artist": {
+ "name": "藝人 |||| 藝人",
+ "fields": {
+ "name": "名稱",
+ "albumCount": "專輯數",
+ "songCount": "歌曲數",
+ "size": "檔案大小",
+ "playCount": "播放次數",
+ "rating": "評分",
+ "genre": "曲風",
+ "role": "參與角色",
+ "missing": "遺失"
+ },
+ "roles": {
+ "albumartist": "專輯藝人 |||| 專輯藝人",
+ "artist": "藝人 |||| 藝人",
+ "composer": "作曲 |||| 作曲",
+ "conductor": "指揮 |||| 指揮",
+ "lyricist": "作詞 |||| 作詞",
+ "arranger": "編曲 |||| 編曲",
+ "producer": "製作人 |||| 製作人",
+ "director": "導演 |||| 導演",
+ "engineer": "工程師 |||| 工程師",
+ "mixer": "混音師 |||| 混音師",
+ "remixer": "重混師 |||| 重混師",
+ "djmixer": "DJ 混音師 |||| DJ 混音師",
+ "performer": "表演者 |||| 表演者",
+ "maincredit": "專輯藝人或藝人 |||| 專輯藝人或藝人"
+ },
+ "actions": {
+ "topSongs": "熱門歌曲",
+ "shuffle": "隨機播放",
+ "radio": "電台"
+ }
},
- "menu": {
- "library": "音樂庫",
- "settings": "設定",
- "version": "版本",
- "theme": "主題",
- "personal": {
- "name": "個人化",
- "options": {
- "theme": "主題",
- "language": "語言",
- "defaultView": "預設畫面",
- "desktop_notifications": "桌面通知",
- "lastfmScrobbling": "啟用 Last.fm 音樂記錄",
- "listenBrainzScrobbling": "啟用 ListenBrainz 音樂記錄",
- "replaygain": "重播增益",
- "preAmp": "前置放大器 (dB)",
- "gain": {
- "none": "無",
- "album": "專輯增益",
- "track": "曲目增益"
- }
- }
- },
- "albumList": "專輯",
- "about": "關於",
- "playlists": "播放清單",
- "sharedPlaylists": "分享的播放清單"
+ "user": {
+ "name": "使用者 |||| 使用者",
+ "fields": {
+ "userName": "使用者名稱",
+ "isAdmin": "管理員",
+ "lastLoginAt": "上次登入",
+ "lastAccessAt": "上次存取",
+ "updatedAt": "更新於",
+ "name": "名稱",
+ "password": "密碼",
+ "createdAt": "建立於",
+ "changePassword": "變更密碼？",
+ "currentPassword": "目前密碼",
+ "newPassword": "新密碼",
+ "token": "權杖",
+ "libraries": "媒體庫"
+ },
+ "helperTexts": {
+ "name": "您的名稱會在下次登入時生效",
+ "libraries": "為該使用者選擇指定媒體庫，留空則使用預設媒體庫"
+ },
+ "notifications": {
+ "created": "使用者已建立",
+ "updated": "使用者已更新",
+ "deleted": "使用者已刪除"
+ },
+ "validation": {
+ "librariesRequired": "非管理員使用者必須至少選擇一個媒體庫"
+ },
+ "message": {
+ "listenBrainzToken": "輸入您的 ListenBrainz 使用者權杖",
+ "clickHereForToken": "點擊此處來獲得您的 ListenBrainz 權杖",
+ "selectAllLibraries": "選取全部媒體庫",
+ "adminAutoLibraries": "管理員預設可存取所有媒體庫"
+ }
},
"player": {
- "playListsText": "播放佇列",
- "openText": "打開",
- "closeText": "關閉",
- "notContentText": "沒有音樂",
- "clickToPlayText": "點擊播放",
- "clickToPauseText": "點擊暫停",
- "nextTrackText": "下一首",
- "previousTrackText": "上一首",
- "reloadText": "重新播放",
- "volumeText": "音量",
- "toggleLyricText": "切換歌詞",
- "toggleMiniModeText": "最小化",
- "destroyText": "關閉",
- "downloadText": "下載",
- "removeAudioListsText": "清空播放佇列",
- "clickToDeleteText": "點擊刪除 %{name}",
- "emptyLyricText": "無歌詞",
- "playModeText": {
- "order": "順序播放",
- "orderLoop": "列表循環",
- "singleLoop": "單曲循環",
- "shufflePlay": "隨機播放"
- }
+ "name": "播放器 |||| 播放器",
+ "fields": {
+ "name": "名稱",
+ "transcodingId": "轉碼",
+ "maxBitRate": "最大位元率",
+ "client": "客戶端",
+ "userName": "使用者名稱",
+ "lastSeen": "上次上線",
+ "reportRealPath": "回報實際路徑",
+ "scrobbleEnabled": "傳送音樂記錄至外部服務"
+ }
},
- "about": {
- "links": {
- "homepage": "主頁",
- "source": "原始碼",
- "featureRequests": "功能請求"
- }
+ "transcoding": {
+ "name": "轉碼 |||| 轉碼",
+ "fields": {
+ "name": "名稱",
+ "targetFormat": "目標格式",
+ "defaultBitRate": "預設位元率",
+ "command": "指令"
+ }
},
- "activity": {
- "title": "運作狀況",
- "totalScanned": "已完成掃描的目錄",
- "quickScan": "快速掃描",
- "fullScan": "完全掃描",
- "serverUptime": "伺服器已運作時間",
- "serverDown": "伺服器離線"
+ "playlist": {
+ "name": "播放清單 |||| 播放清單",
+ "fields": {
+ "name": "名稱",
+ "duration": "長度",
+ "ownerName": "擁有者",
+ "public": "公開",
+ "updatedAt": "更新於",
+ "createdAt": "建立於",
+ "songCount": "歌曲數",
+ "comment": "註解",
+ "sync": "自動匯入",
+ "path": "匯入來源"
+ },
+ "actions": {
+ "selectPlaylist": "選取播放清單：",
+ "addNewPlaylist": "建立「%{name}」",
+ "export": "匯出",
+ "saveQueue": "將播放佇列儲存到播放清單",
+ "makePublic": "設為公開",
+ "makePrivate": "設為私人",
+ "searchOrCreate": "搜尋播放清單，或輸入名稱來新建…",
+ "pressEnterToCreate": "按 Enter 鍵建立新的播放清單",
+ "removeFromSelection": "移除選取項目"
+ },
+ "message": {
+ "duplicate_song": "加入重複的歌曲",
+ "song_exist": "有重複歌曲正要加入播放清單，您要加入或略過重複歌曲？",
+ "noPlaylistsFound": "找不到播放清單",
+ "noPlaylists": "暫無播放清單"
+ }
},
- "help": {
- "title": "Navidrome 快捷鍵",
- "hotkeys": {
- "show_help": "顯示此幫助",
- "toggle_menu": "顯示/隱藏選單側欄",
- "toggle_play": "播放/暫停",
- "prev_song": "上一首歌",
- "next_song": "下一首歌",
- "vol_up": "提高音量",
- "vol_down": "降低音量",
- "toggle_love": "添加或移除星標",
- "current_song": "目前歌曲"
- }
+ "radio": {
+ "name": "電台 |||| 電台",
+ "fields": {
+ "name": "名稱",
+ "streamUrl": "串流網址",
+ "homePageUrl": "首頁網址",
+ "updatedAt": "更新於",
+ "createdAt": "建立於"
+ },
+ "actions": {
+ "playNow": "立即播放"
+ }
+ },
+ "share": {
+ "name": "分享 |||| 分享",
+ "fields": {
+ "username": "分享者",
+ "url": "網址",
+ "description": "描述",
+ "downloadable": "允許下載？",
+ "contents": "內容",
+ "expiresAt": "過期時間",
+ "lastVisitedAt": "上次造訪時間",
+ "visitCount": "造訪次數",
+ "format": "格式",
+ "maxBitRate": "最大位元率",
+ "updatedAt": "更新於",
+ "createdAt": "建立於"
+ },
+ "notifications": {},
+ "actions": {}
+ },
+ "missing": {
+ "name": "遺失檔案 |||| 遺失檔案",
+ "empty": "無遺失檔案",
+ "fields": {
+ "path": "路徑",
+ "size": "檔案大小",
+ "libraryName": "媒體庫",
+ "updatedAt": "遺失於"
+ },
+ "actions": {
+ "remove": "刪除",
+ "remove_all": "刪除所有"
+ },
+ "notifications": {
+ "removed": "遺失檔案已刪除"
+ }
+ },
+ "library": {
+ "name": "媒體庫 |||| 媒體庫",
+ "fields": {
+ "name": "名稱",
+ "path": "路徑",
+ "remotePath": "遠端路徑",
+ "lastScanAt": "上次掃描",
+ "songCount": "歌曲",
+ "albumCount": "專輯",
+ "artistCount": "藝人",
+ "totalSongs": "歌曲",
+ "totalAlbums": "專輯",
+ "totalArtists": "藝人",
+ "totalFolders": "資料夾",
+ "totalFiles": "檔案",
+ "totalMissingFiles": "遺失檔案",
+ "totalSize": "總大小",
+ "totalDuration": "時長",
+ "defaultNewUsers": "新使用者預設媒體庫",
+ "createdAt": "建立於",
+ "updatedAt": "更新於"
+ },
+ "sections": {
+ "basic": "基本資訊",
+ "statistics": "統計"
+ },
+ "actions": {
+ "scan": "掃描媒體庫",
+ "manageUsers": "管理使用者權限",
+ "viewDetails": "查看詳細資料"
+ },
+ "notifications": {
+ "created": "成功建立媒體庫",
+ "updated": "成功更新媒體庫",
+ "deleted": "成功刪除媒體庫",
+ "scanStarted": "開始掃描媒體庫",
+ "scanCompleted": "媒體庫掃描完成"
+ },
+ "validation": {
+ "nameRequired": "請輸入媒體庫名稱",
+ "pathRequired": "請提供媒體庫路徑",
+ "pathNotDirectory": "媒體庫路徑必須為目錄",
+ "pathNotFound": "媒體庫路徑不存在",
+ "pathNotAccessible": "無法存取媒體庫路徑",
+ "pathInvalid": "媒體庫路徑無效"
+ },
+ "messages": {
+ "deleteConfirm": "您確定要刪除此媒體庫嗎？這將刪除所有相關資料和使用者存取權限。",
+ "scanInProgress": "正在掃描...",
+ "noLibrariesAssigned": "沒有為該使用者指派任何媒體庫"
+ }
}
+ },
+ "ra": {
+ "auth": {
+ "welcome1": "感謝您安裝 Navidrome！",
+ "welcome2": "開始前，請先建立一個管理員帳號",
+ "confirmPassword": "確認密碼",
+ "buttonCreateAdmin": "建立管理員",
+ "auth_check_error": "請登入以繼續",
+ "user_menu": "個人檔案",
+ "username": "使用者名稱",
+ "password": "密碼",
+ "sign_in": "登入",
+ "sign_in_error": "驗證失敗，請重試",
+ "logout": "登出",
+ "insightsCollectionNote": "Navidrome 會收集匿名使用資料以協助改善項目。\n點擊[此處]了解更多資訊或選擇退出。"
+ },
+ "validation": {
+ "invalidChars": "請使用字母和數字",
+ "passwordDoesNotMatch": "密碼不相符",
+ "required": "必填",
+ "minLength": "必須不少於 %{min} 個字元",
+ "maxLength": "必須不多於 %{max} 個字元",
+ "minValue": "必須不小於 %{min}",
+ "maxValue": "必須不大於 %{max}",
+ "number": "必須為數字",
+ "email": "必須為有效的電子郵件",
+ "oneOf": "必須為以下其中一項：%{options}",
+ "regex": "必須符合指定的格式（正規表達式）：%{pattern}",
+ "unique": "必須是唯一的",
+ "url": "必須為有效的網址"
+ },
+ "action": {
+ "add_filter": "加入篩選",
+ "add": "加入",
+ "back": "返回",
+ "bulk_actions": "選中 1 項 |||| 選中 %{smart_count} 項",
+ "bulk_actions_mobile": "1 |||| %{smart_count}",
+ "cancel": "取消",
+ "clear_input_value": "清除",
+ "clone": "複製",
+ "confirm": "確認",
+ "create": "建立",
+ "delete": "刪除",
+ "edit": "編輯",
+ "export": "匯出",
+ "list": "列表",
+ "refresh": "重新整理",
+ "remove_filter": "清除此條件",
+ "remove": "移除",
+ "save": "儲存",
+ "search": "搜尋",
+ "show": "顯示",
+ "sort": "排序",
+ "undo": "復原",
+ "expand": "展開",
+ "close": "關閉",
+ "open_menu": "開啟選單",
+ "close_menu": "關閉選單",
+ "unselect": "取消選取",
+ "skip": "略過",
+ "share": "分享",
+ "download": "下載"
+ },
+ "boolean": {
+ "true": "是",
+ "false": "否"
+ },
+ "page": {
+ "create": "建立 %{name}",
+ "dashboard": "儀表板",
+ "edit": "%{name} #%{id}",
+ "error": "發生錯誤",
+ "list": "%{name}",
+ "loading": "載入中",
+ "not_found": "找不到",
+ "show": "%{name} #%{id}",
+ "empty": "還沒有 %{name}。",
+ "invite": "您要建立一個嗎？"
+ },
+ "input": {
+ "file": {
+ "upload_several": "拖曳多個檔案上傳或點擊選擇一個",
+ "upload_single": "拖曳單個檔案上傳或點擊選擇一個"
+ },
+ "image": {
+ "upload_several": "拖曳多個圖片上傳或點擊選擇一個",
+ "upload_single": "拖曳單個圖片上傳或點擊選擇一個"
+ },
+ "references": {
+ "all_missing": "未找到參考數據",
+ "many_missing": "至少有一條參考數據不再可用",
+ "single_missing": "關聯的參考數據不再可用"
+ },
+ "password": {
+ "toggle_visible": "隱藏密碼",
+ "toggle_hidden": "顯示密碼"
+ }
+ },
+ "message": {
+ "about": "關於",
+ "are_you_sure": "您確定嗎？",
+ "bulk_delete_content": "您確定要刪除 %{name}？ |||| 您確定要刪除這 %{smart_count} 個項目嗎？",
+ "bulk_delete_title": "刪除 %{name} |||| 刪除 %{smart_count} 項 %{name}",
+ "delete_content": "您確定要刪除該項目？",
+ "delete_title": "刪除 %{name} #%{id}",
+ "details": "詳細資訊",
+ "error": "發生客戶端錯誤，您的請求無法完成",
+ "invalid_form": "提交內容無效，請檢查錯誤",
+ "loading": "正在載入頁面，請稍候",
+ "no": "否",
+ "not_found": "您輸入了錯誤的連結或連結遺失",
+ "yes": "是",
+ "unsaved_changes": "某些更改尚未儲存，您確定要離開此頁面嗎？"
+ },
+ "navigation": {
+ "no_results": "沒有找到結果",
+ "no_more_results": "頁碼 %{page} 超出邊界，嘗試返回上一頁",
+ "page_out_of_boundaries": "頁碼 %{page} 超出邊界",
+ "page_out_from_end": "已經是最後一頁",
+ "page_out_from_begin": "已經是第一頁",
+ "page_range_info": "%{offsetBegin}-%{offsetEnd} / %{total}",
+ "page_rows_per_page": "每頁項目數：",
+ "next": "下一頁",
+ "prev": "上一頁",
+ "skip_nav": "跳至內容"
+ },
+ "notification": {
+ "updated": "項目已更新 |||| %{smart_count} 項已更新",
+ "created": "項目已建立",
+ "deleted": "項目已刪除 |||| %{smart_count} 項已刪除",
+ "bad_item": "項目不正確",
+ "item_doesnt_exist": "項目不存在",
+ "http_error": "伺服器通訊錯誤",
+ "data_provider_error": "資料來源錯誤，請檢查控制台的詳細資訊",
+ "i18n_error": "無法載入所選語言",
+ "canceled": "操作已取消",
+ "logged_out": "您的工作階段已結束，請重新登入",
+ "new_version": "發現新版本！請重新整理視窗"
+ },
+ "toggleFieldsMenu": {
+ "columnsToDisplay": "顯示欄位",
+ "layout": "版面",
+ "grid": "網格",
+ "table": "表格"
+ }
+ },
+ "message": {
+ "note": "注意",
+ "transcodingDisabled": "出於安全原因，已停用了從 Web 介面更改參數。要更改（編輯或新增）轉碼選項，請在啟用 %{config} 選項的情況下重新啟動伺服器。",
+ "transcodingEnabled": "Navidrome 目前與 %{config} 一起使用，因此可以透過 Web 介面從轉碼設定中執行系統命令。出於安全考慮，我們建議停用此功能，並僅在設定轉碼選項時啟用。",
+ "songsAddedToPlaylist": "已加入一首歌到播放清單 |||| 已新增 %{smart_count} 首歌到播放清單",
+ "noSimilarSongsFound": "找不到相似歌曲",
+ "noTopSongsFound": "找不到熱門歌曲",
+ "noPlaylistsAvailable": "沒有可用的播放清單",
+ "delete_user_title": "刪除使用者「%{name}」",
+ "delete_user_content": "您確定要刪除此使用者及其所有資料（包括播放清單和偏好設定）嗎？",
+ "remove_missing_title": "刪除遺失檔案",
+ "remove_missing_content": "您確定要從媒體庫中刪除所選的遺失的檔案嗎？這將永久刪除它們的所有相關資訊，包括其播放次數和評分。",
+ "remove_all_missing_title": "刪除所有遺失檔案",
+ "remove_all_missing_content": "您確定要從媒體庫中刪除所有遺失的檔案嗎？這將永久刪除它們的所有相關資訊，包括它們的播放次數和評分。",
+ "notifications_blocked": "您已在瀏覽器設定中封鎖了此網站的通知",
+ "notifications_not_available": "此瀏覽器不支援桌面通知，或您並非透過 HTTPS 存取 Navidrome",
+ "lastfmLinkSuccess": "已成功連接 Last.fm 並開啟音樂記錄",
+ "lastfmLinkFailure": "無法連接 Last.fm",
+ "lastfmUnlinkSuccess": "已取消 Last.fm 的連接並停用音樂記錄",
+ "lastfmUnlinkFailure": "無法取消 Last.fm 的連接",
+ "listenBrainzLinkSuccess": "已成功以 %{user} 身份連接 ListenBrainz 並開啟音樂記錄",
+ "listenBrainzLinkFailure": "無法連接 ListenBrainz：%{error}",
+ "listenBrainzUnlinkSuccess": "已取消 ListenBrainz 的連接並停用音樂記錄",
+ "listenBrainzUnlinkFailure": "無法取消 ListenBrainz 的連接",
+ "openIn": {
+ "lastfm": "在 Last.fm 中開啟",
+ "musicbrainz": "在 MusicBrainz 中開啟"
+ },
+ "lastfmLink": "查看更多…",
+ "shareOriginalFormat": "分享原始格式",
+ "shareDialogTitle": "分享 %{resource} '%{name}'",
+ "shareBatchDialogTitle": "分享 1 個%{resource} |||| 分享 %{smart_count} 個%{resource}",
+ "shareCopyToClipboard": "複製到剪貼簿：Ctrl+C, Enter",
+ "shareSuccess": "分享成功，連結已複製到剪貼簿：%{url}",
+ "shareFailure": "分享連結複製失敗：%{url}",
+ "downloadDialogTitle": "下載 %{resource} '%{name}' (%{size})",
+ "downloadOriginalFormat": "下載原始格式"
+ },
+ "menu": {
+ "library": "媒體庫",
+ "librarySelector": {
+ "allLibraries": "所有媒體庫 (%{count})",
+ "multipleLibraries": "已選 %{selected} 共 %{total} 媒體庫",
+ "selectLibraries": "選取媒體庫",
+ "none": "無"
+ },
+ "settings": "設定",
+ "version": "版本",
+ "theme": "主題",
+ "personal": {
+ "name": "個人化",
+ "options": {
+ "theme": "主題",
+ "language": "語言",
+ "defaultView": "預設畫面",
+ "desktop_notifications": "桌面通知",
+ "lastfmNotConfigured": "Last.fm API 金鑰未設定",
+ "lastfmScrobbling": "啟用 Last.fm 音樂記錄",
+ "listenBrainzScrobbling": "啟用 ListenBrainz 音樂記錄",
+ "replaygain": "重播增益模式",
+ "preAmp": "重播增益前置放大器 (dB)",
+ "gain": {
+ "none": "無",
+ "album": "專輯增益",
+ "track": "曲目增益"
+ }
+ }
+ },
+ "albumList": "專輯",
+ "playlists": "播放清單",
+ "sharedPlaylists": "分享的播放清單",
+ "about": "關於"
+ },
+ "player": {
+ "playListsText": "播放佇列",
+ "openText": "開啟",
+ "closeText": "關閉",
+ "notContentText": "沒有音樂",
+ "clickToPlayText": "點擊播放",
+ "clickToPauseText": "點擊暫停",
+ "nextTrackText": "下一首",
+ "previousTrackText": "上一首",
+ "reloadText": "重新載入",
+ "volumeText": "音量",
+ "toggleLyricText": "切換歌詞",
+ "toggleMiniModeText": "最小化",
+ "destroyText": "關閉",
+ "downloadText": "下載",
+ "removeAudioListsText": "清空播放佇列",
+ "clickToDeleteText": "點擊刪除 %{name}",
+ "emptyLyricText": "無歌詞",
+ "playModeText": {
+ "order": "順序播放",
+ "orderLoop": "循環播放",
+ "singleLoop": "單曲循環",
+ "shufflePlay": "隨機播放"
+ }
+ },
+ "about": {
+ "links": {
+ "homepage": "首頁",
+ "source": "原始碼",
+ "featureRequests": "功能請求",
+ "lastInsightsCollection": "最近一次洞察資料收集",
+ "insights": {
+ "disabled": "已停用",
+ "waiting": "等待中"
+ }
+ },
+ "tabs": {
+ "about": "關於",
+ "config": "設定"
+ },
+ "config": {
+ "configName": "設定名稱",
+ "environmentVariable": "環境變數",
+ "currentValue": "目前值",
+ "configurationFile": "設定檔案",
+ "exportToml": "匯出設定（TOML 格式）",
+ "exportSuccess": "設定已以 TOML 格式匯出至剪貼簿",
+ "exportFailed": "設定複製失敗",
+ "devFlagsHeader": "開發旗標（可能會更改/刪除）",
+ "devFlagsComment": "這些是實驗性設定，可能會在未來版本中刪除"
+ }
+ },
+ "activity": {
+ "title": "運作狀況",
+ "totalScanned": "已掃描的資料夾總數",
+ "quickScan": "快速掃描",
+ "fullScan": "完全掃描",
+ "serverUptime": "伺服器運作時間",
+ "serverDown": "伺服器已離線",
+ "scanType": "掃描類型",
+ "status": "掃描錯誤",
+ "elapsedTime": "經過時間"
+ },
+ "nowPlaying": {
+ "title": "正在播放",
+ "empty": "無播放內容",
+ "minutesAgo": "1 分鐘前 |||| %{smart_count} 分鐘前"
+ },
+ "help": {
+ "title": "Navidrome 快捷鍵",
+ "hotkeys": {
+ "show_help": "顯示此說明",
+ "toggle_menu": "顯示/隱藏選單側欄",
+ "toggle_play": "播放/暫停",
+ "prev_song": "上一首歌",
+ "next_song": "下一首歌",
+ "current_song": "前往目前歌曲",
+ "vol_up": "提高音量",
+ "vol_down": "降低音量",
+ "toggle_love": "新增此歌曲至收藏"
+ }
+ }
}
diff --git a/scanner/controller.go b/scanner/controller.go
index c1347077a..b42246a50 100644
--- a/scanner/controller.go
+++ b/scanner/controller.go
@@ -26,24 +26,8 @@ var (
ErrAlreadyScanning = errors.New("already scanning")
)
-type Scanner interface {
- // ScanAll starts a full scan of the music library. This is a blocking operation.
- ScanAll(ctx context.Context, fullScan bool) (warnings []string, err error)
- Status(context.Context) (*StatusInfo, error)
-}
-
-type StatusInfo struct {
- Scanning bool
- LastScan time.Time
- Count uint32
- FolderCount uint32
- LastError string
- ScanType string
- ElapsedTime time.Duration
-}
-
func New(rootCtx context.Context, ds model.DataStore, cw artwork.CacheWarmer, broker events.Broker,
- pls core.Playlists, m metrics.Metrics) Scanner {
+ pls core.Playlists, m metrics.Metrics) model.Scanner {
c := &controller{
rootCtx: rootCtx,
ds: ds,
@@ -65,9 +49,10 @@ func (s *controller) getScanner() scanner {
return &scannerImpl{ds: s.ds, cw: s.cw, pls: s.pls}
}
-// CallScan starts an in-process scan of the music library.
+// CallScan starts an in-process scan of specific library/folder pairs.
+// If targets is empty, it scans all libraries.
// This is meant to be called from the command line (see cmd/scan.go).
-func CallScan(ctx context.Context, ds model.DataStore, pls core.Playlists, fullScan bool) (<-chan *ProgressInfo, error) {
+func CallScan(ctx context.Context, ds model.DataStore, pls core.Playlists, fullScan bool, targets []model.ScanTarget) (<-chan *ProgressInfo, error) {
release, err := lockScan(ctx)
if err != nil {
return nil, err
@@ -79,7 +64,7 @@ func CallScan(ctx context.Context, ds model.DataStore, pls core.Playlists, fullS
go func() {
defer close(progress)
scanner := &scannerImpl{ds: ds, cw: artwork.NoopCacheWarmer(), pls: pls}
- scanner.scanAll(ctx, fullScan, progress)
+ scanner.scanFolders(ctx, fullScan, targets, progress)
}()
return progress, nil
}
@@ -99,8 +84,11 @@ type ProgressInfo struct {
ForceUpdate bool
}
+// scanner defines the interface for different scanner implementations.
+// This allows for swapping between in-process and external scanners.
type scanner interface {
- scanAll(ctx context.Context, fullScan bool, progress chan<- *ProgressInfo)
+ // scanFolders performs the actual scanning of folders. If targets is nil, it scans all libraries.
+ scanFolders(ctx context.Context, fullScan bool, targets []model.ScanTarget, progress chan<- *ProgressInfo)
}
type controller struct {
@@ -158,7 +146,7 @@ func (s *controller) getScanInfo(ctx context.Context) (scanType string, elapsed
return scanType, elapsed, lastErr
}
-func (s *controller) Status(ctx context.Context) (*StatusInfo, error) {
+func (s *controller) Status(ctx context.Context) (*model.ScannerStatus, error) {
lastScanTime, err := s.getLastScanTime(ctx)
if err != nil {
return nil, fmt.Errorf("getting last scan time: %w", err)
@@ -167,7 +155,7 @@ func (s *controller) Status(ctx context.Context) (*StatusInfo, error) {
scanType, elapsed, lastErr := s.getScanInfo(ctx)
if running.Load() {
- status := &StatusInfo{
+ status := &model.ScannerStatus{
Scanning: true,
LastScan: lastScanTime,
Count: s.count.Load(),
@@ -183,7 +171,7 @@ func (s *controller) Status(ctx context.Context) (*StatusInfo, error) {
if err != nil {
return nil, fmt.Errorf("getting library stats: %w", err)
}
- return &StatusInfo{
+ return &model.ScannerStatus{
Scanning: false,
LastScan: lastScanTime,
Count: uint32(count),
@@ -208,6 +196,10 @@ func (s *controller) getCounters(ctx context.Context) (int64, int64, error) {
}
func (s *controller) ScanAll(requestCtx context.Context, fullScan bool) ([]string, error) {
+ return s.ScanFolders(requestCtx, fullScan, nil)
+}
+
+func (s *controller) ScanFolders(requestCtx context.Context, fullScan bool, targets []model.ScanTarget) ([]string, error) {
release, err := lockScan(requestCtx)
if err != nil {
return nil, err
@@ -224,7 +216,7 @@ func (s *controller) ScanAll(requestCtx context.Context, fullScan bool) ([]strin
go func() {
defer close(progress)
scanner := s.getScanner()
- scanner.scanAll(ctx, fullScan, progress)
+ scanner.scanFolders(ctx, fullScan, targets, progress)
}()
// Wait for the scan to finish, sending progress events to all connected clients
diff --git a/scanner/controller_test.go b/scanner/controller_test.go
index e551e15b1..f5ccabc86 100644
--- a/scanner/controller_test.go
+++ b/scanner/controller_test.go
@@ -9,6 +9,7 @@ import (
"github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/metrics"
"github.com/navidrome/navidrome/db"
+ "github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/persistence"
"github.com/navidrome/navidrome/scanner"
"github.com/navidrome/navidrome/server/events"
@@ -20,7 +21,7 @@ import (
var _ = Describe("Controller", func() {
var ctx context.Context
var ds *tests.MockDataStore
- var ctrl scanner.Scanner
+ var ctrl model.Scanner
Describe("Status", func() {
BeforeEach(func() {
diff --git a/scanner/external.go b/scanner/external.go
index c4a29efa3..b6d7639be 100644
--- a/scanner/external.go
+++ b/scanner/external.go
@@ -8,10 +8,12 @@ import (
"io"
"os"
"os/exec"
+ "strings"
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/log"
- . "github.com/navidrome/navidrome/utils/gg"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/utils/slice"
)
// scannerExternal is a scanner that runs an external process to do the scanning. It is used to avoid
@@ -23,19 +25,41 @@ import (
// process will forward them to the caller.
type scannerExternal struct{}
-func (s *scannerExternal) scanAll(ctx context.Context, fullScan bool, progress chan<- *ProgressInfo) {
+func (s *scannerExternal) scanFolders(ctx context.Context, fullScan bool, targets []model.ScanTarget, progress chan<- *ProgressInfo) {
+ s.scan(ctx, fullScan, targets, progress)
+}
+
+func (s *scannerExternal) scan(ctx context.Context, fullScan bool, targets []model.ScanTarget, progress chan<- *ProgressInfo) {
exe, err := os.Executable()
if err != nil {
progress <- &ProgressInfo{Error: fmt.Sprintf("failed to get executable path: %s", err)}
return
}
- log.Debug(ctx, "Spawning external scanner process", "fullScan", fullScan, "path", exe)
- cmd := exec.CommandContext(ctx, exe, "scan",
+
+ // Build command arguments
+ args := []string{
+ "scan",
"--nobanner", "--subprocess",
"--configfile", conf.Server.ConfigFile,
"--datafolder", conf.Server.DataFolder,
"--cachefolder", conf.Server.CacheFolder,
- If(fullScan, "--full", ""))
+ }
+
+ // Add targets if provided
+ if len(targets) > 0 {
+ targetsStr := strings.Join(slice.Map(targets, func(t model.ScanTarget) string { return t.String() }), ",")
+ args = append(args, "--targets", targetsStr)
+ log.Debug(ctx, "Spawning external scanner process with targets", "fullScan", fullScan, "path", exe, "targets", targetsStr)
+ } else {
+ log.Debug(ctx, "Spawning external scanner process", "fullScan", fullScan, "path", exe)
+ }
+
+ // Add full scan flag if needed
+ if fullScan {
+ args = append(args, "--full")
+ }
+
+ cmd := exec.CommandContext(ctx, exe, args...)
in, out := io.Pipe()
defer in.Close()
diff --git a/scanner/folder_entry.go b/scanner/folder_entry.go
index fc68cb561..9d8d0c571 100644
--- a/scanner/folder_entry.go
+++ b/scanner/folder_entry.go
@@ -15,9 +15,7 @@ import (
"github.com/navidrome/navidrome/utils/chrono"
)
-func newFolderEntry(job *scanJob, path string) *folderEntry {
- id := model.FolderID(job.lib, path)
- info := job.popLastUpdate(id)
+func newFolderEntry(job *scanJob, id, path string, updTime time.Time, hash string) *folderEntry {
f := &folderEntry{
id: id,
job: job,
@@ -25,8 +23,8 @@ func newFolderEntry(job *scanJob, path string) *folderEntry {
audioFiles: make(map[string]fs.DirEntry),
imageFiles: make(map[string]fs.DirEntry),
albumIDMap: make(map[string]string),
- updTime: info.UpdatedAt,
- prevHash: info.Hash,
+ updTime: updTime,
+ prevHash: hash,
}
return f
}
diff --git a/scanner/folder_entry_test.go b/scanner/folder_entry_test.go
index c6d1b2ce4..0328c6653 100644
--- a/scanner/folder_entry_test.go
+++ b/scanner/folder_entry_test.go
@@ -40,9 +40,8 @@ var _ = Describe("folder_entry", func() {
UpdatedAt: time.Now().Add(-30 * time.Minute),
Hash: "previous-hash",
}
- job.lastUpdates[folderID] = updateInfo
- entry := newFolderEntry(job, path)
+ entry := newFolderEntry(job, folderID, path, updateInfo.UpdatedAt, updateInfo.Hash)
Expect(entry.id).To(Equal(folderID))
Expect(entry.job).To(Equal(job))
@@ -53,15 +52,10 @@ var _ = Describe("folder_entry", func() {
Expect(entry.updTime).To(Equal(updateInfo.UpdatedAt))
Expect(entry.prevHash).To(Equal(updateInfo.Hash))
})
+ })
- It("creates a new folder entry with zero time when no previous update exists", func() {
- entry := newFolderEntry(job, path)
-
- Expect(entry.updTime).To(BeZero())
- Expect(entry.prevHash).To(BeEmpty())
- })
-
- It("removes the lastUpdate from the job after popping", func() {
+ Describe("createFolderEntry", func() {
+ It("removes the lastUpdate from the job after creation", func() {
folderID := model.FolderID(lib, path)
updateInfo := model.FolderUpdateInfo{
UpdatedAt: time.Now().Add(-30 * time.Minute),
@@ -69,8 +63,10 @@ var _ = Describe("folder_entry", func() {
}
job.lastUpdates[folderID] = updateInfo
- newFolderEntry(job, path)
+ entry := job.createFolderEntry(path)
+ Expect(entry.updTime).To(Equal(updateInfo.UpdatedAt))
+ Expect(entry.prevHash).To(Equal(updateInfo.Hash))
Expect(job.lastUpdates).ToNot(HaveKey(folderID))
})
})
@@ -79,7 +75,8 @@ var _ = Describe("folder_entry", func() {
var entry *folderEntry
BeforeEach(func() {
- entry = newFolderEntry(job, path)
+ folderID := model.FolderID(lib, path)
+ entry = newFolderEntry(job, folderID, path, time.Time{}, "")
})
Describe("hasNoFiles", func() {
@@ -458,7 +455,9 @@ var _ = Describe("folder_entry", func() {
Describe("integration scenarios", func() {
It("handles complete folder lifecycle", func() {
// Create new folder entry
- entry := newFolderEntry(job, "music/rock/album")
+ folderPath := "music/rock/album"
+ folderID := model.FolderID(lib, folderPath)
+ entry := newFolderEntry(job, folderID, folderPath, time.Time{}, "")
// Initially new and has no files
Expect(entry.isNew()).To(BeTrue())
diff --git a/scanner/ignore_checker.go b/scanner/ignore_checker.go
new file mode 100644
index 000000000..da74293fa
--- /dev/null
+++ b/scanner/ignore_checker.go
@@ -0,0 +1,163 @@
+package scanner
+
+import (
+ "bufio"
+ "context"
+ "io/fs"
+ "path"
+ "strings"
+
+ "github.com/navidrome/navidrome/consts"
+ "github.com/navidrome/navidrome/log"
+ ignore "github.com/sabhiram/go-gitignore"
+)
+
+// IgnoreChecker manages .ndignore patterns using a stack-based approach.
+// Use Push() to add patterns when entering a folder, Pop() when leaving,
+// and ShouldIgnore() to check if a path should be ignored.
+type IgnoreChecker struct {
+ fsys fs.FS
+ patternStack [][]string // Stack of patterns for each folder level
+ currentPatterns []string // Flattened current patterns
+ matcher *ignore.GitIgnore // Compiled matcher for current patterns
+}
+
+// newIgnoreChecker creates a new IgnoreChecker for the given filesystem.
+func newIgnoreChecker(fsys fs.FS) *IgnoreChecker {
+ return &IgnoreChecker{
+ fsys: fsys,
+ patternStack: make([][]string, 0),
+ }
+}
+
+// Push loads .ndignore patterns from the specified folder and adds them to the pattern stack.
+// Use this when entering a folder during directory tree traversal.
+func (ic *IgnoreChecker) Push(ctx context.Context, folder string) error {
+ patterns := ic.loadPatternsFromFolder(ctx, folder)
+ ic.patternStack = append(ic.patternStack, patterns)
+ ic.rebuildCurrentPatterns()
+ return nil
+}
+
+// Pop removes the most recent patterns from the stack.
+// Use this when leaving a folder during directory tree traversal.
+func (ic *IgnoreChecker) Pop() {
+ if len(ic.patternStack) > 0 {
+ ic.patternStack = ic.patternStack[:len(ic.patternStack)-1]
+ ic.rebuildCurrentPatterns()
+ }
+}
+
+// PushAllParents pushes patterns from root down to the target path.
+// This is a convenience method for when you need to check a specific path
+// without recursively walking the tree. It handles the common pattern of
+// pushing all parent directories from root to the target.
+// This method is optimized to compile patterns only once at the end.
+func (ic *IgnoreChecker) PushAllParents(ctx context.Context, targetPath string) error {
+ if targetPath == "." || targetPath == "" {
+ // Simple case: just push root
+ return ic.Push(ctx, ".")
+ }
+
+ // Load patterns for root
+ patterns := ic.loadPatternsFromFolder(ctx, ".")
+ ic.patternStack = append(ic.patternStack, patterns)
+
+ // Load patterns for each parent directory
+ currentPath := "."
+ parts := strings.Split(path.Clean(targetPath), "/")
+ for _, part := range parts {
+ if part == "." || part == "" {
+ continue
+ }
+ currentPath = path.Join(currentPath, part)
+ patterns = ic.loadPatternsFromFolder(ctx, currentPath)
+ ic.patternStack = append(ic.patternStack, patterns)
+ }
+
+ // Rebuild and compile patterns only once at the end
+ ic.rebuildCurrentPatterns()
+ return nil
+}
+
+// ShouldIgnore checks if the given path should be ignored based on the current patterns.
+// Returns true if the path matches any ignore pattern, false otherwise.
+func (ic *IgnoreChecker) ShouldIgnore(ctx context.Context, relPath string) bool {
+ // Handle root/empty path - never ignore
+ if relPath == "" || relPath == "." {
+ return false
+ }
+
+ // If no patterns loaded, nothing to ignore
+ if ic.matcher == nil {
+ return false
+ }
+
+ matches := ic.matcher.MatchesPath(relPath)
+ if matches {
+ log.Trace(ctx, "Scanner: Ignoring entry matching .ndignore", "path", relPath)
+ }
+ return matches
+}
+
+// loadPatternsFromFolder reads the .ndignore file in the specified folder and returns the patterns.
+// If the file doesn't exist, returns an empty slice.
+// If the file exists but is empty, returns a pattern to ignore everything ("**/*").
+func (ic *IgnoreChecker) loadPatternsFromFolder(ctx context.Context, folder string) []string {
+ ignoreFilePath := path.Join(folder, consts.ScanIgnoreFile)
+ var patterns []string
+
+ // Check if .ndignore file exists
+ if _, err := fs.Stat(ic.fsys, ignoreFilePath); err != nil {
+ // No .ndignore file in this folder
+ return patterns
+ }
+
+ // Read and parse the .ndignore file
+ ignoreFile, err := ic.fsys.Open(ignoreFilePath)
+ if err != nil {
+ log.Warn(ctx, "Scanner: Error opening .ndignore file", "path", ignoreFilePath, err)
+ return patterns
+ }
+ defer ignoreFile.Close()
+
+ lineScanner := bufio.NewScanner(ignoreFile)
+ for lineScanner.Scan() {
+ line := strings.TrimSpace(lineScanner.Text())
+ if line == "" || strings.HasPrefix(line, "#") {
+ continue // Skip empty lines, whitespace-only lines, and comments
+ }
+ patterns = append(patterns, line)
+ }
+
+ if err := lineScanner.Err(); err != nil {
+ log.Warn(ctx, "Scanner: Error reading .ndignore file", "path", ignoreFilePath, err)
+ return patterns
+ }
+
+ // If the .ndignore file is empty, ignore everything
+ if len(patterns) == 0 {
+ log.Trace(ctx, "Scanner: .ndignore file is empty, ignoring everything", "path", folder)
+ patterns = []string{"**/*"}
+ }
+
+ return patterns
+}
+
+// rebuildCurrentPatterns flattens the pattern stack into currentPatterns and recompiles the matcher.
+func (ic *IgnoreChecker) rebuildCurrentPatterns() {
+ ic.currentPatterns = make([]string, 0)
+ for _, patterns := range ic.patternStack {
+ ic.currentPatterns = append(ic.currentPatterns, patterns...)
+ }
+ ic.compilePatterns()
+}
+
+// compilePatterns compiles the current patterns into a GitIgnore matcher.
+func (ic *IgnoreChecker) compilePatterns() {
+ if len(ic.currentPatterns) == 0 {
+ ic.matcher = nil
+ return
+ }
+ ic.matcher = ignore.CompileIgnoreLines(ic.currentPatterns...)
+}
diff --git a/scanner/ignore_checker_test.go b/scanner/ignore_checker_test.go
new file mode 100644
index 000000000..5378ed4fa
--- /dev/null
+++ b/scanner/ignore_checker_test.go
@@ -0,0 +1,313 @@
+package scanner
+
+import (
+ "context"
+ "testing/fstest"
+
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+var _ = Describe("IgnoreChecker", func() {
+ Describe("loadPatternsFromFolder", func() {
+ var ic *IgnoreChecker
+ var ctx context.Context
+
+ BeforeEach(func() {
+ ctx = context.Background()
+ })
+
+ Context("when .ndignore file does not exist", func() {
+ It("should return empty patterns", func() {
+ fsys := fstest.MapFS{}
+ ic = newIgnoreChecker(fsys)
+ patterns := ic.loadPatternsFromFolder(ctx, ".")
+ Expect(patterns).To(BeEmpty())
+ })
+ })
+
+ Context("when .ndignore file is empty", func() {
+ It("should return wildcard to ignore everything", func() {
+ fsys := fstest.MapFS{
+ ".ndignore": &fstest.MapFile{Data: []byte("")},
+ }
+ ic = newIgnoreChecker(fsys)
+ patterns := ic.loadPatternsFromFolder(ctx, ".")
+ Expect(patterns).To(Equal([]string{"**/*"}))
+ })
+ })
+
+ DescribeTable("parsing .ndignore content",
+ func(content string, expectedPatterns []string) {
+ fsys := fstest.MapFS{
+ ".ndignore": &fstest.MapFile{Data: []byte(content)},
+ }
+ ic = newIgnoreChecker(fsys)
+ patterns := ic.loadPatternsFromFolder(ctx, ".")
+ Expect(patterns).To(Equal(expectedPatterns))
+ },
+ Entry("single pattern", "*.txt", []string{"*.txt"}),
+ Entry("multiple patterns", "*.txt\n*.log", []string{"*.txt", "*.log"}),
+ Entry("with comments", "# comment\n*.txt\n# another\n*.log", []string{"*.txt", "*.log"}),
+ Entry("with empty lines", "*.txt\n\n*.log\n\n", []string{"*.txt", "*.log"}),
+ Entry("mixed content", "# header\n\n*.txt\n# middle\n*.log\n\n", []string{"*.txt", "*.log"}),
+ Entry("only comments and empty lines", "# comment\n\n# another\n", []string{"**/*"}),
+ Entry("trailing newline", "*.txt\n*.log\n", []string{"*.txt", "*.log"}),
+ Entry("directory pattern", "temp/", []string{"temp/"}),
+ Entry("wildcard pattern", "**/*.mp3", []string{"**/*.mp3"}),
+ Entry("multiple wildcards", "**/*.mp3\n**/*.flac\n*.log", []string{"**/*.mp3", "**/*.flac", "*.log"}),
+ Entry("negation pattern", "!important.txt", []string{"!important.txt"}),
+ Entry("comment with hash not at start is pattern", "not#comment", []string{"not#comment"}),
+ Entry("whitespace-only lines skipped", "*.txt\n \n*.log\n\t\n", []string{"*.txt", "*.log"}),
+ Entry("patterns with whitespace trimmed", " *.txt \n\t*.log\t", []string{"*.txt", "*.log"}),
+ )
+ })
+
+ Describe("Push and Pop", func() {
+ var ic *IgnoreChecker
+ var fsys fstest.MapFS
+ var ctx context.Context
+
+ BeforeEach(func() {
+ ctx = context.Background()
+ fsys = fstest.MapFS{
+ ".ndignore": &fstest.MapFile{Data: []byte("*.txt")},
+ "folder1/.ndignore": &fstest.MapFile{Data: []byte("*.mp3")},
+ "folder2/.ndignore": &fstest.MapFile{Data: []byte("*.flac")},
+ }
+ ic = newIgnoreChecker(fsys)
+ })
+
+ Context("Push", func() {
+ It("should add patterns to stack", func() {
+ err := ic.Push(ctx, ".")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(len(ic.patternStack)).To(Equal(1))
+ Expect(ic.currentPatterns).To(ContainElement("*.txt"))
+ })
+
+ It("should compile matcher after push", func() {
+ err := ic.Push(ctx, ".")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ic.matcher).ToNot(BeNil())
+ })
+
+ It("should accumulate patterns from multiple levels", func() {
+ err := ic.Push(ctx, ".")
+ Expect(err).ToNot(HaveOccurred())
+ err = ic.Push(ctx, "folder1")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(len(ic.patternStack)).To(Equal(2))
+ Expect(ic.currentPatterns).To(ConsistOf("*.txt", "*.mp3"))
+ })
+
+ It("should handle push when no .ndignore exists", func() {
+ err := ic.Push(ctx, "nonexistent")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(len(ic.patternStack)).To(Equal(1))
+ Expect(ic.currentPatterns).To(BeEmpty())
+ })
+ })
+
+ Context("Pop", func() {
+ It("should remove most recent patterns", func() {
+ err := ic.Push(ctx, ".")
+ Expect(err).ToNot(HaveOccurred())
+ err = ic.Push(ctx, "folder1")
+ Expect(err).ToNot(HaveOccurred())
+ ic.Pop()
+ Expect(len(ic.patternStack)).To(Equal(1))
+ Expect(ic.currentPatterns).To(Equal([]string{"*.txt"}))
+ })
+
+ It("should handle Pop on empty stack gracefully", func() {
+ Expect(func() { ic.Pop() }).ToNot(Panic())
+ Expect(ic.patternStack).To(BeEmpty())
+ })
+
+ It("should set matcher to nil when all patterns popped", func() {
+ err := ic.Push(ctx, ".")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ic.matcher).ToNot(BeNil())
+ ic.Pop()
+ Expect(ic.matcher).To(BeNil())
+ })
+
+ It("should update matcher after pop", func() {
+ err := ic.Push(ctx, ".")
+ Expect(err).ToNot(HaveOccurred())
+ err = ic.Push(ctx, "folder1")
+ Expect(err).ToNot(HaveOccurred())
+ matcher1 := ic.matcher
+ ic.Pop()
+ matcher2 := ic.matcher
+ Expect(matcher1).ToNot(Equal(matcher2))
+ })
+ })
+
+ Context("multiple Push/Pop cycles", func() {
+ It("should maintain correct state through cycles", func() {
+ err := ic.Push(ctx, ".")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ic.currentPatterns).To(Equal([]string{"*.txt"}))
+
+ err = ic.Push(ctx, "folder1")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ic.currentPatterns).To(ConsistOf("*.txt", "*.mp3"))
+
+ ic.Pop()
+ Expect(ic.currentPatterns).To(Equal([]string{"*.txt"}))
+
+ err = ic.Push(ctx, "folder2")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ic.currentPatterns).To(ConsistOf("*.txt", "*.flac"))
+
+ ic.Pop()
+ Expect(ic.currentPatterns).To(Equal([]string{"*.txt"}))
+
+ ic.Pop()
+ Expect(ic.currentPatterns).To(BeEmpty())
+ })
+ })
+ })
+
+ Describe("PushAllParents", func() {
+ var ic *IgnoreChecker
+ var ctx context.Context
+
+ BeforeEach(func() {
+ ctx = context.Background()
+ fsys := fstest.MapFS{
+ ".ndignore": &fstest.MapFile{Data: []byte("root.txt")},
+ "folder1/.ndignore": &fstest.MapFile{Data: []byte("level1.txt")},
+ "folder1/folder2/.ndignore": &fstest.MapFile{Data: []byte("level2.txt")},
+ "folder1/folder2/folder3/.ndignore": &fstest.MapFile{Data: []byte("level3.txt")},
+ }
+ ic = newIgnoreChecker(fsys)
+ })
+
+ DescribeTable("loading parent patterns",
+ func(targetPath string, expectedStackDepth int, expectedPatterns []string) {
+ err := ic.PushAllParents(ctx, targetPath)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(len(ic.patternStack)).To(Equal(expectedStackDepth))
+ Expect(ic.currentPatterns).To(ConsistOf(expectedPatterns))
+ },
+ Entry("root path", ".", 1, []string{"root.txt"}),
+ Entry("empty path", "", 1, []string{"root.txt"}),
+ Entry("single level", "folder1", 2, []string{"root.txt", "level1.txt"}),
+ Entry("two levels", "folder1/folder2", 3, []string{"root.txt", "level1.txt", "level2.txt"}),
+ Entry("three levels", "folder1/folder2/folder3", 4, []string{"root.txt", "level1.txt", "level2.txt", "level3.txt"}),
+ )
+
+ It("should only compile patterns once at the end", func() {
+ // This is more of a behavioral test - we verify the matcher is not nil after PushAllParents
+ err := ic.PushAllParents(ctx, "folder1/folder2")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ic.matcher).ToNot(BeNil())
+ })
+
+ It("should handle paths with dot", func() {
+ err := ic.PushAllParents(ctx, "./folder1")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(len(ic.patternStack)).To(Equal(2))
+ })
+
+ Context("when some parent folders have no .ndignore", func() {
+ BeforeEach(func() {
+ fsys := fstest.MapFS{
+ ".ndignore": &fstest.MapFile{Data: []byte("root.txt")},
+ "folder1/folder2/.ndignore": &fstest.MapFile{Data: []byte("level2.txt")},
+ }
+ ic = newIgnoreChecker(fsys)
+ })
+
+ It("should still push all parent levels", func() {
+ err := ic.PushAllParents(ctx, "folder1/folder2")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(len(ic.patternStack)).To(Equal(3)) // root, folder1 (empty), folder2
+ Expect(ic.currentPatterns).To(ConsistOf("root.txt", "level2.txt"))
+ })
+ })
+ })
+
+ Describe("ShouldIgnore", func() {
+ var ic *IgnoreChecker
+ var ctx context.Context
+
+ BeforeEach(func() {
+ ctx = context.Background()
+ })
+
+ Context("with no patterns loaded", func() {
+ It("should not ignore any path", func() {
+ fsys := fstest.MapFS{}
+ ic = newIgnoreChecker(fsys)
+ Expect(ic.ShouldIgnore(ctx, "anything.txt")).To(BeFalse())
+ Expect(ic.ShouldIgnore(ctx, "folder/file.mp3")).To(BeFalse())
+ })
+ })
+
+ Context("special paths", func() {
+ BeforeEach(func() {
+ fsys := fstest.MapFS{
+ ".ndignore": &fstest.MapFile{Data: []byte("**/*")},
+ }
+ ic = newIgnoreChecker(fsys)
+ err := ic.Push(ctx, ".")
+ Expect(err).ToNot(HaveOccurred())
+ })
+
+ It("should never ignore root or empty paths", func() {
+ Expect(ic.ShouldIgnore(ctx, "")).To(BeFalse())
+ Expect(ic.ShouldIgnore(ctx, ".")).To(BeFalse())
+ })
+
+ It("should ignore all other paths with wildcard", func() {
+ Expect(ic.ShouldIgnore(ctx, "file.txt")).To(BeTrue())
+ Expect(ic.ShouldIgnore(ctx, "folder/file.mp3")).To(BeTrue())
+ })
+ })
+
+ DescribeTable("pattern matching",
+ func(pattern string, path string, shouldMatch bool) {
+ fsys := fstest.MapFS{
+ ".ndignore": &fstest.MapFile{Data: []byte(pattern)},
+ }
+ ic = newIgnoreChecker(fsys)
+ err := ic.Push(ctx, ".")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ic.ShouldIgnore(ctx, path)).To(Equal(shouldMatch))
+ },
+ Entry("glob match", "*.txt", "file.txt", true),
+ Entry("glob no match", "*.txt", "file.mp3", false),
+ Entry("directory pattern match", "tmp/", "tmp/file.txt", true),
+ Entry("directory pattern no match", "tmp/", "temporary/file.txt", false),
+ Entry("nested glob match", "**/*.log", "deep/nested/file.log", true),
+ Entry("nested glob no match", "**/*.log", "deep/nested/file.txt", false),
+ Entry("specific file match", "ignore.me", "ignore.me", true),
+ Entry("specific file no match", "ignore.me", "keep.me", false),
+ Entry("wildcard all", "**/*", "any/path/file.txt", true),
+ Entry("nested specific match", "temp/*", "temp/cache.db", true),
+ Entry("nested specific no match", "temp/*", "temporary/cache.db", false),
+ )
+
+ Context("with multiple patterns", func() {
+ BeforeEach(func() {
+ fsys := fstest.MapFS{
+ ".ndignore": &fstest.MapFile{Data: []byte("*.txt\n*.log\ntemp/")},
+ }
+ ic = newIgnoreChecker(fsys)
+ err := ic.Push(ctx, ".")
+ Expect(err).ToNot(HaveOccurred())
+ })
+
+ It("should match any of the patterns", func() {
+ Expect(ic.ShouldIgnore(ctx, "file.txt")).To(BeTrue())
+ Expect(ic.ShouldIgnore(ctx, "debug.log")).To(BeTrue())
+ Expect(ic.ShouldIgnore(ctx, "temp/cache")).To(BeTrue())
+ Expect(ic.ShouldIgnore(ctx, "music.mp3")).To(BeFalse())
+ })
+ })
+ })
+})
diff --git a/scanner/phase_1_folders.go b/scanner/phase_1_folders.go
index e04f10c70..2f6b62b2d 100644
--- a/scanner/phase_1_folders.go
+++ b/scanner/phase_1_folders.go
@@ -26,58 +26,46 @@ import (
"github.com/navidrome/navidrome/utils/slice"
)
-func createPhaseFolders(ctx context.Context, state *scanState, ds model.DataStore, cw artwork.CacheWarmer, libs []model.Library) *phaseFolders {
+func createPhaseFolders(ctx context.Context, state *scanState, ds model.DataStore, cw artwork.CacheWarmer) *phaseFolders {
var jobs []*scanJob
- var updatedLibs []model.Library
- for _, lib := range libs {
- if lib.LastScanStartedAt.IsZero() {
- err := ds.Library(ctx).ScanBegin(lib.ID, state.fullScan)
- if err != nil {
- log.Error(ctx, "Scanner: Error updating last scan started at", "lib", lib.Name, err)
- state.sendWarning(err.Error())
- continue
- }
- // Reload library to get updated state
- l, err := ds.Library(ctx).Get(lib.ID)
- if err != nil {
- log.Error(ctx, "Scanner: Error reloading library", "lib", lib.Name, err)
- state.sendWarning(err.Error())
- continue
- }
- lib = *l
- } else {
- log.Debug(ctx, "Scanner: Resuming previous scan", "lib", lib.Name, "lastScanStartedAt", lib.LastScanStartedAt, "fullScan", lib.FullScanInProgress)
+
+ // Create scan jobs for all libraries
+ for _, lib := range state.libraries {
+ // Get target folders for this library if selective scan
+ var targetFolders []string
+ if state.isSelectiveScan() {
+ targetFolders = state.targets[lib.ID]
}
- job, err := newScanJob(ctx, ds, cw, lib, state.fullScan)
+
+ job, err := newScanJob(ctx, ds, cw, lib, state.fullScan, targetFolders)
if err != nil {
log.Error(ctx, "Scanner: Error creating scan context", "lib", lib.Name, err)
state.sendWarning(err.Error())
continue
}
jobs = append(jobs, job)
- updatedLibs = append(updatedLibs, lib)
}
- // Update the state with the libraries that have been processed and have their scan timestamps set
- state.libraries = updatedLibs
-
return &phaseFolders{jobs: jobs, ctx: ctx, ds: ds, state: state}
}
type scanJob struct {
- lib model.Library
- fs storage.MusicFS
- cw artwork.CacheWarmer
- lastUpdates map[string]model.FolderUpdateInfo
- lock sync.Mutex
- numFolders atomic.Int64
+ lib model.Library
+ fs storage.MusicFS
+ cw artwork.CacheWarmer
+ lastUpdates map[string]model.FolderUpdateInfo // Holds last update info for all (DB) folders in this library
+ targetFolders []string // Specific folders to scan (including all descendants)
+ lock sync.Mutex
+ numFolders atomic.Int64
}
-func newScanJob(ctx context.Context, ds model.DataStore, cw artwork.CacheWarmer, lib model.Library, fullScan bool) (*scanJob, error) {
- lastUpdates, err := ds.Folder(ctx).GetLastUpdates(lib)
+func newScanJob(ctx context.Context, ds model.DataStore, cw artwork.CacheWarmer, lib model.Library, fullScan bool, targetFolders []string) (*scanJob, error) {
+ // Get folder updates, optionally filtered to specific target folders
+ lastUpdates, err := ds.Folder(ctx).GetFolderUpdateInfo(lib, targetFolders...)
if err != nil {
return nil, fmt.Errorf("getting last updates: %w", err)
}
+
fileStore, err := storage.For(lib.Path)
if err != nil {
log.Error(ctx, "Error getting storage for library", "library", lib.Name, "path", lib.Path, err)
@@ -88,15 +76,17 @@ func newScanJob(ctx context.Context, ds model.DataStore, cw artwork.CacheWarmer,
log.Error(ctx, "Error getting fs for library", "library", lib.Name, "path", lib.Path, err)
return nil, fmt.Errorf("getting fs for library: %w", err)
}
- lib.FullScanInProgress = lib.FullScanInProgress || fullScan
return &scanJob{
- lib: lib,
- fs: fsys,
- cw: cw,
- lastUpdates: lastUpdates,
+ lib: lib,
+ fs: fsys,
+ cw: cw,
+ lastUpdates: lastUpdates,
+ targetFolders: targetFolders,
}, nil
}
+// popLastUpdate retrieves and removes the last update info for the given folder ID
+// This is used to track which folders have been found during the walk_dir_tree
func (j *scanJob) popLastUpdate(folderID string) model.FolderUpdateInfo {
j.lock.Lock()
defer j.lock.Unlock()
@@ -106,6 +96,15 @@ func (j *scanJob) popLastUpdate(folderID string) model.FolderUpdateInfo {
return lastUpdate
}
+// createFolderEntry creates a new folderEntry for the given path, using the last update info from the job
+// to populate the previous update time and hash. It also removes the folder from the job's lastUpdates map.
+// This is used to track which folders have been found during the walk_dir_tree.
+func (j *scanJob) createFolderEntry(path string) *folderEntry {
+ id := model.FolderID(j.lib, path)
+ info := j.popLastUpdate(id)
+ return newFolderEntry(j, id, path, info.UpdatedAt, info.Hash)
+}
+
// phaseFolders represents the first phase of the scanning process, which is responsible
// for scanning all libraries and importing new or updated files. This phase involves
// traversing the directory tree of each library, identifying new or modified media files,
@@ -144,7 +143,8 @@ func (p *phaseFolders) producer() ppl.Producer[*folderEntry] {
if utils.IsCtxDone(p.ctx) {
break
}
- outputChan, err := walkDirTree(p.ctx, job)
+
+ outputChan, err := walkDirTree(p.ctx, job, job.targetFolders...)
if err != nil {
log.Warn(p.ctx, "Scanner: Error scanning library", "lib", job.lib.Name, err)
}
diff --git a/scanner/phase_2_missing_tracks.go b/scanner/phase_2_missing_tracks.go
index a6c0e261e..de93ed6ee 100644
--- a/scanner/phase_2_missing_tracks.go
+++ b/scanner/phase_2_missing_tracks.go
@@ -69,9 +69,6 @@ func (p *phaseMissingTracks) produce(put func(tracks *missingTracks)) error {
}
}
for _, lib := range p.state.libraries {
- if lib.LastScanStartedAt.IsZero() {
- continue
- }
log.Debug(p.ctx, "Scanner: Checking missing tracks", "libraryId", lib.ID, "libraryName", lib.Name)
cursor, err := p.ds.MediaFile(p.ctx).GetMissingAndMatching(lib.ID)
if err != nil {
diff --git a/scanner/phase_3_refresh_albums.go b/scanner/phase_3_refresh_albums.go
index f51aa8f4b..33e0fed01 100644
--- a/scanner/phase_3_refresh_albums.go
+++ b/scanner/phase_3_refresh_albums.go
@@ -27,14 +27,13 @@ import (
type phaseRefreshAlbums struct {
ds model.DataStore
ctx context.Context
- libs model.Libraries
refreshed atomic.Uint32
skipped atomic.Uint32
state *scanState
}
-func createPhaseRefreshAlbums(ctx context.Context, state *scanState, ds model.DataStore, libs model.Libraries) *phaseRefreshAlbums {
- return &phaseRefreshAlbums{ctx: ctx, ds: ds, libs: libs, state: state}
+func createPhaseRefreshAlbums(ctx context.Context, state *scanState, ds model.DataStore) *phaseRefreshAlbums {
+ return &phaseRefreshAlbums{ctx: ctx, ds: ds, state: state}
}
func (p *phaseRefreshAlbums) description() string {
@@ -47,7 +46,7 @@ func (p *phaseRefreshAlbums) producer() ppl.Producer[*model.Album] {
func (p *phaseRefreshAlbums) produce(put func(album *model.Album)) error {
count := 0
- for _, lib := range p.libs {
+ for _, lib := range p.state.libraries {
cursor, err := p.ds.Album(p.ctx).GetTouchedAlbums(lib.ID)
if err != nil {
return fmt.Errorf("loading touched albums: %w", err)
diff --git a/scanner/phase_3_refresh_albums_test.go b/scanner/phase_3_refresh_albums_test.go
index dea2556f0..1f0baf428 100644
--- a/scanner/phase_3_refresh_albums_test.go
+++ b/scanner/phase_3_refresh_albums_test.go
@@ -32,8 +32,8 @@ var _ = Describe("phaseRefreshAlbums", func() {
{ID: 1, Name: "Library 1"},
{ID: 2, Name: "Library 2"},
}
- state = &scanState{}
- phase = createPhaseRefreshAlbums(ctx, state, ds, libs)
+ state = &scanState{libraries: libs}
+ phase = createPhaseRefreshAlbums(ctx, state, ds)
})
Describe("description", func() {
diff --git a/scanner/scanner.go b/scanner/scanner.go
index 04a5c2456..20f3f5da8 100644
--- a/scanner/scanner.go
+++ b/scanner/scanner.go
@@ -3,6 +3,8 @@ package scanner
import (
"context"
"fmt"
+ "maps"
+ "slices"
"sync/atomic"
"time"
@@ -15,6 +17,7 @@ import (
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/utils/run"
+ "github.com/navidrome/navidrome/utils/slice"
)
type scannerImpl struct {
@@ -28,7 +31,8 @@ type scanState struct {
progress chan<- *ProgressInfo
fullScan bool
changesDetected atomic.Bool
- libraries model.Libraries // Store libraries list for consistency across phases
+ libraries model.Libraries // Store libraries list for consistency across phases
+ targets map[int][]string // Optional: map[libraryID][]folderPaths for selective scans
}
func (s *scanState) sendProgress(info *ProgressInfo) {
@@ -37,6 +41,10 @@ func (s *scanState) sendProgress(info *ProgressInfo) {
}
}
+func (s *scanState) isSelectiveScan() bool {
+ return len(s.targets) > 0
+}
+
func (s *scanState) sendWarning(msg string) {
s.sendProgress(&ProgressInfo{Warning: msg})
}
@@ -45,7 +53,7 @@ func (s *scanState) sendError(err error) {
s.sendProgress(&ProgressInfo{Error: err.Error()})
}
-func (s *scannerImpl) scanAll(ctx context.Context, fullScan bool, progress chan<- *ProgressInfo) {
+func (s *scannerImpl) scanFolders(ctx context.Context, fullScan bool, targets []model.ScanTarget, progress chan<- *ProgressInfo) {
startTime := time.Now()
state := scanState{
@@ -59,38 +67,75 @@ func (s *scannerImpl) scanAll(ctx context.Context, fullScan bool, progress chan<
state.changesDetected.Store(true)
}
- libs, err := s.ds.Library(ctx).GetAll()
+ // Get libraries and optionally filter by targets
+ allLibs, err := s.ds.Library(ctx).GetAll()
if err != nil {
state.sendWarning(fmt.Sprintf("getting libraries: %s", err))
return
}
- state.libraries = libs
- log.Info(ctx, "Scanner: Starting scan", "fullScan", state.fullScan, "numLibraries", len(libs))
+ if len(targets) > 0 {
+ // Selective scan: filter libraries and build targets map
+ state.targets = make(map[int][]string)
+
+ for _, target := range targets {
+ folderPath := target.FolderPath
+ if folderPath == "" {
+ folderPath = "."
+ }
+ state.targets[target.LibraryID] = append(state.targets[target.LibraryID], folderPath)
+ }
+
+ // Filter libraries to only those in targets
+ state.libraries = slice.Filter(allLibs, func(lib model.Library) bool {
+ return len(state.targets[lib.ID]) > 0
+ })
+
+ log.Info(ctx, "Scanner: Starting selective scan", "fullScan", state.fullScan, "numLibraries", len(state.libraries), "numTargets", len(targets))
+ } else {
+ // Full library scan
+ state.libraries = allLibs
+ log.Info(ctx, "Scanner: Starting scan", "fullScan", state.fullScan, "numLibraries", len(state.libraries))
+ }
// Store scan type and start time
scanType := "quick"
if state.fullScan {
scanType = "full"
}
+ if state.isSelectiveScan() {
+ scanType += "-selective"
+ }
_ = s.ds.Property(ctx).Put(consts.LastScanTypeKey, scanType)
_ = s.ds.Property(ctx).Put(consts.LastScanStartTimeKey, startTime.Format(time.RFC3339))
// if there was a full scan in progress, force a full scan
if !state.fullScan {
- for _, lib := range libs {
+ for _, lib := range state.libraries {
if lib.FullScanInProgress {
log.Info(ctx, "Scanner: Interrupted full scan detected", "lib", lib.Name)
state.fullScan = true
- _ = s.ds.Property(ctx).Put(consts.LastScanTypeKey, "full")
+ if state.isSelectiveScan() {
+ _ = s.ds.Property(ctx).Put(consts.LastScanTypeKey, "full-selective")
+ } else {
+ _ = s.ds.Property(ctx).Put(consts.LastScanTypeKey, "full")
+ }
break
}
}
}
+ // Prepare libraries for scanning (initialize LastScanStartedAt if needed)
+ err = s.prepareLibrariesForScan(ctx, &state)
+ if err != nil {
+ log.Error(ctx, "Scanner: Error preparing libraries for scan", err)
+ state.sendError(err)
+ return
+ }
+
err = run.Sequentially(
// Phase 1: Scan all libraries and import new/updated files
- runPhase[*folderEntry](ctx, 1, createPhaseFolders(ctx, &state, s.ds, s.cw, libs)),
+ runPhase[*folderEntry](ctx, 1, createPhaseFolders(ctx, &state, s.ds, s.cw)),
// Phase 2: Process missing files, checking for moves
runPhase[*missingTracks](ctx, 2, createPhaseMissingTracks(ctx, &state, s.ds)),
@@ -98,7 +143,7 @@ func (s *scannerImpl) scanAll(ctx context.Context, fullScan bool, progress chan<
// Phases 3 and 4 can be run in parallel
run.Parallel(
// Phase 3: Refresh all new/changed albums and update artists
- runPhase[*model.Album](ctx, 3, createPhaseRefreshAlbums(ctx, &state, s.ds, libs)),
+ runPhase[*model.Album](ctx, 3, createPhaseRefreshAlbums(ctx, &state, s.ds)),
// Phase 4: Import/update playlists
runPhase[*model.Folder](ctx, 4, createPhasePlaylists(ctx, &state, s.ds, s.pls, s.cw)),
@@ -131,7 +176,53 @@ func (s *scannerImpl) scanAll(ctx context.Context, fullScan bool, progress chan<
state.sendProgress(&ProgressInfo{ChangesDetected: true})
}
- log.Info(ctx, "Scanner: Finished scanning all libraries", "duration", time.Since(startTime))
+ if state.isSelectiveScan() {
+ log.Info(ctx, "Scanner: Finished scanning selected folders", "duration", time.Since(startTime), "numTargets", len(targets))
+ } else {
+ log.Info(ctx, "Scanner: Finished scanning all libraries", "duration", time.Since(startTime))
+ }
+}
+
+// prepareLibrariesForScan initializes the scan for all libraries in the state.
+// It calls ScanBegin for libraries that haven't started scanning yet (LastScanStartedAt is zero),
+// reloads them to get the updated state, and filters out any libraries that fail to initialize.
+func (s *scannerImpl) prepareLibrariesForScan(ctx context.Context, state *scanState) error {
+ var successfulLibs []model.Library
+
+ for _, lib := range state.libraries {
+ if lib.LastScanStartedAt.IsZero() {
+ // This is a new scan - mark it as started
+ err := s.ds.Library(ctx).ScanBegin(lib.ID, state.fullScan)
+ if err != nil {
+ log.Error(ctx, "Scanner: Error marking scan start", "lib", lib.Name, err)
+ state.sendWarning(err.Error())
+ continue
+ }
+
+ // Reload library to get updated state (timestamps, etc.)
+ reloadedLib, err := s.ds.Library(ctx).Get(lib.ID)
+ if err != nil {
+ log.Error(ctx, "Scanner: Error reloading library", "lib", lib.Name, err)
+ state.sendWarning(err.Error())
+ continue
+ }
+ lib = *reloadedLib
+ } else {
+ // This is a resumed scan
+ log.Debug(ctx, "Scanner: Resuming previous scan", "lib", lib.Name,
+ "lastScanStartedAt", lib.LastScanStartedAt, "fullScan", lib.FullScanInProgress)
+ }
+
+ successfulLibs = append(successfulLibs, lib)
+ }
+
+ if len(successfulLibs) == 0 {
+ return fmt.Errorf("no libraries available for scanning")
+ }
+
+ // Update state with only successfully initialized libraries
+ state.libraries = successfulLibs
+ return nil
}
func (s *scannerImpl) runGC(ctx context.Context, state *scanState) func() error {
@@ -140,7 +231,15 @@ func (s *scannerImpl) runGC(ctx context.Context, state *scanState) func() error
return s.ds.WithTx(func(tx model.DataStore) error {
if state.changesDetected.Load() {
start := time.Now()
- err := tx.GC(ctx)
+
+ // For selective scans, extract library IDs to scope GC operations
+ var libraryIDs []int
+ if state.isSelectiveScan() {
+ libraryIDs = slices.Collect(maps.Keys(state.targets))
+ log.Debug(ctx, "Scanner: Running selective GC", "libraryIDs", libraryIDs)
+ }
+
+ err := tx.GC(ctx, libraryIDs...)
if err != nil {
log.Error(ctx, "Scanner: Error running GC", err)
return fmt.Errorf("running GC: %w", err)
diff --git a/scanner/scanner_multilibrary_test.go b/scanner/scanner_multilibrary_test.go
index f27ad52fc..66db62edf 100644
--- a/scanner/scanner_multilibrary_test.go
+++ b/scanner/scanner_multilibrary_test.go
@@ -32,7 +32,7 @@ var _ = Describe("Scanner - Multi-Library", Ordered, func() {
var ctx context.Context
var lib1, lib2 model.Library
var ds *tests.MockDataStore
- var s scanner.Scanner
+ var s model.Scanner
createFS := func(path string, files fstest.MapFS) storagetest.FakeFS {
fs := storagetest.FakeFS{}
diff --git a/scanner/scanner_selective_test.go b/scanner/scanner_selective_test.go
new file mode 100644
index 000000000..629826db4
--- /dev/null
+++ b/scanner/scanner_selective_test.go
@@ -0,0 +1,293 @@
+package scanner_test
+
+import (
+ "context"
+ "path/filepath"
+ "testing/fstest"
+
+ "github.com/Masterminds/squirrel"
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/conf/configtest"
+ "github.com/navidrome/navidrome/core"
+ "github.com/navidrome/navidrome/core/artwork"
+ "github.com/navidrome/navidrome/core/metrics"
+ "github.com/navidrome/navidrome/core/storage/storagetest"
+ "github.com/navidrome/navidrome/db"
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/model/request"
+ "github.com/navidrome/navidrome/persistence"
+ "github.com/navidrome/navidrome/scanner"
+ "github.com/navidrome/navidrome/server/events"
+ "github.com/navidrome/navidrome/tests"
+ "github.com/navidrome/navidrome/utils/slice"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+var _ = Describe("ScanFolders", Ordered, func() {
+ var ctx context.Context
+ var lib model.Library
+ var ds model.DataStore
+ var s model.Scanner
+ var fsys storagetest.FakeFS
+
+ BeforeAll(func() {
+ ctx = request.WithUser(GinkgoT().Context(), model.User{ID: "123", IsAdmin: true})
+ tmpDir := GinkgoT().TempDir()
+ conf.Server.DbPath = filepath.Join(tmpDir, "test-selective-scan.db?_journal_mode=WAL")
+ log.Warn("Using DB at " + conf.Server.DbPath)
+ db.Db().SetMaxOpenConns(1)
+ })
+
+ BeforeEach(func() {
+ DeferCleanup(configtest.SetupConfig())
+ conf.Server.MusicFolder = "fake:///music"
+ conf.Server.DevExternalScanner = false
+
+ db.Init(ctx)
+ DeferCleanup(func() {
+ Expect(tests.ClearDB()).To(Succeed())
+ })
+
+ ds = persistence.New(db.Db())
+
+ // Create the admin user in the database to match the context
+ adminUser := model.User{
+ ID: "123",
+ UserName: "admin",
+ Name: "Admin User",
+ IsAdmin: true,
+ NewPassword: "password",
+ }
+ Expect(ds.User(ctx).Put(&adminUser)).To(Succeed())
+
+ s = scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),
+ core.NewPlaylists(ds), metrics.NewNoopInstance())
+
+ lib = model.Library{ID: 1, Name: "Fake Library", Path: "fake:///music"}
+ Expect(ds.Library(ctx).Put(&lib)).To(Succeed())
+
+ // Initialize fake filesystem
+ fsys = storagetest.FakeFS{}
+ storagetest.Register("fake", &fsys)
+ })
+
+ Describe("Adding tracks to the library", func() {
+ It("scans specified folders recursively including all subdirectories", func() {
+ rock := template(_t{"albumartist": "Rock Artist", "album": "Rock Album"})
+ jazz := template(_t{"albumartist": "Jazz Artist", "album": "Jazz Album"})
+ pop := template(_t{"albumartist": "Pop Artist", "album": "Pop Album"})
+ createFS(fstest.MapFS{
+ "rock/track1.mp3": rock(track(1, "Rock Track 1")),
+ "rock/track2.mp3": rock(track(2, "Rock Track 2")),
+ "rock/subdir/track3.mp3": rock(track(3, "Rock Track 3")),
+ "jazz/track4.mp3": jazz(track(1, "Jazz Track 1")),
+ "jazz/subdir/track5.mp3": jazz(track(2, "Jazz Track 2")),
+ "pop/track6.mp3": pop(track(1, "Pop Track 1")),
+ })
+
+ // Scan only the "rock" and "jazz" folders (including their subdirectories)
+ targets := []model.ScanTarget{
+ {LibraryID: lib.ID, FolderPath: "rock"},
+ {LibraryID: lib.ID, FolderPath: "jazz"},
+ }
+
+ warnings, err := s.ScanFolders(ctx, false, targets)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(warnings).To(BeEmpty())
+
+ // Verify all tracks in rock and jazz folders (including subdirectories) were imported
+ allFiles, err := ds.MediaFile(ctx).GetAll()
+ Expect(err).ToNot(HaveOccurred())
+
+ // Should have 5 tracks (all rock and jazz tracks including subdirectories)
+ Expect(allFiles).To(HaveLen(5))
+
+ // Get the file paths
+ paths := slice.Map(allFiles, func(mf model.MediaFile) string {
+ return filepath.ToSlash(mf.Path)
+ })
+
+ // Verify the correct files were scanned (including subdirectories)
+ Expect(paths).To(ContainElements(
+ "rock/track1.mp3",
+ "rock/track2.mp3",
+ "rock/subdir/track3.mp3",
+ "jazz/track4.mp3",
+ "jazz/subdir/track5.mp3",
+ ))
+
+ // Verify files in the pop folder were NOT scanned
+ Expect(paths).ToNot(ContainElement("pop/track6.mp3"))
+ })
+ })
+
+ Describe("Deleting folders", func() {
+ Context("when a child folder is deleted", func() {
+ var (
+ revolver, help func(...map[string]any) *fstest.MapFile
+ artistFolderID string
+ album1FolderID string
+ album2FolderID string
+ album1TrackIDs []string
+ album2TrackIDs []string
+ )
+
+ BeforeEach(func() {
+ // Setup template functions for creating test files
+ revolver = storagetest.Template(_t{"albumartist": "The Beatles", "album": "Revolver", "year": 1966})
+ help = storagetest.Template(_t{"albumartist": "The Beatles", "album": "Help!", "year": 1965})
+
+ // Initial filesystem with nested folders
+ fsys.SetFiles(fstest.MapFS{
+ "The Beatles/Revolver/01 - Taxman.mp3": revolver(storagetest.Track(1, "Taxman")),
+ "The Beatles/Revolver/02 - Eleanor Rigby.mp3": revolver(storagetest.Track(2, "Eleanor Rigby")),
+ "The Beatles/Help!/01 - Help!.mp3": help(storagetest.Track(1, "Help!")),
+ "The Beatles/Help!/02 - The Night Before.mp3": help(storagetest.Track(2, "The Night Before")),
+ })
+
+ // First scan - import everything
+ _, err := s.ScanAll(ctx, true)
+ Expect(err).ToNot(HaveOccurred())
+
+ // Verify initial state - all folders exist
+ folders, err := ds.Folder(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"library_id": lib.ID}})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(folders).To(HaveLen(4)) // root, Artist, Album1, Album2
+
+ // Store folder IDs for later verification
+ for _, f := range folders {
+ switch f.Name {
+ case "The Beatles":
+ artistFolderID = f.ID
+ case "Revolver":
+ album1FolderID = f.ID
+ case "Help!":
+ album2FolderID = f.ID
+ }
+ }
+
+ // Verify all tracks exist
+ allTracks, err := ds.MediaFile(ctx).GetAll()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(allTracks).To(HaveLen(4))
+
+ // Store track IDs for later verification
+ for _, t := range allTracks {
+ if t.Album == "Revolver" {
+ album1TrackIDs = append(album1TrackIDs, t.ID)
+ } else if t.Album == "Help!" {
+ album2TrackIDs = append(album2TrackIDs, t.ID)
+ }
+ }
+
+ // Verify no tracks are missing initially
+ for _, t := range allTracks {
+ Expect(t.Missing).To(BeFalse())
+ }
+ })
+
+ It("should mark child folder and its tracks as missing when parent is scanned", func() {
+ // Delete the child folder (Help!) from the filesystem
+ fsys.SetFiles(fstest.MapFS{
+ "The Beatles/Revolver/01 - Taxman.mp3": revolver(storagetest.Track(1, "Taxman")),
+ "The Beatles/Revolver/02 - Eleanor Rigby.mp3": revolver(storagetest.Track(2, "Eleanor Rigby")),
+ // "The Beatles/Help!" folder and its contents are DELETED
+ })
+
+ // Run selective scan on the parent folder (Artist)
+ // This simulates what the watcher does when a child folder is deleted
+ _, err := s.ScanFolders(ctx, false, []model.ScanTarget{
+ {LibraryID: lib.ID, FolderPath: "The Beatles"},
+ })
+ Expect(err).ToNot(HaveOccurred())
+
+ // Verify the deleted child folder is now marked as missing
+ deletedFolder, err := ds.Folder(ctx).Get(album2FolderID)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(deletedFolder.Missing).To(BeTrue(), "Deleted child folder should be marked as missing")
+
+ // Verify the deleted folder's tracks are marked as missing
+ for _, trackID := range album2TrackIDs {
+ track, err := ds.MediaFile(ctx).Get(trackID)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(track.Missing).To(BeTrue(), "Track in deleted folder should be marked as missing")
+ }
+
+ // Verify the parent folder is still present and not marked as missing
+ parentFolder, err := ds.Folder(ctx).Get(artistFolderID)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(parentFolder.Missing).To(BeFalse(), "Parent folder should not be marked as missing")
+
+ // Verify the sibling folder and its tracks are still present and not missing
+ siblingFolder, err := ds.Folder(ctx).Get(album1FolderID)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(siblingFolder.Missing).To(BeFalse(), "Sibling folder should not be marked as missing")
+
+ for _, trackID := range album1TrackIDs {
+ track, err := ds.MediaFile(ctx).Get(trackID)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(track.Missing).To(BeFalse(), "Track in sibling folder should not be marked as missing")
+ }
+ })
+
+ It("should mark deeply nested child folders as missing", func() {
+ // Add a deeply nested folder structure
+ fsys.SetFiles(fstest.MapFS{
+ "The Beatles/Revolver/01 - Taxman.mp3": revolver(storagetest.Track(1, "Taxman")),
+ "The Beatles/Revolver/02 - Eleanor Rigby.mp3": revolver(storagetest.Track(2, "Eleanor Rigby")),
+ "The Beatles/Help!/01 - Help!.mp3": help(storagetest.Track(1, "Help!")),
+ "The Beatles/Help!/02 - The Night Before.mp3": help(storagetest.Track(2, "The Night Before")),
+ "The Beatles/Help!/Bonus/01 - Bonus Track.mp3": help(storagetest.Track(99, "Bonus Track")),
+ "The Beatles/Help!/Bonus/Nested/01 - Deep Track.mp3": help(storagetest.Track(100, "Deep Track")),
+ })
+
+ // Rescan to import the new nested structure
+ _, err := s.ScanAll(ctx, true)
+ Expect(err).ToNot(HaveOccurred())
+
+ // Verify nested folders were created
+ allFolders, err := ds.Folder(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"library_id": lib.ID}})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(len(allFolders)).To(BeNumerically(">", 4), "Should have more folders with nested structure")
+
+ // Now delete the entire Help! folder including nested children
+ fsys.SetFiles(fstest.MapFS{
+ "The Beatles/Revolver/01 - Taxman.mp3": revolver(storagetest.Track(1, "Taxman")),
+ "The Beatles/Revolver/02 - Eleanor Rigby.mp3": revolver(storagetest.Track(2, "Eleanor Rigby")),
+ // All Help! subfolders are deleted
+ })
+
+ // Run selective scan on parent
+ _, err = s.ScanFolders(ctx, false, []model.ScanTarget{
+ {LibraryID: lib.ID, FolderPath: "The Beatles"},
+ })
+ Expect(err).ToNot(HaveOccurred())
+
+ // Verify all Help! folders (including nested ones) are marked as missing
+ missingFolders, err := ds.Folder(ctx).GetAll(model.QueryOptions{
+ Filters: squirrel.And{
+ squirrel.Eq{"library_id": lib.ID},
+ squirrel.Eq{"missing": true},
+ },
+ })
+ Expect(err).ToNot(HaveOccurred())
+ Expect(len(missingFolders)).To(BeNumerically(">", 0), "At least one folder should be marked as missing")
+
+ // Verify all tracks in deleted folders are marked as missing
+ allTracks, err := ds.MediaFile(ctx).GetAll()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(allTracks).To(HaveLen(6))
+
+ for _, track := range allTracks {
+ if track.Album == "Help!" {
+ Expect(track.Missing).To(BeTrue(), "All tracks in deleted Help! folder should be marked as missing")
+ } else if track.Album == "Revolver" {
+ Expect(track.Missing).To(BeFalse(), "Tracks in Revolver folder should not be marked as missing")
+ }
+ }
+ })
+ })
+ })
+})
diff --git a/scanner/scanner_test.go b/scanner/scanner_test.go
index e7e354f21..873065aa3 100644
--- a/scanner/scanner_test.go
+++ b/scanner/scanner_test.go
@@ -34,19 +34,19 @@ type _t = map[string]any
var template = storagetest.Template
var track = storagetest.Track
+func createFS(files fstest.MapFS) storagetest.FakeFS {
+ fs := storagetest.FakeFS{}
+ fs.SetFiles(files)
+ storagetest.Register("fake", &fs)
+ return fs
+}
+
var _ = Describe("Scanner", Ordered, func() {
var ctx context.Context
var lib model.Library
var ds *tests.MockDataStore
var mfRepo *mockMediaFileRepo
- var s scanner.Scanner
-
- createFS := func(files fstest.MapFS) storagetest.FakeFS {
- fs := storagetest.FakeFS{}
- fs.SetFiles(files)
- storagetest.Register("fake", &fs)
- return fs
- }
+ var s model.Scanner
BeforeAll(func() {
ctx = request.WithUser(GinkgoT().Context(), model.User{ID: "123", IsAdmin: true})
@@ -478,6 +478,56 @@ var _ = Describe("Scanner", Ordered, func() {
Expect(mf.Missing).To(BeFalse())
})
+ It("marks tracks as missing when scanning a deleted folder with ScanFolders", func() {
+ By("Adding a third track to Revolver to have more test data")
+ fsys.Add("The Beatles/Revolver/03 - I'm Only Sleeping.mp3", revolver(track(3, "I'm Only Sleeping")))
+ Expect(runScanner(ctx, false)).To(Succeed())
+
+ By("Verifying initial state has 5 tracks")
+ Expect(ds.MediaFile(ctx).CountAll(model.QueryOptions{
+ Filters: squirrel.Eq{"missing": false},
+ })).To(Equal(int64(5)))
+
+ By("Removing the entire Revolver folder from filesystem")
+ fsys.Remove("The Beatles/Revolver/01 - Taxman.mp3")
+ fsys.Remove("The Beatles/Revolver/02 - Eleanor Rigby.mp3")
+ fsys.Remove("The Beatles/Revolver/03 - I'm Only Sleeping.mp3")
+
+ By("Scanning the parent folder (simulating watcher behavior)")
+ targets := []model.ScanTarget{
+ {LibraryID: lib.ID, FolderPath: "The Beatles"},
+ }
+ _, err := s.ScanFolders(ctx, false, targets)
+ Expect(err).To(Succeed())
+
+ By("Checking all Revolver tracks are marked as missing")
+ mf, err := findByPath("The Beatles/Revolver/01 - Taxman.mp3")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(mf.Missing).To(BeTrue())
+
+ mf, err = findByPath("The Beatles/Revolver/02 - Eleanor Rigby.mp3")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(mf.Missing).To(BeTrue())
+
+ mf, err = findByPath("The Beatles/Revolver/03 - I'm Only Sleeping.mp3")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(mf.Missing).To(BeTrue())
+
+ By("Checking the Help! tracks are not affected")
+ mf, err = findByPath("The Beatles/Help!/01 - Help!.mp3")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(mf.Missing).To(BeFalse())
+
+ mf, err = findByPath("The Beatles/Help!/02 - The Night Before.mp3")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(mf.Missing).To(BeFalse())
+
+ By("Verifying only 2 non-missing tracks remain (Help! tracks)")
+ Expect(ds.MediaFile(ctx).CountAll(model.QueryOptions{
+ Filters: squirrel.Eq{"missing": false},
+ })).To(Equal(int64(2)))
+ })
+
It("does not override artist fields when importing an undertagged file", func() {
By("Making sure artist in the DB contains MBID and sort name")
aa, err := ds.Artist(ctx).GetAll(model.QueryOptions{
diff --git a/scanner/walk_dir_tree.go b/scanner/walk_dir_tree.go
index 63854d262..e6a694f2b 100644
--- a/scanner/walk_dir_tree.go
+++ b/scanner/walk_dir_tree.go
@@ -1,7 +1,6 @@
package scanner
import (
- "bufio"
"context"
"io/fs"
"maps"
@@ -11,37 +10,69 @@ import (
"strings"
"github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/consts"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/utils"
- ignore "github.com/sabhiram/go-gitignore"
)
-func walkDirTree(ctx context.Context, job *scanJob) (<-chan *folderEntry, error) {
+// walkDirTree recursively walks the directory tree starting from the given targetFolders.
+// If no targetFolders are provided, it starts from the root folder (".").
+// It returns a channel of folderEntry pointers representing each folder found.
+func walkDirTree(ctx context.Context, job *scanJob, targetFolders ...string) (<-chan *folderEntry, error) {
results := make(chan *folderEntry)
+ folders := targetFolders
+ if len(targetFolders) == 0 {
+ // No specific folders provided, scan the root folder
+ folders = []string{"."}
+ }
go func() {
defer close(results)
- err := walkFolder(ctx, job, ".", nil, results)
- if err != nil {
- log.Error(ctx, "Scanner: There were errors reading directories from filesystem", "path", job.lib.Path, err)
- return
+ for _, folderPath := range folders {
+ if utils.IsCtxDone(ctx) {
+ return
+ }
+
+ // Check if target folder exists before walking it
+ // If it doesn't exist (e.g., deleted between watcher detection and scan execution),
+ // skip it so it remains in job.lastUpdates and gets handled in following steps
+ _, err := fs.Stat(job.fs, folderPath)
+ if err != nil {
+ log.Warn(ctx, "Scanner: Target folder does not exist.", "path", folderPath, err)
+ continue
+ }
+
+ // Create checker and push patterns from root to this folder
+ checker := newIgnoreChecker(job.fs)
+ err = checker.PushAllParents(ctx, folderPath)
+ if err != nil {
+ log.Error(ctx, "Scanner: Error pushing ignore patterns for target folder", "path", folderPath, err)
+ continue
+ }
+
+ // Recursively walk this folder and all its children
+ err = walkFolder(ctx, job, folderPath, checker, results)
+ if err != nil {
+ log.Error(ctx, "Scanner: Error walking target folder", "path", folderPath, err)
+ continue
+ }
}
- log.Debug(ctx, "Scanner: Finished reading folders", "lib", job.lib.Name, "path", job.lib.Path, "numFolders", job.numFolders.Load())
+ log.Debug(ctx, "Scanner: Finished reading target folders", "lib", job.lib.Name, "path", job.lib.Path, "numFolders", job.numFolders.Load())
}()
return results, nil
}
-func walkFolder(ctx context.Context, job *scanJob, currentFolder string, ignorePatterns []string, results chan<- *folderEntry) error {
- ignorePatterns = loadIgnoredPatterns(ctx, job.fs, currentFolder, ignorePatterns)
+func walkFolder(ctx context.Context, job *scanJob, currentFolder string, checker *IgnoreChecker, results chan<- *folderEntry) error {
+ // Push patterns for this folder onto the stack
+ _ = checker.Push(ctx, currentFolder)
+ defer checker.Pop() // Pop patterns when leaving this folder
- folder, children, err := loadDir(ctx, job, currentFolder, ignorePatterns)
+ folder, children, err := loadDir(ctx, job, currentFolder, checker)
if err != nil {
log.Warn(ctx, "Scanner: Error loading dir. Skipping", "path", currentFolder, err)
return nil
}
for _, c := range children {
- err := walkFolder(ctx, job, c, ignorePatterns, results)
+ err := walkFolder(ctx, job, c, checker, results)
if err != nil {
return err
}
@@ -59,50 +90,17 @@ func walkFolder(ctx context.Context, job *scanJob, currentFolder string, ignoreP
return nil
}
-func loadIgnoredPatterns(ctx context.Context, fsys fs.FS, currentFolder string, currentPatterns []string) []string {
- ignoreFilePath := path.Join(currentFolder, consts.ScanIgnoreFile)
- var newPatterns []string
- if _, err := fs.Stat(fsys, ignoreFilePath); err == nil {
- // Read and parse the .ndignore file
- ignoreFile, err := fsys.Open(ignoreFilePath)
- if err != nil {
- log.Warn(ctx, "Scanner: Error opening .ndignore file", "path", ignoreFilePath, err)
- // Continue with previous patterns
- } else {
- defer ignoreFile.Close()
- scanner := bufio.NewScanner(ignoreFile)
- for scanner.Scan() {
- line := scanner.Text()
- if line == "" || strings.HasPrefix(line, "#") {
- continue // Skip empty lines and comments
- }
- newPatterns = append(newPatterns, line)
- }
- if err := scanner.Err(); err != nil {
- log.Warn(ctx, "Scanner: Error reading .ignore file", "path", ignoreFilePath, err)
- }
- }
- // If the .ndignore file is empty, mimic the current behavior and ignore everything
- if len(newPatterns) == 0 {
- log.Trace(ctx, "Scanner: .ndignore file is empty, ignoring everything", "path", currentFolder)
- newPatterns = []string{"**/*"}
- } else {
- log.Trace(ctx, "Scanner: .ndignore file found ", "path", ignoreFilePath, "patterns", newPatterns)
- }
- }
- // Combine the patterns from the .ndignore file with the ones passed as argument
- combinedPatterns := append([]string{}, currentPatterns...)
- return append(combinedPatterns, newPatterns...)
-}
-
-func loadDir(ctx context.Context, job *scanJob, dirPath string, ignorePatterns []string) (folder *folderEntry, children []string, err error) {
- folder = newFolderEntry(job, dirPath)
-
+func loadDir(ctx context.Context, job *scanJob, dirPath string, checker *IgnoreChecker) (folder *folderEntry, children []string, err error) {
+ // Check if directory exists before creating the folder entry
+ // This is important to avoid removing the folder from lastUpdates if it doesn't exist
dirInfo, err := fs.Stat(job.fs, dirPath)
if err != nil {
log.Warn(ctx, "Scanner: Error stating dir", "path", dirPath, err)
return nil, nil, err
}
+
+ // Now that we know the folder exists, create the entry (which removes it from lastUpdates)
+ folder = job.createFolderEntry(dirPath)
folder.modTime = dirInfo.ModTime()
dir, err := job.fs.Open(dirPath)
@@ -117,12 +115,11 @@ func loadDir(ctx context.Context, job *scanJob, dirPath string, ignorePatterns [
return folder, children, err
}
- ignoreMatcher := ignore.CompileIgnoreLines(ignorePatterns...)
entries := fullReadDir(ctx, dirFile)
children = make([]string, 0, len(entries))
for _, entry := range entries {
entryPath := path.Join(dirPath, entry.Name())
- if len(ignorePatterns) > 0 && isScanIgnored(ctx, ignoreMatcher, entryPath) {
+ if checker.ShouldIgnore(ctx, entryPath) {
log.Trace(ctx, "Scanner: Ignoring entry", "path", entryPath)
continue
}
@@ -234,6 +231,7 @@ func isDirReadable(ctx context.Context, fsys fs.FS, dirPath string) bool {
var ignoredDirs = []string{
"$RECYCLE.BIN",
"#snapshot",
+ "@Recycle",
"@Recently-Snapshot",
".streams",
"lost+found",
@@ -254,11 +252,3 @@ func isDirIgnored(name string) bool {
func isEntryIgnored(name string) bool {
return strings.HasPrefix(name, ".") && !strings.HasPrefix(name, "..")
}
-
-func isScanIgnored(ctx context.Context, matcher *ignore.GitIgnore, entryPath string) bool {
- matches := matcher.MatchesPath(entryPath)
- if matches {
- log.Trace(ctx, "Scanner: Ignoring entry matching .ndignore: ", "path", entryPath)
- }
- return matches
-}
diff --git a/scanner/walk_dir_tree_test.go b/scanner/walk_dir_tree_test.go
index 1cab8a0b7..c9add0bd1 100644
--- a/scanner/walk_dir_tree_test.go
+++ b/scanner/walk_dir_tree_test.go
@@ -25,82 +25,196 @@ var _ = Describe("walk_dir_tree", func() {
ctx context.Context
)
- BeforeEach(func() {
- DeferCleanup(configtest.SetupConfig())
- ctx = GinkgoT().Context()
- fsys = &mockMusicFS{
- FS: fstest.MapFS{
- "root/a/.ndignore": {Data: []byte("ignored/*")},
- "root/a/f1.mp3": {},
- "root/a/f2.mp3": {},
- "root/a/ignored/bad.mp3": {},
- "root/b/cover.jpg": {},
- "root/c/f3": {},
- "root/d": {},
- "root/d/.ndignore": {},
- "root/d/f1.mp3": {},
- "root/d/f2.mp3": {},
- "root/d/f3.mp3": {},
- "root/e/original/f1.mp3": {},
- "root/e/symlink": {Mode: fs.ModeSymlink, Data: []byte("original")},
+ Context("full library", func() {
+ BeforeEach(func() {
+ DeferCleanup(configtest.SetupConfig())
+ ctx = GinkgoT().Context()
+ fsys = &mockMusicFS{
+ FS: fstest.MapFS{
+ "root/a/.ndignore": {Data: []byte("ignored/*")},
+ "root/a/f1.mp3": {},
+ "root/a/f2.mp3": {},
+ "root/a/ignored/bad.mp3": {},
+ "root/b/cover.jpg": {},
+ "root/c/f3": {},
+ "root/d": {},
+ "root/d/.ndignore": {},
+ "root/d/f1.mp3": {},
+ "root/d/f2.mp3": {},
+ "root/d/f3.mp3": {},
+ "root/e/original/f1.mp3": {},
+ "root/e/symlink": {Mode: fs.ModeSymlink, Data: []byte("original")},
+ },
+ }
+ job = &scanJob{
+ fs: fsys,
+ lib: model.Library{Path: "/music"},
+ }
+ })
+
+ // Helper function to call walkDirTree and collect folders from the results channel
+ getFolders := func() map[string]*folderEntry {
+ results, err := walkDirTree(ctx, job)
+ Expect(err).ToNot(HaveOccurred())
+
+ folders := map[string]*folderEntry{}
+ g := errgroup.Group{}
+ g.Go(func() error {
+ for folder := range results {
+ folders[folder.path] = folder
+ }
+ return nil
+ })
+ _ = g.Wait()
+ return folders
+ }
+
+ DescribeTable("symlink handling",
+ func(followSymlinks bool, expectedFolderCount int) {
+ conf.Server.Scanner.FollowSymlinks = followSymlinks
+ folders := getFolders()
+
+ Expect(folders).To(HaveLen(expectedFolderCount + 2)) // +2 for `.` and `root`
+
+ // Basic folder structure checks
+ Expect(folders["root/a"].audioFiles).To(SatisfyAll(
+ HaveLen(2),
+ HaveKey("f1.mp3"),
+ HaveKey("f2.mp3"),
+ ))
+ Expect(folders["root/a"].imageFiles).To(BeEmpty())
+ Expect(folders["root/b"].audioFiles).To(BeEmpty())
+ Expect(folders["root/b"].imageFiles).To(SatisfyAll(
+ HaveLen(1),
+ HaveKey("cover.jpg"),
+ ))
+ Expect(folders["root/c"].audioFiles).To(BeEmpty())
+ Expect(folders["root/c"].imageFiles).To(BeEmpty())
+ Expect(folders).ToNot(HaveKey("root/d"))
+
+ // Symlink specific checks
+ if followSymlinks {
+ Expect(folders["root/e/symlink"].audioFiles).To(HaveLen(1))
+ } else {
+ Expect(folders).ToNot(HaveKey("root/e/symlink"))
+ }
},
- }
- job = &scanJob{
- fs: fsys,
- lib: model.Library{Path: "/music"},
- }
+ Entry("with symlinks enabled", true, 7),
+ Entry("with symlinks disabled", false, 6),
+ )
})
- // Helper function to call walkDirTree and collect folders from the results channel
- getFolders := func() map[string]*folderEntry {
- results, err := walkDirTree(ctx, job)
- Expect(err).ToNot(HaveOccurred())
-
- folders := map[string]*folderEntry{}
- g := errgroup.Group{}
- g.Go(func() error {
- for folder := range results {
- folders[folder.path] = folder
+ Context("with target folders", func() {
+ BeforeEach(func() {
+ DeferCleanup(configtest.SetupConfig())
+ ctx = GinkgoT().Context()
+ fsys = &mockMusicFS{
+ FS: fstest.MapFS{
+ "Artist/Album1/track1.mp3": {},
+ "Artist/Album1/track2.mp3": {},
+ "Artist/Album2/track1.mp3": {},
+ "Artist/Album2/track2.mp3": {},
+ "Artist/Album2/Sub/track3.mp3": {},
+ "OtherArtist/Album3/track1.mp3": {},
+ },
+ }
+ job = &scanJob{
+ fs: fsys,
+ lib: model.Library{Path: "/music"},
}
- return nil
})
- _ = g.Wait()
- return folders
- }
- DescribeTable("symlink handling",
- func(followSymlinks bool, expectedFolderCount int) {
- conf.Server.Scanner.FollowSymlinks = followSymlinks
- folders := getFolders()
+ It("should recursively walk all subdirectories of target folders", func() {
+ results, err := walkDirTree(ctx, job, "Artist")
+ Expect(err).ToNot(HaveOccurred())
- Expect(folders).To(HaveLen(expectedFolderCount + 2)) // +2 for `.` and `root`
+ folders := map[string]*folderEntry{}
+ g := errgroup.Group{}
+ g.Go(func() error {
+ for folder := range results {
+ folders[folder.path] = folder
+ }
+ return nil
+ })
+ _ = g.Wait()
- // Basic folder structure checks
- Expect(folders["root/a"].audioFiles).To(SatisfyAll(
- HaveLen(2),
- HaveKey("f1.mp3"),
- HaveKey("f2.mp3"),
+ // Should include the target folder and all its descendants
+ Expect(folders).To(SatisfyAll(
+ HaveKey("Artist"),
+ HaveKey("Artist/Album1"),
+ HaveKey("Artist/Album2"),
+ HaveKey("Artist/Album2/Sub"),
))
- Expect(folders["root/a"].imageFiles).To(BeEmpty())
- Expect(folders["root/b"].audioFiles).To(BeEmpty())
- Expect(folders["root/b"].imageFiles).To(SatisfyAll(
- HaveLen(1),
- HaveKey("cover.jpg"),
- ))
- Expect(folders["root/c"].audioFiles).To(BeEmpty())
- Expect(folders["root/c"].imageFiles).To(BeEmpty())
- Expect(folders).ToNot(HaveKey("root/d"))
- // Symlink specific checks
- if followSymlinks {
- Expect(folders["root/e/symlink"].audioFiles).To(HaveLen(1))
- } else {
- Expect(folders).ToNot(HaveKey("root/e/symlink"))
+ // Should not include folders outside the target
+ Expect(folders).ToNot(HaveKey("OtherArtist"))
+ Expect(folders).ToNot(HaveKey("OtherArtist/Album3"))
+
+ // Verify audio files are present
+ Expect(folders["Artist/Album1"].audioFiles).To(HaveLen(2))
+ Expect(folders["Artist/Album2"].audioFiles).To(HaveLen(2))
+ Expect(folders["Artist/Album2/Sub"].audioFiles).To(HaveLen(1))
+ })
+
+ It("should handle multiple target folders", func() {
+ results, err := walkDirTree(ctx, job, "Artist/Album1", "OtherArtist")
+ Expect(err).ToNot(HaveOccurred())
+
+ folders := map[string]*folderEntry{}
+ g := errgroup.Group{}
+ g.Go(func() error {
+ for folder := range results {
+ folders[folder.path] = folder
+ }
+ return nil
+ })
+ _ = g.Wait()
+
+ // Should include both target folders and their descendants
+ Expect(folders).To(SatisfyAll(
+ HaveKey("Artist/Album1"),
+ HaveKey("OtherArtist"),
+ HaveKey("OtherArtist/Album3"),
+ ))
+
+ // Should not include other folders
+ Expect(folders).ToNot(HaveKey("Artist"))
+ Expect(folders).ToNot(HaveKey("Artist/Album2"))
+ Expect(folders).ToNot(HaveKey("Artist/Album2/Sub"))
+ })
+
+ It("should skip non-existent target folders and preserve them in lastUpdates", func() {
+ // Setup job with lastUpdates for both existing and non-existing folders
+ job.lastUpdates = map[string]model.FolderUpdateInfo{
+ model.FolderID(job.lib, "Artist/Album1"): {},
+ model.FolderID(job.lib, "NonExistent/DeletedFolder"): {},
+ model.FolderID(job.lib, "OtherArtist/Album3"): {},
}
- },
- Entry("with symlinks enabled", true, 7),
- Entry("with symlinks disabled", false, 6),
- )
+
+ // Try to scan existing folder and non-existing folder
+ results, err := walkDirTree(ctx, job, "Artist/Album1", "NonExistent/DeletedFolder")
+ Expect(err).ToNot(HaveOccurred())
+
+ // Collect results
+ folders := map[string]struct{}{}
+ for folder := range results {
+ folders[folder.path] = struct{}{}
+ }
+
+ // Should only include the existing folder
+ Expect(folders).To(HaveKey("Artist/Album1"))
+ Expect(folders).ToNot(HaveKey("NonExistent/DeletedFolder"))
+
+ // The non-existent folder should still be in lastUpdates (not removed by popLastUpdate)
+ Expect(job.lastUpdates).To(HaveKey(model.FolderID(job.lib, "NonExistent/DeletedFolder")))
+
+ // The existing folder should have been removed from lastUpdates
+ Expect(job.lastUpdates).ToNot(HaveKey(model.FolderID(job.lib, "Artist/Album1")))
+
+ // Folders not in targets should remain in lastUpdates
+ Expect(job.lastUpdates).To(HaveKey(model.FolderID(job.lib, "OtherArtist/Album3")))
+ })
+ })
})
Describe("helper functions", func() {
diff --git a/scanner/watcher.go b/scanner/watcher.go
index 37cfb5e22..3efebaacc 100644
--- a/scanner/watcher.go
+++ b/scanner/watcher.go
@@ -24,9 +24,9 @@ type Watcher interface {
type watcher struct {
mainCtx context.Context
ds model.DataStore
- scanner Scanner
+ scanner model.Scanner
triggerWait time.Duration
- watcherNotify chan model.Library
+ watcherNotify chan scanNotification
libraryWatchers map[int]*libraryWatcherInstance
mu sync.RWMutex
}
@@ -36,14 +36,19 @@ type libraryWatcherInstance struct {
cancel context.CancelFunc
}
+type scanNotification struct {
+ Library *model.Library
+ FolderPath string
+}
+
// GetWatcher returns the watcher singleton
-func GetWatcher(ds model.DataStore, s Scanner) Watcher {
+func GetWatcher(ds model.DataStore, s model.Scanner) Watcher {
return singleton.GetInstance(func() *watcher {
return &watcher{
ds: ds,
scanner: s,
triggerWait: conf.Server.Scanner.WatcherWait,
- watcherNotify: make(chan model.Library, 1),
+ watcherNotify: make(chan scanNotification, 1),
libraryWatchers: make(map[int]*libraryWatcherInstance),
}
})
@@ -68,11 +73,11 @@ func (w *watcher) Run(ctx context.Context) error {
// Main scan triggering loop
trigger := time.NewTimer(w.triggerWait)
trigger.Stop()
- waiting := false
+ targets := make(map[model.ScanTarget]struct{})
for {
select {
case <-trigger.C:
- log.Info("Watcher: Triggering scan")
+ log.Info("Watcher: Triggering scan for changed folders", "numTargets", len(targets))
status, err := w.scanner.Status(ctx)
if err != nil {
log.Error(ctx, "Watcher: Error retrieving Scanner status", err)
@@ -83,9 +88,23 @@ func (w *watcher) Run(ctx context.Context) error {
trigger.Reset(w.triggerWait * 3)
continue
}
- waiting = false
+
+ // Convert targets map to slice
+ targetSlice := make([]model.ScanTarget, 0, len(targets))
+ for target := range targets {
+ targetSlice = append(targetSlice, target)
+ }
+
+ // Clear targets for next batch
+ targets = make(map[model.ScanTarget]struct{})
+
go func() {
- _, err := w.scanner.ScanAll(ctx, false)
+ var err error
+ if conf.Server.DevSelectiveWatcher {
+ _, err = w.scanner.ScanFolders(ctx, false, targetSlice)
+ } else {
+ _, err = w.scanner.ScanAll(ctx, false)
+ }
if err != nil {
log.Error(ctx, "Watcher: Error scanning", err)
} else {
@@ -102,13 +121,22 @@ func (w *watcher) Run(ctx context.Context) error {
w.libraryWatchers = make(map[int]*libraryWatcherInstance)
w.mu.Unlock()
return nil
- case lib := <-w.watcherNotify:
- if !waiting {
- log.Debug(ctx, "Watcher: Detected changes. Waiting for more changes before triggering scan",
- "libraryID", lib.ID, "name", lib.Name, "path", lib.Path)
- waiting = true
- }
+ case notification := <-w.watcherNotify:
+ // Reset the trigger timer for debounce
trigger.Reset(w.triggerWait)
+
+ lib := notification.Library
+ folderPath := notification.FolderPath
+
+ // If already scheduled for scan, skip
+ target := model.ScanTarget{LibraryID: lib.ID, FolderPath: folderPath}
+ if _, exists := targets[target]; exists {
+ continue
+ }
+ targets[target] = struct{}{}
+
+ log.Debug(ctx, "Watcher: Detected changes. Waiting for more changes before triggering scan",
+ "libraryID", lib.ID, "name", lib.Name, "path", lib.Path, "folderPath", folderPath)
}
}
}
@@ -199,13 +227,18 @@ func (w *watcher) watchLibrary(ctx context.Context, lib *model.Library) error {
log.Info(ctx, "Watcher started for library", "libraryID", lib.ID, "name", lib.Name, "path", lib.Path, "absoluteLibPath", absLibPath)
+ return w.processLibraryEvents(ctx, lib, fsys, c, absLibPath)
+}
+
+// processLibraryEvents processes filesystem events for a library.
+func (w *watcher) processLibraryEvents(ctx context.Context, lib *model.Library, fsys storage.MusicFS, events <-chan string, absLibPath string) error {
for {
select {
case <-ctx.Done():
log.Debug(ctx, "Watcher stopped due to context cancellation", "libraryID", lib.ID, "name", lib.Name)
return nil
- case path := <-c:
- path, err = filepath.Rel(absLibPath, path)
+ case path := <-events:
+ path, err := filepath.Rel(absLibPath, path)
if err != nil {
log.Error(ctx, "Error getting relative path", "libraryID", lib.ID, "absolutePath", absLibPath, "path", path, err)
continue
@@ -215,12 +248,27 @@ func (w *watcher) watchLibrary(ctx context.Context, lib *model.Library) error {
log.Trace(ctx, "Ignoring change", "libraryID", lib.ID, "path", path)
continue
}
-
log.Trace(ctx, "Detected change", "libraryID", lib.ID, "path", path, "absoluteLibPath", absLibPath)
+ // Check if the original path (before resolution) matches .ndignore patterns
+ // This is crucial for deleted folders - if a deleted folder matches .ndignore,
+ // we should ignore it BEFORE resolveFolderPath walks up to the parent
+ if w.shouldIgnoreFolderPath(ctx, fsys, path) {
+ log.Debug(ctx, "Ignoring change matching .ndignore pattern", "libraryID", lib.ID, "path", path)
+ continue
+ }
+
+ // Find the folder to scan - validate path exists as directory, walk up if needed
+ folderPath := resolveFolderPath(fsys, path)
+ // Double-check after resolution in case the resolved path is different and also matches patterns
+ if folderPath != path && w.shouldIgnoreFolderPath(ctx, fsys, folderPath) {
+ log.Trace(ctx, "Ignoring change in folder matching .ndignore pattern", "libraryID", lib.ID, "folderPath", folderPath)
+ continue
+ }
+
// Notify the main watcher of changes
select {
- case w.watcherNotify <- *lib:
+ case w.watcherNotify <- scanNotification{Library: lib, FolderPath: folderPath}:
default:
// Channel is full, notification already pending
}
@@ -228,6 +276,47 @@ func (w *watcher) watchLibrary(ctx context.Context, lib *model.Library) error {
}
}
+// resolveFolderPath takes a path (which may be a file or directory) and returns
+// the folder path to scan. If the path is a file, it walks up to find the parent
+// directory. Returns empty string if the path should scan the library root.
+func resolveFolderPath(fsys fs.FS, path string) string {
+ // Handle root paths immediately
+ if path == "." || path == "" {
+ return ""
+ }
+
+ folderPath := path
+ for {
+ info, err := fs.Stat(fsys, folderPath)
+ if err == nil && info.IsDir() {
+ // Found a valid directory
+ return folderPath
+ }
+ if folderPath == "." || folderPath == "" {
+ // Reached root, scan entire library
+ return ""
+ }
+ // Walk up the tree
+ dir, _ := filepath.Split(folderPath)
+ if dir == "" || dir == "." {
+ return ""
+ }
+ // Remove trailing slash
+ folderPath = filepath.Clean(dir)
+ }
+}
+
+// shouldIgnoreFolderPath checks if the given folderPath should be ignored based on .ndignore patterns
+// in the library. It pushes all parent folders onto the IgnoreChecker stack before checking.
+func (w *watcher) shouldIgnoreFolderPath(ctx context.Context, fsys storage.MusicFS, folderPath string) bool {
+ checker := newIgnoreChecker(fsys)
+ err := checker.PushAllParents(ctx, folderPath)
+ if err != nil {
+ log.Warn(ctx, "Watcher: Error pushing ignore patterns for folder", "path", folderPath, err)
+ }
+ return checker.ShouldIgnore(ctx, folderPath)
+}
+
func isIgnoredPath(_ context.Context, _ fs.FS, path string) bool {
baseDir, name := filepath.Split(path)
switch {
diff --git a/scanner/watcher_test.go b/scanner/watcher_test.go
new file mode 100644
index 000000000..01bfb2491
--- /dev/null
+++ b/scanner/watcher_test.go
@@ -0,0 +1,491 @@
+package scanner
+
+import (
+ "context"
+ "io/fs"
+ "path/filepath"
+ "testing/fstest"
+ "time"
+
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/conf/configtest"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+var _ = Describe("Watcher", func() {
+ var ctx context.Context
+ var cancel context.CancelFunc
+ var mockScanner *tests.MockScanner
+ var mockDS *tests.MockDataStore
+ var w *watcher
+ var lib *model.Library
+
+ BeforeEach(func() {
+ DeferCleanup(configtest.SetupConfig())
+ conf.Server.Scanner.WatcherWait = 50 * time.Millisecond // Short wait for tests
+
+ ctx, cancel = context.WithCancel(context.Background())
+ DeferCleanup(cancel)
+
+ lib = &model.Library{
+ ID: 1,
+ Name: "Test Library",
+ Path: "/test/library",
+ }
+
+ // Set up mocks
+ mockScanner = tests.NewMockScanner()
+ mockDS = &tests.MockDataStore{}
+ mockLibRepo := &tests.MockLibraryRepo{}
+ mockLibRepo.SetData(model.Libraries{*lib})
+ mockDS.MockedLibrary = mockLibRepo
+
+ // Create a new watcher instance (not singleton) for testing
+ w = &watcher{
+ ds: mockDS,
+ scanner: mockScanner,
+ triggerWait: conf.Server.Scanner.WatcherWait,
+ watcherNotify: make(chan scanNotification, 10),
+ libraryWatchers: make(map[int]*libraryWatcherInstance),
+ mainCtx: ctx,
+ }
+ })
+
+ Describe("Target Collection and Deduplication", func() {
+ BeforeEach(func() {
+ // Start watcher in background
+ go func() {
+ _ = w.Run(ctx)
+ }()
+
+ // Give watcher time to initialize
+ time.Sleep(10 * time.Millisecond)
+ })
+
+ It("creates separate targets for different folders", func() {
+ // Send notifications for different folders
+ w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1"}
+ time.Sleep(10 * time.Millisecond)
+ w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist2"}
+
+ // Wait for watcher to process and trigger scan
+ Eventually(func() int {
+ return mockScanner.GetScanFoldersCallCount()
+ }, 200*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
+
+ // Verify two targets
+ calls := mockScanner.GetScanFoldersCalls()
+ Expect(calls).To(HaveLen(1))
+ Expect(calls[0].Targets).To(HaveLen(2))
+
+ // Extract folder paths
+ folderPaths := make(map[string]bool)
+ for _, target := range calls[0].Targets {
+ Expect(target.LibraryID).To(Equal(1))
+ folderPaths[target.FolderPath] = true
+ }
+ Expect(folderPaths).To(HaveKey("artist1"))
+ Expect(folderPaths).To(HaveKey("artist2"))
+ })
+
+ It("handles different folder paths correctly", func() {
+ // Send notification for nested folder
+ w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1/album1"}
+
+ // Wait for watcher to process and trigger scan
+ Eventually(func() int {
+ return mockScanner.GetScanFoldersCallCount()
+ }, 200*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
+
+ // Verify the target
+ calls := mockScanner.GetScanFoldersCalls()
+ Expect(calls).To(HaveLen(1))
+ Expect(calls[0].Targets).To(HaveLen(1))
+ Expect(calls[0].Targets[0].FolderPath).To(Equal("artist1/album1"))
+ })
+
+ It("deduplicates folder and file within same folder", func() {
+ // Send notification for a folder
+ w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1/album1"}
+ time.Sleep(10 * time.Millisecond)
+ // Send notification for same folder (as if file change was detected there)
+ // In practice, watchLibrary() would walk up from file path to folder
+ w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1/album1"}
+ time.Sleep(10 * time.Millisecond)
+ // Send another for same folder
+ w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1/album1"}
+
+ // Wait for watcher to process and trigger scan
+ Eventually(func() int {
+ return mockScanner.GetScanFoldersCallCount()
+ }, 200*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
+
+ // Verify only one target despite multiple file/folder changes
+ calls := mockScanner.GetScanFoldersCalls()
+ Expect(calls).To(HaveLen(1))
+ Expect(calls[0].Targets).To(HaveLen(1))
+ Expect(calls[0].Targets[0].FolderPath).To(Equal("artist1/album1"))
+ })
+ })
+
+ Describe("Timer Behavior", func() {
+ BeforeEach(func() {
+ // Start watcher in background
+ go func() {
+ _ = w.Run(ctx)
+ }()
+
+ // Give watcher time to initialize
+ time.Sleep(10 * time.Millisecond)
+ })
+
+ It("resets timer on each change (debouncing)", func() {
+ // Send first notification
+ w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1"}
+
+ // Wait a bit less than half the watcher wait time to ensure timer doesn't fire
+ time.Sleep(20 * time.Millisecond)
+
+ // No scan should have been triggered yet
+ Expect(mockScanner.GetScanFoldersCallCount()).To(Equal(0))
+
+ // Send another notification (resets timer)
+ w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1"}
+
+ // Wait a bit less than half the watcher wait time again
+ time.Sleep(20 * time.Millisecond)
+
+ // Still no scan
+ Expect(mockScanner.GetScanFoldersCallCount()).To(Equal(0))
+
+ // Wait for full timer to expire after last notification (plus margin)
+ time.Sleep(60 * time.Millisecond)
+
+ // Now scan should have been triggered
+ Eventually(func() int {
+ return mockScanner.GetScanFoldersCallCount()
+ }, 100*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
+ })
+
+ It("triggers scan after quiet period", func() {
+ // Send notification
+ w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1"}
+
+ // No scan immediately
+ Expect(mockScanner.GetScanFoldersCallCount()).To(Equal(0))
+
+ // Wait for quiet period
+ Eventually(func() int {
+ return mockScanner.GetScanFoldersCallCount()
+ }, 200*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
+ })
+ })
+
+ Describe("Empty and Root Paths", func() {
+ BeforeEach(func() {
+ // Start watcher in background
+ go func() {
+ _ = w.Run(ctx)
+ }()
+
+ // Give watcher time to initialize
+ time.Sleep(10 * time.Millisecond)
+ })
+
+ It("handles empty folder path (library root)", func() {
+ // Send notification with empty folder path
+ w.watcherNotify <- scanNotification{Library: lib, FolderPath: ""}
+
+ // Wait for scan
+ Eventually(func() int {
+ return mockScanner.GetScanFoldersCallCount()
+ }, 200*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
+
+ // Should scan the library root
+ calls := mockScanner.GetScanFoldersCalls()
+ Expect(calls).To(HaveLen(1))
+ Expect(calls[0].Targets).To(HaveLen(1))
+ Expect(calls[0].Targets[0].FolderPath).To(Equal(""))
+ })
+
+ It("deduplicates empty and dot paths", func() {
+ // Send notifications with empty and dot paths
+ w.watcherNotify <- scanNotification{Library: lib, FolderPath: ""}
+ time.Sleep(10 * time.Millisecond)
+ w.watcherNotify <- scanNotification{Library: lib, FolderPath: ""}
+
+ // Wait for scan
+ Eventually(func() int {
+ return mockScanner.GetScanFoldersCallCount()
+ }, 200*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
+
+ // Should have only one target
+ calls := mockScanner.GetScanFoldersCalls()
+ Expect(calls).To(HaveLen(1))
+ Expect(calls[0].Targets).To(HaveLen(1))
+ })
+ })
+
+ Describe("Multiple Libraries", func() {
+ var lib2 *model.Library
+
+ BeforeEach(func() {
+ // Create second library
+ lib2 = &model.Library{
+ ID: 2,
+ Name: "Test Library 2",
+ Path: "/test/library2",
+ }
+
+ mockLibRepo := mockDS.MockedLibrary.(*tests.MockLibraryRepo)
+ mockLibRepo.SetData(model.Libraries{*lib, *lib2})
+
+ // Start watcher in background
+ go func() {
+ _ = w.Run(ctx)
+ }()
+
+ // Give watcher time to initialize
+ time.Sleep(10 * time.Millisecond)
+ })
+
+ It("creates separate targets for different libraries", func() {
+ // Send notifications for both libraries
+ w.watcherNotify <- scanNotification{Library: lib, FolderPath: "artist1"}
+ time.Sleep(10 * time.Millisecond)
+ w.watcherNotify <- scanNotification{Library: lib2, FolderPath: "artist2"}
+
+ // Wait for scan
+ Eventually(func() int {
+ return mockScanner.GetScanFoldersCallCount()
+ }, 200*time.Millisecond, 10*time.Millisecond).Should(Equal(1))
+
+ // Verify two targets for different libraries
+ calls := mockScanner.GetScanFoldersCalls()
+ Expect(calls).To(HaveLen(1))
+ Expect(calls[0].Targets).To(HaveLen(2))
+
+ // Verify library IDs are different
+ libraryIDs := make(map[int]bool)
+ for _, target := range calls[0].Targets {
+ libraryIDs[target.LibraryID] = true
+ }
+ Expect(libraryIDs).To(HaveKey(1))
+ Expect(libraryIDs).To(HaveKey(2))
+ })
+ })
+
+ Describe(".ndignore handling", func() {
+ var ctx context.Context
+ var cancel context.CancelFunc
+ var w *watcher
+ var mockFS *mockMusicFS
+ var lib *model.Library
+ var eventChan chan string
+ var absLibPath string
+
+ BeforeEach(func() {
+ ctx, cancel = context.WithCancel(GinkgoT().Context())
+ DeferCleanup(cancel)
+
+ // Set up library
+ var err error
+ absLibPath, err = filepath.Abs(".")
+ Expect(err).NotTo(HaveOccurred())
+
+ lib = &model.Library{
+ ID: 1,
+ Name: "Test Library",
+ Path: absLibPath,
+ }
+
+ // Create watcher with notification channel
+ w = &watcher{
+ watcherNotify: make(chan scanNotification, 10),
+ }
+
+ eventChan = make(chan string, 10)
+ })
+
+ // Helper to send an event - converts relative path to absolute
+ sendEvent := func(relativePath string) {
+ path := filepath.Join(absLibPath, relativePath)
+ eventChan <- path
+ }
+
+ // Helper to start the real event processing loop
+ startEventProcessing := func() {
+ go func() {
+ defer GinkgoRecover()
+ // Call the actual processLibraryEvents method - testing the real implementation!
+ _ = w.processLibraryEvents(ctx, lib, mockFS, eventChan, absLibPath)
+ }()
+ }
+
+ Context("when a folder matching .ndignore is deleted", func() {
+ BeforeEach(func() {
+ // Create filesystem with .ndignore containing _TEMP pattern
+ // The deleted folder (_TEMP) will NOT exist in the filesystem
+ mockFS = &mockMusicFS{
+ FS: fstest.MapFS{
+ "rock": &fstest.MapFile{Mode: fs.ModeDir},
+ "rock/.ndignore": &fstest.MapFile{Data: []byte("_TEMP\n")},
+ "rock/valid_album": &fstest.MapFile{Mode: fs.ModeDir},
+ "rock/valid_album/track.mp3": &fstest.MapFile{Data: []byte("audio")},
+ },
+ }
+ })
+
+ It("should NOT send scan notification when deleted folder matches .ndignore", func() {
+ startEventProcessing()
+
+ // Simulate deletion event for rock/_TEMP
+ sendEvent("rock/_TEMP")
+
+ // Wait a bit to ensure event is processed
+ time.Sleep(50 * time.Millisecond)
+
+ // No notification should have been sent
+ Consistently(eventChan, 100*time.Millisecond).Should(BeEmpty())
+ })
+
+ It("should send scan notification for valid folder deletion", func() {
+ startEventProcessing()
+
+ // Simulate deletion event for rock/other_folder (not in .ndignore and doesn't exist)
+ // Since it doesn't exist in mockFS, resolveFolderPath will walk up to "rock"
+ sendEvent("rock/other_folder")
+
+ // Should receive notification for parent folder
+ Eventually(w.watcherNotify, 200*time.Millisecond).Should(Receive(Equal(scanNotification{
+ Library: lib,
+ FolderPath: "rock",
+ })))
+ })
+ })
+
+ Context("with nested folder patterns", func() {
+ BeforeEach(func() {
+ mockFS = &mockMusicFS{
+ FS: fstest.MapFS{
+ "music": &fstest.MapFile{Mode: fs.ModeDir},
+ "music/.ndignore": &fstest.MapFile{Data: []byte("**/temp\n**/cache\n")},
+ "music/rock": &fstest.MapFile{Mode: fs.ModeDir},
+ "music/rock/artist": &fstest.MapFile{Mode: fs.ModeDir},
+ },
+ }
+ })
+
+ It("should NOT send notification when nested ignored folder is deleted", func() {
+ startEventProcessing()
+
+ // Simulate deletion of music/rock/artist/temp (matches **/temp)
+ sendEvent("music/rock/artist/temp")
+
+ // Wait to ensure event is processed
+ time.Sleep(50 * time.Millisecond)
+
+ // No notification should be sent
+ Expect(w.watcherNotify).To(BeEmpty(), "Expected no scan notification for nested ignored folder")
+ })
+
+ It("should send notification for non-ignored nested folder", func() {
+ startEventProcessing()
+
+ // Simulate change in music/rock/artist (doesn't match any pattern)
+ sendEvent("music/rock/artist")
+
+ // Should receive notification
+ Eventually(w.watcherNotify, 200*time.Millisecond).Should(Receive(Equal(scanNotification{
+ Library: lib,
+ FolderPath: "music/rock/artist",
+ })))
+ })
+ })
+
+ Context("with file events in ignored folders", func() {
+ BeforeEach(func() {
+ mockFS = &mockMusicFS{
+ FS: fstest.MapFS{
+ "rock": &fstest.MapFile{Mode: fs.ModeDir},
+ "rock/.ndignore": &fstest.MapFile{Data: []byte("_TEMP\n")},
+ },
+ }
+ })
+
+ It("should NOT send notification for file changes in ignored folders", func() {
+ startEventProcessing()
+
+ // Simulate file change in rock/_TEMP/file.mp3
+ sendEvent("rock/_TEMP/file.mp3")
+
+ // Wait to ensure event is processed
+ time.Sleep(50 * time.Millisecond)
+
+ // No notification should be sent
+ Expect(w.watcherNotify).To(BeEmpty(), "Expected no scan notification for file in ignored folder")
+ })
+ })
+ })
+})
+
+var _ = Describe("resolveFolderPath", func() {
+ var mockFS fs.FS
+
+ BeforeEach(func() {
+ // Create a mock filesystem with some directories and files
+ mockFS = fstest.MapFS{
+ "artist1": &fstest.MapFile{Mode: fs.ModeDir},
+ "artist1/album1": &fstest.MapFile{Mode: fs.ModeDir},
+ "artist1/album1/track1.mp3": &fstest.MapFile{Data: []byte("audio")},
+ "artist1/album1/track2.mp3": &fstest.MapFile{Data: []byte("audio")},
+ "artist1/album2": &fstest.MapFile{Mode: fs.ModeDir},
+ "artist1/album2/song.flac": &fstest.MapFile{Data: []byte("audio")},
+ "artist2": &fstest.MapFile{Mode: fs.ModeDir},
+ "artist2/cover.jpg": &fstest.MapFile{Data: []byte("image")},
+ }
+ })
+
+ It("returns directory path when given a directory", func() {
+ result := resolveFolderPath(mockFS, "artist1/album1")
+ Expect(result).To(Equal("artist1/album1"))
+ })
+
+ It("walks up to parent directory when given a file path", func() {
+ result := resolveFolderPath(mockFS, "artist1/album1/track1.mp3")
+ Expect(result).To(Equal("artist1/album1"))
+ })
+
+ It("walks up multiple levels if needed", func() {
+ result := resolveFolderPath(mockFS, "artist1/album1/nonexistent/file.mp3")
+ Expect(result).To(Equal("artist1/album1"))
+ })
+
+ It("returns empty string for non-existent paths at root", func() {
+ result := resolveFolderPath(mockFS, "nonexistent/path/file.mp3")
+ Expect(result).To(Equal(""))
+ })
+
+ It("returns empty string for dot path", func() {
+ result := resolveFolderPath(mockFS, ".")
+ Expect(result).To(Equal(""))
+ })
+
+ It("returns empty string for empty path", func() {
+ result := resolveFolderPath(mockFS, "")
+ Expect(result).To(Equal(""))
+ })
+
+ It("handles nested file paths correctly", func() {
+ result := resolveFolderPath(mockFS, "artist1/album2/song.flac")
+ Expect(result).To(Equal("artist1/album2"))
+ })
+
+ It("resolves to top-level directory", func() {
+ result := resolveFolderPath(mockFS, "artist2/cover.jpg")
+ Expect(result).To(Equal("artist2"))
+ })
+})
diff --git a/server/nativeapi/config_test.go b/server/nativeapi/config_test.go
index 60f7c3394..d9c722955 100644
--- a/server/nativeapi/config_test.go
+++ b/server/nativeapi/config_test.go
@@ -29,7 +29,7 @@ var _ = Describe("Config API", func() {
conf.Server.DevUIShowConfig = true // Enable config endpoint for tests
ds = &tests.MockDataStore{}
auth.Init(ds)
- nativeRouter := New(ds, nil, nil, nil, core.NewMockLibraryService())
+ nativeRouter := New(ds, nil, nil, nil, core.NewMockLibraryService(), nil)
router = server.JWTVerifier(nativeRouter)
// Create test users
diff --git a/server/nativeapi/library.go b/server/nativeapi/library.go
index f081eca78..1636e1dbb 100644
--- a/server/nativeapi/library.go
+++ b/server/nativeapi/library.go
@@ -13,11 +13,11 @@ import (
)
// User-library association endpoints (admin only)
-func (n *Router) addUserLibraryRoute(r chi.Router) {
+func (api *Router) addUserLibraryRoute(r chi.Router) {
r.Route("/user/{id}/library", func(r chi.Router) {
r.Use(parseUserIDMiddleware)
- r.Get("/", getUserLibraries(n.libs))
- r.Put("/", setUserLibraries(n.libs))
+ r.Get("/", getUserLibraries(api.libs))
+ r.Put("/", setUserLibraries(api.libs))
})
}
diff --git a/server/nativeapi/library_test.go b/server/nativeapi/library_test.go
index 4e6d34582..950338492 100644
--- a/server/nativeapi/library_test.go
+++ b/server/nativeapi/library_test.go
@@ -30,7 +30,7 @@ var _ = Describe("Library API", func() {
DeferCleanup(configtest.SetupConfig())
ds = &tests.MockDataStore{}
auth.Init(ds)
- nativeRouter := New(ds, nil, nil, nil, core.NewMockLibraryService())
+ nativeRouter := New(ds, nil, nil, nil, core.NewMockLibraryService(), nil)
router = server.JWTVerifier(nativeRouter)
// Create test users
diff --git a/server/nativeapi/missing.go b/server/nativeapi/missing.go
index 0d311f492..2b455e622 100644
--- a/server/nativeapi/missing.go
+++ b/server/nativeapi/missing.go
@@ -8,9 +8,9 @@ import (
"github.com/Masterminds/squirrel"
"github.com/deluan/rest"
+ "github.com/navidrome/navidrome/core"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
- "github.com/navidrome/navidrome/model/request"
"github.com/navidrome/navidrome/utils/req"
)
@@ -63,45 +63,32 @@ func (r *missingRepository) EntityName() string {
return "missing_files"
}
-func deleteMissingFiles(ds model.DataStore, w http.ResponseWriter, r *http.Request) {
- ctx := r.Context()
- p := req.Params(r)
- ids, _ := p.Strings("id")
- err := ds.WithTx(func(tx model.DataStore) error {
+func deleteMissingFiles(maintenance core.Maintenance) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ ctx := r.Context()
+
+ p := req.Params(r)
+ ids, _ := p.Strings("id")
+
+ var err error
if len(ids) == 0 {
- _, err := tx.MediaFile(ctx).DeleteAllMissing()
- return err
- }
- return tx.MediaFile(ctx).DeleteMissing(ids)
- })
- if len(ids) == 1 && errors.Is(err, model.ErrNotFound) {
- log.Warn(ctx, "Missing file not found", "id", ids[0])
- http.Error(w, "not found", http.StatusNotFound)
- return
- }
- if err != nil {
- log.Error(ctx, "Error deleting missing tracks from DB", "ids", ids, err)
- http.Error(w, err.Error(), http.StatusInternalServerError)
- return
- }
- err = ds.GC(ctx)
- if err != nil {
- log.Error(ctx, "Error running GC after deleting missing tracks", err)
- http.Error(w, err.Error(), http.StatusInternalServerError)
- return
- }
-
- // Refresh artist stats in background after deleting missing files
- go func() {
- bgCtx := request.AddValues(context.Background(), r.Context())
- if _, err := ds.Artist(bgCtx).RefreshStats(true); err != nil {
- log.Error(bgCtx, "Error refreshing artist stats after deleting missing files", err)
+ err = maintenance.DeleteAllMissingFiles(ctx)
} else {
- log.Debug(bgCtx, "Successfully refreshed artist stats after deleting missing files")
+ err = maintenance.DeleteMissingFiles(ctx, ids)
}
- }()
- writeDeleteManyResponse(w, r, ids)
+ if len(ids) == 1 && errors.Is(err, model.ErrNotFound) {
+ log.Warn(ctx, "Missing file not found", "id", ids[0])
+ http.Error(w, "not found", http.StatusNotFound)
+ return
+ }
+ if err != nil {
+ http.Error(w, "failed to delete missing files", http.StatusInternalServerError)
+ return
+ }
+
+ writeDeleteManyResponse(w, r, ids)
+ }
}
var _ model.ResourceRepository = &missingRepository{}
diff --git a/server/nativeapi/native_api.go b/server/nativeapi/native_api.go
index 370bdbd1e..969650e0a 100644
--- a/server/nativeapi/native_api.go
+++ b/server/nativeapi/native_api.go
@@ -22,70 +22,71 @@ import (
type Router struct {
http.Handler
- ds model.DataStore
- share core.Share
- playlists core.Playlists
- insights metrics.Insights
- libs core.Library
+ ds model.DataStore
+ share core.Share
+ playlists core.Playlists
+ insights metrics.Insights
+ libs core.Library
+ maintenance core.Maintenance
}
-func New(ds model.DataStore, share core.Share, playlists core.Playlists, insights metrics.Insights, libraryService core.Library) *Router {
- r := &Router{ds: ds, share: share, playlists: playlists, insights: insights, libs: libraryService}
+func New(ds model.DataStore, share core.Share, playlists core.Playlists, insights metrics.Insights, libraryService core.Library, maintenance core.Maintenance) *Router {
+ r := &Router{ds: ds, share: share, playlists: playlists, insights: insights, libs: libraryService, maintenance: maintenance}
r.Handler = r.routes()
return r
}
-func (n *Router) routes() http.Handler {
+func (api *Router) routes() http.Handler {
r := chi.NewRouter()
// Public
- n.RX(r, "/translation", newTranslationRepository, false)
+ api.RX(r, "/translation", newTranslationRepository, false)
// Protected
r.Group(func(r chi.Router) {
- r.Use(server.Authenticator(n.ds))
+ r.Use(server.Authenticator(api.ds))
r.Use(server.JWTRefresher)
- r.Use(server.UpdateLastAccessMiddleware(n.ds))
- n.R(r, "/user", model.User{}, true)
- n.R(r, "/song", model.MediaFile{}, false)
- n.R(r, "/album", model.Album{}, false)
- n.R(r, "/artist", model.Artist{}, false)
- n.R(r, "/genre", model.Genre{}, false)
- n.R(r, "/player", model.Player{}, true)
- n.R(r, "/transcoding", model.Transcoding{}, conf.Server.EnableTranscodingConfig)
- n.R(r, "/radio", model.Radio{}, true)
- n.R(r, "/tag", model.Tag{}, true)
+ r.Use(server.UpdateLastAccessMiddleware(api.ds))
+ api.R(r, "/user", model.User{}, true)
+ api.R(r, "/song", model.MediaFile{}, false)
+ api.R(r, "/album", model.Album{}, false)
+ api.R(r, "/artist", model.Artist{}, false)
+ api.R(r, "/genre", model.Genre{}, false)
+ api.R(r, "/player", model.Player{}, true)
+ api.R(r, "/transcoding", model.Transcoding{}, conf.Server.EnableTranscodingConfig)
+ api.R(r, "/radio", model.Radio{}, true)
+ api.R(r, "/tag", model.Tag{}, true)
if conf.Server.EnableSharing {
- n.RX(r, "/share", n.share.NewRepository, true)
+ api.RX(r, "/share", api.share.NewRepository, true)
}
- n.addPlaylistRoute(r)
- n.addPlaylistTrackRoute(r)
- n.addSongPlaylistsRoute(r)
- n.addQueueRoute(r)
- n.addMissingFilesRoute(r)
- n.addKeepAliveRoute(r)
- n.addInsightsRoute(r)
+ api.addPlaylistRoute(r)
+ api.addPlaylistTrackRoute(r)
+ api.addSongPlaylistsRoute(r)
+ api.addQueueRoute(r)
+ api.addMissingFilesRoute(r)
+ api.addKeepAliveRoute(r)
+ api.addInsightsRoute(r)
r.With(adminOnlyMiddleware).Group(func(r chi.Router) {
- n.addInspectRoute(r)
- n.addConfigRoute(r)
- n.addUserLibraryRoute(r)
- n.RX(r, "/library", n.libs.NewRepository, true)
+ api.addInspectRoute(r)
+ api.addConfigRoute(r)
+ api.addUserLibraryRoute(r)
+ api.RX(r, "/library", api.libs.NewRepository, true)
})
})
return r
}
-func (n *Router) R(r chi.Router, pathPrefix string, model interface{}, persistable bool) {
+func (api *Router) R(r chi.Router, pathPrefix string, model interface{}, persistable bool) {
constructor := func(ctx context.Context) rest.Repository {
- return n.ds.Resource(ctx, model)
+ return api.ds.Resource(ctx, model)
}
- n.RX(r, pathPrefix, constructor, persistable)
+ api.RX(r, pathPrefix, constructor, persistable)
}
-func (n *Router) RX(r chi.Router, pathPrefix string, constructor rest.RepositoryConstructor, persistable bool) {
+func (api *Router) RX(r chi.Router, pathPrefix string, constructor rest.RepositoryConstructor, persistable bool) {
r.Route(pathPrefix, func(r chi.Router) {
r.Get("/", rest.GetAll(constructor))
if persistable {
@@ -102,9 +103,9 @@ func (n *Router) RX(r chi.Router, pathPrefix string, constructor rest.Repository
})
}
-func (n *Router) addPlaylistRoute(r chi.Router) {
+func (api *Router) addPlaylistRoute(r chi.Router) {
constructor := func(ctx context.Context) rest.Repository {
- return n.ds.Resource(ctx, model.Playlist{})
+ return api.ds.Resource(ctx, model.Playlist{})
}
r.Route("/playlist", func(r chi.Router) {
@@ -114,7 +115,7 @@ func (n *Router) addPlaylistRoute(r chi.Router) {
rest.Post(constructor)(w, r)
return
}
- createPlaylistFromM3U(n.playlists)(w, r)
+ createPlaylistFromM3U(api.playlists)(w, r)
})
r.Route("/{id}", func(r chi.Router) {
@@ -126,55 +127,53 @@ func (n *Router) addPlaylistRoute(r chi.Router) {
})
}
-func (n *Router) addPlaylistTrackRoute(r chi.Router) {
+func (api *Router) addPlaylistTrackRoute(r chi.Router) {
r.Route("/playlist/{playlistId}/tracks", func(r chi.Router) {
r.Get("/", func(w http.ResponseWriter, r *http.Request) {
- getPlaylist(n.ds)(w, r)
+ getPlaylist(api.ds)(w, r)
})
r.With(server.URLParamsMiddleware).Route("/", func(r chi.Router) {
r.Delete("/", func(w http.ResponseWriter, r *http.Request) {
- deleteFromPlaylist(n.ds)(w, r)
+ deleteFromPlaylist(api.ds)(w, r)
})
r.Post("/", func(w http.ResponseWriter, r *http.Request) {
- addToPlaylist(n.ds)(w, r)
+ addToPlaylist(api.ds)(w, r)
})
})
r.Route("/{id}", func(r chi.Router) {
r.Use(server.URLParamsMiddleware)
r.Get("/", func(w http.ResponseWriter, r *http.Request) {
- getPlaylistTrack(n.ds)(w, r)
+ getPlaylistTrack(api.ds)(w, r)
})
r.Put("/", func(w http.ResponseWriter, r *http.Request) {
- reorderItem(n.ds)(w, r)
+ reorderItem(api.ds)(w, r)
})
r.Delete("/", func(w http.ResponseWriter, r *http.Request) {
- deleteFromPlaylist(n.ds)(w, r)
+ deleteFromPlaylist(api.ds)(w, r)
})
})
})
}
-func (n *Router) addSongPlaylistsRoute(r chi.Router) {
+func (api *Router) addSongPlaylistsRoute(r chi.Router) {
r.With(server.URLParamsMiddleware).Get("/song/{id}/playlists", func(w http.ResponseWriter, r *http.Request) {
- getSongPlaylists(n.ds)(w, r)
+ getSongPlaylists(api.ds)(w, r)
})
}
-func (n *Router) addQueueRoute(r chi.Router) {
+func (api *Router) addQueueRoute(r chi.Router) {
r.Route("/queue", func(r chi.Router) {
- r.Get("/", getQueue(n.ds))
- r.Post("/", saveQueue(n.ds))
- r.Put("/", updateQueue(n.ds))
- r.Delete("/", clearQueue(n.ds))
+ r.Get("/", getQueue(api.ds))
+ r.Post("/", saveQueue(api.ds))
+ r.Put("/", updateQueue(api.ds))
+ r.Delete("/", clearQueue(api.ds))
})
}
-func (n *Router) addMissingFilesRoute(r chi.Router) {
+func (api *Router) addMissingFilesRoute(r chi.Router) {
r.Route("/missing", func(r chi.Router) {
- n.RX(r, "/", newMissingRepository(n.ds), false)
- r.Delete("/", func(w http.ResponseWriter, r *http.Request) {
- deleteMissingFiles(n.ds, w, r)
- })
+ api.RX(r, "/", newMissingRepository(api.ds), false)
+ r.Delete("/", deleteMissingFiles(api.maintenance))
})
}
@@ -198,7 +197,7 @@ func writeDeleteManyResponse(w http.ResponseWriter, r *http.Request, ids []strin
}
}
-func (n *Router) addInspectRoute(r chi.Router) {
+func (api *Router) addInspectRoute(r chi.Router) {
if conf.Server.Inspect.Enabled {
r.Group(func(r chi.Router) {
if conf.Server.Inspect.MaxRequests > 0 {
@@ -207,26 +206,26 @@ func (n *Router) addInspectRoute(r chi.Router) {
conf.Server.Inspect.BacklogTimeout)
r.Use(middleware.ThrottleBacklog(conf.Server.Inspect.MaxRequests, conf.Server.Inspect.BacklogLimit, time.Duration(conf.Server.Inspect.BacklogTimeout)))
}
- r.Get("/inspect", inspect(n.ds))
+ r.Get("/inspect", inspect(api.ds))
})
}
}
-func (n *Router) addConfigRoute(r chi.Router) {
+func (api *Router) addConfigRoute(r chi.Router) {
if conf.Server.DevUIShowConfig {
r.Get("/config/*", getConfig)
}
}
-func (n *Router) addKeepAliveRoute(r chi.Router) {
+func (api *Router) addKeepAliveRoute(r chi.Router) {
r.Get("/keepalive/*", func(w http.ResponseWriter, r *http.Request) {
_, _ = w.Write([]byte(`{"response":"ok", "id":"keepalive"}`))
})
}
-func (n *Router) addInsightsRoute(r chi.Router) {
+func (api *Router) addInsightsRoute(r chi.Router) {
r.Get("/insights/*", func(w http.ResponseWriter, r *http.Request) {
- last, success := n.insights.LastRun(r.Context())
+ last, success := api.insights.LastRun(r.Context())
if conf.Server.EnableInsightsCollector {
_, _ = w.Write([]byte(`{"id":"insights_status", "lastRun":"` + last.Format("2006-01-02 15:04:05") + `", "success":` + strconv.FormatBool(success) + `}`))
} else {
diff --git a/server/nativeapi/native_api_song_test.go b/server/nativeapi/native_api_song_test.go
index d7209a164..b52042643 100644
--- a/server/nativeapi/native_api_song_test.go
+++ b/server/nativeapi/native_api_song_test.go
@@ -95,7 +95,7 @@ var _ = Describe("Song Endpoints", func() {
mfRepo.SetData(testSongs)
// Create the native API router and wrap it with the JWTVerifier middleware
- nativeRouter := New(ds, nil, nil, nil, core.NewMockLibraryService())
+ nativeRouter := New(ds, nil, nil, nil, core.NewMockLibraryService(), nil)
router = server.JWTVerifier(nativeRouter)
w = httptest.NewRecorder()
})
diff --git a/server/subsonic/api.go b/server/subsonic/api.go
index bb3d20e5c..f0e73c3d2 100644
--- a/server/subsonic/api.go
+++ b/server/subsonic/api.go
@@ -18,7 +18,6 @@ import (
"github.com/navidrome/navidrome/core/scrobbler"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
- "github.com/navidrome/navidrome/scanner"
"github.com/navidrome/navidrome/server"
"github.com/navidrome/navidrome/server/events"
"github.com/navidrome/navidrome/server/subsonic/responses"
@@ -39,7 +38,7 @@ type Router struct {
players core.Players
provider external.Provider
playlists core.Playlists
- scanner scanner.Scanner
+ scanner model.Scanner
broker events.Broker
scrobbler scrobbler.PlayTracker
share core.Share
@@ -48,7 +47,7 @@ type Router struct {
}
func New(ds model.DataStore, artwork artwork.Artwork, streamer core.MediaStreamer, archiver core.Archiver,
- players core.Players, provider external.Provider, scanner scanner.Scanner, broker events.Broker,
+ players core.Players, provider external.Provider, scanner model.Scanner, broker events.Broker,
playlists core.Playlists, scrobbler scrobbler.PlayTracker, share core.Share, playback playback.PlaybackServer,
metrics metrics.Metrics,
) *Router {
@@ -148,7 +147,9 @@ func (api *Router) routes() http.Handler {
h(r, "createBookmark", api.CreateBookmark)
h(r, "deleteBookmark", api.DeleteBookmark)
h(r, "getPlayQueue", api.GetPlayQueue)
+ h(r, "getPlayQueueByIndex", api.GetPlayQueueByIndex)
h(r, "savePlayQueue", api.SavePlayQueue)
+ h(r, "savePlayQueueByIndex", api.SavePlayQueueByIndex)
})
r.Group(func(r chi.Router) {
r.Use(getPlayer(api.players))
diff --git a/server/subsonic/bookmarks.go b/server/subsonic/bookmarks.go
index d7286c20c..b1e71b1c7 100644
--- a/server/subsonic/bookmarks.go
+++ b/server/subsonic/bookmarks.go
@@ -91,7 +91,7 @@ func (api *Router) GetPlayQueue(r *http.Request) (*responses.Subsonic, error) {
Current: currentID,
Position: pq.Position,
Username: user.UserName,
- Changed: &pq.UpdatedAt,
+ Changed: pq.UpdatedAt,
ChangedBy: pq.ChangedBy,
}
return response, nil
@@ -135,3 +135,74 @@ func (api *Router) SavePlayQueue(r *http.Request) (*responses.Subsonic, error) {
}
return newResponse(), nil
}
+
+func (api *Router) GetPlayQueueByIndex(r *http.Request) (*responses.Subsonic, error) {
+ user, _ := request.UserFrom(r.Context())
+
+ repo := api.ds.PlayQueue(r.Context())
+ pq, err := repo.RetrieveWithMediaFiles(user.ID)
+ if err != nil && !errors.Is(err, model.ErrNotFound) {
+ return nil, err
+ }
+ if pq == nil || len(pq.Items) == 0 {
+ return newResponse(), nil
+ }
+
+ response := newResponse()
+
+ var index *int
+ if len(pq.Items) > 0 {
+ index = &pq.Current
+ }
+
+ response.PlayQueueByIndex = &responses.PlayQueueByIndex{
+ Entry: slice.MapWithArg(pq.Items, r.Context(), childFromMediaFile),
+ CurrentIndex: index,
+ Position: pq.Position,
+ Username: user.UserName,
+ Changed: pq.UpdatedAt,
+ ChangedBy: pq.ChangedBy,
+ }
+ return response, nil
+}
+
+func (api *Router) SavePlayQueueByIndex(r *http.Request) (*responses.Subsonic, error) {
+ p := req.Params(r)
+ ids, _ := p.Strings("id")
+
+ position := p.Int64Or("position", 0)
+
+ var err error
+ var currentIndex int
+
+ if len(ids) > 0 {
+ currentIndex, err = p.Int("currentIndex")
+ if err != nil || currentIndex < 0 || currentIndex >= len(ids) {
+ return nil, newError(responses.ErrorMissingParameter, "missing parameter index, err: %s", err)
+ }
+ }
+
+ items := slice.Map(ids, func(id string) model.MediaFile {
+ return model.MediaFile{ID: id}
+ })
+
+ user, _ := request.UserFrom(r.Context())
+ client, _ := request.ClientFrom(r.Context())
+
+ pq := &model.PlayQueue{
+ UserID: user.ID,
+ Current: currentIndex,
+ Position: position,
+ ChangedBy: client,
+ Items: items,
+ CreatedAt: time.Time{},
+ UpdatedAt: time.Time{},
+ }
+
+ repo := api.ds.PlayQueue(r.Context())
+ err = repo.Store(pq)
+ if err != nil {
+ return nil, err
+ }
+ return newResponse(), nil
+}
diff --git a/server/subsonic/library_scanning.go b/server/subsonic/library_scanning.go
index b6ccb9ae6..c9dd64968 100644
--- a/server/subsonic/library_scanning.go
+++ b/server/subsonic/library_scanning.go
@@ -1,10 +1,13 @@
package subsonic
import (
+ "fmt"
"net/http"
+ "slices"
"time"
"github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/request"
"github.com/navidrome/navidrome/server/subsonic/responses"
"github.com/navidrome/navidrome/utils/req"
@@ -44,15 +47,56 @@ func (api *Router) StartScan(r *http.Request) (*responses.Subsonic, error) {
p := req.Params(r)
fullScan := p.BoolOr("fullScan", false)
+ // Parse optional target parameters for selective scanning
+ var targets []model.ScanTarget
+ if targetParams, err := p.Strings("target"); err == nil && len(targetParams) > 0 {
+ targets, err = model.ParseTargets(targetParams)
+ if err != nil {
+ return nil, newError(responses.ErrorGeneric, fmt.Sprintf("Invalid target parameter: %v", err))
+ }
+
+ // Validate all libraries in targets exist and user has access to them
+ userLibraries, err := api.ds.User(ctx).GetUserLibraries(loggedUser.ID)
+ if err != nil {
+ return nil, newError(responses.ErrorGeneric, "Internal error")
+ }
+
+ // Check each target library
+ for _, target := range targets {
+ if !slices.ContainsFunc(userLibraries, func(lib model.Library) bool { return lib.ID == target.LibraryID }) {
+ return nil, newError(responses.ErrorDataNotFound, fmt.Sprintf("Library with ID %d not found", target.LibraryID))
+ }
+ }
+
+ // Special case: if single library with empty path and it's the only library in DB, call ScanAll
+ if len(targets) == 1 && targets[0].FolderPath == "" {
+ allLibs, err := api.ds.Library(ctx).GetAll()
+ if err != nil {
+ return nil, newError(responses.ErrorGeneric, "Internal error")
+ }
+ if len(allLibs) == 1 {
+ targets = nil // This will trigger ScanAll below
+ }
+ }
+ }
+
go func() {
start := time.Now()
- log.Info(ctx, "Triggering manual scan", "fullScan", fullScan, "user", loggedUser.UserName)
- _, err := api.scanner.ScanAll(ctx, fullScan)
+ var err error
+
+ if len(targets) > 0 {
+ log.Info(ctx, "Triggering on-demand scan", "fullScan", fullScan, "targets", len(targets), "user", loggedUser.UserName)
+ _, err = api.scanner.ScanFolders(ctx, fullScan, targets)
+ } else {
+ log.Info(ctx, "Triggering on-demand scan", "fullScan", fullScan, "user", loggedUser.UserName)
+ _, err = api.scanner.ScanAll(ctx, fullScan)
+ }
+
if err != nil {
log.Error(ctx, "Error scanning", err)
return
}
- log.Info(ctx, "Manual scan complete", "user", loggedUser.UserName, "elapsed", time.Since(start))
+ log.Info(ctx, "On-demand scan complete", "user", loggedUser.UserName, "elapsed", time.Since(start))
}()
return api.GetScanStatus(r)
diff --git a/server/subsonic/library_scanning_test.go b/server/subsonic/library_scanning_test.go
new file mode 100644
index 000000000..d8eba296b
--- /dev/null
+++ b/server/subsonic/library_scanning_test.go
@@ -0,0 +1,396 @@
+package subsonic
+
+import (
+ "context"
+ "errors"
+ "net/http/httptest"
+
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/model/request"
+ "github.com/navidrome/navidrome/server/subsonic/responses"
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+var _ = Describe("LibraryScanning", func() {
+ var api *Router
+ var ms *tests.MockScanner
+
+ BeforeEach(func() {
+ ms = tests.NewMockScanner()
+ api = &Router{scanner: ms}
+ })
+
+ Describe("StartScan", func() {
+ It("requires admin authentication", func() {
+ // Create non-admin user
+ ctx := request.WithUser(context.Background(), model.User{
+ ID: "user-id",
+ IsAdmin: false,
+ })
+
+ // Create request
+ r := httptest.NewRequest("GET", "/rest/startScan", nil)
+ r = r.WithContext(ctx)
+
+ // Call endpoint
+ response, err := api.StartScan(r)
+
+ // Should return authorization error
+ Expect(err).To(HaveOccurred())
+ Expect(response).To(BeNil())
+ var subErr subError
+ ok := errors.As(err, &subErr)
+ Expect(ok).To(BeTrue())
+ Expect(subErr.code).To(Equal(responses.ErrorAuthorizationFail))
+ })
+
+ It("triggers a full scan with no parameters", func() {
+ // Create admin user
+ ctx := request.WithUser(context.Background(), model.User{
+ ID: "admin-id",
+ IsAdmin: true,
+ })
+
+ // Create request with no parameters
+ r := httptest.NewRequest("GET", "/rest/startScan", nil)
+ r = r.WithContext(ctx)
+
+ // Call endpoint
+ response, err := api.StartScan(r)
+
+ // Should succeed
+ Expect(err).ToNot(HaveOccurred())
+ Expect(response).ToNot(BeNil())
+
+ // Verify ScanAll was called (eventually, since it's in a goroutine)
+ Eventually(func() int {
+ return ms.GetScanAllCallCount()
+ }).Should(BeNumerically(">", 0))
+ calls := ms.GetScanAllCalls()
+ Expect(calls).To(HaveLen(1))
+ Expect(calls[0].FullScan).To(BeFalse())
+ })
+
+ It("triggers a full scan with fullScan=true", func() {
+ // Create admin user
+ ctx := request.WithUser(context.Background(), model.User{
+ ID: "admin-id",
+ IsAdmin: true,
+ })
+
+ // Create request with fullScan parameter
+ r := httptest.NewRequest("GET", "/rest/startScan?fullScan=true", nil)
+ r = r.WithContext(ctx)
+
+ // Call endpoint
+ response, err := api.StartScan(r)
+
+ // Should succeed
+ Expect(err).ToNot(HaveOccurred())
+ Expect(response).ToNot(BeNil())
+
+ // Verify ScanAll was called with fullScan=true
+ Eventually(func() int {
+ return ms.GetScanAllCallCount()
+ }).Should(BeNumerically(">", 0))
+ calls := ms.GetScanAllCalls()
+ Expect(calls).To(HaveLen(1))
+ Expect(calls[0].FullScan).To(BeTrue())
+ })
+
+ It("triggers a selective scan with single target parameter", func() {
+ // Setup mocks
+ mockUserRepo := tests.CreateMockUserRepo()
+ _ = mockUserRepo.SetUserLibraries("admin-id", []int{1, 2})
+ mockDS := &tests.MockDataStore{MockedUser: mockUserRepo}
+ api.ds = mockDS
+
+ // Create admin user
+ ctx := request.WithUser(context.Background(), model.User{
+ ID: "admin-id",
+ IsAdmin: true,
+ })
+
+ // Create request with single target parameter
+ r := httptest.NewRequest("GET", "/rest/startScan?target=1:Music/Rock", nil)
+ r = r.WithContext(ctx)
+
+ // Call endpoint
+ response, err := api.StartScan(r)
+
+ // Should succeed
+ Expect(err).ToNot(HaveOccurred())
+ Expect(response).ToNot(BeNil())
+
+ // Verify ScanFolders was called with correct targets
+ Eventually(func() int {
+ return ms.GetScanFoldersCallCount()
+ }).Should(BeNumerically(">", 0))
+ calls := ms.GetScanFoldersCalls()
+ Expect(calls).To(HaveLen(1))
+ targets := calls[0].Targets
+ Expect(targets).To(HaveLen(1))
+ Expect(targets[0].LibraryID).To(Equal(1))
+ Expect(targets[0].FolderPath).To(Equal("Music/Rock"))
+ })
+
+ It("triggers a selective scan with multiple target parameters", func() {
+ // Setup mocks
+ mockUserRepo := tests.CreateMockUserRepo()
+ _ = mockUserRepo.SetUserLibraries("admin-id", []int{1, 2})
+ mockDS := &tests.MockDataStore{MockedUser: mockUserRepo}
+ api.ds = mockDS
+
+ // Create admin user
+ ctx := request.WithUser(context.Background(), model.User{
+ ID: "admin-id",
+ IsAdmin: true,
+ })
+
+ // Create request with multiple target parameters
+ r := httptest.NewRequest("GET", "/rest/startScan?target=1:Music/Reggae&target=2:Classical/Bach", nil)
+ r = r.WithContext(ctx)
+
+ // Call endpoint
+ response, err := api.StartScan(r)
+
+ // Should succeed
+ Expect(err).ToNot(HaveOccurred())
+ Expect(response).ToNot(BeNil())
+
+ // Verify ScanFolders was called with correct targets
+ Eventually(func() int {
+ return ms.GetScanFoldersCallCount()
+ }).Should(BeNumerically(">", 0))
+ calls := ms.GetScanFoldersCalls()
+ Expect(calls).To(HaveLen(1))
+ targets := calls[0].Targets
+ Expect(targets).To(HaveLen(2))
+ Expect(targets[0].LibraryID).To(Equal(1))
+ Expect(targets[0].FolderPath).To(Equal("Music/Reggae"))
+ Expect(targets[1].LibraryID).To(Equal(2))
+ Expect(targets[1].FolderPath).To(Equal("Classical/Bach"))
+ })
+
+ It("triggers a selective full scan with target and fullScan parameters", func() {
+ // Setup mocks
+ mockUserRepo := tests.CreateMockUserRepo()
+ _ = mockUserRepo.SetUserLibraries("admin-id", []int{1})
+ mockDS := &tests.MockDataStore{MockedUser: mockUserRepo}
+ api.ds = mockDS
+
+ // Create admin user
+ ctx := request.WithUser(context.Background(), model.User{
+ ID: "admin-id",
+ IsAdmin: true,
+ })
+
+ // Create request with target and fullScan parameters
+ r := httptest.NewRequest("GET", "/rest/startScan?target=1:Music/Jazz&fullScan=true", nil)
+ r = r.WithContext(ctx)
+
+ // Call endpoint
+ response, err := api.StartScan(r)
+
+ // Should succeed
+ Expect(err).ToNot(HaveOccurred())
+ Expect(response).ToNot(BeNil())
+
+ // Verify ScanFolders was called with fullScan=true
+ Eventually(func() int {
+ return ms.GetScanFoldersCallCount()
+ }).Should(BeNumerically(">", 0))
+ calls := ms.GetScanFoldersCalls()
+ Expect(calls).To(HaveLen(1))
+ Expect(calls[0].FullScan).To(BeTrue())
+ targets := calls[0].Targets
+ Expect(targets).To(HaveLen(1))
+ })
+
+ It("returns error for invalid target format", func() {
+ // Create admin user
+ ctx := request.WithUser(context.Background(), model.User{
+ ID: "admin-id",
+ IsAdmin: true,
+ })
+
+ // Create request with invalid target format (missing colon)
+ r := httptest.NewRequest("GET", "/rest/startScan?target=1MusicRock", nil)
+ r = r.WithContext(ctx)
+
+ // Call endpoint
+ response, err := api.StartScan(r)
+
+ // Should return error
+ Expect(err).To(HaveOccurred())
+ Expect(response).To(BeNil())
+ var subErr subError
+ ok := errors.As(err, &subErr)
+ Expect(ok).To(BeTrue())
+ Expect(subErr.code).To(Equal(responses.ErrorGeneric))
+ })
+
+ It("returns error for invalid library ID in target", func() {
+ // Create admin user
+ ctx := request.WithUser(context.Background(), model.User{
+ ID: "admin-id",
+ IsAdmin: true,
+ })
+
+ // Create request with invalid library ID
+ r := httptest.NewRequest("GET", "/rest/startScan?target=0:Music/Rock", nil)
+ r = r.WithContext(ctx)
+
+ // Call endpoint
+ response, err := api.StartScan(r)
+
+ // Should return error
+ Expect(err).To(HaveOccurred())
+ Expect(response).To(BeNil())
+ var subErr subError
+ ok := errors.As(err, &subErr)
+ Expect(ok).To(BeTrue())
+ Expect(subErr.code).To(Equal(responses.ErrorGeneric))
+ })
+
+ It("returns error when library does not exist", func() {
+ // Setup mocks - user has access to library 1 and 2 only
+ mockUserRepo := tests.CreateMockUserRepo()
+ _ = mockUserRepo.SetUserLibraries("admin-id", []int{1, 2})
+ mockDS := &tests.MockDataStore{MockedUser: mockUserRepo}
+ api.ds = mockDS
+
+ // Create admin user
+ ctx := request.WithUser(context.Background(), model.User{
+ ID: "admin-id",
+ IsAdmin: true,
+ })
+
+ // Create request with library ID that doesn't exist
+ r := httptest.NewRequest("GET", "/rest/startScan?target=999:Music/Rock", nil)
+ r = r.WithContext(ctx)
+
+ // Call endpoint
+ response, err := api.StartScan(r)
+
+ // Should return ErrorDataNotFound
+ Expect(err).To(HaveOccurred())
+ Expect(response).To(BeNil())
+ var subErr subError
+ ok := errors.As(err, &subErr)
+ Expect(ok).To(BeTrue())
+ Expect(subErr.code).To(Equal(responses.ErrorDataNotFound))
+ })
+
+ It("calls ScanAll when single library with empty path and only one library exists", func() {
+ // Setup mocks - single library in DB
+ mockUserRepo := tests.CreateMockUserRepo()
+ _ = mockUserRepo.SetUserLibraries("admin-id", []int{1})
+ mockLibraryRepo := &tests.MockLibraryRepo{}
+ mockLibraryRepo.SetData(model.Libraries{
+ {ID: 1, Name: "Music Library", Path: "/music"},
+ })
+ mockDS := &tests.MockDataStore{
+ MockedUser: mockUserRepo,
+ MockedLibrary: mockLibraryRepo,
+ }
+ api.ds = mockDS
+
+ // Create admin user
+ ctx := request.WithUser(context.Background(), model.User{
+ ID: "admin-id",
+ IsAdmin: true,
+ })
+
+ // Create request with single library and empty path
+ r := httptest.NewRequest("GET", "/rest/startScan?target=1:", nil)
+ r = r.WithContext(ctx)
+
+ // Call endpoint
+ response, err := api.StartScan(r)
+
+ // Should succeed
+ Expect(err).ToNot(HaveOccurred())
+ Expect(response).ToNot(BeNil())
+
+ // Verify ScanAll was called instead of ScanFolders
+ Eventually(func() int {
+ return ms.GetScanAllCallCount()
+ }).Should(BeNumerically(">", 0))
+ Expect(ms.GetScanFoldersCallCount()).To(Equal(0))
+ })
+
+ It("calls ScanFolders when single library with empty path but multiple libraries exist", func() {
+ // Setup mocks - multiple libraries in DB
+ mockUserRepo := tests.CreateMockUserRepo()
+ _ = mockUserRepo.SetUserLibraries("admin-id", []int{1, 2})
+ mockLibraryRepo := &tests.MockLibraryRepo{}
+ mockLibraryRepo.SetData(model.Libraries{
+ {ID: 1, Name: "Music Library", Path: "/music"},
+ {ID: 2, Name: "Audiobooks", Path: "/audiobooks"},
+ })
+ mockDS := &tests.MockDataStore{
+ MockedUser: mockUserRepo,
+ MockedLibrary: mockLibraryRepo,
+ }
+ api.ds = mockDS
+
+ // Create admin user
+ ctx := request.WithUser(context.Background(), model.User{
+ ID: "admin-id",
+ IsAdmin: true,
+ })
+
+ // Create request with single library and empty path
+ r := httptest.NewRequest("GET", "/rest/startScan?target=1:", nil)
+ r = r.WithContext(ctx)
+
+ // Call endpoint
+ response, err := api.StartScan(r)
+
+ // Should succeed
+ Expect(err).ToNot(HaveOccurred())
+ Expect(response).ToNot(BeNil())
+
+ // Verify ScanFolders was called (not ScanAll)
+ Eventually(func() int {
+ return ms.GetScanFoldersCallCount()
+ }).Should(BeNumerically(">", 0))
+ calls := ms.GetScanFoldersCalls()
+ Expect(calls).To(HaveLen(1))
+ targets := calls[0].Targets
+ Expect(targets).To(HaveLen(1))
+ Expect(targets[0].LibraryID).To(Equal(1))
+ Expect(targets[0].FolderPath).To(Equal(""))
+ })
+ })
+
+ Describe("GetScanStatus", func() {
+ It("returns scan status", func() {
+ // Setup mock scanner status
+ ms.SetStatusResponse(&model.ScannerStatus{
+ Scanning: false,
+ Count: 100,
+ FolderCount: 10,
+ })
+
+ // Create request
+ ctx := context.Background()
+ r := httptest.NewRequest("GET", "/rest/getScanStatus", nil)
+ r = r.WithContext(ctx)
+
+ // Call endpoint
+ response, err := api.GetScanStatus(r)
+
+ // Should succeed
+ Expect(err).ToNot(HaveOccurred())
+ Expect(response).ToNot(BeNil())
+ Expect(response.ScanStatus).ToNot(BeNil())
+ Expect(response.ScanStatus.Scanning).To(BeFalse())
+ Expect(response.ScanStatus.Count).To(Equal(int64(100)))
+ Expect(response.ScanStatus.FolderCount).To(Equal(int64(10)))
+ })
+ })
+})
diff --git a/server/subsonic/opensubsonic.go b/server/subsonic/opensubsonic.go
index 17ce3c2b0..a364651c5 100644
--- a/server/subsonic/opensubsonic.go
+++ b/server/subsonic/opensubsonic.go
@@ -12,6 +12,7 @@ func (api *Router) GetOpenSubsonicExtensions(_ *http.Request) (*responses.Subson
{Name: "transcodeOffset", Versions: []int32{1}},
{Name: "formPost", Versions: []int32{1}},
{Name: "songLyrics", Versions: []int32{1}},
+ {Name: "indexBasedQueue", Versions: []int32{1}},
}
return response, nil
}
diff --git a/server/subsonic/opensubsonic_test.go b/server/subsonic/opensubsonic_test.go
index 3cc680afe..58dca682c 100644
--- a/server/subsonic/opensubsonic_test.go
+++ b/server/subsonic/opensubsonic_test.go
@@ -35,10 +35,11 @@ var _ = Describe("GetOpenSubsonicExtensions", func() {
err := json.Unmarshal(w.Body.Bytes(), &response)
Expect(err).NotTo(HaveOccurred())
Expect(*response.Subsonic.OpenSubsonicExtensions).To(SatisfyAll(
- HaveLen(3),
+ HaveLen(4),
ContainElement(responses.OpenSubsonicExtension{Name: "transcodeOffset", Versions: []int32{1}}),
ContainElement(responses.OpenSubsonicExtension{Name: "formPost", Versions: []int32{1}}),
ContainElement(responses.OpenSubsonicExtension{Name: "songLyrics", Versions: []int32{1}}),
+ ContainElement(responses.OpenSubsonicExtension{Name: "indexBasedQueue", Versions: []int32{1}}),
))
})
})
diff --git a/server/subsonic/responses/.snapshots/Responses PlayQueue without data should match .JSON b/server/subsonic/responses/.snapshots/Responses PlayQueue without data should match .JSON
index 88eebb276..70b10c059 100644
--- a/server/subsonic/responses/.snapshots/Responses PlayQueue without data should match .JSON
+++ b/server/subsonic/responses/.snapshots/Responses PlayQueue without data should match .JSON
@@ -6,6 +6,7 @@
"openSubsonic": true,
"playQueue": {
"username": "",
+ "changed": "0001-01-01T00:00:00Z",
"changedBy": ""
}
}
diff --git a/server/subsonic/responses/.snapshots/Responses PlayQueue without data should match .XML b/server/subsonic/responses/.snapshots/Responses PlayQueue without data should match .XML
index 5af3d9157..597781cbd 100644
--- a/server/subsonic/responses/.snapshots/Responses PlayQueue without data should match .XML
+++ b/server/subsonic/responses/.snapshots/Responses PlayQueue without data should match .XML
@@ -1,3 +1,3 @@
-
+
diff --git a/server/subsonic/responses/.snapshots/Responses PlayQueueByIndex with data should match .JSON b/server/subsonic/responses/.snapshots/Responses PlayQueueByIndex with data should match .JSON
new file mode 100644
index 000000000..efc032ca6
--- /dev/null
+++ b/server/subsonic/responses/.snapshots/Responses PlayQueueByIndex with data should match .JSON
@@ -0,0 +1,22 @@
+{
+ "status": "ok",
+ "version": "1.16.1",
+ "type": "navidrome",
+ "serverVersion": "v0.55.0",
+ "openSubsonic": true,
+ "playQueueByIndex": {
+ "entry": [
+ {
+ "id": "1",
+ "isDir": false,
+ "title": "title",
+ "isVideo": false
+ }
+ ],
+ "currentIndex": 0,
+ "position": 243,
+ "username": "user1",
+ "changed": "0001-01-01T00:00:00Z",
+ "changedBy": "a_client"
+ }
+}
diff --git a/server/subsonic/responses/.snapshots/Responses PlayQueueByIndex with data should match .XML b/server/subsonic/responses/.snapshots/Responses PlayQueueByIndex with data should match .XML
new file mode 100644
index 000000000..1d31b334e
--- /dev/null
+++ b/server/subsonic/responses/.snapshots/Responses PlayQueueByIndex with data should match .XML
@@ -0,0 +1,5 @@
+
+
+
+
+
diff --git a/server/subsonic/responses/.snapshots/Responses PlayQueueByIndex without data should match .JSON b/server/subsonic/responses/.snapshots/Responses PlayQueueByIndex without data should match .JSON
new file mode 100644
index 000000000..ad49a35e5
--- /dev/null
+++ b/server/subsonic/responses/.snapshots/Responses PlayQueueByIndex without data should match .JSON
@@ -0,0 +1,12 @@
+{
+ "status": "ok",
+ "version": "1.16.1",
+ "type": "navidrome",
+ "serverVersion": "v0.55.0",
+ "openSubsonic": true,
+ "playQueueByIndex": {
+ "username": "",
+ "changed": "0001-01-01T00:00:00Z",
+ "changedBy": ""
+ }
+}
diff --git a/server/subsonic/responses/.snapshots/Responses PlayQueueByIndex without data should match .XML b/server/subsonic/responses/.snapshots/Responses PlayQueueByIndex without data should match .XML
new file mode 100644
index 000000000..d99681f4c
--- /dev/null
+++ b/server/subsonic/responses/.snapshots/Responses PlayQueueByIndex without data should match .XML
@@ -0,0 +1,3 @@
+
+
+
diff --git a/server/subsonic/responses/responses.go b/server/subsonic/responses/responses.go
index ffda2aa43..0724d2fff 100644
--- a/server/subsonic/responses/responses.go
+++ b/server/subsonic/responses/responses.go
@@ -60,6 +60,7 @@ type Subsonic struct {
// OpenSubsonic extensions
OpenSubsonicExtensions *OpenSubsonicExtensions `xml:"openSubsonicExtensions,omitempty" json:"openSubsonicExtensions,omitempty"`
LyricsList *LyricsList `xml:"lyricsList,omitempty" json:"lyricsList,omitempty"`
+ PlayQueueByIndex *PlayQueueByIndex `xml:"playQueueByIndex,omitempty" json:"playQueueByIndex,omitempty"`
}
const (
@@ -439,12 +440,21 @@ type TopSongs struct {
}
type PlayQueue struct {
- Entry []Child `xml:"entry,omitempty" json:"entry,omitempty"`
- Current string `xml:"current,attr,omitempty" json:"current,omitempty"`
- Position int64 `xml:"position,attr,omitempty" json:"position,omitempty"`
- Username string `xml:"username,attr" json:"username"`
- Changed *time.Time `xml:"changed,attr,omitempty" json:"changed,omitempty"`
- ChangedBy string `xml:"changedBy,attr" json:"changedBy"`
+ Entry []Child `xml:"entry,omitempty" json:"entry,omitempty"`
+ Current string `xml:"current,attr,omitempty" json:"current,omitempty"`
+ Position int64 `xml:"position,attr,omitempty" json:"position,omitempty"`
+ Username string `xml:"username,attr" json:"username"`
+ Changed time.Time `xml:"changed,attr" json:"changed"`
+ ChangedBy string `xml:"changedBy,attr" json:"changedBy"`
+}
+
+type PlayQueueByIndex struct {
+ Entry []Child `xml:"entry,omitempty" json:"entry,omitempty"`
+ CurrentIndex *int `xml:"currentIndex,attr,omitempty" json:"currentIndex,omitempty"`
+ Position int64 `xml:"position,attr,omitempty" json:"position,omitempty"`
+ Username string `xml:"username,attr" json:"username"`
+ Changed time.Time `xml:"changed,attr" json:"changed"`
+ ChangedBy string `xml:"changedBy,attr" json:"changedBy"`
}
type Bookmark struct {
diff --git a/server/subsonic/responses/responses_test.go b/server/subsonic/responses/responses_test.go
index 7238665cf..2ee8e080d 100644
--- a/server/subsonic/responses/responses_test.go
+++ b/server/subsonic/responses/responses_test.go
@@ -768,7 +768,7 @@ var _ = Describe("Responses", func() {
response.PlayQueue.Username = "user1"
response.PlayQueue.Current = "111"
response.PlayQueue.Position = 243
- response.PlayQueue.Changed = &time.Time{}
+ response.PlayQueue.Changed = time.Time{}
response.PlayQueue.ChangedBy = "a_client"
child := make([]Child, 1)
child[0] = Child{Id: "1", Title: "title", IsDir: false}
@@ -783,6 +783,40 @@ var _ = Describe("Responses", func() {
})
})
+ Describe("PlayQueueByIndex", func() {
+ BeforeEach(func() {
+ response.PlayQueueByIndex = &PlayQueueByIndex{}
+ })
+
+ Context("without data", func() {
+ It("should match .XML", func() {
+ Expect(xml.MarshalIndent(response, "", " ")).To(MatchSnapshot())
+ })
+ It("should match .JSON", func() {
+ Expect(json.MarshalIndent(response, "", " ")).To(MatchSnapshot())
+ })
+ })
+
+ Context("with data", func() {
+ BeforeEach(func() {
+ response.PlayQueueByIndex.Username = "user1"
+ response.PlayQueueByIndex.CurrentIndex = gg.P(0)
+ response.PlayQueueByIndex.Position = 243
+ response.PlayQueueByIndex.Changed = time.Time{}
+ response.PlayQueueByIndex.ChangedBy = "a_client"
+ child := make([]Child, 1)
+ child[0] = Child{Id: "1", Title: "title", IsDir: false}
+ response.PlayQueueByIndex.Entry = child
+ })
+ It("should match .XML", func() {
+ Expect(xml.MarshalIndent(response, "", " ")).To(MatchSnapshot())
+ })
+ It("should match .JSON", func() {
+ Expect(json.MarshalIndent(response, "", " ")).To(MatchSnapshot())
+ })
+ })
+ })
+
Describe("Shares", func() {
BeforeEach(func() {
response.Shares = &Shares{}
diff --git a/tests/fixtures/lastfm.artist.page.html b/tests/fixtures/lastfm.artist.page.html
new file mode 100644
index 000000000..1922e313b
--- /dev/null
+++ b/tests/fixtures/lastfm.artist.page.html
@@ -0,0 +1,7 @@
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/fixtures/lastfm.artist.page.ignored.html b/tests/fixtures/lastfm.artist.page.ignored.html
new file mode 100644
index 000000000..96eda2377
--- /dev/null
+++ b/tests/fixtures/lastfm.artist.page.ignored.html
@@ -0,0 +1,7 @@
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/fixtures/lastfm.artist.page.no_meta.html b/tests/fixtures/lastfm.artist.page.no_meta.html
new file mode 100644
index 000000000..aa7b9c934
--- /dev/null
+++ b/tests/fixtures/lastfm.artist.page.no_meta.html
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/mock_data_store.go b/tests/mock_data_store.go
index 56f68a74b..ba586ab53 100644
--- a/tests/mock_data_store.go
+++ b/tests/mock_data_store.go
@@ -28,6 +28,10 @@ type MockDataStore struct {
MockedRadio model.RadioRepository
scrobbleBufferMu sync.Mutex
repoMu sync.Mutex
+
+ // GC tracking
+ GCCalled bool
+ GCError error
}
func (db *MockDataStore) Library(ctx context.Context) model.LibraryRepository {
@@ -258,6 +262,10 @@ func (db *MockDataStore) Resource(ctx context.Context, m any) model.ResourceRepo
}
}
-func (db *MockDataStore) GC(context.Context) error {
+func (db *MockDataStore) GC(context.Context, ...int) error {
+ db.GCCalled = true
+ if db.GCError != nil {
+ return db.GCError
+ }
return nil
}
diff --git a/tests/mock_scanner.go b/tests/mock_scanner.go
new file mode 100644
index 000000000..52396723f
--- /dev/null
+++ b/tests/mock_scanner.go
@@ -0,0 +1,120 @@
+package tests
+
+import (
+ "context"
+ "sync"
+
+ "github.com/navidrome/navidrome/model"
+)
+
+// MockScanner implements scanner.Scanner for testing with proper synchronization
+type MockScanner struct {
+ mu sync.Mutex
+ scanAllCalls []ScanAllCall
+ scanFoldersCalls []ScanFoldersCall
+ scanningStatus bool
+ statusResponse *model.ScannerStatus
+}
+
+type ScanAllCall struct {
+ FullScan bool
+}
+
+type ScanFoldersCall struct {
+ FullScan bool
+ Targets []model.ScanTarget
+}
+
+func NewMockScanner() *MockScanner {
+ return &MockScanner{
+ scanAllCalls: make([]ScanAllCall, 0),
+ scanFoldersCalls: make([]ScanFoldersCall, 0),
+ }
+}
+
+func (m *MockScanner) ScanAll(_ context.Context, fullScan bool) ([]string, error) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+
+ m.scanAllCalls = append(m.scanAllCalls, ScanAllCall{FullScan: fullScan})
+
+ return nil, nil
+}
+
+func (m *MockScanner) ScanFolders(_ context.Context, fullScan bool, targets []model.ScanTarget) ([]string, error) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+
+ // Make a copy of targets to avoid race conditions
+ targetsCopy := make([]model.ScanTarget, len(targets))
+ copy(targetsCopy, targets)
+
+ m.scanFoldersCalls = append(m.scanFoldersCalls, ScanFoldersCall{
+ FullScan: fullScan,
+ Targets: targetsCopy,
+ })
+
+ return nil, nil
+}
+
+func (m *MockScanner) Status(_ context.Context) (*model.ScannerStatus, error) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+
+ if m.statusResponse != nil {
+ return m.statusResponse, nil
+ }
+
+ return &model.ScannerStatus{
+ Scanning: m.scanningStatus,
+ }, nil
+}
+
+func (m *MockScanner) GetScanAllCallCount() int {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ return len(m.scanAllCalls)
+}
+
+func (m *MockScanner) GetScanAllCalls() []ScanAllCall {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ // Return a copy to avoid race conditions
+ calls := make([]ScanAllCall, len(m.scanAllCalls))
+ copy(calls, m.scanAllCalls)
+ return calls
+}
+
+func (m *MockScanner) GetScanFoldersCallCount() int {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ return len(m.scanFoldersCalls)
+}
+
+func (m *MockScanner) GetScanFoldersCalls() []ScanFoldersCall {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ // Return a copy to avoid race conditions
+ calls := make([]ScanFoldersCall, len(m.scanFoldersCalls))
+ copy(calls, m.scanFoldersCalls)
+ return calls
+}
+
+func (m *MockScanner) Reset() {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ m.scanAllCalls = make([]ScanAllCall, 0)
+ m.scanFoldersCalls = make([]ScanFoldersCall, 0)
+}
+
+func (m *MockScanner) SetScanning(scanning bool) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ m.scanningStatus = scanning
+}
+
+func (m *MockScanner) SetStatusResponse(status *model.ScannerStatus) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ m.statusResponse = status
+}
diff --git a/tests/test_helpers.go b/tests/test_helpers.go
index 1251c90cd..0a2cad4ad 100644
--- a/tests/test_helpers.go
+++ b/tests/test_helpers.go
@@ -6,7 +6,10 @@ import (
"path/filepath"
"github.com/navidrome/navidrome/db"
+ "github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model/id"
+ "github.com/sirupsen/logrus"
+ "github.com/sirupsen/logrus/hooks/test"
)
type testingT interface {
@@ -35,3 +38,23 @@ func ClearDB() error {
`)
return err
}
+
+// LogHook sets up a logrus test hook and configures the default logger to use it.
+// It returns the hook and a cleanup function to restore the default logger.
+// Example usage:
+//
+// hook, cleanup := LogHook()
+// defer cleanup()
+// // ... perform logging operations ...
+// Expect(hook.LastEntry()).ToNot(BeNil())
+// Expect(hook.LastEntry().Level).To(Equal(logrus.WarnLevel))
+// Expect(hook.LastEntry().Message).To(Equal("log message"))
+func LogHook() (*test.Hook, func()) {
+ l, hook := test.NewNullLogger()
+ log.SetLevel(log.LevelWarn)
+ log.SetDefaultLogger(l)
+ return hook, func() {
+ // Restore default logger after test
+ log.SetDefaultLogger(logrus.New())
+ }
+}
diff --git a/ui/src/album/AlbumDetails.test.jsx b/ui/src/album/AlbumDetails.test.jsx
index e03022677..484045444 100644
--- a/ui/src/album/AlbumDetails.test.jsx
+++ b/ui/src/album/AlbumDetails.test.jsx
@@ -14,6 +14,24 @@ vi.mock('@material-ui/core', async () => {
}
})
+// Mock formatFullDate to return deterministic results
+vi.mock('../utils', async () => {
+ const actual = await import('../utils')
+ return {
+ ...actual,
+ formatFullDate: (date) => {
+ if (!date) return ''
+ // Use en-CA locale for consistent test results
+ return new Date(date).toLocaleDateString('en-CA', {
+ year: 'numeric',
+ month: 'short',
+ day: 'numeric',
+ timeZone: 'UTC',
+ })
+ },
+ }
+})
+
describe('Details component', () => {
describe('Desktop view', () => {
beforeEach(() => {
diff --git a/ui/src/dataProvider/wrapperDataProvider.js b/ui/src/dataProvider/wrapperDataProvider.js
index 8b4a0cb62..268d3668d 100644
--- a/ui/src/dataProvider/wrapperDataProvider.js
+++ b/ui/src/dataProvider/wrapperDataProvider.js
@@ -12,7 +12,21 @@ const isAdmin = () => {
const getSelectedLibraries = () => {
try {
const state = JSON.parse(localStorage.getItem('state'))
- return state?.library?.selectedLibraries || []
+ const selectedLibraries = state?.library?.selectedLibraries || []
+ const userLibraries = state?.library?.userLibraries || []
+
+ // Validate selected libraries against current user libraries
+ const userLibraryIds = userLibraries.map((lib) => lib.id)
+ const validatedSelection = selectedLibraries.filter((id) =>
+ userLibraryIds.includes(id),
+ )
+
+ // If user has only one library, return empty array (no filter needed)
+ if (userLibraryIds.length === 1) {
+ return []
+ }
+
+ return validatedSelection
} catch (err) {
return []
}
diff --git a/ui/src/i18n/en.json b/ui/src/i18n/en.json
index 4a9039a67..9ef65d668 100644
--- a/ui/src/i18n/en.json
+++ b/ui/src/i18n/en.json
@@ -302,6 +302,8 @@
},
"actions": {
"scan": "Scan Library",
+ "quickScan": "Quick Scan",
+ "fullScan": "Full Scan",
"manageUsers": "Manage User Access",
"viewDetails": "View Details"
},
@@ -310,6 +312,9 @@
"updated": "Library updated successfully",
"deleted": "Library deleted successfully",
"scanStarted": "Library scan started",
+ "quickScanStarted": "Quick scan started",
+ "fullScanStarted": "Full scan started",
+ "scanError": "Error starting scan. Check logs",
"scanCompleted": "Library scan completed"
},
"validation": {
@@ -600,11 +605,12 @@
"activity": {
"title": "Activity",
"totalScanned": "Total Folders Scanned",
- "quickScan": "Quick Scan",
- "fullScan": "Full Scan",
+ "quickScan": "Quick",
+ "fullScan": "Full",
+ "selectiveScan": "Selective",
"serverUptime": "Server Uptime",
"serverDown": "OFFLINE",
- "scanType": "Type",
+ "scanType": "Last Scan",
"status": "Scan Error",
"elapsedTime": "Elapsed Time"
},
diff --git a/ui/src/layout/ActivityPanel.jsx b/ui/src/layout/ActivityPanel.jsx
index 18af8dc93..6d5d32d31 100644
--- a/ui/src/layout/ActivityPanel.jsx
+++ b/ui/src/layout/ActivityPanel.jsx
@@ -113,6 +113,9 @@ const ActivityPanel = () => {
return translate('activity.fullScan')
case 'quick':
return translate('activity.quickScan')
+ case 'full-selective':
+ case 'quick-selective':
+ return translate('activity.selectiveScan')
default:
return ''
}
diff --git a/ui/src/library/LibraryEdit.jsx b/ui/src/library/LibraryEdit.jsx
index 3d981b076..7e89c892c 100644
--- a/ui/src/library/LibraryEdit.jsx
+++ b/ui/src/library/LibraryEdit.jsx
@@ -169,7 +169,7 @@ const LibraryEdit = (props) => {
resource={'library'}
source={'totalSize'}
label={translate('resources.library.fields.totalSize')}
- format={formatBytes}
+ format={(v) => formatBytes(v, 2)}
fullWidth
variant="outlined"
/>
diff --git a/ui/src/library/LibraryList.jsx b/ui/src/library/LibraryList.jsx
index c2d2f6295..aa1294882 100644
--- a/ui/src/library/LibraryList.jsx
+++ b/ui/src/library/LibraryList.jsx
@@ -9,7 +9,9 @@ import {
BooleanField,
} from 'react-admin'
import { useMediaQuery } from '@material-ui/core'
-import { List, DateField, useResourceRefresh } from '../common'
+import { List, DateField, useResourceRefresh, SizeField } from '../common'
+import LibraryListBulkActions from './LibraryListBulkActions'
+import LibraryListActions from './LibraryListActions'
const LibraryFilter = (props) => (
@@ -26,8 +28,9 @@ const LibraryList = (props) => {
{...props}
sort={{ field: 'name', order: 'ASC' }}
exporter={false}
- bulkActionButtons={false}
+ bulkActionButtons={!isXsmall && }
filters={}
+ actions={}
>
{isXsmall ? (
{
-
-
-
-
+
+
+
+
+
)}
diff --git a/ui/src/library/LibraryListActions.jsx b/ui/src/library/LibraryListActions.jsx
new file mode 100644
index 000000000..f4d0913df
--- /dev/null
+++ b/ui/src/library/LibraryListActions.jsx
@@ -0,0 +1,31 @@
+import React, { cloneElement } from 'react'
+import { sanitizeListRestProps, TopToolbar, CreateButton } from 'react-admin'
+import LibraryScanButton from './LibraryScanButton'
+
+const LibraryListActions = ({
+ className,
+ filters,
+ resource,
+ showFilter,
+ displayedFilters,
+ filterValues,
+ ...rest
+}) => {
+ return (
+
+ {filters &&
+ cloneElement(filters, {
+ resource,
+ showFilter,
+ displayedFilters,
+ filterValues,
+ context: 'button',
+ })}
+
+
+
+
+ )
+}
+
+export default LibraryListActions
diff --git a/ui/src/library/LibraryListBulkActions.jsx b/ui/src/library/LibraryListBulkActions.jsx
new file mode 100644
index 000000000..8862a4f51
--- /dev/null
+++ b/ui/src/library/LibraryListBulkActions.jsx
@@ -0,0 +1,11 @@
+import React from 'react'
+import LibraryScanButton from './LibraryScanButton'
+
+const LibraryListBulkActions = (props) => (
+ <>
+
+
+
+)
+
+export default LibraryListBulkActions
diff --git a/ui/src/library/LibraryScanButton.jsx b/ui/src/library/LibraryScanButton.jsx
new file mode 100644
index 000000000..50d90e615
--- /dev/null
+++ b/ui/src/library/LibraryScanButton.jsx
@@ -0,0 +1,77 @@
+import React, { useState } from 'react'
+import PropTypes from 'prop-types'
+import {
+ Button,
+ useNotify,
+ useRefresh,
+ useTranslate,
+ useUnselectAll,
+} from 'react-admin'
+import { useSelector } from 'react-redux'
+import SyncIcon from '@material-ui/icons/Sync'
+import CachedIcon from '@material-ui/icons/Cached'
+import subsonic from '../subsonic'
+
+const LibraryScanButton = ({ fullScan, selectedIds, className }) => {
+ const [loading, setLoading] = useState(false)
+ const notify = useNotify()
+ const refresh = useRefresh()
+ const translate = useTranslate()
+ const unselectAll = useUnselectAll()
+ const scanStatus = useSelector((state) => state.activity.scanStatus)
+
+ const handleClick = async () => {
+ setLoading(true)
+ try {
+ // Build scan options
+ const options = { fullScan }
+
+ // If specific libraries are selected, scan only those
+ // Format: "libraryID:" to scan entire library (no folder path specified)
+ if (selectedIds && selectedIds.length > 0) {
+ options.target = selectedIds.map((id) => `${id}:`)
+ }
+
+ await subsonic.startScan(options)
+ const notificationKey = fullScan
+ ? 'resources.library.notifications.fullScanStarted'
+ : 'resources.library.notifications.quickScanStarted'
+ notify(notificationKey, 'info')
+ refresh()
+
+ // Unselect all items after successful scan
+ unselectAll('library')
+ } catch (error) {
+ notify('resources.library.notifications.scanError', 'warning')
+ } finally {
+ setLoading(false)
+ }
+ }
+
+ const isDisabled = loading || scanStatus.scanning
+
+ const label = fullScan
+ ? translate('resources.library.actions.fullScan')
+ : translate('resources.library.actions.quickScan')
+
+ const icon = fullScan ? :
+
+ return (
+
+ )
+}
+
+LibraryScanButton.propTypes = {
+ fullScan: PropTypes.bool.isRequired,
+ selectedIds: PropTypes.array,
+ className: PropTypes.string,
+}
+
+export default LibraryScanButton
diff --git a/ui/src/reducers/libraryReducer.js b/ui/src/reducers/libraryReducer.js
index 7cda10bcf..ef613260f 100644
--- a/ui/src/reducers/libraryReducer.js
+++ b/ui/src/reducers/libraryReducer.js
@@ -8,18 +8,39 @@ const initialState = {
export const libraryReducer = (previousState = initialState, payload) => {
const { type, data } = payload
switch (type) {
- case SET_USER_LIBRARIES:
+ case SET_USER_LIBRARIES: {
+ const newUserLibraryIds = data.map((lib) => lib.id)
+
+ // Validate and filter selected libraries to only include IDs that exist in new user libraries
+ const validatedSelection = previousState.selectedLibraries.filter((id) =>
+ newUserLibraryIds.includes(id),
+ )
+
+ // Determine the final selection:
+ // 1. If first time setting libraries (no previous user libraries), select all
+ // 2. If user now has only one library, reset to empty (no filter needed)
+ // 3. Otherwise, use validated selection (may be empty if all previous selections were invalid)
+ let finalSelection
+ if (
+ previousState.selectedLibraries.length === 0 &&
+ previousState.userLibraries.length === 0
+ ) {
+ // First time: select all libraries
+ finalSelection = newUserLibraryIds
+ } else if (newUserLibraryIds.length === 1) {
+ // Single library: reset selection (empty means "all accessible")
+ finalSelection = []
+ } else {
+ // Multiple libraries: use validated selection
+ finalSelection = validatedSelection
+ }
+
return {
...previousState,
userLibraries: data,
- // If this is the first time setting user libraries and no selection exists,
- // default to all libraries
- selectedLibraries:
- previousState.selectedLibraries.length === 0 &&
- previousState.userLibraries.length === 0
- ? data.map((lib) => lib.id)
- : previousState.selectedLibraries,
+ selectedLibraries: finalSelection,
}
+ }
case SET_SELECTED_LIBRARIES:
return {
...previousState,
diff --git a/ui/src/reducers/libraryReducer.test.js b/ui/src/reducers/libraryReducer.test.js
new file mode 100644
index 000000000..b962c1036
--- /dev/null
+++ b/ui/src/reducers/libraryReducer.test.js
@@ -0,0 +1,186 @@
+import { describe, it, expect } from 'vitest'
+import { libraryReducer } from './libraryReducer'
+import { SET_SELECTED_LIBRARIES, SET_USER_LIBRARIES } from '../actions'
+
+describe('libraryReducer', () => {
+ const mockLibraries = [
+ { id: '1', name: 'Music Library' },
+ { id: '2', name: 'Podcasts' },
+ { id: '3', name: 'Audiobooks' },
+ ]
+
+ const initialState = {
+ userLibraries: [],
+ selectedLibraries: [],
+ }
+
+ describe('SET_USER_LIBRARIES', () => {
+ it('should set user libraries and select all on first load', () => {
+ const action = {
+ type: SET_USER_LIBRARIES,
+ data: mockLibraries,
+ }
+
+ const result = libraryReducer(initialState, action)
+
+ expect(result.userLibraries).toEqual(mockLibraries)
+ expect(result.selectedLibraries).toEqual(['1', '2', '3'])
+ })
+
+ it('should reset selection to empty when user has only one library', () => {
+ const previousState = {
+ userLibraries: mockLibraries,
+ selectedLibraries: ['1', '2'],
+ }
+
+ const action = {
+ type: SET_USER_LIBRARIES,
+ data: [mockLibraries[0]], // Only one library now
+ }
+
+ const result = libraryReducer(previousState, action)
+
+ expect(result.userLibraries).toEqual([mockLibraries[0]])
+ expect(result.selectedLibraries).toEqual([]) // Reset for single library
+ })
+
+ it('should filter out invalid library IDs from selection', () => {
+ const previousState = {
+ userLibraries: mockLibraries,
+ selectedLibraries: ['1', '2', '3'],
+ }
+
+ const action = {
+ type: SET_USER_LIBRARIES,
+ data: [mockLibraries[0], mockLibraries[1]], // Only libraries 1 and 2 remain
+ }
+
+ const result = libraryReducer(previousState, action)
+
+ expect(result.userLibraries).toEqual([mockLibraries[0], mockLibraries[1]])
+ expect(result.selectedLibraries).toEqual(['1', '2']) // Library 3 removed
+ })
+
+ it('should keep valid selection when libraries change', () => {
+ const previousState = {
+ userLibraries: mockLibraries,
+ selectedLibraries: ['1'],
+ }
+
+ const action = {
+ type: SET_USER_LIBRARIES,
+ data: mockLibraries, // Same libraries
+ }
+
+ const result = libraryReducer(previousState, action)
+
+ expect(result.userLibraries).toEqual(mockLibraries)
+ expect(result.selectedLibraries).toEqual(['1']) // Selection preserved
+ })
+
+ it('should handle selection becoming empty after filtering invalid IDs', () => {
+ const previousState = {
+ userLibraries: mockLibraries,
+ selectedLibraries: ['1', '2'],
+ }
+
+ const newLibraries = [{ id: '4', name: 'New Library' }]
+ const action = {
+ type: SET_USER_LIBRARIES,
+ data: newLibraries,
+ }
+
+ const result = libraryReducer(previousState, action)
+
+ expect(result.userLibraries).toEqual(newLibraries)
+ expect(result.selectedLibraries).toEqual([]) // All selected IDs were invalid
+ })
+
+ it('should handle transition from multiple to single library with invalid selection', () => {
+ const previousState = {
+ userLibraries: mockLibraries,
+ selectedLibraries: ['2', '3'], // User had libraries 2 and 3 selected
+ }
+
+ const action = {
+ type: SET_USER_LIBRARIES,
+ data: [mockLibraries[0]], // Now only has access to library 1
+ }
+
+ const result = libraryReducer(previousState, action)
+
+ expect(result.userLibraries).toEqual([mockLibraries[0]])
+ expect(result.selectedLibraries).toEqual([]) // Reset for single library
+ })
+
+ it('should handle empty library list', () => {
+ const previousState = {
+ userLibraries: mockLibraries,
+ selectedLibraries: ['1', '2'],
+ }
+
+ const action = {
+ type: SET_USER_LIBRARIES,
+ data: [],
+ }
+
+ const result = libraryReducer(previousState, action)
+
+ expect(result.userLibraries).toEqual([])
+ expect(result.selectedLibraries).toEqual([]) // All selections filtered out
+ })
+ })
+
+ describe('SET_SELECTED_LIBRARIES', () => {
+ it('should update selected libraries', () => {
+ const previousState = {
+ userLibraries: mockLibraries,
+ selectedLibraries: ['1'],
+ }
+
+ const action = {
+ type: SET_SELECTED_LIBRARIES,
+ data: ['2', '3'],
+ }
+
+ const result = libraryReducer(previousState, action)
+
+ expect(result.selectedLibraries).toEqual(['2', '3'])
+ expect(result.userLibraries).toEqual(mockLibraries) // Unchanged
+ })
+
+ it('should allow setting empty selection', () => {
+ const previousState = {
+ userLibraries: mockLibraries,
+ selectedLibraries: ['1', '2'],
+ }
+
+ const action = {
+ type: SET_SELECTED_LIBRARIES,
+ data: [],
+ }
+
+ const result = libraryReducer(previousState, action)
+
+ expect(result.selectedLibraries).toEqual([])
+ })
+ })
+
+ describe('unknown action', () => {
+ it('should return previous state for unknown action', () => {
+ const previousState = {
+ userLibraries: mockLibraries,
+ selectedLibraries: ['1'],
+ }
+
+ const action = {
+ type: 'UNKNOWN_ACTION',
+ data: null,
+ }
+
+ const result = libraryReducer(previousState, action)
+
+ expect(result).toBe(previousState) // Same reference
+ })
+ })
+})
diff --git a/ui/src/subsonic/index.js b/ui/src/subsonic/index.js
index ad7a391e0..cfcc01043 100644
--- a/ui/src/subsonic/index.js
+++ b/ui/src/subsonic/index.js
@@ -23,7 +23,13 @@ const url = (command, id, options) => {
delete options.ts
}
Object.keys(options).forEach((k) => {
- params.append(k, options[k])
+ const value = options[k]
+ // Handle array parameters by appending each value separately
+ if (Array.isArray(value)) {
+ value.forEach((v) => params.append(k, v))
+ } else {
+ params.append(k, value)
+ }
})
}
return `/rest/${command}?${params.toString()}`
diff --git a/ui/src/themes/dark.js b/ui/src/themes/dark.js
index 2f06b4337..15d8aa365 100644
--- a/ui/src/themes/dark.js
+++ b/ui/src/themes/dark.js
@@ -16,6 +16,11 @@ export default {
color: 'white',
},
},
+ MuiButton: {
+ textPrimary: {
+ color: '#fff',
+ },
+ },
NDLogin: {
systemNameLink: {
color: '#0085ff',
diff --git a/ui/src/themes/ligera.js b/ui/src/themes/ligera.js
index 0ef1601a2..363a379bc 100644
--- a/ui/src/themes/ligera.js
+++ b/ui/src/themes/ligera.js
@@ -70,7 +70,7 @@ export default {
},
background: {
default: '#f0f2f5',
- paper: 'inherit',
+ paper: bLight['500'],
},
text: {
secondary: '#232323',
@@ -448,6 +448,11 @@ export default {
backgroundColor: bLight['500'],
},
},
+ RaButton: {
+ button: {
+ margin: '0 5px 0 5px',
+ },
+ },
RaPaginationActions: {
button: {
backgroundColor: '#fff',
diff --git a/ui/src/themes/spotify.js b/ui/src/themes/spotify.js
index c40ed20aa..725831cc7 100644
--- a/ui/src/themes/spotify.js
+++ b/ui/src/themes/spotify.js
@@ -389,6 +389,11 @@ export default {
marginRight: '1rem',
},
},
+ RaButton: {
+ button: {
+ margin: '0 5px 0 5px',
+ },
+ },
RaPaginationActions: {
currentPageButton: {
border: '1px solid #b3b3b3',
diff --git a/ui/src/utils/formatters.js b/ui/src/utils/formatters.js
index 74cce6e15..cfcb84b05 100644
--- a/ui/src/utils/formatters.js
+++ b/ui/src/utils/formatters.js
@@ -95,7 +95,7 @@ export const formatFullDate = (date, locale) => {
return new Date(date).toLocaleDateString(locale, options)
}
-export const formatNumber = (value) => {
+export const formatNumber = (value, locale) => {
if (value === null || value === undefined) return '0'
- return value.toLocaleString()
+ return value.toLocaleString(locale)
}
diff --git a/ui/src/utils/formatters.test.js b/ui/src/utils/formatters.test.js
index 7709dd91b..d633e96f2 100644
--- a/ui/src/utils/formatters.test.js
+++ b/ui/src/utils/formatters.test.js
@@ -121,35 +121,35 @@ describe('formatDuration2', () => {
describe('formatNumber', () => {
it('handles null and undefined values', () => {
- expect(formatNumber(null)).toEqual('0')
- expect(formatNumber(undefined)).toEqual('0')
+ expect(formatNumber(null, 'en-CA')).toEqual('0')
+ expect(formatNumber(undefined, 'en-CA')).toEqual('0')
})
it('formats integers', () => {
- expect(formatNumber(0)).toEqual('0')
- expect(formatNumber(1)).toEqual('1')
- expect(formatNumber(123)).toEqual('123')
- expect(formatNumber(1000)).toEqual('1,000')
- expect(formatNumber(1234567)).toEqual('1,234,567')
+ expect(formatNumber(0, 'en-CA')).toEqual('0')
+ expect(formatNumber(1, 'en-CA')).toEqual('1')
+ expect(formatNumber(123, 'en-CA')).toEqual('123')
+ expect(formatNumber(1000, 'en-CA')).toEqual('1,000')
+ expect(formatNumber(1234567, 'en-CA')).toEqual('1,234,567')
})
it('formats decimal numbers', () => {
- expect(formatNumber(123.45)).toEqual('123.45')
- expect(formatNumber(1234.567)).toEqual('1,234.567')
+ expect(formatNumber(123.45, 'en-CA')).toEqual('123.45')
+ expect(formatNumber(1234.567, 'en-CA')).toEqual('1,234.567')
})
it('formats negative numbers', () => {
- expect(formatNumber(-123)).toEqual('-123')
- expect(formatNumber(-1234)).toEqual('-1,234')
- expect(formatNumber(-123.45)).toEqual('-123.45')
+ expect(formatNumber(-123, 'en-CA')).toEqual('-123')
+ expect(formatNumber(-1234, 'en-CA')).toEqual('-1,234')
+ expect(formatNumber(-123.45, 'en-CA')).toEqual('-123.45')
})
})
describe('formatFullDate', () => {
it('format dates', () => {
- expect(formatFullDate('2011', 'en-US')).toEqual('2011')
- expect(formatFullDate('2011-06', 'en-US')).toEqual('Jun 2011')
- expect(formatFullDate('1985-01-01', 'en-US')).toEqual('Jan 1, 1985')
+ expect(formatFullDate('2011', 'en-CA')).toEqual('2011')
+ expect(formatFullDate('2011-06', 'en-CA')).toEqual('Jun 2011')
+ expect(formatFullDate('1985-01-01', 'en-CA')).toEqual('Jan 1, 1985')
expect(formatFullDate('199704')).toEqual('')
})
})
diff --git a/utils/slice/slice.go b/utils/slice/slice.go
index 1d7c64f50..b1f50afcc 100644
--- a/utils/slice/slice.go
+++ b/utils/slice/slice.go
@@ -171,3 +171,14 @@ func SeqFunc[I, O any](s []I, f func(I) O) iter.Seq[O] {
}
}
}
+
+// Filter returns a new slice containing only the elements of s for which filterFunc returns true
+func Filter[T any](s []T, filterFunc func(T) bool) []T {
+ var result []T
+ for _, item := range s {
+ if filterFunc(item) {
+ result = append(result, item)
+ }
+ }
+ return result
+}
diff --git a/utils/slice/slice_test.go b/utils/slice/slice_test.go
index c6d4be1e0..65e5f0934 100644
--- a/utils/slice/slice_test.go
+++ b/utils/slice/slice_test.go
@@ -172,4 +172,42 @@ var _ = Describe("Slice Utils", func() {
Expect(result).To(ConsistOf("2", "4", "6", "8"))
})
})
+
+ Describe("Filter", func() {
+ It("returns empty slice for an empty input", func() {
+ filterFunc := func(v int) bool { return v > 0 }
+ result := slice.Filter([]int{}, filterFunc)
+ Expect(result).To(BeEmpty())
+ })
+
+ It("returns all elements when filter matches all", func() {
+ filterFunc := func(v int) bool { return v > 0 }
+ result := slice.Filter([]int{1, 2, 3, 4}, filterFunc)
+ Expect(result).To(HaveExactElements(1, 2, 3, 4))
+ })
+
+ It("returns empty slice when filter matches none", func() {
+ filterFunc := func(v int) bool { return v > 10 }
+ result := slice.Filter([]int{1, 2, 3, 4}, filterFunc)
+ Expect(result).To(BeEmpty())
+ })
+
+ It("returns only matching elements", func() {
+ filterFunc := func(v int) bool { return v%2 == 0 }
+ result := slice.Filter([]int{1, 2, 3, 4, 5, 6}, filterFunc)
+ Expect(result).To(HaveExactElements(2, 4, 6))
+ })
+
+ It("works with string slices", func() {
+ filterFunc := func(s string) bool { return len(s) > 3 }
+ result := slice.Filter([]string{"a", "abc", "abcd", "ab", "abcde"}, filterFunc)
+ Expect(result).To(HaveExactElements("abcd", "abcde"))
+ })
+
+ It("preserves order of elements", func() {
+ filterFunc := func(v int) bool { return v%2 == 1 }
+ result := slice.Filter([]int{9, 8, 7, 6, 5, 4, 3, 2, 1}, filterFunc)
+ Expect(result).To(HaveExactElements(9, 7, 5, 3, 1))
+ })
+ })
})
diff --git a/utils/str/str.go b/utils/str/str.go
index 8a94488de..f662473da 100644
--- a/utils/str/str.go
+++ b/utils/str/str.go
@@ -2,6 +2,7 @@ package str
import (
"strings"
+ "unicode/utf8"
)
var utf8ToAscii = func() *strings.Replacer {
@@ -39,3 +40,25 @@ func LongestCommonPrefix(list []string) string {
}
return list[0]
}
+
+// TruncateRunes truncates a string to a maximum number of runes, adding a suffix if truncated.
+// The suffix is included in the rune count, so if maxRunes is 30 and suffix is "...", the actual
+// string content will be truncated to fit within the maxRunes limit including the suffix.
+func TruncateRunes(s string, maxRunes int, suffix string) string {
+ if utf8.RuneCountInString(s) <= maxRunes {
+ return s
+ }
+
+ suffixRunes := utf8.RuneCountInString(suffix)
+ truncateAt := maxRunes - suffixRunes
+ if truncateAt < 0 {
+ truncateAt = 0
+ }
+
+ runes := []rune(s)
+ if truncateAt >= len(runes) {
+ return s + suffix
+ }
+
+ return string(runes[:truncateAt]) + suffix
+}
diff --git a/utils/str/str_test.go b/utils/str/str_test.go
index 0c3524e4e..511805831 100644
--- a/utils/str/str_test.go
+++ b/utils/str/str_test.go
@@ -31,6 +31,72 @@ var _ = Describe("String Utils", func() {
Expect(str.LongestCommonPrefix(albums)).To(Equal("/artist/album"))
})
})
+
+ Describe("TruncateRunes", func() {
+ It("returns string unchanged if under max runes", func() {
+ Expect(str.TruncateRunes("hello", 10, "...")).To(Equal("hello"))
+ })
+
+ It("returns string unchanged if exactly at max runes", func() {
+ Expect(str.TruncateRunes("hello", 5, "...")).To(Equal("hello"))
+ })
+
+ It("truncates and adds suffix when over max runes", func() {
+ Expect(str.TruncateRunes("hello world", 8, "...")).To(Equal("hello..."))
+ })
+
+ It("handles unicode characters correctly", func() {
+ // 6 emoji characters, maxRunes=5, suffix="..." (3 runes)
+ // So content gets 5-3=2 runes
+ Expect(str.TruncateRunes("😀😁😂😃😄😅", 5, "...")).To(Equal("😀😁..."))
+ })
+
+ It("handles multi-byte UTF-8 characters", func() {
+ // Characters like é are single runes
+ Expect(str.TruncateRunes("Café au Lait", 5, "...")).To(Equal("Ca..."))
+ })
+
+ It("works with empty suffix", func() {
+ Expect(str.TruncateRunes("hello world", 5, "")).To(Equal("hello"))
+ })
+
+ It("accounts for suffix length in truncation", func() {
+ // maxRunes=10, suffix="..." (3 runes) -> leaves 7 runes for content
+ result := str.TruncateRunes("hello world this is long", 10, "...")
+ Expect(result).To(Equal("hello w..."))
+ // Verify total rune count is <= maxRunes
+ runeCount := len([]rune(result))
+ Expect(runeCount).To(BeNumerically("<=", 10))
+ })
+
+ It("handles very long suffix gracefully", func() {
+ // If suffix is longer than maxRunes, we still add it
+ // but the content will be truncated to 0
+ result := str.TruncateRunes("hello world", 5, "... (truncated)")
+ // Result will be just the suffix (since truncateAt=0)
+ Expect(result).To(Equal("... (truncated)"))
+ })
+
+ It("handles empty string", func() {
+ Expect(str.TruncateRunes("", 10, "...")).To(Equal(""))
+ })
+
+ It("uses custom suffix", func() {
+ // maxRunes=11, suffix=" [...]" (6 runes) -> content gets 5 runes
+ // "hello world" is 11 runes exactly, so we need a longer string
+ Expect(str.TruncateRunes("hello world extra", 11, " [...]")).To(Equal("hello [...]"))
+ })
+
+ DescribeTable("truncates at rune boundaries (not byte boundaries)",
+ func(input string, maxRunes int, suffix string, expected string) {
+ Expect(str.TruncateRunes(input, maxRunes, suffix)).To(Equal(expected))
+ },
+ Entry("ASCII", "abcdefghij", 5, "...", "ab..."),
+ Entry("Mixed ASCII and Unicode", "ab😀cd", 4, ".", "ab😀."),
+ Entry("All emoji", "😀😁😂😃😄", 3, "…", "😀😁…"),
+ Entry("Japanese", "こんにちは世界", 3, "…", "こん…"),
+ )
+ })
})
var testPaths = []string{