New: Added Torznab as generic indexer.

2026-04-25 22:36:59 -04:00 · 2015-03-12 21:01:54 +01:00
parent 37e4a06b5d
commit c7470a426a
13 changed files with 1005 additions and 0 deletions
@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NLog;
+using NzbDrone.Common.Http;
+using NzbDrone.Core.Configuration;
+using NzbDrone.Core.Parser;
+using NzbDrone.Core.ThingiProvider;
+
+namespace NzbDrone.Core.Indexers.Torznab
+{
+    public class Torznab : HttpIndexerBase<TorznabSettings>
+    {
+        public override DownloadProtocol Protocol { get { return DownloadProtocol.Torrent; } }
+        public override Int32 PageSize { get { return 100; } }
+
+        public override IIndexerRequestGenerator GetRequestGenerator()
+        {
+            return new TorznabRequestGenerator()
+            {
+                PageSize = PageSize, 
+                Settings = Settings
+            };
+        }
+
+        public override IParseIndexerResponse GetParser()
+        {
+            return new TorznabRssParser();
+        }
+
+        public override IEnumerable<ProviderDefinition> DefaultDefinitions
+        {
+            get
+            {
+                yield return GetDefinition("HDAccess.net", GetSettings("http://hdaccess.net"));
+            }
+        }
+
+        public Torznab(IHttpClient httpClient, IConfigService configService, IParsingService parsingService, Logger logger)
+            : base(httpClient, configService, parsingService, logger)
+        {
+
+        }
+
+        private IndexerDefinition GetDefinition(String name, TorznabSettings settings)
+        {
+            return new IndexerDefinition
+                   {
+                       EnableRss = false,
+                       EnableSearch = false,
+                       Name = name,
+                       Implementation = GetType().Name,
+                       Settings = settings,
+                       Protocol = DownloadProtocol.Usenet,
+                       SupportsRss = SupportsRss,
+                       SupportsSearch = SupportsSearch
+                   };
+        }
+
+        private TorznabSettings GetSettings(String url, params int[] categories)
+        {
+            var settings = new TorznabSettings { Url = url };
+
+            if (categories.Any())
+            {
+                settings.Categories = categories;
+            }
+
+            return settings;
+        }
+    }
+}
@@ -0,0 +1,16 @@
+using NzbDrone.Common.Exceptions;
+
+namespace NzbDrone.Core.Indexers.Torznab
+{
+    public class TorznabException : NzbDroneException
+    {
+        public TorznabException(string message, params object[] args) : base(message, args)
+        {
+        }
+
+        public TorznabException(string message)
+            : base(message)
+        {
+        }
+    }
+}
@@ -0,0 +1,175 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NzbDrone.Common.Extensions;
+using NzbDrone.Common.Http;
+using NzbDrone.Core.IndexerSearch.Definitions;
+
+namespace NzbDrone.Core.Indexers.Torznab
+{
+    public class TorznabRequestGenerator : IIndexerRequestGenerator
+    {
+        public Int32 MaxPages { get; set; }
+        public Int32 PageSize { get; set; }
+        public TorznabSettings Settings { get; set; }
+
+        public TorznabRequestGenerator()
+        {
+            MaxPages = 30;
+            PageSize = 100;
+        }
+
+        public virtual IList<IEnumerable<IndexerRequest>> GetRecentRequests()
+        {
+            var pageableRequests = new List<IEnumerable<IndexerRequest>>();
+
+            // TODO: We might consider getting multiple pages in the future, but atm we limit it to 1 page.
+            pageableRequests.AddIfNotNull(GetPagedRequests(1, Settings.Categories.Concat(Settings.AnimeCategories), "tvsearch", ""));
+
+            return pageableRequests;
+        }
+
+        public virtual IList<IEnumerable<IndexerRequest>> GetSearchRequests(SingleEpisodeSearchCriteria searchCriteria)
+        {
+            var pageableRequests = new List<IEnumerable<IndexerRequest>>();
+
+            if (searchCriteria.Series.TvRageId > 0)
+            {
+                pageableRequests.AddIfNotNull(GetPagedRequests(MaxPages, Settings.Categories, "tvsearch",
+                    String.Format("&rid={0}&season={1}&ep={2}",
+                    searchCriteria.Series.TvRageId,
+                    searchCriteria.SeasonNumber,
+                    searchCriteria.EpisodeNumber)));
+            }
+            else
+            {
+                foreach (var queryTitle in searchCriteria.QueryTitles)
+                {
+                    pageableRequests.AddIfNotNull(GetPagedRequests(MaxPages, Settings.Categories, "tvsearch",
+                        String.Format("&q={0}&season={1}&ep={2}",
+                        NewsnabifyTitle(queryTitle),
+                        searchCriteria.SeasonNumber,
+                        searchCriteria.EpisodeNumber)));
+                }
+            }
+
+            return pageableRequests;
+        }
+
+        public virtual IList<IEnumerable<IndexerRequest>> GetSearchRequests(SeasonSearchCriteria searchCriteria)
+        {
+            var pageableRequests = new List<IEnumerable<IndexerRequest>>();
+
+            if (searchCriteria.Series.TvRageId > 0)
+            {
+                pageableRequests.AddIfNotNull(GetPagedRequests(MaxPages, Settings.Categories, "tvsearch",
+                    String.Format("&rid={0}&season={1}",
+                    searchCriteria.Series.TvRageId,
+                    searchCriteria.SeasonNumber)));
+            }
+            else
+            {
+                foreach (var queryTitle in searchCriteria.QueryTitles)
+                {
+                    pageableRequests.AddIfNotNull(GetPagedRequests(MaxPages, Settings.Categories, "tvsearch",
+                        String.Format("&q={0}&season={1}",
+                        NewsnabifyTitle(queryTitle),
+                        searchCriteria.SeasonNumber)));
+                }
+            }
+
+            return pageableRequests;
+        }
+
+        public virtual IList<IEnumerable<IndexerRequest>> GetSearchRequests(DailyEpisodeSearchCriteria searchCriteria)
+        {
+            var pageableRequests = new List<IEnumerable<IndexerRequest>>();
+
+            if (searchCriteria.Series.TvRageId > 0)
+            {
+                pageableRequests.AddIfNotNull(GetPagedRequests(MaxPages, Settings.Categories, "tvsearch",
+                    String.Format("&rid={0}&season={1:yyyy}&ep={1:MM}/{1:dd}",
+                    searchCriteria.Series.TvRageId,
+                    searchCriteria.AirDate)));
+            }
+            else
+            {
+                foreach (var queryTitle in searchCriteria.QueryTitles)
+                {
+                    pageableRequests.AddIfNotNull(GetPagedRequests(MaxPages, Settings.Categories, "tvsearch",
+                        String.Format("&q={0}&season={1:yyyy}&ep={1:MM}/{1:dd}",
+                        NewsnabifyTitle(queryTitle),
+                        searchCriteria.AirDate)));
+                }
+            }
+
+            return pageableRequests;
+        }
+
+        public virtual IList<IEnumerable<IndexerRequest>> GetSearchRequests(AnimeEpisodeSearchCriteria searchCriteria)
+        {
+            var pageableRequests = new List<IEnumerable<IndexerRequest>>();
+
+            foreach (var queryTitle in searchCriteria.QueryTitles)
+            {
+                pageableRequests.AddIfNotNull(GetPagedRequests(MaxPages, Settings.AnimeCategories, "search",
+                    String.Format("&q={0}+{1:00}",
+                    NewsnabifyTitle(queryTitle),
+                    searchCriteria.AbsoluteEpisodeNumber)));
+            }
+
+            return pageableRequests;
+        }
+
+        public virtual IList<IEnumerable<IndexerRequest>> GetSearchRequests(SpecialEpisodeSearchCriteria searchCriteria)
+        {
+            var pageableRequests = new List<IEnumerable<IndexerRequest>>();
+
+            foreach (var queryTitle in searchCriteria.EpisodeQueryTitles)
+            {
+                var query = queryTitle.Replace('+', ' ');
+                query = System.Web.HttpUtility.UrlEncode(query);
+
+                pageableRequests.AddIfNotNull(GetPagedRequests(MaxPages, Settings.Categories.Concat(Settings.AnimeCategories), "search",
+                    String.Format("&q={0}",
+                    query)));
+            }
+
+            return pageableRequests;
+        }
+
+        private IEnumerable<IndexerRequest> GetPagedRequests(Int32 maxPages, IEnumerable<Int32> categories, String searchType, String parameters)
+        {
+            if (categories.Empty())
+            {
+                yield break;
+            }
+
+            var categoriesQuery = String.Join(",", categories.Distinct());
+
+            var baseUrl = String.Format("{0}/api?t={1}&cat={2}&extended=1{3}", Settings.Url.TrimEnd('/'), searchType, categoriesQuery, Settings.AdditionalParameters);
+
+            if (Settings.ApiKey.IsNotNullOrWhiteSpace())
+            {
+                baseUrl += "&apikey=" + Settings.ApiKey;
+            }
+
+            if (PageSize == 0)
+            {
+                yield return new IndexerRequest(String.Format("{0}{1}", baseUrl, parameters), HttpAccept.Rss);
+            }
+            else
+            {
+                for (var page = 0; page < maxPages; page++)
+                {
+                    yield return new IndexerRequest(String.Format("{0}&offset={1}&limit={2}{3}", baseUrl, page * PageSize, PageSize, parameters), HttpAccept.Rss);
+                }
+            }
+        }
+
+        private static String NewsnabifyTitle(String title)
+        {
+            return title.Replace("+", "%20");
+        }
+    }
+}
@@ -0,0 +1,168 @@
+using System;
+using System.Linq;
+using System.Xml.Linq;
+using NzbDrone.Common.Extensions;
+using NzbDrone.Core.Indexers.Exceptions;
+using NzbDrone.Core.Parser.Model;
+
+namespace NzbDrone.Core.Indexers.Torznab
+{
+    public class TorznabRssParser : TorrentRssParser
+    {
+        public const String ns = "{http://torznab.com/schemas/2015/feed}";
+
+        protected override bool PreProcess(IndexerResponse indexerResponse)
+        {
+            var xdoc = XDocument.Parse(indexerResponse.Content);
+            var error = xdoc.Descendants("error").FirstOrDefault();
+
+            if (error == null) return true;
+
+            var code = Convert.ToInt32(error.Attribute("code").Value);
+            var errorMessage = error.Attribute("description").Value;
+
+            if (code >= 100 && code <= 199) throw new ApiKeyException("Invalid API key");
+
+            if (!indexerResponse.Request.Url.ToString().Contains("apikey=") && errorMessage == "Missing parameter")
+            {
+                throw new ApiKeyException("Indexer requires an API key");
+            }
+
+            if (errorMessage == "Request limit reached")
+            {
+                throw new RequestLimitReachedException("API limit reached");
+            }
+
+            throw new TorznabException("Torznab error detected: {0}", errorMessage);
+        }
+
+        protected override ReleaseInfo ProcessItem(XElement item, ReleaseInfo releaseInfo)
+        {
+            var torrentInfo = base.ProcessItem(item, releaseInfo) as TorrentInfo;
+
+            torrentInfo.TvRageId = GetTvRageId(item);
+
+            return torrentInfo;
+        }
+
+        protected override ReleaseInfo PostProcess(XElement item, ReleaseInfo releaseInfo)
+        {
+            var enclosureType = item.Element("enclosure").Attribute("type").Value;
+            if (enclosureType != "application/x-bittorrent")
+            {
+                throw new UnsupportedFeedException("Feed contains {0} instead of application/x-bittorrent", enclosureType);
+            }
+
+            return base.PostProcess(item, releaseInfo);
+        }
+
+
+        protected override String GetInfoUrl(XElement item)
+        {
+            return item.TryGetValue("comments").TrimEnd("#comments");
+        }
+
+        protected override String GetCommentUrl(XElement item)
+        {
+            return item.TryGetValue("comments");
+        }
+
+        protected override Int64 GetSize(XElement item)
+        {
+            Int64 size;
+
+            var sizeString = TryGetTorznabAttribute(item, "size");
+            if (!sizeString.IsNullOrWhiteSpace() && Int64.TryParse(sizeString, out size))
+            {
+                return size;
+            }
+
+            size = GetEnclosureLength(item);
+
+            return size;
+        }
+
+        protected override DateTime GetPublishDate(XElement item)
+        {
+            return base.GetPublishDate(item);
+        }
+
+        protected override string GetDownloadUrl(XElement item)
+        {
+            var url = base.GetDownloadUrl(item);
+
+            if (!Uri.IsWellFormedUriString(url, UriKind.Absolute))
+            {
+                url = item.Element("enclosure").Attribute("url").Value;
+            }
+
+            return url;
+        }
+
+        protected virtual Int32 GetTvRageId(XElement item)
+        {
+            var tvRageIdString = TryGetTorznabAttribute(item, "rageid");
+            Int32 tvRageId;
+
+            if (!tvRageIdString.IsNullOrWhiteSpace() && Int32.TryParse(tvRageIdString, out tvRageId))
+            {
+                return tvRageId;
+            }
+
+            return 0;
+        }
+        protected override String GetInfoHash(XElement item)
+        {
+            return TryGetTorznabAttribute(item, "infohash");
+        }
+
+        protected override String GetMagnetUrl(XElement item)
+        {
+            return TryGetTorznabAttribute(item, "magneturl");
+        }
+
+        protected override Int32? GetSeeders(XElement item)
+        {
+            var seeders = TryGetTorznabAttribute(item, "seeders");
+
+            if (seeders.IsNotNullOrWhiteSpace())
+            {
+                return Int32.Parse(seeders);
+            }
+
+            return base.GetSeeders(item);
+        }
+
+        protected override Int32? GetPeers(XElement item)
+        {
+            var peers = TryGetTorznabAttribute(item, "peers");
+
+            if (peers.IsNotNullOrWhiteSpace())
+            {
+                return Int32.Parse(peers);
+            }
+
+            var seeders = TryGetTorznabAttribute(item, "seeders");
+            var leechers = TryGetTorznabAttribute(item, "leechers");
+
+            if (seeders.IsNotNullOrWhiteSpace() && leechers.IsNotNullOrWhiteSpace())
+            {
+                return Int32.Parse(seeders) + Int32.Parse(leechers);
+            }
+
+            return base.GetPeers(item);
+        }
+
+        protected String TryGetTorznabAttribute(XElement item, String key, String defaultValue = "")
+        {
+            var attr = item.Elements(ns + "attr").SingleOrDefault(e => e.Attribute("name").Value.Equals(key, StringComparison.CurrentCultureIgnoreCase));
+
+            if (attr != null)
+            {
+                return attr.Attribute("value").Value;
+            }
+
+            return defaultValue;
+        }
+    }
+}
@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using FluentValidation;
+using FluentValidation.Results;
+using NzbDrone.Common.Extensions;
+using NzbDrone.Core.Annotations;
+using NzbDrone.Core.ThingiProvider;
+using NzbDrone.Core.Validation;
+
+namespace NzbDrone.Core.Indexers.Torznab
+{
+    public class TorznabSettingsValidator : AbstractValidator<TorznabSettings>
+    {
+        private static readonly string[] ApiKeyWhiteList =
+        {
+            "hdaccess.net",
+        };
+
+        private static bool ShouldHaveApiKey(TorznabSettings settings)
+        {
+            if (settings.Url == null)
+            {
+                return false;
+            }
+
+            return ApiKeyWhiteList.Any(c => settings.Url.ToLowerInvariant().Contains(c));
+        }
+
+        private static readonly Regex AdditionalParametersRegex = new Regex(@"(&.+?\=.+?)+", RegexOptions.Compiled);
+
+        public TorznabSettingsValidator()
+        {
+            RuleFor(c => c.Url).ValidRootUrl();
+            RuleFor(c => c.ApiKey).NotEmpty().When(ShouldHaveApiKey);
+            RuleFor(c => c.Categories).NotEmpty().When(c => !c.AnimeCategories.Any());
+            RuleFor(c => c.AnimeCategories).NotEmpty().When(c => !c.Categories.Any());
+            RuleFor(c => c.AdditionalParameters)
+                .Matches(AdditionalParametersRegex)
+                .When(c => !c.AdditionalParameters.IsNullOrWhiteSpace());
+        }
+    }
+
+    public class TorznabSettings : IProviderConfig
+    {
+        private static readonly TorznabSettingsValidator Validator = new TorznabSettingsValidator();
+
+        public TorznabSettings()
+        {
+            Categories = new[] { 5030, 5040 };
+            AnimeCategories = Enumerable.Empty<Int32>();
+        }
+
+        [FieldDefinition(0, Label = "URL")]
+        public String Url { get; set; }
+
+        [FieldDefinition(1, Label = "API Key")]
+        public String ApiKey { get; set; }
+
+        [FieldDefinition(2, Label = "Categories", HelpText = "Comma Separated list, leave blank to disable standard/daily shows", Advanced = true)]
+        public IEnumerable<Int32> Categories { get; set; }
+
+        [FieldDefinition(3, Label = "Anime Categories", HelpText = "Comma Separated list, leave blank to disable anime", Advanced = true)]
+        public IEnumerable<Int32> AnimeCategories { get; set; }
+
+        [FieldDefinition(4, Label = "Additional Parameters", HelpText = "Additional Torznab parameters", Advanced = true)]
+        public String AdditionalParameters { get; set; }
+
+        public ValidationResult Validate()
+        {
+            return Validator.Validate(this);
+        }
+    }
+}