fix(releases): max downloads per hour (#883)

* fix(releases): max downloads per hour

* refactor: release processing

* compare apples to apples (#884)

* from rocketships back to apples

* Update internal/database/filter.go

* cast me to the

* keep your eye on the case

---------

Co-authored-by: Kyle Sanderson <kyle.leet@gmail.com>
This commit is contained in:
ze0s 2023-04-29 21:52:49 +02:00 committed by GitHub
parent da5492febb
commit ef3445cbed
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 139 additions and 107 deletions

View file

@ -73,8 +73,8 @@ func (s *service) Store(ctx context.Context, release *domain.Release) error {
return nil
}
func (s *service) StoreReleaseActionStatus(ctx context.Context, actionStatus *domain.ReleaseActionStatus) error {
return s.repo.StoreReleaseActionStatus(ctx, actionStatus)
func (s *service) StoreReleaseActionStatus(ctx context.Context, status *domain.ReleaseActionStatus) error {
return s.repo.StoreReleaseActionStatus(ctx, status)
}
func (s *service) Delete(ctx context.Context) error {
@ -86,7 +86,16 @@ func (s *service) Process(release *domain.Release) {
return
}
defer func() {
if r := recover(); r != nil {
s.log.Error().Msgf("recovering from panic in release process %s error: %v", release.TorrentName, r)
//err := errors.New("panic in release process: %s", release.TorrentName)
return
}
}()
defer release.CleanupTemporaryFiles()
ctx := context.Background()
// TODO check in config for "Save all releases"
@ -94,13 +103,14 @@ func (s *service) Process(release *domain.Release) {
// TODO dupe checks
// get filters by priority
filters, err := s.filterSvc.FindByIndexerIdentifier(release.Indexer)
filters, err := s.filterSvc.FindByIndexerIdentifier(ctx, release.Indexer)
if err != nil {
s.log.Error().Err(err).Msgf("release.Process: error finding filters for indexer: %v", release.Indexer)
s.log.Error().Err(err).Msgf("release.Process: error finding filters for indexer: %s", release.Indexer)
return
}
if len(filters) == 0 {
s.log.Warn().Msgf("no active filters found for indexer: %s", release.Indexer)
return
}
@ -125,13 +135,13 @@ func (s *service) Process(release *domain.Release) {
}
if !match {
l.Trace().Msgf("release.Process: indexer: %v, filter: %v release: %v, no match. rejections: %v", release.Indexer, release.Filter.Name, release.TorrentName, release.RejectionsString())
l.Trace().Msgf("release.Process: indexer: %s, filter: %s release: %s, no match. rejections: %s", release.Indexer, release.Filter.Name, release.TorrentName, release.RejectionsString())
l.Debug().Msgf("release rejected: %v", release.RejectionsString())
l.Debug().Msgf("release rejected: %s", release.RejectionsString())
continue
}
l.Info().Msgf("Matched '%v' (%v) for %v", release.TorrentName, release.Filter.Name, release.Indexer)
l.Info().Msgf("Matched '%s' (%s) for %s", release.TorrentName, release.Filter.Name, release.Indexer)
// save release here to only save those with rejections from actions instead of all releases
if release.ID == 0 {
@ -145,7 +155,7 @@ func (s *service) Process(release *domain.Release) {
// sleep for the delay period specified in the filter before running actions
delay := release.Filter.Delay
if delay > 0 {
l.Debug().Msgf("Delaying processing of '%v' (%v) for %v by %d seconds as specified in the filter", release.TorrentName, release.Filter.Name, release.Indexer, delay)
l.Debug().Msgf("Delaying processing of '%s' (%s) for %s by %d seconds as specified in the filter", release.TorrentName, release.Filter.Name, release.Indexer, delay)
time.Sleep(time.Duration(delay) * time.Second)
}
@ -153,33 +163,42 @@ func (s *service) Process(release *domain.Release) {
// run actions (watchFolder, test, exec, qBittorrent, Deluge, arr etc.)
for _, a := range release.Filter.Actions {
act := a
// only run enabled actions
if !a.Enabled {
l.Trace().Msgf("release.Process: indexer: %v, filter: %v release: %v action '%v' not enabled, skip", release.Indexer, release.Filter.Name, release.TorrentName, a.Name)
if !act.Enabled {
l.Trace().Msgf("release.Process: indexer: %s, filter: %s release: %s action '%s' not enabled, skip", release.Indexer, release.Filter.Name, release.TorrentName, act.Name)
continue
}
l.Trace().Msgf("release.Process: indexer: %v, filter: %v release: %v , run action: %v", release.Indexer, release.Filter.Name, release.TorrentName, a.Name)
l.Trace().Msgf("release.Process: indexer: %s, filter: %s release: %s , run action: %s", release.Indexer, release.Filter.Name, release.TorrentName, act.Name)
// keep track of action clients to avoid sending the same thing all over again
_, tried := triedActionClients[actionClientTypeKey{Type: a.Type, ClientID: a.ClientID}]
// keep track of actiom clients to avoid sending the same thing all over again
_, tried := triedActionClients[actionClientTypeKey{Type: act.Type, ClientID: act.ClientID}]
if tried {
l.Trace().Msgf("release.Process: indexer: %v, filter: %v release: %v action client already tried, skip", release.Indexer, release.Filter.Name, release.TorrentName)
l.Trace().Msgf("release.Process: indexer: %s, filter: %s release: %s action client already tried, skip", release.Indexer, release.Filter.Name, release.TorrentName)
continue
}
rejections, err = s.actionSvc.RunAction(ctx, a, release)
// run action
status, err := s.runAction(ctx, act, release)
if err != nil {
l.Error().Stack().Err(err).Msgf("release.Process: error running actions for filter: %v", release.Filter.Name)
continue
l.Error().Stack().Err(err).Msgf("release.Process: error running actions for filter: %s", release.Filter.Name)
//continue
}
rejections = status.Rejections
if err := s.StoreReleaseActionStatus(ctx, status); err != nil {
s.log.Error().Err(err).Msgf("release.Process: error storing action status for filter: %s", release.Filter.Name)
}
if len(rejections) > 0 {
// if we get a rejection, remember which action client it was from
triedActionClients[actionClientTypeKey{Type: a.Type, ClientID: a.ClientID}] = struct{}{}
// if we get action rejection, remember which action client it was from
triedActionClients[actionClientTypeKey{Type: act.Type, ClientID: act.ClientID}] = struct{}{}
// log something and fire events
l.Debug().Str("action", a.Name).Str("action_type", string(a.Type)).Msgf("release rejected: %v", strings.Join(rejections, ", "))
l.Debug().Str("action", act.Name).Str("action_type", string(act.Type)).Msgf("release rejected: %s", strings.Join(rejections, ", "))
}
// if no rejections consider action approved, run next
@ -209,3 +228,33 @@ func (s *service) ProcessMultiple(releases []*domain.Release) {
s.Process(rls)
}
}
func (s *service) runAction(ctx context.Context, action *domain.Action, release *domain.Release) (*domain.ReleaseActionStatus, error) {
// add action status as pending
status := domain.NewReleaseActionStatus(action, release)
if err := s.StoreReleaseActionStatus(ctx, status); err != nil {
s.log.Error().Err(err).Msgf("release.runAction: error storing action for filter: %s", release.Filter.Name)
}
rejections, err := s.actionSvc.RunAction(ctx, action, release)
if err != nil {
s.log.Error().Stack().Err(err).Msgf("release.runAction: error running actions for filter: %s", release.Filter.Name)
status.Status = domain.ReleasePushStatusErr
status.Rejections = []string{err.Error()}
return status, err
}
if rejections != nil {
status.Status = domain.ReleasePushStatusRejected
status.Rejections = rejections
return status, nil
}
status.Status = domain.ReleasePushStatusApproved
return status, nil
}