feat(confg): reload on save and refactor logging (#275)

* feat(confg): reload on save

* refactor(logging): rework
This commit is contained in:
Ludvig Lundgren 2022-05-20 09:27:01 +02:00 committed by GitHub
parent 198528a474
commit 91b094f4f4
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
56 changed files with 995 additions and 873 deletions

View file

@ -9,8 +9,6 @@ import (
"path"
"time"
"github.com/rs/zerolog/log"
"github.com/autobrr/autobrr/internal/domain"
)
@ -22,11 +20,11 @@ func (s *service) RunActions(actions []domain.Action, release domain.Release) er
continue
}
log.Debug().Msgf("process action: %v for '%v'", action.Name, release.TorrentName)
s.log.Debug().Msgf("process action: %v for '%v'", action.Name, release.TorrentName)
err := s.runAction(action, release)
if err != nil {
log.Err(err).Stack().Msgf("process action failed: %v for '%v'", action.Name, release.TorrentName)
s.log.Err(err).Stack().Msgf("process action failed: %v for '%v'", action.Name, release.TorrentName)
s.bus.Publish("release:store-action-status", &domain.ReleaseActionStatus{
ReleaseID: release.ID,
@ -71,7 +69,7 @@ func (s *service) RunAction(action *domain.Action, release domain.Release) ([]st
case domain.ActionTypeExec:
if release.TorrentTmpFile == "" {
if err := release.DownloadTorrentFile(); err != nil {
log.Error().Stack().Err(err)
s.log.Error().Stack().Err(err)
break
}
}
@ -81,7 +79,7 @@ func (s *service) RunAction(action *domain.Action, release domain.Release) ([]st
case domain.ActionTypeWatchFolder:
if release.TorrentTmpFile == "" {
if err := release.DownloadTorrentFile(); err != nil {
log.Error().Stack().Err(err)
s.log.Error().Stack().Err(err)
break
}
}
@ -91,7 +89,7 @@ func (s *service) RunAction(action *domain.Action, release domain.Release) ([]st
case domain.ActionTypeWebhook:
if release.TorrentTmpFile == "" {
if err := release.DownloadTorrentFile(); err != nil {
log.Error().Stack().Err(err)
s.log.Error().Stack().Err(err)
break
}
}
@ -101,7 +99,7 @@ func (s *service) RunAction(action *domain.Action, release domain.Release) ([]st
case domain.ActionTypeDelugeV1, domain.ActionTypeDelugeV2:
canDownload, err := s.delugeCheckRulesCanDownload(*action)
if err != nil {
log.Error().Stack().Err(err).Msgf("error checking client rules: %v", action.Name)
s.log.Error().Stack().Err(err).Msgf("error checking client rules: %v", action.Name)
break
}
if !canDownload {
@ -111,21 +109,21 @@ func (s *service) RunAction(action *domain.Action, release domain.Release) ([]st
if release.TorrentTmpFile == "" {
if err := release.DownloadTorrentFile(); err != nil {
log.Error().Stack().Err(err)
s.log.Error().Stack().Err(err)
break
}
}
err = s.deluge(*action, release)
if err != nil {
log.Error().Stack().Err(err).Msg("error sending torrent to Deluge")
s.log.Error().Stack().Err(err).Msg("error sending torrent to Deluge")
break
}
case domain.ActionTypeQbittorrent:
canDownload, client, err := s.qbittorrentCheckRulesCanDownload(*action)
if err != nil {
log.Error().Stack().Err(err).Msgf("error checking client rules: %v", action.Name)
s.log.Error().Stack().Err(err).Msgf("error checking client rules: %v", action.Name)
break
}
if !canDownload {
@ -135,47 +133,47 @@ func (s *service) RunAction(action *domain.Action, release domain.Release) ([]st
if release.TorrentTmpFile == "" {
if err := release.DownloadTorrentFile(); err != nil {
log.Error().Stack().Err(err)
s.log.Error().Stack().Err(err)
break
}
}
err = s.qbittorrent(client, *action, release)
if err != nil {
log.Error().Stack().Err(err).Msg("error sending torrent to qBittorrent")
s.log.Error().Stack().Err(err).Msg("error sending torrent to qBittorrent")
break
}
case domain.ActionTypeRadarr:
rejections, err = s.radarr(release, *action)
if err != nil {
log.Error().Stack().Err(err).Msg("error sending torrent to radarr")
s.log.Error().Stack().Err(err).Msg("error sending torrent to radarr")
break
}
case domain.ActionTypeSonarr:
rejections, err = s.sonarr(release, *action)
if err != nil {
log.Error().Stack().Err(err).Msg("error sending torrent to sonarr")
s.log.Error().Stack().Err(err).Msg("error sending torrent to sonarr")
break
}
case domain.ActionTypeLidarr:
rejections, err = s.lidarr(release, *action)
if err != nil {
log.Error().Stack().Err(err).Msg("error sending torrent to lidarr")
s.log.Error().Stack().Err(err).Msg("error sending torrent to lidarr")
break
}
case domain.ActionTypeWhisparr:
rejections, err = s.whisparr(release, *action)
if err != nil {
log.Error().Stack().Err(err).Msg("error sending torrent to whisparr")
s.log.Error().Stack().Err(err).Msg("error sending torrent to whisparr")
break
}
default:
log.Warn().Msgf("unsupported action type: %v", action.Type)
s.log.Warn().Msgf("unsupported action type: %v", action.Type)
return rejections, err
}
@ -205,7 +203,7 @@ func (s *service) RunAction(action *domain.Action, release domain.Release) ([]st
}
if err != nil {
log.Err(err).Stack().Msgf("process action failed: %v for '%v'", action.Name, release.TorrentName)
s.log.Err(err).Stack().Msgf("process action failed: %v for '%v'", action.Name, release.TorrentName)
rlsActionStatus.Status = domain.ReleasePushStatusErr
rlsActionStatus.Rejections = []string{err.Error()}
@ -243,7 +241,7 @@ func (s *service) runAction(action domain.Action, release domain.Release) error
case domain.ActionTypeExec:
if release.TorrentTmpFile == "" {
if err := release.DownloadTorrentFile(); err != nil {
log.Error().Stack().Err(err)
s.log.Error().Stack().Err(err)
return err
}
}
@ -253,7 +251,7 @@ func (s *service) runAction(action domain.Action, release domain.Release) error
case domain.ActionTypeWatchFolder:
if release.TorrentTmpFile == "" {
if err := release.DownloadTorrentFile(); err != nil {
log.Error().Stack().Err(err)
s.log.Error().Stack().Err(err)
return err
}
}
@ -263,7 +261,7 @@ func (s *service) runAction(action domain.Action, release domain.Release) error
case domain.ActionTypeWebhook:
if release.TorrentTmpFile == "" {
if err := release.DownloadTorrentFile(); err != nil {
log.Error().Stack().Err(err)
s.log.Error().Stack().Err(err)
return err
}
}
@ -273,7 +271,7 @@ func (s *service) runAction(action domain.Action, release domain.Release) error
case domain.ActionTypeDelugeV1, domain.ActionTypeDelugeV2:
canDownload, err := s.delugeCheckRulesCanDownload(action)
if err != nil {
log.Error().Stack().Err(err).Msgf("error checking client rules: %v", action.Name)
s.log.Error().Stack().Err(err).Msgf("error checking client rules: %v", action.Name)
return err
}
if !canDownload {
@ -283,21 +281,21 @@ func (s *service) runAction(action domain.Action, release domain.Release) error
if release.TorrentTmpFile == "" {
if err := release.DownloadTorrentFile(); err != nil {
log.Error().Stack().Err(err)
s.log.Error().Stack().Err(err)
return err
}
}
err = s.deluge(action, release)
if err != nil {
log.Error().Stack().Err(err).Msg("error sending torrent to Deluge")
s.log.Error().Stack().Err(err).Msg("error sending torrent to Deluge")
return err
}
case domain.ActionTypeQbittorrent:
canDownload, client, err := s.qbittorrentCheckRulesCanDownload(action)
if err != nil {
log.Error().Stack().Err(err).Msgf("error checking client rules: %v", action.Name)
s.log.Error().Stack().Err(err).Msgf("error checking client rules: %v", action.Name)
return err
}
if !canDownload {
@ -307,47 +305,47 @@ func (s *service) runAction(action domain.Action, release domain.Release) error
if release.TorrentTmpFile == "" {
if err := release.DownloadTorrentFile(); err != nil {
log.Error().Stack().Err(err)
s.log.Error().Stack().Err(err)
return err
}
}
err = s.qbittorrent(client, action, release)
if err != nil {
log.Error().Stack().Err(err).Msg("error sending torrent to qBittorrent")
s.log.Error().Stack().Err(err).Msg("error sending torrent to qBittorrent")
return err
}
case domain.ActionTypeRadarr:
rejections, err = s.radarr(release, action)
if err != nil {
log.Error().Stack().Err(err).Msg("error sending torrent to radarr")
s.log.Error().Stack().Err(err).Msg("error sending torrent to radarr")
return err
}
case domain.ActionTypeSonarr:
rejections, err = s.sonarr(release, action)
if err != nil {
log.Error().Stack().Err(err).Msg("error sending torrent to sonarr")
s.log.Error().Stack().Err(err).Msg("error sending torrent to sonarr")
return err
}
case domain.ActionTypeLidarr:
rejections, err = s.lidarr(release, action)
if err != nil {
log.Error().Stack().Err(err).Msg("error sending torrent to lidarr")
s.log.Error().Stack().Err(err).Msg("error sending torrent to lidarr")
return err
}
case domain.ActionTypeWhisparr:
rejections, err = s.whisparr(release, action)
if err != nil {
log.Error().Stack().Err(err).Msg("error sending torrent to whisparr")
s.log.Error().Stack().Err(err).Msg("error sending torrent to whisparr")
return err
}
default:
log.Warn().Msgf("unsupported action: %v type: %v", action.Name, action.Type)
s.log.Warn().Msgf("unsupported action: %v type: %v", action.Name, action.Type)
return nil
}
@ -399,13 +397,13 @@ func (s *service) CheckCanDownload(actions []domain.Action) bool {
continue
}
log.Debug().Msgf("action-service: check can download action: %v", action.Name)
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 {
log.Error().Stack().Err(err).Msgf("error checking client rules: %v", action.Name)
s.log.Error().Stack().Err(err).Msgf("error checking client rules: %v", action.Name)
continue
}
if !canDownload {
@ -417,7 +415,7 @@ func (s *service) CheckCanDownload(actions []domain.Action) bool {
case domain.ActionTypeQbittorrent:
canDownload, _, err := s.qbittorrentCheckRulesCanDownload(action)
if err != nil {
log.Error().Stack().Err(err).Msgf("error checking client rules: %v", action.Name)
s.log.Error().Stack().Err(err).Msgf("error checking client rules: %v", action.Name)
continue
}
if !canDownload {
@ -432,7 +430,7 @@ func (s *service) CheckCanDownload(actions []domain.Action) bool {
}
func (s *service) test(name string) {
log.Info().Msgf("action TEST: %v", name)
s.log.Info().Msgf("action TEST: %v", name)
}
func (s *service) watchFolder(action domain.Action, release domain.Release) {
@ -441,15 +439,15 @@ func (s *service) watchFolder(action domain.Action, release domain.Release) {
// parse and replace values in argument string before continuing
watchFolderArgs, err := m.Parse(action.WatchFolder)
if err != nil {
log.Error().Stack().Err(err).Msgf("could not parse macro: %v", action.WatchFolder)
s.log.Error().Stack().Err(err).Msgf("could not parse macro: %v", action.WatchFolder)
}
log.Trace().Msgf("action WATCH_FOLDER: %v file: %v", watchFolderArgs, release.TorrentTmpFile)
s.log.Trace().Msgf("action WATCH_FOLDER: %v file: %v", watchFolderArgs, release.TorrentTmpFile)
// Open original file
original, err := os.Open(release.TorrentTmpFile)
if err != nil {
log.Error().Stack().Err(err).Msgf("could not open temp file '%v'", release.TorrentTmpFile)
s.log.Error().Stack().Err(err).Msgf("could not open temp file '%v'", release.TorrentTmpFile)
return
}
defer original.Close()
@ -460,7 +458,7 @@ func (s *service) watchFolder(action domain.Action, release domain.Release) {
// Create new file
newFile, err := os.Create(fullFileName)
if err != nil {
log.Error().Stack().Err(err).Msgf("could not create new temp file '%v'", fullFileName)
s.log.Error().Stack().Err(err).Msgf("could not create new temp file '%v'", fullFileName)
return
}
defer newFile.Close()
@ -468,11 +466,11 @@ func (s *service) watchFolder(action domain.Action, release domain.Release) {
// Copy file
_, err = io.Copy(newFile, original)
if err != nil {
log.Error().Stack().Err(err).Msgf("could not copy file %v to watch folder", fullFileName)
s.log.Error().Stack().Err(err).Msgf("could not copy file %v to watch folder", fullFileName)
return
}
log.Info().Msgf("saved file to watch folder: %v", fullFileName)
s.log.Info().Msgf("saved file to watch folder: %v", fullFileName)
}
func (s *service) webhook(action domain.Action, release domain.Release) {
@ -481,12 +479,12 @@ func (s *service) webhook(action domain.Action, release domain.Release) {
// parse and replace values in argument string before continuing
dataArgs, err := m.Parse(action.WebhookData)
if err != nil {
log.Error().Stack().Err(err).Msgf("could not parse macro: %v", action.WebhookData)
s.log.Error().Stack().Err(err).Msgf("could not parse macro: %v", action.WebhookData)
return
}
log.Trace().Msgf("action WEBHOOK: '%v' file: %v", action.Name, release.TorrentName)
log.Trace().Msgf("webhook action '%v' - host: %v data: %v", action.Name, action.WebhookHost, action.WebhookData)
s.log.Trace().Msgf("action WEBHOOK: '%v' file: %v", action.Name, release.TorrentName)
s.log.Trace().Msgf("webhook action '%v' - host: %v data: %v", action.Name, action.WebhookHost, action.WebhookData)
t := &http.Transport{
TLSClientConfig: &tls.Config{
@ -498,7 +496,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 {
log.Error().Err(err).Msgf("webhook client request error: %v", action.WebhookHost)
s.log.Error().Err(err).Msgf("webhook client request error: %v", action.WebhookHost)
return
}
@ -507,13 +505,13 @@ func (s *service) webhook(action domain.Action, release domain.Release) {
res, err := client.Do(req)
if err != nil {
log.Error().Err(err).Msgf("webhook client request error: %v", action.WebhookHost)
s.log.Error().Err(err).Msgf("webhook client request error: %v", action.WebhookHost)
return
}
defer res.Body.Close()
log.Info().Msgf("successfully ran webhook action: '%v' to: %v payload: %v", action.Name, action.WebhookHost, dataArgs)
s.log.Info().Msgf("successfully ran webhook action: '%v' to: %v payload: %v", action.Name, action.WebhookHost, dataArgs)
return
}