feat(actions): improve errors and logs (#340)

This commit is contained in:
Ludvig Lundgren 2022-07-07 16:28:14 +02:00 committed by GitHub
parent 31fbe013ff
commit 402596523d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
15 changed files with 315 additions and 418 deletions

View file

@ -10,122 +10,46 @@ import (
"time"
"github.com/autobrr/autobrr/internal/domain"
"github.com/autobrr/autobrr/pkg/errors"
)
func (s *service) RunAction(action *domain.Action, release domain.Release) ([]string, error) {
var err error
var rejections []string
var (
err error
rejections []string
)
switch action.Type {
case domain.ActionTypeTest:
s.test(action.Name)
case domain.ActionTypeExec:
if release.TorrentTmpFile == "" {
if err := release.DownloadTorrentFile(); err != nil {
s.log.Error().Stack().Err(err)
break
}
}
s.execCmd(release, *action)
err = s.execCmd(*action, release)
case domain.ActionTypeWatchFolder:
if release.TorrentTmpFile == "" {
if err := release.DownloadTorrentFile(); err != nil {
s.log.Error().Stack().Err(err)
break
}
}
s.watchFolder(*action, release)
err = s.watchFolder(*action, release)
case domain.ActionTypeWebhook:
if release.TorrentTmpFile == "" {
if err := release.DownloadTorrentFile(); err != nil {
s.log.Error().Stack().Err(err)
break
}
}
s.webhook(*action, release)
err = s.webhook(*action, release)
case domain.ActionTypeDelugeV1, domain.ActionTypeDelugeV2:
canDownload, err := s.delugeCheckRulesCanDownload(*action)
if err != nil {
s.log.Error().Stack().Err(err).Msgf("error checking client rules: %v", action.Name)
break
}
if !canDownload {
rejections = []string{"max active downloads reached, skipping"}
break
}
if release.TorrentTmpFile == "" {
if err := release.DownloadTorrentFile(); err != nil {
s.log.Error().Stack().Err(err)
break
}
}
err = s.deluge(*action, release)
if err != nil {
s.log.Error().Stack().Err(err).Msg("error sending torrent to Deluge")
break
}
rejections, err = s.deluge(*action, release)
case domain.ActionTypeQbittorrent:
canDownload, client, err := s.qbittorrentCheckRulesCanDownload(*action)
if err != nil {
s.log.Error().Stack().Err(err).Msgf("error checking client rules: %v", action.Name)
break
}
if !canDownload {
rejections = []string{"max active downloads reached, skipping"}
break
}
if release.TorrentTmpFile == "" {
if err := release.DownloadTorrentFile(); err != nil {
s.log.Error().Stack().Err(err)
break
}
}
err = s.qbittorrent(client, *action, release)
if err != nil {
s.log.Error().Stack().Err(err).Msg("error sending torrent to qBittorrent")
break
}
rejections, err = s.qbittorrent(*action, release)
case domain.ActionTypeRadarr:
rejections, err = s.radarr(release, *action)
if err != nil {
s.log.Error().Stack().Err(err).Msg("error sending torrent to radarr")
break
}
rejections, err = s.radarr(*action, release)
case domain.ActionTypeSonarr:
rejections, err = s.sonarr(release, *action)
if err != nil {
s.log.Error().Stack().Err(err).Msg("error sending torrent to sonarr")
break
}
rejections, err = s.sonarr(*action, release)
case domain.ActionTypeLidarr:
rejections, err = s.lidarr(release, *action)
if err != nil {
s.log.Error().Stack().Err(err).Msg("error sending torrent to lidarr")
break
}
rejections, err = s.lidarr(*action, release)
case domain.ActionTypeWhisparr:
rejections, err = s.whisparr(release, *action)
if err != nil {
s.log.Error().Stack().Err(err).Msg("error sending torrent to whisparr")
break
}
rejections, err = s.whisparr(*action, release)
default:
s.log.Warn().Msgf("unsupported action type: %v", action.Type)
@ -161,7 +85,7 @@ func (s *service) RunAction(action *domain.Action, release domain.Release) ([]st
}
if err != nil {
s.log.Err(err).Stack().Msgf("process action failed: %v for '%v'", action.Name, release.TorrentName)
s.log.Error().Err(err).Msgf("process action failed: %v for '%v'", action.Name, release.TorrentName)
rlsActionStatus.Status = domain.ReleasePushStatusErr
rlsActionStatus.Rejections = []string{err.Error()}
@ -189,56 +113,23 @@ func (s *service) RunAction(action *domain.Action, release domain.Release) ([]st
return rejections, err
}
func (s *service) CheckCanDownload(actions []domain.Action) bool {
for _, action := range actions {
if !action.Enabled {
// only run active actions
continue
}
s.log.Debug().Msgf("action-service: check can download action: %v", action.Name)
switch action.Type {
case domain.ActionTypeDelugeV1, domain.ActionTypeDelugeV2:
canDownload, err := s.delugeCheckRulesCanDownload(action)
if err != nil {
s.log.Error().Stack().Err(err).Msgf("error checking client rules: %v", action.Name)
continue
}
if !canDownload {
continue
}
return true
case domain.ActionTypeQbittorrent:
canDownload, _, err := s.qbittorrentCheckRulesCanDownload(action)
if err != nil {
s.log.Error().Stack().Err(err).Msgf("error checking client rules: %v", action.Name)
continue
}
if !canDownload {
continue
}
return true
}
}
return false
}
func (s *service) test(name string) {
s.log.Info().Msgf("action TEST: %v", name)
}
func (s *service) watchFolder(action domain.Action, release domain.Release) {
func (s *service) watchFolder(action domain.Action, release domain.Release) error {
if release.TorrentTmpFile == "" {
if err := release.DownloadTorrentFile(); err != nil {
return errors.Wrap(err, "watch folder: could not download torrent file for release: %v", release.TorrentName)
}
}
m := NewMacro(release)
// parse and replace values in argument string before continuing
watchFolderArgs, err := m.Parse(action.WatchFolder)
if err != nil {
s.log.Error().Stack().Err(err).Msgf("could not parse macro: %v", action.WatchFolder)
return errors.Wrap(err, "could not parse watch folder macro: %v", action.WatchFolder)
}
s.log.Trace().Msgf("action WATCH_FOLDER: %v file: %v", watchFolderArgs, release.TorrentTmpFile)
@ -246,8 +137,7 @@ func (s *service) watchFolder(action domain.Action, release domain.Release) {
// Open original file
original, err := os.Open(release.TorrentTmpFile)
if err != nil {
s.log.Error().Stack().Err(err).Msgf("could not open temp file '%v'", release.TorrentTmpFile)
return
return errors.Wrap(err, "could not open temp file: %v", release.TorrentTmpFile)
}
defer original.Close()
@ -257,29 +147,34 @@ func (s *service) watchFolder(action domain.Action, release domain.Release) {
// Create new file
newFile, err := os.Create(fullFileName)
if err != nil {
s.log.Error().Stack().Err(err).Msgf("could not create new temp file '%v'", fullFileName)
return
return errors.Wrap(err, "could not create new file %v", fullFileName)
}
defer newFile.Close()
// Copy file
_, err = io.Copy(newFile, original)
if err != nil {
s.log.Error().Stack().Err(err).Msgf("could not copy file %v to watch folder", fullFileName)
return
return errors.Wrap(err, "could not copy file %v to watch folder", fullFileName)
}
s.log.Info().Msgf("saved file to watch folder: %v", fullFileName)
return nil
}
func (s *service) webhook(action domain.Action, release domain.Release) {
func (s *service) webhook(action domain.Action, release domain.Release) error {
if release.TorrentTmpFile == "" {
if err := release.DownloadTorrentFile(); err != nil {
return errors.Wrap(err, "webhook: could not download torrent file for release: %v", release.TorrentName)
}
}
m := NewMacro(release)
// parse and replace values in argument string before continuing
dataArgs, err := m.Parse(action.WebhookData)
if err != nil {
s.log.Error().Stack().Err(err).Msgf("could not parse macro: %v", action.WebhookData)
return
return errors.Wrap(err, "could not parse webhook data macro: %v", action.WebhookData)
}
s.log.Trace().Msgf("action WEBHOOK: '%v' file: %v", action.Name, release.TorrentName)
@ -295,8 +190,7 @@ func (s *service) webhook(action domain.Action, release domain.Release) {
req, err := http.NewRequest(http.MethodPost, action.WebhookHost, bytes.NewBufferString(dataArgs))
if err != nil {
s.log.Error().Err(err).Msgf("webhook client request error: %v", action.WebhookHost)
return
return errors.Wrap(err, "could not build request for webhook")
}
req.Header.Set("Content-Type", "application/json")
@ -304,13 +198,12 @@ func (s *service) webhook(action domain.Action, release domain.Release) {
res, err := client.Do(req)
if err != nil {
s.log.Error().Err(err).Msgf("webhook client request error: %v", action.WebhookHost)
return
return errors.Wrap(err, "could not make request for webhook")
}
defer res.Body.Close()
s.log.Info().Msgf("successfully ran webhook action: '%v' to: %v payload: %v", action.Name, action.WebhookHost, dataArgs)
return
return nil
}