Everything is in memory now without libs

internal/torrent/cache.go

@@ -1 +0,0 @@
-package torrent

internal/torrent/manager.go

@@ -2,39 +2,30 @@ package torrent
 
 import (
 	"log"
+	"strings"
+	"sync"
 
 	"github.com/debridmediamanager.com/zurg/pkg/realdebrid"
-	"github.com/dgraph-io/ristretto"
 )
 
 type TorrentManager struct {
 	token      string
-	cache      *ristretto.Cache
+	torrents   []Torrent
 	workerPool chan bool
 }
 
 // NewTorrentManager creates a new torrent manager
 // it will fetch all torrents and their info in the background
-// and cache them
+// and store them in-memory
 func NewTorrentManager(token string) *TorrentManager {
-	cache, err := ristretto.NewCache(&ristretto.Config{
-		NumCounters: 1e7,     // number of keys to track frequency of (10M).
-		MaxCost:     1 << 30, // maximum cost of cache (1GB).
-		BufferItems: 64,      // number of keys per Get buffer.
-	})
-	if err != nil {
-		panic(err)
-	}
-
 	handler := &TorrentManager{
 		token:      token,
-		cache:      cache,
 		workerPool: make(chan bool, 10),
 	}
 
-	torrents := handler.getAll()
+	handler.torrents = handler.getAll()
 
-	for _, torrent := range torrents {
+	for _, torrent := range handler.torrents {
 		go func(id string) {
 			handler.workerPool <- true
 			handler.getInfo(id)
@@ -46,48 +37,112 @@ func NewTorrentManager(token string) *TorrentManager {
 	return handler
 }
 
-func (t *TorrentManager) getAll() []realdebrid.Torrent {
-	cacheKey := "t:all"
+func (t *TorrentManager) getAll() []Torrent {
 	torrents, err := realdebrid.GetTorrents(t.token)
 	if err != nil {
 		log.Printf("Cannot get torrents: %v\n", err.Error())
 		return nil
 	}
-	t.cache.Set(cacheKey, torrents, 0)
-	return torrents
-}
-
-func (t *TorrentManager) GetAll() []realdebrid.Torrent {
-	cacheKey := "t:all"
-	if data, found := t.cache.Get(cacheKey); found {
-		if cachedTorrents, ok := data.([]realdebrid.Torrent); ok {
-			return cachedTorrents
-		} else {
-			t.cache.Del(cacheKey)
-		}
+	var torrentsV2 []Torrent
+	for _, torrent := range torrents {
+		torrentsV2 = append(torrentsV2, Torrent{
+			Torrent:       torrent,
+			SelectedFiles: nil,
+		})
 	}
-	return t.getAll()
+	return torrentsV2
 }
 
-func (t *TorrentManager) getInfo(torrentID string) *realdebrid.Torrent {
-	cacheKey := "t:" + torrentID
+func (t *TorrentManager) GetAll() []Torrent {
+	return t.torrents
+}
+
+func (t *TorrentManager) getInfo(torrentID string) *Torrent {
 	info, err := realdebrid.GetTorrentInfo(t.token, torrentID)
 	if err != nil {
 		log.Printf("Cannot get info: %v\n", err.Error())
 		return nil
 	}
-	t.cache.Set(cacheKey, info, 0)
-	return info
-}
+	var selectedFiles []File
+	for _, file := range info.Files {
+		if file.Selected == 0 {
+			continue
+		}
+		selectedFiles = append(selectedFiles, File{
+			File: file,
+			Link: "",
+		})
+	}
+	if len(selectedFiles) != len(info.Links) {
+		type Result struct {
+			Filename string
+			Link     string
+		}
 
-func (t *TorrentManager) GetInfo(torrentID string) *realdebrid.Torrent {
-	cacheKey := "t:" + torrentID
-	if data, found := t.cache.Get(cacheKey); found {
-		if torrent, ok := data.(*realdebrid.Torrent); ok {
-			return torrent
-		} else {
-			t.cache.Del(cacheKey)
+		resultsChan := make(chan Result, len(info.Links))
+		var wg sync.WaitGroup
+
+		// Limit concurrency
+		sem := make(chan struct{}, 10) // e.g., 10 concurrent requests
+
+		for _, link := range info.Links {
+			wg.Add(1)
+			sem <- struct{}{} // Acquire semaphore
+			go func(lnk string) {
+				defer wg.Done()
+				defer func() { <-sem }() // Release semaphore
+
+				unrestrictFn := func() (*realdebrid.UnrestrictResponse, error) {
+					return realdebrid.UnrestrictLink(t.token, lnk)
+				}
+				resp := realdebrid.RetryUntilOk(unrestrictFn)
+				if resp != nil {
+					resultsChan <- Result{Filename: resp.Filename, Link: resp.Link}
+				}
+			}(link)
+		}
+
+		go func() {
+			wg.Wait()
+			close(resultsChan)
+		}()
+
+		for result := range resultsChan {
+			for i := range selectedFiles {
+				if strings.HasSuffix(selectedFiles[i].Path, result.Filename) {
+					selectedFiles[i].Link = result.Link
+				}
+			}
+		}
+	} else {
+		for i, link := range info.Links {
+			selectedFiles[i].Link = link
 		}
 	}
-	return t.getInfo(torrentID)
+	torrent := t.getByID(torrentID)
+	if torrent != nil {
+		torrent.SelectedFiles = selectedFiles
+	}
+	log.Println("Fetched info for", info.Filename)
+	return torrent
+}
+
+func (t *TorrentManager) GetInfo(torrentID string) *Torrent {
+	for _, torrent := range t.torrents {
+		if torrent.ID == torrentID {
+			if torrent.SelectedFiles != nil {
+				return t.getInfo(torrentID)
+			}
+		}
+	}
+	return nil
+}
+
+func (t *TorrentManager) getByID(torrentID string) *Torrent {
+	for _, torrent := range t.torrents {
+		if torrent.ID == torrentID {
+			return &torrent
+		}
+	}
+	return nil
 }

internal/torrent/types.go

@@ -0,0 +1,13 @@
+package torrent
+
+import "github.com/debridmediamanager.com/zurg/pkg/realdebrid"
+
+type Torrent struct {
+	realdebrid.Torrent
+	SelectedFiles []File
+}
+
+type File struct {
+	realdebrid.File
+	Link string
+}