Merge branch 'master' into develop

Author: cYCL157

src/Cortside.Common.Hosting.Tests/Cortside.Common.Hosting.Tests.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net8.0</TargetFramework>
     <IsPackable>false</IsPackable>
@@ -8,6 +8,9 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.3" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="9.0.3" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="9.0.3" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.13.2">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
@@ -18,6 +21,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
+    <PackageReference Include="Shouldly" Version="4.3.0" />
     <PackageReference Include="SonarAnalyzer.CSharp" Version="10.7.0.110445">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>

src/Cortside.Common.Hosting.Tests/Hosting/TestTimedHostedConfiguration.cs

@@ -0,0 +1,6 @@
+namespace Cortside.Common.Hosting.Tests.Hosting {
+    public class TestTimedHostedConfiguration {
+        public int Interval { get; set; }
+        public bool Enabled { get; set; }
+    }
+}

src/Cortside.Common.Hosting.Tests/Hosting/TestTimedHostedService.cs

@@ -0,0 +1,21 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Cortside.Common.Hosting.Tests.Hosting {
+    public class TestTimedHostedService : TimedHostedService, IMonitoredHostedService {
+        public TestTimedHostedService(ILogger logger, TestTimedHostedConfiguration config) : base(logger, config.Enabled, config.Interval) {
+        }
+
+        public Task PublicExecuteAsync(CancellationToken stoppingToken) {
+            return base.ExecuteAsync(stoppingToken);
+        }
+
+        protected override Task ExecuteIntervalAsync() {
+            Executed = true;
+            return Task.CompletedTask;
+        }
+
+        public bool Executed { get; set; } = false;
+    }
+}

src/Cortside.Common.Hosting.Tests/MonitoredHostedServiceTest.cs

@@ -0,0 +1,36 @@
+using System.Linq;
+using Cortside.Common.Hosting.Tests.Hosting;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Shouldly;
+using Xunit;
+
+namespace Cortside.Common.Hosting.Tests {
+    public class MonitoredHostedServiceTest {
+        [Fact]
+        public void ShouldResolveAllMonitoredServices() {
+            var services = new ServiceCollection();
+            var logger = new Mock<ILogger>();
+            services.AddSingleton(logger.Object);
+            services.AddHostedService<TestTimedHostedService>();
+            services.AddSingleton(new TestTimedHostedConfiguration() { Enabled = true, Interval = 30 });
+            var serviceProvider = services.BuildServiceProvider();
+
+            var monitoredServices = serviceProvider.GetServices<IHostedService>()
+                .Where(x =>
+                    x.GetType().GetInterfaces().Any(y => y == typeof(IMonitoredHostedService))
+                )
+                .ToList();
+            monitoredServices.ShouldNotBeNull();
+            monitoredServices.ShouldNotBeEmpty();
+            monitoredServices.ShouldContain(x => x.GetType() == typeof(TestTimedHostedService));
+
+            var monitoredService = monitoredServices.First(x => x.GetType().GetInterfaces().Any(y => y == typeof(IMonitoredHostedService))) as IMonitoredHostedService;
+            monitoredService.ShouldNotBeNull();
+            monitoredService.Interval.TotalSeconds.ShouldBe(30);
+            monitoredService.LastActivity.ShouldBeInRange(System.DateTime.UtcNow.AddSeconds(-1), System.DateTime.UtcNow.AddSeconds(1));
+        }
+    }
+}

…Hosting.Tests/TimedHostedServiceTests.cs ….Hosting.Tests/TimedHostedServiceTest.cssrc/Cortside.Common.Hosting.Tests/TimedHostedServiceTests.cs renamed to src/Cortside.Common.Hosting.Tests/TimedHostedServiceTest.cs src/Cortside.Common.Hosting.Tests/TimedHostedServiceTests.cs renamed to src/Cortside.Common.Hosting.Tests/TimedHostedServiceTest.cs

@@ -1,39 +1,24 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
+using Cortside.Common.Hosting.Tests.Hosting;
 using Microsoft.Extensions.Logging;
 using Moq;
 using Xunit;
 
 namespace Cortside.Common.Hosting.Tests {
-    public class TimedHostedServiceTests {
-        private class TestTimedHostedService : TimedHostedService {
-            public TestTimedHostedService(ILogger logger, bool enabled, int interval) : base(logger, enabled, interval) {
-            }
-
-            public Task PublicExecuteAsync(CancellationToken stoppingToken) {
-                return base.ExecuteAsync(stoppingToken);
-            }
-
-            protected override Task ExecuteIntervalAsync() {
-                Executed = true;
-                return Task.CompletedTask;
-            }
-
-            public bool Executed { get; set; } = false;
-        }
-
+    public class TimedHostedServiceTest {
         private readonly TestTimedHostedService instance;
         private readonly Mock<ILogger> logger;
 
-        public TimedHostedServiceTests() {
+        public TimedHostedServiceTest() {
             logger = new Mock<ILogger>();
-            instance = new TestTimedHostedService(logger.Object, true, 500);
+            instance = new TestTimedHostedService(logger.Object, new TestTimedHostedConfiguration() { Enabled = true, Interval = 500 });
         }
 
         [Fact(Skip = "probably a good check to add")]
         public void CannotConstructWithNullLogger() {
-            Assert.Throws<ArgumentNullException>(() => new TestTimedHostedService(default, true, 5000));
+            Assert.Throws<ArgumentNullException>(() => new TestTimedHostedService(default, new TestTimedHostedConfiguration() { Enabled = true, Interval = 5000 }));
         }
 
         [Fact]

src/Cortside.Common.Hosting/IMonitoredHostedService.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace Cortside.Common.Hosting {
+    public interface IMonitoredHostedService {
+        /// <summary>
+        /// Last activity time for purposes of being able to monitor health
+        /// </summary>
+        DateTime LastActivity { get; }
+
+        /// <summary>
+        /// Sleep delay/interval between executions
+        /// </summary>
+        TimeSpan Interval { get; }
+    }
+}

src/Cortside.Common.Hosting/TimedHostedService.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
@@ -15,6 +15,7 @@ public abstract class TimedHostedService : BackgroundService {
         private readonly int interval;
         private readonly bool enabled;
         private readonly bool generateCorrelationId;
+        protected DateTime lastActivity = DateTime.UtcNow;
 
         /// <summary>
         /// Initializes new instance of the Hosted Service
@@ -28,17 +29,19 @@ protected TimedHostedService(ILogger logger, bool enabled, int interval, bool ge
 
         protected override async Task ExecuteAsync(CancellationToken stoppingToken) {
             // force async so that hosted service does not block Startup
-#pragma warning disable _MissingConfigureAwait // Consider using .ConfigureAwait(false).
             await Task.Yield();
-#pragma warning restore _MissingConfigureAwait // Consider using .ConfigureAwait(false).
 
             if (enabled) {
                 logger.LogInformation($"{this.GetType().Name} is starting with interval of {interval} seconds");
-
                 stoppingToken.Register(() => logger.LogDebug($"{this.GetType().Name} is stopping."));
 
                 while (!stoppingToken.IsCancellationRequested) {
+                    // last execution set before and after interval to catch start and catch after sleep delay
+                    lastActivity = DateTime.UtcNow;
+
                     await IntervalAsync();
+                    lastActivity = DateTime.UtcNow;
+
                     await Task.Delay(TimeSpan.FromSeconds(interval), stoppingToken).ConfigureAwait(false);
                 }
                 logger.LogInformation($"{this.GetType().Name} is stopping");
@@ -61,5 +64,15 @@ private async Task IntervalAsync() {
         }
 
         protected abstract Task ExecuteIntervalAsync();
+
+        /// <summary>
+        /// Last activity time for purposes of being able to monitor health
+        /// </summary>
+        public DateTime LastActivity => lastActivity;
+
+        /// <summary>
+        /// Sleep delay/interval between executions
+        /// </summary>
+        public TimeSpan Interval => TimeSpan.FromSeconds(interval);
     }
 }