Fixed: Prevent two TypeExclusive commands running at once

The check was bypassed if a disk access command was running at the
same time.

src/NzbDrone.Core.Test/Messaging/Commands/CommandQueueFixture.cs

@@ -88,6 +88,25 @@ namespace NzbDrone.Core.Test.Messaging.Commands
             command.Should().BeNull();
         }
 
+        [Test]
+        public void should_not_return_type_exclusive_command_if_another_and_disk_access_command_running()
+        {
+            GivenStartedTypeExclusiveCommand();
+            GivenStartedDiskCommand();
+
+            var newCommandModel = Builder<CommandModel>
+                .CreateNew()
+                .With(c => c.Name = "ImportListSync")
+                .With(c => c.Body = new ImportListSyncCommand())
+                .Build();
+
+            Subject.Add(newCommandModel);
+
+            Subject.TryGet(out var command);
+
+            command.Should().BeNull();
+        }
+
         [Test]
         public void should_return_type_exclusive_command_if_another_not_running()
         {

src/NzbDrone.Core/Messaging/Commands/CommandQueue.cs

@@ -134,59 +134,53 @@ namespace NzbDrone.Core.Messaging.Commands
                         .Select(x => x.Body.Name)
                         .ToList();
 
-                    var localItem = _items.Where(c =>
+                    var queuedCommands = _items.Where(c => c.Status == CommandStatus.Queued);
-                        {
+
-                            // If an executing command requires disk access don't return a command that
+                    if (startedCommands.Any(x => x.Body.RequiresDiskAccess))
-                            // requires disk access. A lower priority or later queued task could be returned
+                    {
-                            // instead, but that will allow other tasks to execute whiule waiting for disk access.
+                        queuedCommands = queuedCommands.Where(c => !c.Body.RequiresDiskAccess);
-                            if (startedCommands.Any(x => x.Body.RequiresDiskAccess))
+                    }
-                            {
+
-                                return c.Status == CommandStatus.Queued &&
+                    if (startedCommands.Any(x => x.Body.IsTypeExclusive))
-                                       !c.Body.RequiresDiskAccess;
+                    {
-                            }
+                        queuedCommands = queuedCommands.Where(c => !exclusiveTypes.Any(x => x == c.Body.Name));
-
+                    }
-                            // If an executing command is TypeExclusive don't return a command with same type
+
-                            if (startedCommands.Any(x => x.Body.IsTypeExclusive)) {
+                    var localItem = queuedCommands.OrderByDescending(c => c.Priority)
-                                return c.Status == CommandStatus.Queued && !exclusiveTypes.Any(x => x == c.Body.Name);
+                        .ThenBy(c => c.QueuedAt)
-                            }
+                        .FirstOrDefault();
-
+                    
-                            return c.Status == CommandStatus.Queued;
+                    // Nothing queued that meets the requirements
-                        })
+                    if (localItem == null)
-                                              .OrderByDescending(c => c.Priority)
+                    {
-                                              .ThenBy(c => c.QueuedAt)
+                        rval = false;
-                                              .FirstOrDefault();
+                    }
-
+
-                        // Nothing queued that meets the requirements
+                    // If any executing command is exclusive don't want return another command until it completes.
-                        if (localItem == null)
+                    else if (startedCommands.Any(c => c.Body.IsExclusive))
-                        {
+                    {
-                            rval = false;
+                        rval = false;
-                        }
+                    }
-
+
-                        // If any executing command is exclusive don't want return another command until it completes.
+                    // If the next command to execute is exclusive wait for executing commands to complete.
-                        else if (startedCommands.Any(c => c.Body.IsExclusive))
+                    // This will prevent other tasks from starting so the exclusive task executes in the order it should.
-                        {
+                    else if (localItem.Body.IsExclusive && startedCommands.Any())
-                            rval = false;
+                    {
-                        }
+                        rval = false;
-
+                    }
-                        // If the next command to execute is exclusive wait for executing commands to complete.
+
-                        // This will prevent other tasks from starting so the exclusive task executes in the order it should.
+                    // A command ready to execute
-                        else if (localItem.Body.IsExclusive && startedCommands.Any())
+                    else
-                        {
+                    {
-                            rval = false;
+                        localItem.StartedAt = DateTime.UtcNow;
-                        }
+                        localItem.Status = CommandStatus.Started;
-
+
-                        // A command ready to execute
+                        item = localItem;
-                        else
-                        {
-                            localItem.StartedAt = DateTime.UtcNow;
-                            localItem.Status = CommandStatus.Started;
-
-                            item = localItem;
-                        }
                     }
                 }
+            }
 
             return rval;
-            }
         }
+    }
 }