New: Drone now uses the Download Client API to determine if a download is ready for import. (User configuration is required to replace the drone factory with this feature)

2025-09-17 17:14:18 +02:00 · 2014-04-19 17:09:22 +02:00
parent dcb586b937
commit 2035fe8578
196 changed files with 3961 additions and 2223 deletions
--- a/src/NzbDrone.Core/Download/DownloadTrackingService.cs
+++ b/src/NzbDrone.Core/Download/DownloadTrackingService.cs
@@ -0,0 +1,209 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NLog;
+using NzbDrone.Common;
+using NzbDrone.Common.Cache;
+using NzbDrone.Core.Configuration;
+using NzbDrone.Core.History;
+using NzbDrone.Core.Messaging.Commands;
+using NzbDrone.Core.Messaging.Events;
+using NzbDrone.Core.Lifecycle;
+using NzbDrone.Core.Queue;
+
+namespace NzbDrone.Core.Download
+{
+    public interface IDownloadTrackingService
+    {
+        List<TrackedDownload> GetTrackedDownloads();
+        List<TrackedDownload> GetCompletedDownloads();
+        List<TrackedDownload> GetQueuedDownloads();
+    }
+
+    public class DownloadTrackingService : IDownloadTrackingService, IExecute<CheckForFinishedDownloadCommand>, IHandle<ApplicationStartedEvent>
+    {
+        private readonly IProvideDownloadClient _downloadClientProvider;
+        private readonly IHistoryService _historyService;
+        private readonly IEventAggregator _eventAggregator;
+        private readonly IConfigService _configService;
+        private readonly IFailedDownloadService _failedDownloadService;
+        private readonly ICompletedDownloadService  _completedDownloadService;
+        private readonly Logger _logger;
+
+        private readonly ICached<TrackedDownload> _trackedDownloads;
+        private readonly ICached<List<TrackedDownload>> _queuedDownloads;
+
+        public static string DOWNLOAD_CLIENT = "downloadClient";
+        public static string DOWNLOAD_CLIENT_ID = "downloadClientId";
+
+        public DownloadTrackingService(IProvideDownloadClient downloadClientProvider,
+                                     IHistoryService historyService,
+                                     IEventAggregator eventAggregator,
+                                     IConfigService configService,
+                                     ICacheManager cacheManager,
+                                     IFailedDownloadService failedDownloadService,
+                                     ICompletedDownloadService completedDownloadService,
+                                     Logger logger)
+        {
+            _downloadClientProvider = downloadClientProvider;
+            _historyService = historyService;
+            _eventAggregator = eventAggregator;
+            _configService = configService;
+            _failedDownloadService = failedDownloadService;
+            _completedDownloadService = completedDownloadService;
+            _logger = logger;
+
+            _trackedDownloads = cacheManager.GetCache<TrackedDownload>(GetType());
+            _queuedDownloads = cacheManager.GetCache<List<TrackedDownload>>(GetType(), "queued");
+        }
+
+        public List<TrackedDownload> GetTrackedDownloads()
+        {
+            return _trackedDownloads.Values.ToList();
+        }
+
+        public List<TrackedDownload> GetCompletedDownloads()
+        {
+            return _trackedDownloads.Values.Where(v => v.State == TrackedDownloadState.Downloading && v.DownloadItem.Status == DownloadItemStatus.Completed).ToList();
+        }
+
+        public List<TrackedDownload> GetQueuedDownloads()
+        {
+            return _queuedDownloads.Get("queued", () =>
+                {
+                    UpdateTrackedDownloads();
+
+                    var enabledFailedDownloadHandling = _configService.EnableFailedDownloadHandling;
+                    var enabledCompletedDownloadHandling = _configService.EnableCompletedDownloadHandling;
+
+                    return _trackedDownloads.Values
+                            .Where(v => v.State == TrackedDownloadState.Downloading)
+                            .Where(v => 
+                                v.DownloadItem.Status == DownloadItemStatus.Queued ||
+                                v.DownloadItem.Status == DownloadItemStatus.Paused ||
+                                v.DownloadItem.Status == DownloadItemStatus.Downloading ||
+                                v.DownloadItem.Status == DownloadItemStatus.Failed && enabledFailedDownloadHandling ||
+                                v.DownloadItem.Status == DownloadItemStatus.Completed && enabledCompletedDownloadHandling)
+                            .ToList();
+
+                }, TimeSpan.FromSeconds(5.0));
+        }
+
+        private TrackedDownload GetTrackedDownload(IDownloadClient downloadClient, DownloadClientItem queueItem)
+        {
+            var id = String.Format("{0}-{1}", downloadClient.Definition.Id, queueItem.DownloadClientId);
+            var trackedDownload = _trackedDownloads.Get(id, () => new TrackedDownload
+            {
+                TrackingId = id,
+                DownloadClient = downloadClient.Definition.Id,
+                StartedTracking = DateTime.UtcNow,
+                State = TrackedDownloadState.Unknown
+            });
+
+            trackedDownload.DownloadItem = queueItem;
+
+            return trackedDownload;
+        }
+
+        private List<History.History> GetHistoryItems(List<History.History> grabbedHistory, string downloadClientId)
+        {
+            return grabbedHistory.Where(h => downloadClientId.Equals(h.Data.GetValueOrDefault(DOWNLOAD_CLIENT_ID)))
+                                 .ToList();
+        }
+
+
+        private Boolean UpdateTrackedDownloads()
+        {
+            var downloadClients = _downloadClientProvider.GetDownloadClients();
+
+            var oldTrackedDownloads = new HashSet<TrackedDownload>(_trackedDownloads.Values);
+            var newTrackedDownloads = new HashSet<TrackedDownload>();
+
+            var stateChanged = false;
+
+            foreach (var downloadClient in downloadClients)
+            {
+                var downloadClientHistory = downloadClient.GetItems().Select(v => GetTrackedDownload(downloadClient, v)).ToList();
+                foreach (var trackedDownload in downloadClientHistory)
+                {
+                    if (!oldTrackedDownloads.Contains(trackedDownload))
+                    {
+                        _logger.Trace("Started tracking download from history: {0}", trackedDownload.TrackingId);
+                        stateChanged = true;
+                    }
+
+                    newTrackedDownloads.Add(trackedDownload);
+                }
+            }
+
+            foreach (var item in oldTrackedDownloads.Except(newTrackedDownloads))
+            {
+                if (item.State != TrackedDownloadState.Removed)
+                {
+                    item.State = TrackedDownloadState.Removed;
+                    stateChanged = true;
+
+                    _logger.Debug("Item removed from download client by user: {0}", item.TrackingId);
+                }
+            }
+
+            foreach (var item in newTrackedDownloads.Union(oldTrackedDownloads).Where(v => v.State == TrackedDownloadState.Removed))
+            {
+                _trackedDownloads.Remove(item.TrackingId);
+
+                _logger.Trace("Stopped tracking download: {0}", item.TrackingId);
+            }
+
+            _queuedDownloads.Clear();
+
+            return stateChanged;
+        }
+
+        private void ProcessTrackedDownloads()
+        {
+            var grabbedHistory = _historyService.Grabbed();
+            var failedHistory = _historyService.Failed();
+            var importedHistory = _historyService.Imported();
+
+            var stateChanged = UpdateTrackedDownloads();
+            
+            var downloadClients = _downloadClientProvider.GetDownloadClients();
+            var trackedDownloads = _trackedDownloads.Values.ToArray();
+
+            foreach (var trackedDownload in trackedDownloads)
+            {
+                var downloadClient = downloadClients.Single(v => v.Definition.Id == trackedDownload.DownloadClient);
+
+                var state = trackedDownload.State;
+
+                if (trackedDownload.State == TrackedDownloadState.Unknown)
+                {
+                    trackedDownload.State = TrackedDownloadState.Downloading;
+                }
+
+                _failedDownloadService.CheckForFailedItem(downloadClient, trackedDownload, grabbedHistory, failedHistory);
+                _completedDownloadService.CheckForCompletedItem(downloadClient, trackedDownload, grabbedHistory, importedHistory);
+
+                if (state != trackedDownload.State)
+                {
+                    stateChanged = true;
+                }
+            }
+
+            if (stateChanged)
+            {
+                _eventAggregator.PublishEvent(new UpdateQueueEvent());
+            }
+        }
+
+        public void Execute(CheckForFinishedDownloadCommand message)
+        {
+            ProcessTrackedDownloads();
+        }
+
+        public void Handle(ApplicationStartedEvent message)
+        {
+            ProcessTrackedDownloads();
+        }
+    }
+}