Merge branch 'beta'

Author: sirrobot01

pkg/debrid/debrid/cache.go

@@ -23,6 +23,7 @@ import (
 	"github.com/sirrobot01/decypharr/internal/logger"
 	"github.com/sirrobot01/decypharr/internal/utils"
 	"github.com/sirrobot01/decypharr/pkg/debrid/types"
+	_ "time/tzdata"
 )
 
 type WebDavFolderNaming string
@@ -109,9 +110,16 @@ type Cache struct {
 
 func New(dc config.Debrid, client types.Client) *Cache {
 	cfg := config.Get()
-	cet, _ := time.LoadLocation("CET")
-	cetSc, _ := gocron.NewScheduler(gocron.WithLocation(cet))
-	scheduler, _ := gocron.NewScheduler(gocron.WithLocation(time.Local))
+	cetSc, err := gocron.NewScheduler(gocron.WithLocation(time.UTC))
+	if err != nil {
+		// If we can't create a CET scheduler, fallback to local time
+		cetSc, _ = gocron.NewScheduler(gocron.WithLocation(time.Local))
+	}
+	scheduler, err := gocron.NewScheduler(gocron.WithLocation(time.Local))
+	if err != nil {
+		// If we can't create a local scheduler, fallback to CET
+		scheduler = cetSc
+	}
 
 	autoExpiresLinksAfter, err := time.ParseDuration(dc.AutoExpireLinksAfter)
 	if autoExpiresLinksAfter == 0 || err != nil {
@@ -307,10 +315,10 @@ func (c *Cache) load(ctx context.Context) (map[string]CachedTorrent, error) {
 				}
 
 				isComplete := true
-				if len(ct.Files) != 0 {
+				if len(ct.GetFiles()) != 0 {
 					// Check if all files are valid, if not, delete the file.json and remove from cache.
-					fs := make(map[string]types.File, len(ct.Files))
-					for _, f := range ct.Files {
+					fs := make(map[string]types.File, len(ct.GetFiles()))
+					for _, f := range ct.GetFiles() {
 						if f.Link == "" {
 							isComplete = false
 							break
@@ -756,7 +764,7 @@ func (c *Cache) deleteTorrent(id string, removeFromDebrid bool) bool {
 
 			newFiles := map[string]types.File{}
 			newId := ""
-			for _, file := range t.Files {
+			for _, file := range t.GetFiles() {
 				if file.TorrentId != "" && file.TorrentId != id {
 					if newId == "" && file.TorrentId != "" {
 						newId = file.TorrentId
@@ -815,6 +823,36 @@ func (c *Cache) OnRemove(torrentId string) {
 	}
 }
 
+// RemoveFile removes a file from the torrent cache
+// TODO sends a re-insert that removes the file from debrid
+func (c *Cache) RemoveFile(torrentId string, filename string) error {
+	c.logger.Debug().Str("torrent_id", torrentId).Msgf("Removing file %s", filename)
+	torrent, ok := c.torrents.getByID(torrentId)
+	if !ok {
+		return fmt.Errorf("torrent %s not found", torrentId)
+	}
+	file, ok := torrent.GetFile(filename)
+	if !ok {
+		return fmt.Errorf("file %s not found in torrent %s", filename, torrentId)
+	}
+	file.Deleted = true
+	torrent.Files[filename] = file
+
+	// If the torrent has no files left, delete it
+	if len(torrent.GetFiles()) == 0 {
+		c.logger.Debug().Msgf("Torrent %s has no files left, deleting it", torrentId)
+		if err := c.DeleteTorrent(torrentId); err != nil {
+			return fmt.Errorf("failed to delete torrent %s: %w", torrentId, err)
+		}
+		return nil
+	}
+
+	c.setTorrent(torrent, func(torrent CachedTorrent) {
+		c.listingDebouncer.Call(true)
+	}) // Update the torrent in the cache
+	return nil
+}
+
 func (c *Cache) GetLogger() zerolog.Logger {
 	return c.logger
 }

pkg/debrid/debrid/download_link.go

@@ -103,15 +103,21 @@ func (c *Cache) fetchDownloadLink(torrentName, filename, fileLink string) (strin
 	if ct == nil {
 		return "", fmt.Errorf("torrent not found")
 	}
-	file := ct.Files[filename]
+	file, ok := ct.GetFile(filename)
+	if !ok {
+		return "", fmt.Errorf("file %s not found in torrent %s", filename, torrentName)
+	}
 
 	if file.Link == "" {
 		// file link is empty, refresh the torrent to get restricted links
 		ct = c.refreshTorrent(file.TorrentId) // Refresh the torrent from the debrid
 		if ct == nil {
 			return "", fmt.Errorf("failed to refresh torrent")
 		} else {
-			file = ct.Files[filename]
+			file, ok = ct.GetFile(filename)
+			if !ok {
+				return "", fmt.Errorf("file %s not found in refreshed torrent %s", filename, torrentName)
+			}
 		}
 	}
 
@@ -123,7 +129,10 @@ func (c *Cache) fetchDownloadLink(torrentName, filename, fileLink string) (strin
 			return "", fmt.Errorf("failed to reinsert torrent. %w", err)
 		}
 		ct = newCt
-		file = ct.Files[filename]
+		file, ok = ct.GetFile(filename)
+		if !ok {
+			return "", fmt.Errorf("file %s not found in reinserted torrent %s", filename, torrentName)
+		}
 	}
 
 	c.logger.Trace().Msgf("Getting download link for %s(%s)", filename, file.Link)
@@ -135,7 +144,10 @@ func (c *Cache) fetchDownloadLink(torrentName, filename, fileLink string) (strin
 				return "", fmt.Errorf("failed to reinsert torrent: %w", err)
 			}
 			ct = newCt
-			file = ct.Files[filename]
+			file, ok = ct.GetFile(filename)
+			if !ok {
+				return "", fmt.Errorf("file %s not found in reinserted torrent %s", filename, torrentName)
+			}
 			// Retry getting the download link
 			downloadLink, err = c.client.GetDownloadLink(ct.Torrent, &file)
 			if err != nil {
@@ -165,7 +177,7 @@ func (c *Cache) GenerateDownloadLinks(t CachedTorrent) {
 		c.logger.Error().Err(err).Str("torrent", t.Name).Msg("Failed to generate download links")
 		return
 	}
-	for _, file := range t.Files {
+	for _, file := range t.GetFiles() {
 		if file.DownloadLink != nil {
 			c.updateDownloadLink(file.DownloadLink)
 		}

pkg/debrid/debrid/misc.go

@@ -19,7 +19,7 @@ func mergeFiles(torrents ...CachedTorrent) map[string]types.File {
 	})
 
 	for _, torrent := range torrents {
-		for _, file := range torrent.Files {
+		for _, file := range torrent.GetFiles() {
 			merged[file.Name] = file
 		}
 	}

pkg/debrid/debrid/repair.go

@@ -59,11 +59,9 @@ func (c *Cache) markAsSuccessfullyReinserted(torrentId string) {
 	}
 }
 
-func (c *Cache) IsTorrentBroken(t *CachedTorrent, filenames []string) bool {
-	// Check torrent files
-
-	isBroken := false
+func (c *Cache) GetBrokenFiles(t *CachedTorrent, filenames []string) []string {
 	files := make(map[string]types.File)
+	brokenFiles := make([]string, 0)
 	if len(filenames) > 0 {
 		for name, f := range t.Files {
 			if utils.Contains(filenames, name) {
@@ -73,8 +71,6 @@ func (c *Cache) IsTorrentBroken(t *CachedTorrent, filenames []string) bool {
 	} else {
 		files = t.Files
 	}
-
-	// Check empty links
 	for _, f := range files {
 		// Check if file is missing
 		if f.Link == "" {
@@ -83,44 +79,43 @@ func (c *Cache) IsTorrentBroken(t *CachedTorrent, filenames []string) bool {
 				t = newT
 			} else {
 				c.logger.Error().Str("torrentId", t.Torrent.Id).Msg("Failed to refresh torrent")
-				return true
+				return filenames // Return original filenames if refresh fails(torrent is somehow botched)
 			}
 		}
 	}
 
 	if t.Torrent == nil {
 		c.logger.Error().Str("torrentId", t.Torrent.Id).Msg("Failed to refresh torrent")
-		return true
+		return filenames // Return original filenames if refresh fails(torrent is somehow botched)
 	}
 
 	files = t.Files
 
 	for _, f := range files {
 		// Check if file link is still missing
 		if f.Link == "" {
-			isBroken = true
-			break
+			brokenFiles = append(brokenFiles, f.Name)
 		} else {
 			// Check if file.Link not in the downloadLink Cache
 			if err := c.client.CheckLink(f.Link); err != nil {
 				if errors.Is(err, request.HosterUnavailableError) {
-					isBroken = true
-					break
+					brokenFiles = append(brokenFiles, f.Name)
 				}
 			}
 		}
 	}
+
 	// Try to reinsert the torrent if it's broken
-	if isBroken && t.Torrent != nil {
+	if len(brokenFiles) > 0 && t.Torrent != nil {
 		// Check if the torrent is already in progress
 		if _, err := c.reInsertTorrent(t); err != nil {
 			c.logger.Error().Err(err).Str("torrentId", t.Torrent.Id).Msg("Failed to reinsert torrent")
-			return true
+			return brokenFiles // Return broken files if reinsert fails
 		}
-		return false
+		return nil // Return nil if the torrent was successfully reinserted
 	}
 
-	return isBroken
+	return brokenFiles
 }
 
 func (c *Cache) repairWorker(ctx context.Context) {
@@ -223,7 +218,7 @@ func (c *Cache) reInsertTorrent(ct *CachedTorrent) (*CachedTorrent, error) {
 	if err != nil {
 		addedOn = time.Now()
 	}
-	for _, f := range newTorrent.Files {
+	for _, f := range newTorrent.GetFiles() {
 		if f.Link == "" {
 			c.markAsFailedToReinsert(oldID)
 			return ct, fmt.Errorf("failed to reinsert torrent: empty link")

pkg/debrid/torbox/torbox.go

@@ -234,7 +234,7 @@ func (tb *Torbox) GetTorrent(torrentId string) (*types.Torrent, error) {
 			Id:        strconv.Itoa(f.Id),
 			Name:      fileName,
 			Size:      f.Size,
-			Path:      fileName,
+			Path:      f.Name,
 		}
 		t.Files[fileName] = file
 	}

pkg/debrid/types/torrent.go

@@ -29,6 +29,7 @@ type Torrent struct {
 	Seeders          int             `json:"seeders"`
 	Links            []string        `json:"links"`
 	MountPath        string          `json:"mount_path"`
+	DeletedFiles     []string        `json:"deleted_files"`
 
 	Debrid string `json:"debrid"`
 
@@ -75,6 +76,24 @@ func (t *Torrent) GetMountFolder(rClonePath string) (string, error) {
 	return "", fmt.Errorf("no path found")
 }
 
+func (t *Torrent) GetFile(filename string) (File, bool) {
+	f, ok := t.Files[filename]
+	if !ok {
+		return File{}, false
+	}
+	return f, !f.Deleted
+}
+
+func (t *Torrent) GetFiles() []File {
+	files := make([]File, 0, len(t.Files))
+	for _, f := range t.Files {
+		if !f.Deleted {
+			files = append(files, f)
+		}
+	}
+	return files
+}
+
 type File struct {
 	TorrentId    string        `json:"torrent_id"`
 	Id           string        `json:"id"`
@@ -85,6 +104,7 @@ type File struct {
 	DownloadLink *DownloadLink `json:"-"`
 	AccountId    string        `json:"account_id"`
 	Generated    time.Time     `json:"generated"`
+	Deleted      bool          `json:"deleted"`
 }
 
 func (t *Torrent) Cleanup(remove bool) {
@@ -96,15 +116,6 @@ func (t *Torrent) Cleanup(remove bool) {
 	}
 }
 
-func (t *Torrent) GetFile(id string) *File {
-	for _, f := range t.Files {
-		if f.Id == id {
-			return &f
-		}
-	}
-	return nil
-}
-
 type Account struct {
 	ID       string `json:"id"`
 	Disabled bool   `json:"disabled"`

pkg/qbit/downloader.go

@@ -68,7 +68,7 @@ func (q *QBit) downloadFiles(torrent *Torrent, parent string) {
 	var wg sync.WaitGroup
 
 	totalSize := int64(0)
-	for _, file := range debridTorrent.Files {
+	for _, file := range debridTorrent.GetFiles() {
 		totalSize += file.Size
 	}
 	debridTorrent.Mu.Lock()
@@ -100,7 +100,7 @@ func (q *QBit) downloadFiles(torrent *Torrent, parent string) {
 		},
 	}
 	errChan := make(chan error, len(debridTorrent.Files))
-	for _, file := range debridTorrent.Files {
+	for _, file := range debridTorrent.GetFiles() {
 		if file.DownloadLink == nil {
 			q.logger.Info().Msgf("No download link found for %s", file.Name)
 			continue
@@ -170,15 +170,34 @@ func (q *QBit) ProcessSymlink(torrent *Torrent) (string, error) {
 		return "", fmt.Errorf("failed to create directory: %s: %v", torrentSymlinkPath, err)
 	}
 
+	realPaths := make(map[string]string)
+	err = filepath.WalkDir(torrentRclonePath, func(path string, d os.DirEntry, err error) error {
+		if err != nil {
+			return nil
+		}
+		if !d.IsDir() {
+			filename := d.Name()
+			rel, _ := filepath.Rel(torrentRclonePath, path)
+			realPaths[filename] = rel
+		}
+		return nil
+	})
+	if err != nil {
+		q.logger.Warn().Msgf("Error while scanning rclone path: %v", err)
+	}
+
 	pending := make(map[string]debridTypes.File)
-	filePaths := make([]string, 0, len(files))
 	for _, file := range files {
+		if realRelPath, ok := realPaths[file.Name]; ok {
+			file.Path = realRelPath
+		}
 		pending[file.Path] = file
 	}
+
 	ticker := time.NewTicker(200 * time.Millisecond)
 	defer ticker.Stop()
-
-	timeout := time.After(30 * time.Minute) // Adjust timeout duration as needed
+	timeout := time.After(30 * time.Minute)
+	filePaths := make([]string, 0, len(pending))
 
 	for len(pending) > 0 {
 		select {
@@ -194,7 +213,6 @@ func (q *QBit) ProcessSymlink(torrent *Torrent) (string, error) {
 						delete(pending, path)
 						q.logger.Info().Msgf("File is ready: %s", file.Name)
 					}
-
 				}
 			}
 		case <-timeout: