public Decision IsSatisfiedBy(RemoteMovie subject, SearchCriteriaBase searchCriteria)
{
var torrentInfo = subject.Release as TorrentInfo;
IIndexerSettings indexerSettings = null;
try {
indexerSettings = _indexerFactory.Get(subject.Release.IndexerId)?.Settings as IIndexerSettings;
}
catch (Exception e)
{
_logger.Debug("Indexer with id {0} does not exist, skipping minimum seeder checks.", subject.Release.IndexerId);
}
if (torrentInfo == null || indexerSettings == null)
{
return(Decision.Accept());
}
if (indexerSettings is ITorrentIndexerSettings torrentIndexerSettings)
{
var minimumSeeders = torrentIndexerSettings.MinimumSeeders;
if (torrentInfo.Seeders.HasValue && torrentInfo.Seeders.Value < minimumSeeders)
{
_logger.Debug("Not enough seeders: {0}. Minimum seeders: {1}", torrentInfo.Seeders, minimumSeeders);
return(Decision.Reject("Not enough seeders: {0}. Minimum seeders: {1}", torrentInfo.Seeders, minimumSeeders));
}
}
return(Decision.Accept());
}
public virtual Decision IsSatisfiedBy(RemoteMovie subject, SearchCriteriaBase searchCriteria)
{
if (subject.Release == null || subject.Movie?.Tags == null || subject.Release.IndexerId == 0)
{
return(Decision.Accept());
}
IndexerDefinition indexer;
try
{
indexer = _indexerFactory.Get(subject.Release.IndexerId);
}
catch (ModelNotFoundException)
{
_logger.Debug("Indexer with id {0} does not exist, skipping indexer tags check", subject.Release.IndexerId);
return(Decision.Accept());
}
// If indexer has tags, check that at least one of them is present on the series
var indexerTags = indexer.Tags;
if (indexerTags.Any() && indexerTags.Intersect(subject.Movie.Tags).Empty())
{
_logger.Debug("Indexer {0} has tags. None of these are present on movie {1}. Rejecting", subject.Release.Indexer, subject.Movie);
return(Decision.Reject("Movie tags do not match any of the indexer tags"));
}
return(Decision.Accept());
}
private void ResolveIndexer(ReleaseInfo release)
{
if (release.IndexerId == 0 && release.Indexer.IsNotNullOrWhiteSpace())
{
var indexer = _indexerFactory.All().FirstOrDefault(v => v.Name == release.Indexer);
if (indexer != null)
{
release.IndexerId = indexer.Id;
_logger.Debug("Push Release {0} associated with indexer {1} - {2}.", release.Title, release.IndexerId, release.Indexer);
}
else
{
_logger.Debug("Push Release {0} not associated with unknown indexer {1}.", release.Title, release.Indexer);
}
}
else if (release.IndexerId != 0 && release.Indexer.IsNullOrWhiteSpace())
{
try
{
var indexer = _indexerFactory.Get(release.IndexerId);
release.Indexer = indexer.Name;
_logger.Debug("Push Release {0} associated with indexer {1} - {2}.", release.Title, release.IndexerId, release.Indexer);
}
catch (ModelNotFoundException)
{
_logger.Debug("Push Release {0} not associated with unknown indexer {0}.", release.Title, release.IndexerId);
release.IndexerId = 0;
}
}
else
{
_logger.Debug("Push Release {0} not associated with an indexer.", release.Title);
}
}
public ActionResult <SearchResource> GrabRelease(SearchResource release)
{
ValidateResource(release);
var releaseInfo = _remoteReleaseCache.Find(GetCacheKey(release));
var indexerDef = _indexerFactory.Get(release.IndexerId);
var source = UserAgentParser.ParseSource(Request.Headers["User-Agent"]);
var host = Request.GetHostName();
try
{
_downloadService.SendReportToClient(releaseInfo, source, host, indexerDef.Redirect);
}
catch (ReleaseDownloadException ex)
{
_logger.Error(ex, "Getting release from indexer failed");
throw new NzbDroneClientException(HttpStatusCode.Conflict, "Getting release from indexer failed");
}
return(Ok(release));
}
private SeedCriteriaSettings FetchSeedCriteria(int indexerId)
{
try
{
var indexer = _indexerFactory.Get(indexerId);
var torrentIndexerSettings = indexer.Settings as ITorrentIndexerSettings;
return(torrentIndexerSettings?.SeedCriteria);
}
catch (ModelNotFoundException)
{
return(null);
}
}
public Decision IsSatisfiedBy(RemoteEpisode remoteEpisode, SearchCriteriaBase searchCriteria)
{
var torrentInfo = remoteEpisode.Release as TorrentInfo;
if (torrentInfo == null || torrentInfo.IndexerId == 0)
{
return(Decision.Accept());
}
IndexerDefinition indexer;
try
{
indexer = _indexerFactory.Get(torrentInfo.IndexerId);
}
catch (ModelNotFoundException)
{
_logger.Debug("Indexer with id {0} does not exist, skipping seeders check", torrentInfo.IndexerId);
return(Decision.Accept());
}
var torrentIndexerSettings = indexer.Settings as ITorrentIndexerSettings;
if (torrentIndexerSettings != null)
{
var minimumSeeders = torrentIndexerSettings.MinimumSeeders;
if (torrentInfo.Seeders.HasValue && torrentInfo.Seeders.Value < minimumSeeders)
{
_logger.Debug("Not enough seeders: {0}. Minimum seeders: {1}", torrentInfo.Seeders, minimumSeeders);
return(Decision.Reject("Not enough seeders: {0}. Minimum seeders: {1}", torrentInfo.Seeders, minimumSeeders));
}
}
return(Decision.Accept());
}
public Decision IsSatisfiedBy(RemoteBook subject, SearchCriteriaBase searchCriteria)
{
var releaseInfo = subject.Release;
if (releaseInfo == null || releaseInfo.IndexerId == 0)
{
return(Decision.Accept());
}
IndexerDefinition indexer;
try
{
indexer = _indexerFactory.Get(subject.Release.IndexerId);
}
catch (ModelNotFoundException)
{
_logger.Debug("Indexer with id {0} does not exist, skipping early release check", subject.Release.IndexerId);
return(Decision.Accept());
}
var indexerSettings = indexer.Settings as IIndexerSettings;
if (subject.Books.Count != 1 || indexerSettings?.EarlyReleaseLimit == null)
{
return(Decision.Accept());
}
var releaseDate = subject.Books.First().ReleaseDate;
if (releaseDate == null)
{
return(Decision.Accept());
}
var isEarly = releaseDate.Value > subject.Release.PublishDate.AddDays(indexerSettings.EarlyReleaseLimit.Value);
if (isEarly)
{
var message = $"Release published date, {subject.Release.PublishDate.ToShortDateString()}, is outside of {indexerSettings.EarlyReleaseLimit.Value} day early grab limit allowed by user";
_logger.Debug(message);
return(Decision.Reject(message));
}
return(Decision.Accept());
}
public Decision IsSatisfiedBy(RemoteMovie subject, SearchCriteriaBase searchCriteria)
{
var torrentInfo = subject.Release;
IIndexerSettings indexerSettings = null;
try
{
indexerSettings = _indexerFactory.Get(subject.Release.IndexerId)?.Settings as IIndexerSettings;
}
catch (Exception)
{
_logger.Debug("Indexer with id {0} does not exist, skipping required indexer flags specs.", subject.Release.IndexerId);
}
if (torrentInfo == null || indexerSettings == null)
{
return(Decision.Accept());
}
if (indexerSettings is ITorrentIndexerSettings torrentIndexerSettings)
{
var requiredFlags = torrentIndexerSettings.RequiredFlags;
var requiredFlag = (IndexerFlags)0;
if (requiredFlags == null || !requiredFlags.Any())
{
return(Decision.Accept());
}
foreach (var flag in requiredFlags)
{
if (torrentInfo.IndexerFlags.HasFlag((IndexerFlags)flag))
{
return(Decision.Accept());
}
requiredFlag |= (IndexerFlags)flag;
}
_logger.Debug("None of the required indexer flags {0} where found. Found flags: {1}", requiredFlag, torrentInfo.IndexerFlags);
return(Decision.Reject("None of the required indexer flags {0} where found. Found flags: {1}", requiredFlag, torrentInfo.IndexerFlags));
}
return(Decision.Accept());
}
public ParsedMovieInfo AugmentMovieInfo(ParsedMovieInfo movieInfo, object helper)
{
if (helper is ReleaseInfo releaseInfo)
{
IIndexerSettings indexerSettings = null;
try
{
indexerSettings = _indexerFactory.Get(releaseInfo.IndexerId)?.Settings as IIndexerSettings;
}
catch (Exception)
{
//_logger.Debug("Indexer with id {0} does not exist, skipping minimum seeder checks.", subject.Release.IndexerId);
} // First, let's augment the language!
var languageTitle = movieInfo.SimpleReleaseTitle;
if (movieInfo.MovieTitle.IsNotNullOrWhiteSpace())
{
if (languageTitle.ToLower().Contains("multi") && indexerSettings?.MultiLanguages?.Any() == true)
{
foreach (var i in indexerSettings.MultiLanguages)
{
var language = (Language)i;
if (!movieInfo.Languages.Contains(language))
{
movieInfo.Languages.Add(language);
}
}
}
}
//Next, let's add other useful info to the extra info dict
if (!movieInfo.ExtraInfo.ContainsKey("Size"))
{
movieInfo.ExtraInfo["Size"] = releaseInfo.Size;
}
movieInfo.ExtraInfo["IndexerFlags"] = releaseInfo.IndexerFlags;
}
return(movieInfo);
}
public TorrentSeedConfiguration GetSeedConfiguration(RemoteMovie remoteMovie)
{
if (remoteMovie.Release.DownloadProtocol != DownloadProtocol.Torrent)
{
return(null);
}
if (remoteMovie.Release.IndexerId == 0)
{
return(null);
}
try
{
var indexer = _indexerFactory.Get(remoteMovie.Release.IndexerId);
var torrentIndexerSettings = indexer.Settings as ITorrentIndexerSettings;
if (torrentIndexerSettings != null && torrentIndexerSettings.SeedCriteria != null)
{
var seedConfig = new TorrentSeedConfiguration
{
Ratio = torrentIndexerSettings.SeedCriteria.SeedRatio
};
var seedTime = torrentIndexerSettings.SeedCriteria.SeedTime;
if (seedTime.HasValue)
{
seedConfig.SeedTime = TimeSpan.FromMinutes(seedTime.Value);
}
return(seedConfig);
}
}
catch (ModelNotFoundException)
{
return(null);
}
return(null);
}
public async Task SendReportToClient(ReleaseInfo release, string source, string host, bool redirect)
{
var downloadTitle = release.Title;
var downloadClient = _downloadClientProvider.GetDownloadClient(release.DownloadProtocol);
if (downloadClient == null)
{
throw new DownloadClientUnavailableException($"{release.DownloadProtocol} Download client isn't configured yet");
}
// Get the seed configuration for this release.
// remoteMovie.SeedConfiguration = _seedConfigProvider.GetSeedConfiguration(remoteMovie);
// Limit grabs to 2 per second.
if (release.DownloadUrl.IsNotNullOrWhiteSpace() && !release.DownloadUrl.StartsWith("magnet:"))
{
var url = new HttpUri(release.DownloadUrl);
_rateLimitService.WaitAndPulse(url.Host, TimeSpan.FromSeconds(2));
}
var indexer = _indexerFactory.GetInstance(_indexerFactory.Get(release.IndexerId));
string downloadClientId;
try
{
downloadClientId = await downloadClient.Download(release, redirect, indexer);
_downloadClientStatusService.RecordSuccess(downloadClient.Definition.Id);
_indexerStatusService.RecordSuccess(release.IndexerId);
}
catch (ReleaseUnavailableException)
{
_logger.Trace("Release {0} no longer available on indexer.", release);
_eventAggregator.PublishEvent(new IndexerDownloadEvent(release.IndexerId, false, source, host, release.Title, release.DownloadUrl, redirect));
throw;
}
catch (DownloadClientRejectedReleaseException)
{
_logger.Trace("Release {0} rejected by download client, possible duplicate.", release);
_eventAggregator.PublishEvent(new IndexerDownloadEvent(release.IndexerId, false, source, host, release.Title, release.DownloadUrl, redirect));
throw;
}
catch (ReleaseDownloadException ex)
{
var http429 = ex.InnerException as TooManyRequestsException;
if (http429 != null)
{
_indexerStatusService.RecordFailure(release.IndexerId, http429.RetryAfter);
}
else
{
_indexerStatusService.RecordFailure(release.IndexerId);
}
_eventAggregator.PublishEvent(new IndexerDownloadEvent(release.IndexerId, false, source, host, release.Title, release.DownloadUrl, redirect));
throw;
}
_logger.ProgressInfo("Report sent to {0}. {1}", downloadClient.Definition.Name, downloadTitle);
_eventAggregator.PublishEvent(new IndexerDownloadEvent(release.IndexerId, true, source, host, release.Title, release.DownloadUrl, redirect));
}
