refactor: download torrent files (#144)

* refactor: download torrent file

* refactor: remove return struct

* chore: remove unused method

internal/action/qbittorrent.go

@@ -13,7 +13,7 @@ import (
 const ReannounceMaxAttempts = 50
 const ReannounceInterval = 7000
 
-func (s *service) qbittorrent(qbt *qbittorrent.Client, action domain.Action, hash string, torrentFile string) error {
+func (s *service) qbittorrent(qbt *qbittorrent.Client, action domain.Action, torrentFile string, hash string) error {
 	log.Debug().Msgf("action qBittorrent: %v", action.Name)
 
 	options := map[string]string{}

internal/action/run.go

@@ -47,8 +47,6 @@ func (s *service) RunActions(actions []domain.Action, release domain.Release) er
 func (s *service) runAction(action domain.Action, release domain.Release) error {
 
 	var err error
-	var tmpFile string
-	var hash string
 	var rejections []string
 
 	switch action.Type {
@@ -57,33 +55,23 @@ func (s *service) runAction(action domain.Action, release domain.Release) error
 
 	case domain.ActionTypeExec:
 		if release.TorrentTmpFile == "" {
-			t, err := release.DownloadTorrentFile(nil)
+			if err := release.DownloadTorrentFile(nil); err != nil {
-			if err != nil {
 				log.Error().Stack().Err(err)
 				return err
 			}
-
-			tmpFile = t.TmpFileName
-		} else {
-			tmpFile = release.TorrentTmpFile
 		}
 
-		s.execCmd(release, action, tmpFile)
+		s.execCmd(release, action, release.TorrentTmpFile)
 
 	case domain.ActionTypeWatchFolder:
 		if release.TorrentTmpFile == "" {
-			t, err := release.DownloadTorrentFile(nil)
+			if err := release.DownloadTorrentFile(nil); err != nil {
-			if err != nil {
 				log.Error().Stack().Err(err)
 				return err
 			}
-
-			tmpFile = t.TmpFileName
-		} else {
-			tmpFile = release.TorrentTmpFile
 		}
 
-		s.watchFolder(action.WatchFolder, tmpFile)
+		s.watchFolder(action.WatchFolder, release.TorrentTmpFile)
 
 	case domain.ActionTypeDelugeV1, domain.ActionTypeDelugeV2:
 		canDownload, err := s.delugeCheckRulesCanDownload(action)
@@ -97,18 +85,13 @@ func (s *service) runAction(action domain.Action, release domain.Release) error
 		}
 
 		if release.TorrentTmpFile == "" {
-			t, err := release.DownloadTorrentFile(nil)
+			if err := release.DownloadTorrentFile(nil); err != nil {
-			if err != nil {
 				log.Error().Stack().Err(err)
 				return err
 			}
-
-			tmpFile = t.TmpFileName
-		} else {
-			tmpFile = release.TorrentTmpFile
 		}
 
-		err = s.deluge(action, tmpFile)
+		err = s.deluge(action, release.TorrentTmpFile)
 		if err != nil {
 			log.Error().Stack().Err(err).Msg("error sending torrent to Deluge")
 			return err
@@ -126,19 +109,13 @@ func (s *service) runAction(action domain.Action, release domain.Release) error
 		}
 
 		if release.TorrentTmpFile == "" {
-			t, err := release.DownloadTorrentFile(nil)
+			if err := release.DownloadTorrentFile(nil); err != nil {
-			if err != nil {
 				log.Error().Stack().Err(err)
 				return err
 			}
-
-			tmpFile = t.TmpFileName
-			hash = t.MetaInfo.HashInfoBytes().String()
-		} else {
-			tmpFile = release.TorrentTmpFile
 		}
 
-		err = s.qbittorrent(client, action, hash, tmpFile)
+		err = s.qbittorrent(client, action, release.TorrentTmpFile, release.TorrentHash)
 		if err != nil {
 			log.Error().Stack().Err(err).Msg("error sending torrent to qBittorrent")
 			return err

internal/domain/release.go

@@ -45,6 +45,7 @@ type Release struct {
 	TorrentID                   string                `json:"torrent_id"`
 	TorrentURL                  string                `json:"-"`
 	TorrentTmpFile              string                `json:"-"`
+	TorrentHash                 string                `json:"-"`
 	TorrentName                 string                `json:"torrent_name"` // full release name
 	Size                        uint64                `json:"size"`
 	Raw                         string                `json:"raw"`   // Raw release
@@ -607,12 +608,12 @@ func (r *Release) ParseTorrentUrl(match string, vars map[string]string, extraVar
 	return nil
 }
 
-func (r *Release) DownloadTorrentFile(opts map[string]string) (*DownloadTorrentFileResponse, error) {
+func (r *Release) DownloadTorrentFile(opts map[string]string) error {
 	if r.TorrentURL == "" {
-		return nil, errors.New("download_file: url can't be empty")
+		return errors.New("download_file: url can't be empty")
 	} else if r.TorrentTmpFile != "" {
 		// already downloaded
-		return nil, nil
+		return nil
 	}
 
 	customTransport := http.DefaultTransport.(*http.Transport).Clone()
@@ -623,7 +624,7 @@ func (r *Release) DownloadTorrentFile(opts map[string]string) (*DownloadTorrentF
 	resp, err := client.Get(r.TorrentURL)
 	if err != nil {
 		log.Error().Stack().Err(err).Msg("error downloading file")
-		return nil, err
+		return err
 	}
 	defer resp.Body.Close()
 
@@ -631,47 +632,45 @@ func (r *Release) DownloadTorrentFile(opts map[string]string) (*DownloadTorrentF
 
 	if resp.StatusCode != http.StatusOK {
 		log.Error().Stack().Err(err).Msgf("error downloading file from: %v - bad status: %d", r.TorrentURL, resp.StatusCode)
-		return nil, fmt.Errorf("error downloading torrent (%v) file (%v) from '%v' - status code: %d", r.TorrentName, r.TorrentURL, r.Indexer, resp.StatusCode)
+		return fmt.Errorf("error downloading torrent (%v) file (%v) from '%v' - status code: %d", r.TorrentName, r.TorrentURL, r.Indexer, resp.StatusCode)
 	}
 
 	// Create tmp file
 	tmpFile, err := os.CreateTemp("", "autobrr-")
 	if err != nil {
 		log.Error().Stack().Err(err).Msg("error creating temp file")
-		return nil, err
+		return err
 	}
 	defer tmpFile.Close()
 
-	r.TorrentTmpFile = tmpFile.Name()
-
 	// Write the body to file
 	_, err = io.Copy(tmpFile, resp.Body)
 	if err != nil {
 		log.Error().Stack().Err(err).Msgf("error writing downloaded file: %v", tmpFile.Name())
-		return nil, err
+		return err
 	}
 
 	meta, err := metainfo.LoadFromFile(tmpFile.Name())
 	if err != nil {
 		log.Error().Stack().Err(err).Msgf("metainfo could not load file contents: %v", tmpFile.Name())
-		return nil, err
+		return err
 	}
 
+	torrentMetaInfo, err := meta.UnmarshalInfo()
+	if err != nil {
+		log.Error().Stack().Err(err).Msgf("metainfo could not unmarshal info from torrent: %v", tmpFile.Name())
+		return err
+	}
+
+	r.TorrentTmpFile = tmpFile.Name()
+	r.TorrentHash = meta.HashInfoBytes().String()
+	r.Size = uint64(torrentMetaInfo.TotalLength())
+
 	// remove file if fail
 
-	res := DownloadTorrentFileResponse{
-		MetaInfo:    meta,
-		TmpFileName: tmpFile.Name(),
-	}
-
-	if res.TmpFileName == "" || res.MetaInfo == nil {
-		log.Error().Stack().Err(err).Msgf("tmp file error - empty body: %v", r.TorrentURL)
-		return nil, errors.New("error downloading file, no tmp file")
-	}
-
 	log.Debug().Msgf("successfully downloaded file: %v", tmpFile.Name())
 
-	return &res, nil
+	return nil
 }
 
 func (r *Release) addRejection(reason string) {

internal/filter/service.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 
-	"github.com/anacrolix/torrent/metainfo"
 	"github.com/dustin/go-humanize"
 	"github.com/rs/zerolog/log"
 
@@ -190,8 +189,6 @@ func (s *service) FindAndCheckFilters(release *domain.Release) (bool, *domain.Fi
 
 	// save outside of loop to check multiple filters with only one fetch
 	var torrentInfo *domain.TorrentBasic
-	var torrentFileRes *domain.DownloadTorrentFileResponse
-	var torrentMetaInfo metainfo.Info
 
 	// loop and check release to filter until match
 	for _, f := range filters {
@@ -244,21 +241,14 @@ func (s *service) FindAndCheckFilters(release *domain.Release) (bool, *domain.Fi
 					log.Trace().Msgf("filter-service.find_and_check_filters: (%v) additional size check required: preparing to download metafile", f.Name)
 
 					// if indexer doesn't have api, download torrent and add to tmpPath
-					torrentFileRes, err = release.DownloadTorrentFile(nil)
+					err = release.DownloadTorrentFile(nil)
 					if err != nil {
 						log.Error().Stack().Err(err).Msgf("filter-service.find_and_check_filters: (%v) could not download torrent file with id: '%v' from: %v", f.Name, release.TorrentID, release.Indexer)
 						return false, nil, err
 					}
 
-					// parse torrent metainfo
-					torrentMetaInfo, err = torrentFileRes.MetaInfo.UnmarshalInfo()
-					if err != nil {
-						log.Error().Stack().Err(err).Msgf("filter-service.find_and_check_filters: could not download torrent file: '%v' from: %v", release.TorrentID, release.Indexer)
-						continue
-					}
-
 					// compare size against filter
-					match, err := checkSizeFilter(f.MinSize, f.MaxSize, uint64(torrentMetaInfo.TotalLength()))
+					match, err := checkSizeFilter(f.MinSize, f.MaxSize, release.Size)
 					if err != nil {
 						log.Error().Stack().Err(err).Msgf("filter-service.find_and_check_filters: (%v) could not check size filter", f.Name)
 						continue
@@ -269,9 +259,6 @@ func (s *service) FindAndCheckFilters(release *domain.Release) (bool, *domain.Fi
 						log.Debug().Msgf("filter-service.find_and_check_filters: (%v) filter did not match after additional size check, trying next", f.Name)
 						continue
 					}
-
-					// store size on the release
-					release.Size = uint64(torrentMetaInfo.TotalLength())
 				}
 			}
 

internal/release/service.go

@@ -3,7 +3,6 @@ package release
 import (
 	"context"
 	"fmt"
-
 	"github.com/rs/zerolog/log"
 
 	"github.com/autobrr/autobrr/internal/action"