pre-cache next two files in queue; TODO - use them

backend/audiocache.go

@@ -0,0 +1,135 @@
+package backend
+
+import (
+	"context"
+	"errors"
+	"log"
+	"os"
+	"path/filepath"
+	"slices"
+	"sync"
+
+	"github.com/20after4/configdir"
+	"github.com/dweymouth/supersonic/sharedutil"
+)
+
+// AudioCache manages temporary local storage of audio files fetched from the remote music server.
+// It prefetches and stores tracks on disk based on an upcoming play queue.
+type AudioCache struct {
+	mutex sync.Mutex
+
+	s            *ServerManager
+	rootCtx      context.Context
+	baseCacheDir string
+
+	entries map[string]*cacheEntry
+}
+
+type cacheEntry struct {
+	done   bool
+	cancel context.CancelFunc
+}
+
+// AudioCacheRequest represents a request to prefetch and cache an audio file.
+type AudioCacheRequest struct {
+	ID          string
+	DownloadURL string
+}
+
+// NewAudioCache initializes an AudioCache using the given context, server manager,
+// and local filesystem directory for storing audio files.
+func NewAudioCache(ctx context.Context, s *ServerManager, baseCacheDir string) (*AudioCache, error) {
+	if err := configdir.MakePath(baseCacheDir); err != nil {
+		return nil, errors.New("failed to create audio cache dir")
+	}
+	return &AudioCache{
+		s:            s,
+		rootCtx:      ctx,
+		baseCacheDir: baseCacheDir,
+		entries:      make(map[string]*cacheEntry),
+	}, nil
+}
+
+// PathForCachedFile returns the local filesystem path for a cached track,
+// if the file has finished downloading. If not cached, it returns an empty string.
+func (a *AudioCache) PathForCachedFile(id string) string {
+	if item, ok := a.entries[id]; ok && item.done {
+		return a.pathForID(id)
+	}
+	return ""
+}
+
+// cacheFile begins downloading a file (if not already downloading) and stores it
+// to the cache directory under its ID as filename. The download is asynchronous.
+func (a *AudioCache) cacheFile(id, dlURL string) {
+	s := a.s.Server
+	if s == nil {
+		return
+	}
+
+	if _, ok := a.entries[id]; !ok {
+		ctx, cancel := context.WithCancel(a.rootCtx)
+		a.entries[id] = &cacheEntry{cancel: cancel}
+		go func() {
+			ok, err := sharedutil.DownloadFileWithContext(ctx, dlURL, a.pathForID(id))
+			if ok {
+				a.mutex.Lock()
+				if e, ok := a.entries[id]; ok {
+					e.done = true
+				}
+				a.mutex.Unlock()
+			} else if err != context.DeadlineExceeded {
+				log.Printf("error downloading audio file: %v", err)
+			}
+			cancel() // release ctx resources when done
+		}()
+	}
+}
+
+// CacheOnly ensures that only the given 'fetch' list of files (plus one extra 'keep' ID) remain cached.
+// Any other cached files are cancelled and deleted from disk.
+func (a *AudioCache) CacheOnly(keep string, fetch []AudioCacheRequest) {
+	a.mutex.Lock()
+	defer a.mutex.Unlock()
+
+	// delete files we're not keeping
+	for id, e := range a.entries {
+		if id != keep && !slices.ContainsFunc(fetch, func(a AudioCacheRequest) bool {
+			return a.ID == id
+		}) {
+			e.cancel()
+			_ = os.Remove(a.pathForID(id))
+			delete(a.entries, id)
+		}
+	}
+
+	// start caching the ones from fetch if not already present
+	for _, item := range fetch {
+		if _, ok := a.entries[item.ID]; !ok {
+			a.cacheFile(item.ID, item.DownloadURL)
+		}
+	}
+}
+
+// Shutdown cancels all in-progress downloads and deletes all files in the audio cache directory.
+// This should be called during application shutdown to clean up temporary audio data.
+func (a *AudioCache) Shutdown() {
+	a.mutex.Lock()
+	// Cancel all active downloads
+	for _, entry := range a.entries {
+		if entry.cancel != nil {
+			entry.cancel()
+		}
+	}
+	a.entries = nil // clear cache state
+	a.mutex.Unlock()
+
+	// Remove all files in the cache directory
+	if a.baseCacheDir != "" {
+		_ = os.RemoveAll(a.baseCacheDir)
+	}
+}
+
+func (a *AudioCache) pathForID(id string) string {
+	return filepath.Join(a.baseCacheDir, id)
+}