Skip to content

🎧 Your Personal Streaming Service

Add scanner status

Deluanaf7eaa2b7a6a
diff --git a/cmd/root.go b/cmd/root.go
index eb8996ce4..751c090b0 100644
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -53,11 +53,8 @@ func runNavidrome() {
var g run.Group
g.Add(startServer())
- if conf.Server.ScanInterval != 0 {
- g.Add(startScanner())
- } else {
- log.Warn("Scanner is disabled", "interval", conf.Server.ScanInterval)
- }
+ g.Add(startScanner())
+
if err := g.Run(); err != nil {
log.Error("Fatal error in Navidrome. Aborting", err)
}
@@ -83,25 +80,16 @@ func startScanner() (func() error, func(err error)) {
log.Info("Starting scanner", "interval", interval.String())
scanner := CreateScanner(conf.Server.MusicFolder)
- ticker := time.NewTicker(interval)
- done := make(chan bool)
-
return func() error {
- time.Sleep(2 * time.Second) // Wait 2 seconds before the first scan
- for {
- if err := scanner.RescanAll(false); err != nil {
- log.Error("Error scanning media folder", "folder", conf.Server.MusicFolder, err)
- }
- select {
- case <-ticker.C:
- continue
- case <-done:
- return nil
- }
+ if interval != 0 {
+ go func() {
+ time.Sleep(2 * time.Second) // Wait 2 seconds before the first scan
+ scanner.RescanAll(false)
+ }()
}
+ return scanner.Start(interval)
}, func(err error) {
- ticker.Stop()
- done <- true
+ scanner.Stop()
if err != nil {
log.Error("Fatal error executing Scanner", err)
} else {
diff --git a/cmd/scan.go b/cmd/scan.go
index 034ea333e..cca15624a 100644
--- a/cmd/scan.go
+++ b/cmd/scan.go
@@ -1,8 +1,11 @@
package cmd
import (
+ "time"
+
"github.com/deluan/navidrome/conf"
"github.com/deluan/navidrome/log"
+ "github.com/deluan/navidrome/scanner"
"github.com/spf13/cobra"
)
@@ -22,12 +25,23 @@ var scanCmd = &cobra.Command{
},
}
+func waitScanToFinish(scanner scanner.Scanner) {
+ time.Sleep(500 * time.Millisecond)
+ ticker := time.Tick(100 * time.Millisecond)
+ for {
+ if !scanner.Scanning() {
+ return
+ }
+ <-ticker
+ }
+}
+
func runScanner() {
scanner := CreateScanner(conf.Server.MusicFolder)
- err := scanner.RescanAll(fullRescan)
- if err != nil {
- log.Error("Error scanning media folder", "folder", conf.Server.MusicFolder, err)
- }
+ go func() { _ = scanner.Start(0) }()
+ scanner.RescanAll(fullRescan)
+ waitScanToFinish(scanner)
+ scanner.Stop()
if fullRescan {
log.Info("Finished full rescan")
} else {
diff --git a/cmd/wire_gen.go b/cmd/wire_gen.go
index 9c3c7ff7f..f3333fc9b 100644
--- a/cmd/wire_gen.go
+++ b/cmd/wire_gen.go
@@ -25,7 +25,7 @@ func CreateServer(musicFolder string) *server.Server {
return serverServer
}
-func CreateScanner(musicFolder string) *scanner.Scanner {
+func CreateScanner(musicFolder string) scanner.Scanner {
dataStore := persistence.New()
scannerScanner := scanner.New(dataStore)
return scannerScanner
diff --git a/cmd/wire_injectors.go b/cmd/wire_injectors.go
index 3b0199b4f..3d3da67b0 100644
--- a/cmd/wire_injectors.go
+++ b/cmd/wire_injectors.go
@@ -29,7 +29,7 @@ func CreateServer(musicFolder string) *server.Server {
))
}
-func CreateScanner(musicFolder string) *scanner.Scanner {
+func CreateScanner(musicFolder string) scanner.Scanner {
panic(wire.Build(
allProviders,
))
diff --git a/scanner/scanner.go b/scanner/scanner.go
index 9d3b1ca0b..ae5f689b5 100644
--- a/scanner/scanner.go
+++ b/scanner/scanner.go
@@ -5,24 +5,88 @@ import (
"errors"
"fmt"
"strconv"
+ "sync"
"time"
"github.com/deluan/navidrome/log"
"github.com/deluan/navidrome/model"
)
-type Scanner struct {
+type Scanner interface {
+ Start(interval time.Duration) error
+ Stop()
+ RescanAll(fullRescan bool)
+ Status(mediaFolder string) (*StatusInfo, error)
+ Scanning() bool
+}
+
+type StatusInfo struct {
+ MediaFolder string
+ Scanning bool
+ LastScan time.Time
+ Count int
+}
+
+type FolderScanner interface {
+ Scan(ctx context.Context, lastModifiedSince time.Time) error
+}
+
+type scanner struct {
folders map[string]FolderScanner
+ status map[string]*scanStatus
+ lock *sync.RWMutex
ds model.DataStore
+ done chan bool
+ scan chan bool
+}
+
+type scanStatus struct {
+ active bool
+ count int
+ lastUpdate time.Time
}
-func New(ds model.DataStore) *Scanner {
- s := &Scanner{ds: ds, folders: map[string]FolderScanner{}}
+func New(ds model.DataStore) Scanner {
+ s := &scanner{
+ ds: ds,
+ folders: map[string]FolderScanner{},
+ status: map[string]*scanStatus{},
+ lock: &sync.RWMutex{},
+ done: make(chan bool),
+ scan: make(chan bool),
+ }
s.loadFolders()
return s
}
-func (s *Scanner) Rescan(mediaFolder string, fullRescan bool) error {
+func (s *scanner) Start(interval time.Duration) error {
+ if interval == 0 {
+ log.Warn("Periodic scan is DISABLED", "interval", interval)
+ }
+ var sleep <-chan time.Time
+ for {
+ if interval == 0 {
+ sleep = make(chan time.Time)
+ } else {
+ sleep = time.After(interval)
+ }
+ select {
+ case full := <-s.scan:
+ s.rescanAll(full)
+ case <-sleep:
+ s.rescanAll(false)
+ continue
+ case <-s.done:
+ return nil
+ }
+ }
+}
+
+func (s *scanner) Stop() {
+ s.done <- true
+}
+
+func (s *scanner) rescan(mediaFolder string, fullRescan bool) error {
folderScanner := s.folders[mediaFolder]
start := time.Now()
@@ -34,6 +98,9 @@ func (s *Scanner) Rescan(mediaFolder string, fullRescan bool) error {
log.Debug("Scanning folder (full scan)", "folder", mediaFolder)
}
+ s.setStatusActive(mediaFolder, true)
+ defer s.setStatus(mediaFolder, false, 0, start)
+
err := folderScanner.Scan(log.NewContext(context.TODO()), lastModifiedSince)
if err != nil {
log.Error("Error importing MediaFolder", "folder", mediaFolder, err)
@@ -43,22 +110,77 @@ func (s *Scanner) Rescan(mediaFolder string, fullRescan bool) error {
return err
}
-func (s *Scanner) RescanAll(fullRescan bool) error {
+func (s *scanner) RescanAll(fullRescan bool) {
+ if s.Scanning() {
+ log.Debug("Scanner already running, ignoring request for rescan.")
+ return
+ }
+ s.scan <- fullRescan
+}
+
+func (s *scanner) rescanAll(fullRescan bool) {
var hasError bool
for folder := range s.folders {
- err := s.Rescan(folder, fullRescan)
+ err := s.rescan(folder, fullRescan)
hasError = hasError || err != nil
}
if hasError {
log.Error("Errors while scanning media. Please check the logs")
- return errors.New("errors while scanning media")
+ }
+}
+
+func (s *scanner) getStatus(folder string) *scanStatus {
+ s.lock.RLock()
+ defer s.lock.RUnlock()
+ if status, ok := s.status[folder]; ok {
+ return status
}
return nil
}
-func (s *Scanner) Status() []StatusInfo { return nil }
+func (s *scanner) setStatus(folder string, active bool, count int, lastUpdate time.Time) {
+ s.lock.Lock()
+ defer s.lock.Unlock()
+ if status, ok := s.status[folder]; ok {
+ status.active = active
+ status.count = count
+ status.lastUpdate = lastUpdate
+ }
+}
+
+func (s *scanner) setStatusActive(folder string, active bool) {
+ s.lock.Lock()
+ defer s.lock.Unlock()
+ if status, ok := s.status[folder]; ok {
+ status.active = active
+ }
+}
+
+func (s *scanner) Scanning() bool {
+ s.lock.RLock()
+ defer s.lock.RUnlock()
+ for _, status := range s.status {
+ if status.active {
+ return true
+ }
+ }
+ return false
+}
-func (s *Scanner) getLastModifiedSince(folder string) time.Time {
+func (s *scanner) Status(mediaFolder string) (*StatusInfo, error) {
+ status := s.getStatus(mediaFolder)
+ if status == nil {
+ return nil, errors.New("mediaFolder not found")
+ }
+ return &StatusInfo{
+ MediaFolder: mediaFolder,
+ Scanning: status.active,
+ LastScan: status.lastUpdate,
+ Count: status.count,
+ }, nil
+}
+
+func (s *scanner) getLastModifiedSince(folder string) time.Time {
ms, err := s.ds.Property(context.TODO()).Get(model.PropLastScan + "-" + folder)
if err != nil {
return time.Time{}
@@ -70,32 +192,26 @@ func (s *Scanner) getLastModifiedSince(folder string) time.Time {
return time.Unix(0, i*int64(time.Millisecond))
}
-func (s *Scanner) updateLastModifiedSince(folder string, t time.Time) {
+func (s *scanner) updateLastModifiedSince(folder string, t time.Time) {
millis := t.UnixNano() / int64(time.Millisecond)
if err := s.ds.Property(context.TODO()).Put(model.PropLastScan+"-"+folder, fmt.Sprint(millis)); err != nil {
log.Error("Error updating DB after scan", err)
}
}
-func (s *Scanner) loadFolders() {
+func (s *scanner) loadFolders() {
fs, _ := s.ds.MediaFolder(context.TODO()).GetAll()
for _, f := range fs {
log.Info("Configuring Media Folder", "name", f.Name, "path", f.Path)
s.folders[f.Path] = s.newScanner(f)
+ s.status[f.Path] = &scanStatus{
+ active: false,
+ count: 0,
+ lastUpdate: s.getLastModifiedSince(f.Path),
+ }
}
}
-func (s *Scanner) newScanner(f model.MediaFolder) FolderScanner {
+func (s *scanner) newScanner(f model.MediaFolder) FolderScanner {
return NewTagScanner(f.Path, s.ds)
}
-
-type Status int
-
-type StatusInfo struct {
- MediaFolder string
- Status Status
-}
-
-type FolderScanner interface {
- Scan(ctx context.Context, lastModifiedSince time.Time) error
-}