New: Event Driven HealthCheck Support

Co-Authored-By: Taloth <Taloth@users.noreply.github.com>
Signed-off-by: Robin Dadswell <robin@dadswell.email>

src/NzbDrone.Common.Test/InstrumentationTests/CleanseLogMessageFixture.cs

@@ -1,4 +1,4 @@
-using FluentAssertions;
+using FluentAssertions;
 using NUnit.Framework;
 using NzbDrone.Common.Instrumentation;
 

src/NzbDrone.Core.Test/HealthCheck/HealthCheckServiceFixture.cs

@@ -0,0 +1,81 @@
+using System.Collections.Generic;
+using FluentAssertions;
+using NUnit.Framework;
+using NzbDrone.Common.Cache;
+using NzbDrone.Common.Messaging;
+using NzbDrone.Core.HealthCheck;
+using NzbDrone.Core.Test.Framework;
+
+namespace NzbDrone.Core.Test.HealthCheck
+{
+    public class HealthCheckServiceFixture : CoreTest<HealthCheckService>
+    {
+        private FakeHealthCheck _healthCheck;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _healthCheck = new FakeHealthCheck();
+
+            Mocker.SetConstant<IEnumerable<IProvideHealthCheck>>(new[] { _healthCheck });
+            Mocker.SetConstant<ICacheManager>(Mocker.Resolve<CacheManager>());
+        }
+
+        [Test]
+        public void should_not_execute_conditional()
+        {
+            Subject.HandleAsync(new FakeEvent());
+
+            _healthCheck.Executed.Should().BeFalse();
+        }
+
+        [Test]
+        public void should_execute_conditional()
+        {
+            Subject.HandleAsync(new FakeEvent() { ShouldExecute = true });
+
+            _healthCheck.Executed.Should().BeTrue();
+        }
+
+        [Test]
+        public void should_execute_unconditional()
+        {
+            Subject.HandleAsync(new FakeEvent2());
+
+            _healthCheck.Executed.Should().BeTrue();
+        }
+    }
+
+    public class FakeEvent : IEvent
+    {
+        public bool ShouldExecute { get; set; }
+    }
+
+    public class FakeEvent2 : IEvent
+    {
+        public bool ShouldExecute { get; set; }
+    }
+
+    [CheckOn(typeof(FakeEvent))]
+    [CheckOn(typeof(FakeEvent2))]
+    public class FakeHealthCheck : IProvideHealthCheck, ICheckOnCondition<FakeEvent>
+    {
+        public bool CheckOnStartup => false;
+        public bool CheckOnSchedule => false;
+
+        public bool Executed { get; set; }
+        public bool Checked { get; set; }
+
+        public Core.HealthCheck.HealthCheck Check()
+        {
+            Executed = true;
+
+            return new Core.HealthCheck.HealthCheck(GetType());
+        }
+
+        public bool ShouldCheckOnEvent(FakeEvent message)
+        {
+            return message.ShouldExecute;
+        }
+    }
+}

src/NzbDrone.Core/HealthCheck/EventDrivenHealthCheck.cs

@@ -1,14 +1,46 @@
+using System;
+using NzbDrone.Common.Messaging;
+
 namespace NzbDrone.Core.HealthCheck
 {
-    public class EventDrivenHealthCheck
+    public interface IEventDrivenHealthCheck
+    {
+        IProvideHealthCheck HealthCheck { get; }
+
+        bool ShouldExecute(IEvent message, bool previouslyFailed);
+    }
+
+    public class EventDrivenHealthCheck<TEvent> : IEventDrivenHealthCheck
     {
         public IProvideHealthCheck HealthCheck { get; set; }
         public CheckOnCondition Condition { get; set; }
+        public ICheckOnCondition<TEvent> EventFilter { get; set; }
 
         public EventDrivenHealthCheck(IProvideHealthCheck healthCheck, CheckOnCondition condition)
         {
             HealthCheck = healthCheck;
             Condition = condition;
+            EventFilter = healthCheck as ICheckOnCondition<TEvent>;
+        }
+
+        public bool ShouldExecute(IEvent message, bool previouslyFailed)
+        {
+            if (Condition == CheckOnCondition.SuccessfulOnly && previouslyFailed)
+            {
+                return false;
+            }
+
+            if (Condition == CheckOnCondition.FailedOnly && !previouslyFailed)
+            {
+                return false;
+            }
+
+            if (EventFilter != null && !EventFilter.ShouldCheckOnEvent((TEvent)message))
+            {
+                return false;
+            }
+
+            return true;
         }
     }
 }

src/NzbDrone.Core/HealthCheck/HealthCheckService.cs

@@ -3,7 +3,6 @@
 using System.Linq;
 using NLog;
 using NzbDrone.Common.Cache;
-using NzbDrone.Common.Extensions;
 using NzbDrone.Common.Messaging;
 using NzbDrone.Common.Reflection;
 using NzbDrone.Core.Lifecycle;
@@ -25,7 +24,7 @@ public class HealthCheckService : IHealthCheckService,
         private readonly IProvideHealthCheck[] _healthChecks;
         private readonly IProvideHealthCheck[] _startupHealthChecks;
         private readonly IProvideHealthCheck[] _scheduledHealthChecks;
-        private readonly Dictionary<Type, EventDrivenHealthCheck[]> _eventDrivenHealthChecks;
+        private readonly Dictionary<Type, IEventDrivenHealthCheck[]> _eventDrivenHealthChecks;
         private readonly IEventAggregator _eventAggregator;
         private readonly ICacheManager _cacheManager;
         private readonly Logger _logger;
@@ -54,10 +53,16 @@ public List<HealthCheck> Results()
             return _healthCheckResults.Values.ToList();
         }
 
-        private Dictionary<Type, EventDrivenHealthCheck[]> GetEventDrivenHealthChecks()
+        private Dictionary<Type, IEventDrivenHealthCheck[]> GetEventDrivenHealthChecks()
         {
             return _healthChecks
-                .SelectMany(h => h.GetType().GetAttributes<CheckOnAttribute>().Select(a => Tuple.Create(a.EventType, new EventDrivenHealthCheck(h, a.Condition))))
+                .SelectMany(h => h.GetType().GetAttributes<CheckOnAttribute>().Select(a =>
+                {
+                    var eventDrivenType = typeof(EventDrivenHealthCheck<>).MakeGenericType(a.EventType);
+                    var eventDriven = (IEventDrivenHealthCheck)Activator.CreateInstance(eventDrivenType, h, a.Condition);
+
+                    return Tuple.Create(a.EventType, eventDriven);
+                }))
                 .GroupBy(t => t.Item1, t => t.Item2)
                 .ToDictionary(g => g.Key, g => g.ToArray());
         }
@@ -122,7 +127,7 @@ public void HandleAsync(IEvent message)
                 return;
             }
 
-            EventDrivenHealthCheck[] checks;
+            IEventDrivenHealthCheck[] checks;
             if (!_eventDrivenHealthChecks.TryGetValue(message.GetType(), out checks))
             {
                 return;
@@ -133,26 +138,14 @@ public void HandleAsync(IEvent message)
 
             foreach (var eventDrivenHealthCheck in checks)
             {
-                if (eventDrivenHealthCheck.Condition == CheckOnCondition.Always)
-                {
-                    filteredChecks.Add(eventDrivenHealthCheck.HealthCheck);
-                    continue;
-                }
-
                 var healthCheckType = eventDrivenHealthCheck.HealthCheck.GetType();
+                var previouslyFailed = healthCheckResults.Any(r => r.Source == healthCheckType);
 
-                if (eventDrivenHealthCheck.Condition == CheckOnCondition.FailedOnly &&
-                    healthCheckResults.Any(r => r.Source == healthCheckType))
+                if (eventDrivenHealthCheck.ShouldExecute(message, previouslyFailed))
                 {
                     filteredChecks.Add(eventDrivenHealthCheck.HealthCheck);
                     continue;
                 }
-
-                if (eventDrivenHealthCheck.Condition == CheckOnCondition.SuccessfulOnly &&
-                    healthCheckResults.None(r => r.Source == healthCheckType))
-                {
-                    filteredChecks.Add(eventDrivenHealthCheck.HealthCheck);
-                }
             }
 
             // TODO: Add debounce

src/NzbDrone.Core/HealthCheck/ICheckOnCondition.cs

@@ -0,0 +1,7 @@
+namespace NzbDrone.Core.HealthCheck
+{
+    public interface ICheckOnCondition<TEvent>
+    {
+        bool ShouldCheckOnEvent(TEvent message);
+    }
+}