Avoid scanning same album concurrently

Author: rigon

server/cmdargs.go

@@ -25,7 +25,7 @@ type CmdArgs struct {
 }
 
 func parseCollectionOptions(collectionOption string, defaultIndex int) (collection *Collection, err error) {
-	collection = new(Collection)
+	collection = NewCollection()
 	collection.Index = defaultIndex
 	collection.Hide = false
 	collection.ReadOnly = false

server/collection.go

@@ -10,6 +10,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 
 	"github.com/dustin/go-humanize"
 	"github.com/shirou/gopsutil/disk"
@@ -25,6 +26,8 @@ type Collection struct {
 	ReadOnly        bool
 	RenameOnReplace bool
 	cache           Cache
+	muxAlbumMap     sync.Mutex
+	muxsAlbums      map[string]*sync.Mutex
 }
 
 type CollectionInfo struct {
@@ -43,6 +46,12 @@ type AddAlbumQuery struct {
 	Type string `json:"type"`
 }
 
+func NewCollection() *Collection {
+	return &Collection{
+		muxsAlbums: make(map[string]*sync.Mutex),
+	}
+}
+
 // List all collections
 func GetCollections(collections map[string]*Collection) []CollectionInfo {
 	list := make([]CollectionInfo, len(collections))
@@ -151,7 +160,22 @@ func (c *Collection) GetAlbumWithPhotos(albumName string, forceUpdate bool, runn
 		if err == nil { // Is cached
 			return cachedAlbum, nil
 		}
+
+		// If we try to get the cached album whilst another scan is in progress, it will fail.
+		// So we try again but locking until the running scan is completed.
+		// That way we do not need to lock getting albums from the cache in the first attempt.
+		c.LockAlbum(albumName)
+		cachedAlbum, err = c.cache.GetAlbum(albumName)
+		c.UnlockAlbum(albumName)
+		if err == nil { // Is cached
+			return cachedAlbum, nil
+		}
 	}
+
+	// Lock album to avoid concurrent scans
+	c.LockAlbum(albumName)
+	defer c.UnlockAlbum(albumName)
+
 	// If not in cache, read from disk
 	album, err := c.GetAlbum(albumName)
 	if err != nil {
@@ -215,3 +239,24 @@ func (collection *Collection) StorageUsage() (CollectionStorage, error) {
 		Percentage: int(math.Round(percentage)),
 	}, nil
 }
+
+func (c *Collection) LockAlbum(id string) {
+	c.muxAlbumMap.Lock()
+	mux, ok := c.muxsAlbums[id]
+	if !ok {
+		mux = new(sync.Mutex)
+		c.muxsAlbums[id] = mux
+	}
+	c.muxAlbumMap.Unlock()
+	mux.Lock()
+}
+
+func (c *Collection) UnlockAlbum(id string) {
+	c.muxAlbumMap.Lock()
+	mux, ok := c.muxsAlbums[id]
+	if ok {
+		mux.Unlock()
+		//delete(c.muxsAlbums, id)
+	}
+	c.muxAlbumMap.Unlock()
+}

server/pseudo.go

@@ -7,7 +7,6 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
-	"sync"
 
 	"golang.org/x/exp/slices"
 )
@@ -54,16 +53,11 @@ func (photo *Photo) CopyForPseudoAlbum() *Photo {
 	}
 }
 
-var mux sync.Mutex
-
 func readPseudoAlbum(collection *Collection, album *Album) ([]PseudoAlbumEntry, error) {
 	if !album.IsPseudo {
 		return nil, errors.New("the destination must be a pseudo album")
 	}
 
-	mux.Lock()
-	defer mux.Unlock()
-
 	filename := filepath.Join(collection.PhotosPath, album.Name+PSEUDO_ALBUM_EXT)
 	file, err := os.Open(filename)
 	if err != nil {
@@ -98,9 +92,6 @@ func writePseudoAlbum(collection *Collection, album *Album, entries ...PseudoAlb
 		return errors.New("the destination must be a pseudo album")
 	}
 
-	mux.Lock()
-	defer mux.Unlock()
-
 	filename := filepath.Join(collection.PhotosPath, album.Name+PSEUDO_ALBUM_EXT)
 	file, err := os.OpenFile(filename, os.O_TRUNC|os.O_WRONLY, 0644)
 	if err != nil {
@@ -168,6 +159,10 @@ func GetPseudoAlbums(collections map[string]*Collection) []PseudoAlbum {
 }
 
 func (album *Album) EditPseudoAlbum(collection *Collection, query PseudoAlbumSaveQuery, isAdd bool) error {
+	// Lock album to avoid concurrent edits
+	collection.LockAlbum(album.Name)
+	defer collection.UnlockAlbum(album.Name)
+
 	// Read entries from target album
 	entries, err := readPseudoAlbum(collection, album)
 	if err != nil {