open-source-mirrors
/
Lidarr
mirror of https://github.com/Lidarr/Lidarr
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fixed: Schedule refresh and process monitored download tasks at high priority

Browse Source 
Fixes #2661
Fixes #2666
Fixes #2674
pull/3241/head
Qstick 1 year ago
parent cb5e249448
commit 5a8082de2d
7 changed files with 164 additions and 74 deletions
Show Stats Download Patch File Download Diff File

11
src/Lidarr.Api.V1/Commands/CommandController.cs
Unescape View File

@ -27,6 +27,8 @@ namespace Lidarr.Api.V1.Commands
private readonly Debouncer _debouncer;
private readonly Dictionary<int, CommandResource> _pendingUpdates;
private readonly CommandPriorityComparer _commandPriorityComparer = new CommandPriorityComparer();
public CommandController(IManageCommandQueue commandQueueManager,
IBroadcastSignalRMessage signalRBroadcaster,
KnownTypes knownTypes)
@ -35,10 +37,10 @@ namespace Lidarr.Api.V1.Commands
_commandQueueManager = commandQueueManager;
_knownTypes = knownTypes;
PostValidator.RuleFor(c => c.Name).NotBlank();
_debouncer = new Debouncer(SendUpdates, TimeSpan.FromSeconds(0.1));
_pendingUpdates = new Dictionary<int, CommandResource>();
PostValidator.RuleFor(c => c.Name).NotBlank();
}
public override CommandResource GetResourceById(int id)
@ -74,7 +76,10 @@ namespace Lidarr.Api.V1.Commands
[HttpGet]
public List<CommandResource> GetStartedCommands()
{
return _commandQueueManager.All().ToResource();
return _commandQueueManager.All()
.OrderBy(c => c.Status, _commandPriorityComparer)
.ThenByDescending(c => c.Priority)
.ToResource();
}
[RestDeleteById]

105
src/NzbDrone.Core/Datastore/TableMapping.cs
Unescape View File

@ -61,7 +61,8 @@ namespace NzbDrone.Core.Datastore
.Ignore(r => r.FreeSpace)
.Ignore(r => r.TotalSpace);
Mapper.Entity<ScheduledTask>("ScheduledTasks").RegisterModel();
Mapper.Entity<ScheduledTask>("ScheduledTasks").RegisterModel()
.Ignore(i => i.Priority);
Mapper.Entity<IndexerDefinition>("Indexers").RegisterModel()
.Ignore(x => x.ImplementationName)
@ -71,9 +72,9 @@ namespace NzbDrone.Core.Datastore
.Ignore(i => i.SupportsSearch);
Mapper.Entity<ImportListDefinition>("ImportLists").RegisterModel()
.Ignore(x => x.ImplementationName)
.Ignore(i => i.Enable)
.Ignore(i => i.ListType);
.Ignore(x => x.ImplementationName)
.Ignore(i => i.Enable)
.Ignore(i => i.ListType);
Mapper.Entity<NotificationDefinition>("Notifications").RegisterModel()
.Ignore(x => x.ImplementationName)
@ -101,64 +102,64 @@ namespace NzbDrone.Core.Datastore
Mapper.Entity<EntityHistory>("History").RegisterModel();
Mapper.Entity<Artist>("Artists")
.Ignore(s => s.RootFolderPath)
.Ignore(s => s.Name)
.Ignore(s => s.ForeignArtistId)
.HasOne(a => a.Metadata, a => a.ArtistMetadataId)
.HasOne(a => a.QualityProfile, a => a.QualityProfileId)
.HasOne(s => s.MetadataProfile, s => s.MetadataProfileId)
.LazyLoad(a => a.Albums, (db, a) => db.Query<Album>(new SqlBuilder(db.DatabaseType).Where<Album>(rg => rg.ArtistMetadataId == a.Id)).ToList(), a => a.Id > 0);
.Ignore(s => s.RootFolderPath)
.Ignore(s => s.Name)
.Ignore(s => s.ForeignArtistId)
.HasOne(a => a.Metadata, a => a.ArtistMetadataId)
.HasOne(a => a.QualityProfile, a => a.QualityProfileId)
.HasOne(s => s.MetadataProfile, s => s.MetadataProfileId)
.LazyLoad(a => a.Albums, (db, a) => db.Query<Album>(new SqlBuilder(db.DatabaseType).Where<Album>(rg => rg.ArtistMetadataId == a.Id)).ToList(), a => a.Id > 0);
Mapper.Entity<ArtistMetadata>("ArtistMetadata").RegisterModel();
Mapper.Entity<Album>("Albums").RegisterModel()
.Ignore(x => x.ArtistId)
.HasOne(r => r.ArtistMetadata, r => r.ArtistMetadataId)
.LazyLoad(a => a.AlbumReleases, (db, album) => db.Query<AlbumRelease>(new SqlBuilder(db.DatabaseType).Where<AlbumRelease>(r => r.AlbumId == album.Id)).ToList(), a => a.Id > 0)
.LazyLoad(a => a.Artist,
(db, album) => ArtistRepository.Query(db,
new SqlBuilder(db.DatabaseType)
.Join<Artist, ArtistMetadata>((a, m) => a.ArtistMetadataId == m.Id)
.Where<Artist>(a => a.ArtistMetadataId == album.ArtistMetadataId)).SingleOrDefault(),
a => a.ArtistMetadataId > 0);
.Ignore(x => x.ArtistId)
.HasOne(r => r.ArtistMetadata, r => r.ArtistMetadataId)
.LazyLoad(a => a.AlbumReleases, (db, album) => db.Query<AlbumRelease>(new SqlBuilder(db.DatabaseType).Where<AlbumRelease>(r => r.AlbumId == album.Id)).ToList(), a => a.Id > 0)
.LazyLoad(a => a.Artist,
(db, album) => ArtistRepository.Query(db,
new SqlBuilder(db.DatabaseType)
.Join<Artist, ArtistMetadata>((a, m) => a.ArtistMetadataId == m.Id)
.Where<Artist>(a => a.ArtistMetadataId == album.ArtistMetadataId)).SingleOrDefault(),
a => a.ArtistMetadataId > 0);
Mapper.Entity<AlbumRelease>("AlbumReleases").RegisterModel()
.HasOne(r => r.Album, r => r.AlbumId)
.LazyLoad(x => x.Tracks, (db, release) => db.Query<Track>(new SqlBuilder(db.DatabaseType).Where<Track>(t => t.AlbumReleaseId == release.Id)).ToList(), r => r.Id > 0);
.HasOne(r => r.Album, r => r.AlbumId)
.LazyLoad(x => x.Tracks, (db, release) => db.Query<Track>(new SqlBuilder(db.DatabaseType).Where<Track>(t => t.AlbumReleaseId == release.Id)).ToList(), r => r.Id > 0);
Mapper.Entity<Track>("Tracks").RegisterModel()
.Ignore(t => t.HasFile)
.Ignore(t => t.AlbumId)
.HasOne(track => track.AlbumRelease, track => track.AlbumReleaseId)
.HasOne(track => track.ArtistMetadata, track => track.ArtistMetadataId)
.LazyLoad(t => t.TrackFile,
(db, track) => MediaFileRepository.Query(db,
new SqlBuilder(db.DatabaseType)
.Join<TrackFile, Track>((l, r) => l.Id == r.TrackFileId)
.Join<TrackFile, Album>((l, r) => l.AlbumId == r.Id)
.Join<Album, Artist>((l, r) => l.ArtistMetadataId == r.ArtistMetadataId)
.Join<Artist, ArtistMetadata>((l, r) => l.ArtistMetadataId == r.Id)
.Where<TrackFile>(t => t.Id == track.TrackFileId)).SingleOrDefault(),
t => t.TrackFileId > 0)
.LazyLoad(x => x.Artist,
(db, t) => ArtistRepository.Query(db,
new SqlBuilder(db.DatabaseType)
.Join<Artist, ArtistMetadata>((a, m) => a.ArtistMetadataId == m.Id)
.Join<Artist, Album>((l, r) => l.ArtistMetadataId == r.ArtistMetadataId)
.Join<Album, AlbumRelease>((l, r) => l.Id == r.AlbumId)
.Where<AlbumRelease>(r => r.Id == t.AlbumReleaseId)).SingleOrDefault(),
t => t.Id > 0);
.Ignore(t => t.HasFile)
.Ignore(t => t.AlbumId)
.HasOne(track => track.AlbumRelease, track => track.AlbumReleaseId)
.HasOne(track => track.ArtistMetadata, track => track.ArtistMetadataId)
.LazyLoad(t => t.TrackFile,
(db, track) => MediaFileRepository.Query(db,
new SqlBuilder(db.DatabaseType)
.Join<TrackFile, Track>((l, r) => l.Id == r.TrackFileId)
.Join<TrackFile, Album>((l, r) => l.AlbumId == r.Id)
.Join<Album, Artist>((l, r) => l.ArtistMetadataId == r.ArtistMetadataId)
.Join<Artist, ArtistMetadata>((l, r) => l.ArtistMetadataId == r.Id)
.Where<TrackFile>(t => t.Id == track.TrackFileId)).SingleOrDefault(),
t => t.TrackFileId > 0)
.LazyLoad(x => x.Artist,
(db, t) => ArtistRepository.Query(db,
new SqlBuilder(db.DatabaseType)
.Join<Artist, ArtistMetadata>((a, m) => a.ArtistMetadataId == m.Id)
.Join<Artist, Album>((l, r) => l.ArtistMetadataId == r.ArtistMetadataId)
.Join<Album, AlbumRelease>((l, r) => l.Id == r.AlbumId)
.Where<AlbumRelease>(r => r.Id == t.AlbumReleaseId)).SingleOrDefault(),
t => t.Id > 0);
Mapper.Entity<TrackFile>("TrackFiles").RegisterModel()
.HasOne(f => f.Album, f => f.AlbumId)
.LazyLoad(x => x.Tracks, (db, file) => db.Query<Track>(new SqlBuilder(db.DatabaseType).Where<Track>(t => t.TrackFileId == file.Id)).ToList(), x => x.Id > 0)
.LazyLoad(x => x.Artist,
(db, f) => ArtistRepository.Query(db,
new SqlBuilder(db.DatabaseType)
.Join<Artist, ArtistMetadata>((a, m) => a.ArtistMetadataId == m.Id)
.Join<Artist, Album>((l, r) => l.ArtistMetadataId == r.ArtistMetadataId)
.Where<Album>(a => a.Id == f.AlbumId)).SingleOrDefault(),
t => t.Id > 0);
.HasOne(f => f.Album, f => f.AlbumId)
.LazyLoad(x => x.Tracks, (db, file) => db.Query<Track>(new SqlBuilder(db.DatabaseType).Where<Track>(t => t.TrackFileId == file.Id)).ToList(), x => x.Id > 0)
.LazyLoad(x => x.Artist,
(db, f) => ArtistRepository.Query(db,
new SqlBuilder(db.DatabaseType)
.Join<Artist, ArtistMetadata>((a, m) => a.ArtistMetadataId == m.Id)
.Join<Artist, Album>((l, r) => l.ArtistMetadataId == r.ArtistMetadataId)
.Where<Album>(a => a.Id == f.AlbumId)).SingleOrDefault(),
t => t.Id > 0);
Mapper.Entity<QualityDefinition>("QualityDefinitions").RegisterModel()
.Ignore(d => d.GroupName)

4
src/NzbDrone.Core/Download/TrackedDownloads/DownloadMonitoringService.cs
Unescape View File

@ -54,7 +54,7 @@ namespace NzbDrone.Core.Download.TrackedDownloads
private void QueueRefresh()
{
_manageCommandQueue.Push(new RefreshMonitoredDownloadsCommand());
_manageCommandQueue.Push(new RefreshMonitoredDownloadsCommand(), CommandPriority.High);
}
private void Refresh()
@ -75,7 +75,7 @@ namespace NzbDrone.Core.Download.TrackedDownloads
_trackedDownloadService.UpdateTrackable(trackedDownloads);
_eventAggregator.PublishEvent(new TrackedDownloadRefreshedEvent(trackedDownloads));
_manageCommandQueue.Push(new ProcessMonitoredDownloadsCommand());
_manageCommandQueue.Push(new ProcessMonitoredDownloadsCommand(), CommandPriority.High);
}
finally
{

7
src/NzbDrone.Core/Jobs/ScheduledTask.cs
Unescape View File

@ -1,5 +1,6 @@
using System;
using NzbDrone.Core.Datastore;
using NzbDrone.Core.Messaging.Commands;
namespace NzbDrone.Core.Jobs
{
@ -9,5 +10,11 @@ namespace NzbDrone.Core.Jobs
public int Interval { get; set; }
public DateTime LastExecution { get; set; }
public DateTime LastStartTime { get; set; }
public CommandPriority Priority { get; set; }
public ScheduledTask()
{
Priority = CommandPriority.Low;
}
}
}

4
src/NzbDrone.Core/Jobs/Scheduler.cs
Unescape View File

@ -1,4 +1,4 @@
using System.Linq;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using NLog;
@ -39,7 +39,7 @@ namespace NzbDrone.Core.Jobs
foreach (var task in tasks)
{
_commandQueueManager.Push(task.TypeName, task.LastExecution, task.LastStartTime, CommandPriority.Low, CommandTrigger.Scheduled);
_commandQueueManager.Push(task.TypeName, task.LastExecution, task.LastStartTime, task.Priority, CommandTrigger.Scheduled);
}
}
finally

75
src/NzbDrone.Core/Jobs/TaskManager.cs
Unescape View File

@ -2,6 +2,7 @@ using System;
using System.Collections.Generic;
using System.Linq;
using NLog;
using NzbDrone.Common.Cache;
using NzbDrone.Core.Backup;
using NzbDrone.Core.Configuration;
using NzbDrone.Core.Configuration.Events;
@ -31,43 +32,81 @@ namespace NzbDrone.Core.Jobs
private readonly IScheduledTaskRepository _scheduledTaskRepository;
private readonly IConfigService _configService;
private readonly Logger _logger;
private readonly ICached<ScheduledTask> _cache;
public TaskManager(IScheduledTaskRepository scheduledTaskRepository, IConfigService configService, Logger logger)
public TaskManager(IScheduledTaskRepository scheduledTaskRepository, IConfigService configService, ICacheManager cacheManager, Logger logger)
{
_scheduledTaskRepository = scheduledTaskRepository;
_configService = configService;
_cache = cacheManager.GetCache<ScheduledTask>(GetType());
_logger = logger;
}
public IList<ScheduledTask> GetPending()
{
return _scheduledTaskRepository.All()
.Where(c => c.Interval > 0 && c.LastExecution.AddMinutes(c.Interval) < DateTime.UtcNow)
.ToList();
return _cache.Values
.Where(c => c.Interval > 0 && c.LastExecution.AddMinutes(c.Interval) < DateTime.UtcNow)
.ToList();
}
public List<ScheduledTask> GetAll()
{
return _scheduledTaskRepository.All().ToList();
return _cache.Values.ToList();
}
public DateTime GetNextExecution(Type type)
{
var scheduledTask = _scheduledTaskRepository.All().Single(v => v.TypeName == type.FullName);
var scheduledTask = _cache.Find(type.FullName);
return scheduledTask.LastExecution.AddMinutes(scheduledTask.Interval);
}
public void Handle(ApplicationStartedEvent message)
{
var defaultTasks = new[]
var defaultTasks = new List<ScheduledTask>
{
new ScheduledTask { Interval = 1, TypeName = typeof(RefreshMonitoredDownloadsCommand).FullName },
new ScheduledTask { Interval = 5, TypeName = typeof(MessagingCleanupCommand).FullName },
new ScheduledTask { Interval = 6 * 60, TypeName = typeof(ApplicationUpdateCheckCommand).FullName },
new ScheduledTask { Interval = 6 * 60, TypeName = typeof(CheckHealthCommand).FullName },
new ScheduledTask { Interval = 24 * 60, TypeName = typeof(RefreshArtistCommand).FullName },
new ScheduledTask { Interval = 24 * 60, TypeName = typeof(RescanFoldersCommand).FullName },
new ScheduledTask { Interval = 24 * 60, TypeName = typeof(HousekeepingCommand).FullName },
new ScheduledTask
{
Interval = 1,
TypeName = typeof(RefreshMonitoredDownloadsCommand).FullName,
Priority = CommandPriority.High
},
new ScheduledTask
{
Interval = 5,
TypeName = typeof(MessagingCleanupCommand).FullName
},
new ScheduledTask
{
Interval = 6 * 60,
TypeName = typeof(ApplicationUpdateCheckCommand).FullName
},
new ScheduledTask
{
Interval = 6 * 60,
TypeName = typeof(CheckHealthCommand).FullName
},
new ScheduledTask
{
Interval = 24 * 60,
TypeName = typeof(RefreshArtistCommand).FullName
},
new ScheduledTask
{
Interval = 24 * 60,
TypeName = typeof(RescanFoldersCommand).FullName
},
new ScheduledTask
{
Interval = 24 * 60,
TypeName = typeof(HousekeepingCommand).FullName
},
new ScheduledTask
{
@ -90,7 +129,7 @@ namespace NzbDrone.Core.Jobs
var currentTasks = _scheduledTaskRepository.All().ToList();
_logger.Trace("Initializing jobs. Available: {0} Existing: {1}", defaultTasks.Count(), currentTasks.Count());
_logger.Trace("Initializing jobs. Available: {0} Existing: {1}", defaultTasks.Count, currentTasks.Count);
foreach (var job in currentTasks)
{
@ -112,6 +151,9 @@ namespace NzbDrone.Core.Jobs
currentDefinition.LastExecution = DateTime.UtcNow;
}
currentDefinition.Priority = defaultTask.Priority;
_cache.Set(currentDefinition.TypeName, currentDefinition);
_scheduledTaskRepository.Upsert(currentDefinition);
}
}
@ -170,6 +212,9 @@ namespace NzbDrone.Core.Jobs
backup.Interval = GetBackupInterval();
_scheduledTaskRepository.UpdateMany(new List<ScheduledTask> { rss, backup });
_cache.Find(rss.TypeName).Interval = rss.Interval;
_cache.Find(backup.TypeName).Interval = backup.Interval;
}
}
}

32
src/NzbDrone.Core/Messaging/Commands/CommandPriorityComparer.cs
Unescape View File

@ -0,0 +1,32 @@
using System.Collections.Generic;
namespace NzbDrone.Core.Messaging.Commands
{
public class CommandPriorityComparer : IComparer<CommandStatus>
{
public int Compare(CommandStatus x, CommandStatus y)
{
if (x == CommandStatus.Started && y != CommandStatus.Started)
{
return -1;
}
if (x != CommandStatus.Started && y == CommandStatus.Started)
{
return 1;
}
if (x < y)
{
return -1;
}
if (x > y)
{
return 1;
}
return 0;
}
}
}
Write Preview
Loading…
Cancel
Save