idanoo/autobrr
1
0
Fork 0
mirror of https://github.com/idanoo/autobrr synced 2025-07-23 00:39:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Feature: Download client rules (#18)

Browse source 
* feat(web): add and update download client rules

* feat: add and update download client rules

* feat: add active downloads check

* chore: update pkg

* feat: deluge max active downloads

* feat: use basic rules for deluge

* feat: add as paused

* refactor: download file if needed

* feat: better errors qbit
This commit is contained in:
Ludvig Lundgren 2021-09-10 16:54:30 +02:00 • committed by GitHub
parent 09eb0b1716
commit c02f16b64d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
25 changed files with 628 additions and 228 deletions
Download patch file Download diff file Expand all files Collapse all files

127
internal/action/qbittorrent.go
View file

@ -9,13 +9,16 @@ import (
"github.com/rs/zerolog/log"
)
const REANNOUNCE_MAX_ATTEMPTS = 30
const REANNOUNCE_INTERVAL = 7000
func (s *service) qbittorrent(action domain.Action, hash string, torrentFile string) error {
log.Trace().Msgf("action QBITTORRENT: %v", torrentFile)
log.Debug().Msgf("action qBittorrent: %v", action.Name)
// get client for action
client, err := s.clientSvc.FindByID(action.ClientID)
if err != nil {
log.Error().Err(err).Msgf("error finding client: %v", action.ClientID)
log.Error().Stack().Err(err).Msgf("error finding client: %v ID %v", action.Name, action.ClientID)
return err
}
@ -35,12 +38,10 @@ func (s *service) qbittorrent(action domain.Action, hash string, torrentFile str
// save cookies?
err = qbt.Login()
if err != nil {
log.Error().Err(err).Msgf("error logging into client: %v", action.ClientID)
log.Error().Stack().Err(err).Msgf("error logging into client: %v %v", client.Name, client.Host)
return err
}
// TODO check for active downloads and other rules
options := map[string]string{}
if action.Paused {
@ -63,67 +64,144 @@ func (s *service) qbittorrent(action domain.Action, hash string, torrentFile str
options["dlLimit"] = strconv.FormatInt(action.LimitDownloadSpeed, 10)
}
log.Trace().Msgf("action qBittorrent options: %+v", options)
err = qbt.AddTorrentFromFile(torrentFile, options)
if err != nil {
log.Error().Err(err).Msgf("error sending to client: %v", action.ClientID)
log.Error().Stack().Err(err).Msgf("could not add torrent %v to client: %v", torrentFile, client.Name)
return err
}
if !action.Paused && hash != "" {
err = checkTrackerStatus(*qbt, hash)
if err != nil {
log.Error().Err(err).Msgf("could not get tracker status for torrent: %v", hash)
log.Error().Stack().Err(err).Msgf("could not get tracker status for torrent: %v", hash)
return err
}
}
log.Debug().Msgf("torrent %v successfully added to: %v", hash, client.Name)
log.Info().Msgf("torrent with hash %v successfully added to client: '%v'", hash, client.Name)
return nil
}
func (s *service) qbittorrentCheckRulesCanDownload(action domain.Action) (bool, error) {
log.Trace().Msgf("action qBittorrent: %v check rules", action.Name)
// get client for action
client, err := s.clientSvc.FindByID(action.ClientID)
if err != nil {
log.Error().Stack().Err(err).Msgf("error finding client: %v", action.ClientID)
return false, err
}
if client == nil {
return false, err
}
qbtSettings := qbittorrent.Settings{
Hostname: client.Host,
Port: uint(client.Port),
Username: client.Username,
Password: client.Password,
SSL: client.SSL,
}
qbt := qbittorrent.NewClient(qbtSettings)
// save cookies?
err = qbt.Login()
if err != nil {
log.Error().Stack().Err(err).Msgf("error logging into client: %v", client.Host)
return false, err
}
// check for active downloads and other rules
if client.Settings.Rules.Enabled && !action.IgnoreRules {
activeDownloads, err := qbt.GetTorrentsFilter(qbittorrent.TorrentFilterDownloading)
if err != nil {
log.Error().Stack().Err(err).Msg("could not fetch downloading torrents")
return false, err
}
// make sure it's not set to 0 by default
if client.Settings.Rules.MaxActiveDownloads > 0 {
// if max active downloads reached, check speed and if lower than threshold add anyways
if len(activeDownloads) >= client.Settings.Rules.MaxActiveDownloads {
if client.Settings.Rules.IgnoreSlowTorrents {
// check speeds of downloads
info, err := qbt.GetTransferInfo()
if err != nil {
log.Error().Err(err).Msg("could not get transfer info")
return false, err
}
// if current transfer speed is more than threshold return out and skip
// DlInfoSpeed is in bytes so lets convert to KB to match DownloadSpeedThreshold
if info.DlInfoSpeed/1024 >= client.Settings.Rules.DownloadSpeedThreshold {
log.Debug().Msg("max active downloads reached, skipping")
return false, nil
}
log.Debug().Msg("active downloads are slower than set limit, lets add it")
}
}
}
}
return true, nil
}
func checkTrackerStatus(qb qbittorrent.Client, hash string) error {
announceOK := false
attempts := 0
for attempts < REANNOUNCE_MAX_ATTEMPTS {
log.Debug().Msgf("RE-ANNOUNCE %v attempt: %v", hash, attempts)
// initial sleep to give tracker a head start
time.Sleep(2 * time.Second)
// initial sleep to give tracker a head start
time.Sleep(REANNOUNCE_INTERVAL * time.Millisecond)
for attempts < REANNOUNCE_MAX_ATTEMPTS {
log.Debug().Msgf("qBittorrent - run re-announce %v attempt: %v", hash, attempts)
trackers, err := qb.GetTorrentTrackers(hash)
if err != nil {
log.Error().Err(err).Msgf("could not get trackers of torrent: %v", hash)
log.Error().Err(err).Msgf("qBittorrent - could not get trackers for torrent: %v", hash)
return err
}
// check if status not working or something else
_, working := findTrackerStatus(trackers, qbittorrent.TrackerStatusOK)
working := findTrackerStatus(trackers, qbittorrent.TrackerStatusOK)
if !working {
log.Trace().Msgf("qBittorrent - not working yet, lets re-announce %v attempt: %v", hash, attempts)
err = qb.ReAnnounceTorrents([]string{hash})
if err != nil {
log.Error().Err(err).Msgf("could not get re-announce torrent: %v", hash)
log.Error().Err(err).Msgf("qBittorrent - could not get re-announce torrent: %v", hash)
return err
}
attempts++
// add delay for next run
time.Sleep(REANNOUNCE_INTERVAL * time.Millisecond)
continue
} else {
log.Debug().Msgf("RE-ANNOUNCE %v OK", hash)
log.Debug().Msgf("qBittorrent - re-announce for %v OK", hash)
announceOK = true
break
}
}
// add extra delay before delete
time.Sleep(30 * time.Second)
if !announceOK {
log.Debug().Msgf("RE-ANNOUNCE %v took too long, deleting torrent", hash)
log.Debug().Msgf("qBittorrent - re-announce for %v took too long, deleting torrent", hash)
err := qb.DeleteTorrents([]string{hash}, false)
if err != nil {
log.Error().Err(err).Msgf("could not delete torrent: %v", hash)
log.Error().Stack().Err(err).Msgf("qBittorrent - could not delete torrent: %v", hash)
return err
}
}
@ -138,11 +216,14 @@ func checkTrackerStatus(qb qbittorrent.Client, hash string) error {
// 2 Tracker has been contacted and is working
// 3 Tracker is updating
// 4 Tracker has been contacted, but it is not working (or doesn't send proper replies)
func findTrackerStatus(slice []qbittorrent.TorrentTracker, status qbittorrent.TrackerStatus) (int, bool) {
for i, item := range slice {
if item.Status == status {
return i, true
func findTrackerStatus(slice []qbittorrent.TorrentTracker, status qbittorrent.TrackerStatus) bool {
for _, item := range slice {
// if updating skip and give some more time
if item.Status == qbittorrent.TrackerStatusUpdating {
return false
} else if item.Status == status {
return true
}
}
return -1, false
return false
}