Something went wrong. Try again.
Self-hosted web interface and downloader for Qobuz.
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463package queue
import ( "bytes" "context" "log/slog" "slices" "sync" "time"
"gobuz/internal/downloader" "gobuz/internal/log" "gobuz/internal/models" "gobuz/internal/web/pages")
type userQueue struct { userID int64 mu sync.RWMutex items map[string]*models.QueueItem order []string broker *SSEBroker dl ReleaseDownloader lockRegistry *releaseLockRegistry pages *pages.Pages currentReleaseID string trackToReleaseMap map[string]string isProcessing bool logger *slog.Logger onComplete func() ctx context.Context cancel context.CancelFunc}
func newUserQueue(userID int64, broker *SSEBroker, dl ReleaseDownloader, lockRegistry *releaseLockRegistry, pgs *pages.Pages, logger *slog.Logger, onComplete func()) *userQueue { ctx, cancel := context.WithCancel(context.Background()) return &userQueue{ userID: userID, items: make(map[string]*models.QueueItem), order: make([]string, 0), broker: broker, dl: dl, lockRegistry: lockRegistry, pages: pgs, trackToReleaseMap: make(map[string]string), logger: logger, onComplete: onComplete, ctx: ctx, cancel: cancel, }}
func (u *userQueue) setOnComplete(fn func()) { u.mu.Lock() defer u.mu.Unlock() u.onComplete = fn}
func (u *userQueue) stop() { u.cancel()}
func (u *userQueue) processing() bool { u.mu.RLock() defer u.mu.RUnlock() return u.isProcessing}
func (u *userQueue) OnRelease(msg downloader.MsgRelease) { u.mu.Lock() defer u.mu.Unlock() if !u.isProcessing || msg.ReleaseID == "" { return } if item, exists := u.items[msg.ReleaseID]; exists { u.currentReleaseID = msg.ReleaseID item.Status = models.StatusDownloading u.broadcastProgressLocked() }}
func (u *userQueue) OnRegisterTrack(msg downloader.MsgRegisterTrack) { u.mu.Lock() defer u.mu.Unlock() if !u.isProcessing { return } releaseID := msg.ReleaseID if releaseID == "" { releaseID = u.currentReleaseID } if releaseID == "" { return } release, exists := u.items[releaseID] if !exists { release = &models.QueueItem{ Release: models.Release{ ID: releaseID, Title: msg.Name, }, Status: models.StatusDownloading, } u.items[releaseID] = release u.order = append(u.order, releaseID) }
release.Status = models.StatusDownloading u.trackToReleaseMap[msg.ID] = releaseID
if track := findTrack(release.Tracks, msg.ID); track != nil { track.Title = msg.Name track.Status = models.StatusDownloading track.Counter = msg.Counter } else { release.Tracks = append(release.Tracks, &models.TrackProgress{ ID: msg.ID, TrackNumber: len(release.Tracks) + 1, Title: msg.Name, Status: models.StatusDownloading, Counter: msg.Counter, }) } u.broadcastProgressLocked()}
func (u *userQueue) OnSetTotal(msg downloader.MsgSetTotal) { u.mu.Lock() defer u.mu.Unlock() if _, track := u.releaseForTrackLocked(msg.ID); track != nil { track.TotalBytes = msg.Total u.broadcastProgressLocked() }}
func (u *userQueue) OnDone(msg downloader.MsgDone) { u.mu.Lock() defer u.mu.Unlock() release, track := u.releaseForTrackLocked(msg.ID) if release == nil { return } if track != nil { track.Status = models.StatusDone if track.TotalBytes > 0 { track.DownloadedBytes = track.TotalBytes track.Percent = 100 } } if len(release.Tracks) > 0 && hasAllTracksSucceeded(release) { release.Status = models.StatusDone release.Percent = 100 } u.broadcastProgressLocked()}
func (u *userQueue) OnFailed(msg downloader.MsgFailed) { u.mu.Lock() defer u.mu.Unlock() release, track := u.releaseForTrackLocked(msg.ID) if release == nil { return } if track != nil { track.Status = models.StatusFailed } release.Status = models.StatusFailed u.broadcastProgressLocked()}
func findTrack(tracks []*models.TrackProgress, trackID string) *models.TrackProgress { for _, t := range tracks { if t.ID == trackID { return t } } return nil}
func (u *userQueue) releaseForTrackLocked(trackID string) (*models.QueueItem, *models.TrackProgress) { releaseID, ok := u.trackToReleaseMap[trackID] if !ok { return nil, nil } release, exists := u.items[releaseID] if !exists { return nil, nil } return release, findTrack(release.Tracks, trackID)}
func (u *userQueue) tick() { u.mu.Lock() defer u.mu.Unlock() changed := false for _, release := range u.items { if release.Status != models.StatusDownloading { continue } var sumDownloaded, sumTotal int64 var sumPercent int trackCount := len(release.Tracks)
for _, t := range release.Tracks { if t.Status == models.StatusDownloading && t.Counter != nil { downloaded := t.Counter.Load() if downloaded != t.DownloadedBytes { t.DownloadedBytes = downloaded if t.TotalBytes > 0 { t.Percent = min(int((float64(downloaded)/float64(t.TotalBytes))*100), 100) } changed = true } } sumDownloaded += t.DownloadedBytes sumTotal += t.TotalBytes sumPercent += t.Percent }
if trackCount > 0 { release.DownloadedBytes = sumDownloaded release.TotalBytes = sumTotal release.Percent = sumPercent / trackCount } } if changed { u.broadcastProgressLocked() }}
func (u *userQueue) isQueued(id string) bool { if id == "" { return false } u.mu.RLock() defer u.mu.RUnlock() _, exists := u.items[id] return exists}
func (u *userQueue) stageRelease(item models.QueueItem) { if item.ID == "" { return } u.mu.Lock() defer u.mu.Unlock() if _, exists := u.items[item.ID]; !exists { item.Status = models.StatusStaged u.items[item.ID] = &item u.order = append(u.order, item.ID) }}
func (u *userQueue) removeRelease(id string) { if id == "" { return } u.mu.Lock() defer u.mu.Unlock() delete(u.items, id) u.order = slices.DeleteFunc(u.order, func(oid string) bool { return oid == id })}
func (u *userQueue) clear() { u.mu.Lock() defer u.mu.Unlock() if !u.isProcessing { u.items = make(map[string]*models.QueueItem) u.order = nil u.trackToReleaseMap = make(map[string]string) return } newItems := make(map[string]*models.QueueItem) var newOrder []string for _, id := range u.order { if item, ok := u.items[id]; ok && (item.Status == models.StatusDownloading || item.Status == models.StatusPending) { newItems[id] = item newOrder = append(newOrder, id) } } u.items = newItems u.order = newOrder}
func (u *userQueue) getItem(id string) *models.QueueItem { if id == "" { return nil } u.mu.RLock() defer u.mu.RUnlock() if item, exists := u.items[id]; exists { cpy := *item return &cpy } return nil}
func (u *userQueue) startDownloads() { u.mu.Lock() for _, id := range u.order { if item, ok := u.items[id]; ok && item.Status == models.StatusStaged { item.Status = models.StatusPending } } u.broadcastProgressLocked()
if u.isProcessing { u.mu.Unlock() return }
u.isProcessing = true u.mu.Unlock()
go u.processQueueLoop()}
func (u *userQueue) processQueueLoop() { defer func() { u.mu.Lock() if u.isProcessing { u.isProcessing = false u.broadcastProgressLocked() } u.mu.Unlock() }()
stopTicker := make(chan struct{}) go func() { ticker := time.NewTicker(500 * time.Millisecond) defer ticker.Stop() for { select { case <-ticker.C: u.tick() case <-stopTicker: return } } }() defer close(stopTicker)
for { select { case <-u.ctx.Done(): return default: }
nextID, requestedBy := u.nextPendingRelease() if nextID == "" { return }
u.logger.Info("starting download", "id", nextID, "requested_by", requestedBy)
l := u.lockRegistry.getLock(nextID) l.Lock() downloadCtx := downloader.WithRequestedBy(u.ctx, requestedBy) downloadCtx = downloader.WithProgressListener(downloadCtx, u) downloadCtx = log.IntoContext(downloadCtx, u.logger) downloadErr := u.dl.DownloadRelease(downloadCtx, nextID) if downloadErr != nil { u.logger.Error("release download failed", "id", nextID, "err", downloadErr) } l.Unlock()
if onComplete := u.finalizeReleaseDownload(nextID, requestedBy, downloadErr); onComplete != nil { onComplete() } }}
func (u *userQueue) nextPendingRelease() (string, string) { u.mu.Lock() defer u.mu.Unlock()
for _, id := range u.order { if item, ok := u.items[id]; ok && item.Status == models.StatusPending { item.Status = models.StatusDownloading u.currentReleaseID = id u.broadcastProgressLocked() return id, item.RequestedBy } } u.isProcessing = false u.broadcastProgressLocked() return "", ""}
func (u *userQueue) finalizeReleaseDownload(releaseID, requestedBy string, downloadErr error) func() { u.mu.Lock() defer u.mu.Unlock()
var onComplete func() if item, ok := u.items[releaseID]; ok { if downloadErr != nil || !hasAllTracksSucceeded(item) { item.Status = models.StatusFailed u.logger.Warn("download failed", "id", releaseID, "requested_by", requestedBy) } else { item.Status = models.StatusDone item.Percent = 100 for _, t := range item.Tracks { t.Status = models.StatusDone t.Percent = 100 } u.logger.Info("download completed", "id", releaseID, "requested_by", requestedBy, "tracks", len(item.Tracks)) onComplete = u.onComplete } } u.broadcastProgressLocked() return onComplete}
func hasAllTracksSucceeded(item *models.QueueItem) bool { if item.TracksCount > 0 && len(item.Tracks) < item.TracksCount { return false } for _, t := range item.Tracks { if t.Status != models.StatusDone { return false } } return true}
func (u *userQueue) getViewModelLocked() pages.QueueViewModel { items := make([]*models.QueueItem, len(u.order)) stagedCount := 0 isDownloading := false for i, id := range u.order { item := u.items[id] items[i] = item switch item.Status { case models.StatusStaged: stagedCount++ case models.StatusDownloading, models.StatusPending: isDownloading = true } } return pages.QueueViewModel{ Items: items, StagedCount: stagedCount, Downloading: isDownloading, }}
func (u *userQueue) getViewModel() pages.QueueViewModel { u.mu.RLock() defer u.mu.RUnlock() return u.getViewModelLocked()}
func (u *userQueue) broadcastProgressLocked() { vm := u.getViewModelLocked() var buf bytes.Buffer if err := u.pages.RenderQueue(&buf, vm); err == nil { u.broker.Broadcast(u.userID, "queue-progress", buf.String()) }}