Add healthcheck

.gitignore

@@ -12,3 +12,4 @@ dist
 *.user
 .env
 *.xmldocs.xml
+**/CONDUCTORSHARP_HEALTH.json

docker-compose.override.yml

@@ -1,7 +1,30 @@
 version: '3.4'
 
 services:
+
+  conductorsharp.noapi:
+    healthcheck:
+      test: bash -c "[ -f /app/CONDUCTORSHARP_HEALTH.json ]"
+      interval: 60s
+      retries: 5
+      start_period: 20s
+      timeout: 10s
+
+  conductorsharp.definitions:
+    healthcheck:
+      test: bash -c "[ -f /app/CONDUCTORSHARP_HEALTH.json ]"
+      interval: 60s
+      retries: 5
+      start_period: 20s
+      timeout: 10s
+
   conductorsharp.apienabled:
+    healthcheck:
+      test: bash -c "[ -f /app/CONDUCTORSHARP_HEALTH.json ]"
+      interval: 60s
+      retries: 5
+      start_period: 20s
+      timeout: 10s
     environment:
       - ASPNETCORE_ENVIRONMENT=Development
     ports:

examples/ConductorSharp.ApiEnabled/Extensions/HostConfiguration.cs

@@ -1,5 +1,6 @@
 using Autofac;
 using ConductorSharp.Engine.Extensions;
+using ConductorSharp.Engine.Health;
 using MediatR.Extensions.Autofac.DependencyInjection;
 
 namespace ConductorSharp.ApiEnabled.Extensions;
@@ -22,6 +23,7 @@ public static IHostBuilder ConfigureApiEnabled(this IHostBuilder hostBuilder, Co
                     longPollInterval: configuration.GetValue<int>("Conductor:LongPollInterval"),
                     domain: configuration.GetValue<string>("Conductor:WorkerDomain")
                 )
+                .SetHealthCheckService<FileHealthService>()
                 .AddPipelines(pipelines =>
                 {
                     pipelines.AddContextLogging();

examples/ConductorSharp.ApiEnabled/Program.cs

@@ -1,5 +1,6 @@
 using Autofac.Extensions.DependencyInjection;
 using ConductorSharp.ApiEnabled.Extensions;
+using ConductorSharp.Engine.Health;
 using ConductorSharp.Engine.Util;
 using Serilog;
 
@@ -12,6 +13,7 @@
 // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen();
+builder.Services.AddHealthChecks().AddCheck<ConductorSharpHealthCheck>("running");
 
 //Autofac dependency injection
 builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory()).ConfigureApiEnabled(configuration);
@@ -26,5 +28,7 @@
 }
 
 app.UseAuthorization();
+
 app.MapControllers();
+app.MapHealthChecks("/health");
 app.Run();

examples/ConductorSharp.Definitions/Program.cs

@@ -2,6 +2,7 @@
 using Autofac.Extensions.DependencyInjection;
 using ConductorSharp.Definitions;
 using ConductorSharp.Engine.Extensions;
+using ConductorSharp.Engine.Health;
 using MediatR.Extensions.Autofac.DependencyInjection;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
@@ -39,6 +40,7 @@
                     longPollInterval: configuration.GetValue<int>("Conductor:LongPollInterval"),
                     domain: configuration.GetValue<string>("Conductor:WorkerDomain")
                 )
+                .SetHealthCheckService<FileHealthService>()
                 .AddPipelines(pipelines =>
                 {
                     pipelines.AddRequestResponseLogging();

examples/ConductorSharp.Definitions/appsettings.json

@@ -5,6 +5,6 @@
     "LongPollInterval": 100,
     "MaxConcurrentWorkers": 10,
     "SleepInterval": 500,
-    "PreventErrorOnBadRequest": false
+    "PreventErrorOnBadRequest": true
   }
 }

examples/ConductorSharp.NoApi/Program.cs

@@ -1,6 +1,7 @@
 using Autofac;
 using Autofac.Extensions.DependencyInjection;
 using ConductorSharp.Engine.Extensions;
+using ConductorSharp.Engine.Health;
 using ConductorSharp.NoApi;
 using MediatR.Extensions.Autofac.DependencyInjection;
 using Microsoft.Extensions.Configuration;
@@ -39,6 +40,7 @@
                     longPollInterval: configuration.GetValue<int>("Conductor:LongPollInterval"),
                     domain: configuration.GetValue<string>("Conductor:WorkerDomain")
                 )
+                .SetHealthCheckService<FileHealthService>()
                 .AddPipelines(pipelines =>
                 {
                     pipelines.AddContextLogging();

examples/ConductorSharp.NoApi/appsettings.json

@@ -5,6 +5,6 @@
     "LongPollInterval": 100,
     "MaxConcurrentWorkers": 10,
     "SleepInterval": 500,
-    "PreventErrorOnBadRequest": true
+    "PreventErrorOnBadRequest": false
   }
 }

src/ConductorSharp.Engine/ConductorSharp.Engine.csproj

@@ -18,6 +18,7 @@
   <ItemGroup>
     <PackageReference Include="Autofac" Version="6.3.0" />
     <PackageReference Include="MediatR" Version="10.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks.Abstractions" Version="6.0.9" />
     <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="6.0.0" />
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="6.0.1" />
     <PackageReference Include="Serilog" Version="2.12.0" />

src/ConductorSharp.Engine/ExecutionManager.cs

@@ -12,11 +12,12 @@
 using System.Threading.Tasks;
 using Autofac;
 using ConductorSharp.Engine.Util;
+using ConductorSharp.Engine.Health;
 using ConductorSharp.Engine.Polling;
 
 namespace ConductorSharp.Engine
 {
-    public class ExecutionManager
+    internal class ExecutionManager
     {
         private readonly SemaphoreSlim _semaphore;
         private readonly WorkerSetConfig _configuration;

src/ConductorSharp.Engine/Extensions/ConductorSharpBuilder.cs

@@ -1,5 +1,6 @@
 using Autofac;
 using ConductorSharp.Engine.Behaviors;
+using ConductorSharp.Engine.Health;
 using ConductorSharp.Engine.Interface;
 using ConductorSharp.Engine.Polling;
 using ConductorSharp.Engine.Service;
@@ -40,6 +41,8 @@ public IExecutionManagerBuilder AddExecutionManager(int maxConcurrentWorkers, in
 
             _builder.RegisterType<ConductorSharpExecutionContext>().InstancePerLifetimeScope();
 
+            _builder.RegisterType<InMemoryHealthService>().As<IConductorSharpHealthService>().SingleInstance();
+
             _builder.RegisterType<InverseExponentialBackoff>().As<IPollTimingStrategy>();
 
             _builder.RegisterType<RandomOrdering>().As<IPollOrderStrategy>();
@@ -59,5 +62,11 @@ public void AddRequestResponseLogging() =>
         public void AddValidation() => _builder.RegisterGeneric(typeof(ValidationBehavior<,>)).As(typeof(IPipelineBehavior<,>));
 
         public void AddContextLogging() => _builder.RegisterGeneric(typeof(ContextLoggingBehavior<,>)).As(typeof(IPipelineBehavior<,>));
+
+        public IExecutionManagerBuilder SetHealthCheckService<T>() where T : IConductorSharpHealthService
+        {
+            _builder.RegisterType<T>().As<IConductorSharpHealthService>().SingleInstance();
+            return this;
+        }
     }
 }

src/ConductorSharp.Engine/Extensions/IExecutionManagerBuilder.cs

@@ -1,4 +1,5 @@
-using System;
+using ConductorSharp.Engine.Health;
+using System;
 using System.Collections.Generic;
 using System.Text;
 
@@ -7,5 +8,6 @@ namespace ConductorSharp.Engine.Extensions
     public interface IExecutionManagerBuilder
     {
         IExecutionManagerBuilder AddPipelines(Action<IPipelineBuilder> pipelines);
+        IExecutionManagerBuilder SetHealthCheckService<T>() where T : IConductorSharpHealthService;
     }
 }

src/ConductorSharp.Engine/Extensions/WorkflowEngineBuilder.cs

@@ -1,5 +1,6 @@
 using Autofac;
 using ConductorSharp.Engine.Behaviors;
+using ConductorSharp.Engine.Health;
 using ConductorSharp.Engine.Interface;
 using ConductorSharp.Engine.Polling;
 using ConductorSharp.Engine.Service;

src/ConductorSharp.Engine/Health/ConductorSharpHealthCheck.cs

@@ -0,0 +1,33 @@
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ConductorSharp.Engine.Health
+{
+    public class ConductorSharpHealthCheck : IHealthCheck
+    {
+        private readonly IConductorSharpHealthService _healthService;
+
+        public ConductorSharpHealthCheck(IConductorSharpHealthService healthService)
+        {
+            _healthService = healthService;
+        }
+
+        public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
+        {
+            var healthData = await _healthService.GetHealthData(cancellationToken);
+
+            if (healthData.IsExecutionManagerRunning)
+            {
+                return new HealthCheckResult(HealthStatus.Healthy, "Deployment has been completed and Execution Manager is running");
+            }
+            else
+            {
+                return new HealthCheckResult(context.Registration.FailureStatus, "Execution Manager is not running");
+            }
+        }
+    }
+}

src/ConductorSharp.Engine/Health/FileHealthService.cs

@@ -0,0 +1,80 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ConductorSharp.Engine.Health
+{
+    public class HealthData
+    {
+        public bool IsExecutionManagerRunning { get; set; }
+    }
+
+    public class FileHealthService : IConductorSharpHealthService
+    {
+        private readonly SemaphoreSlim _semaphore = new(1);
+
+        private const string HealthFileName = "CONDUCTORSHARP_HEALTH.json";
+
+        public async Task UnsetExecutionManagerRunning(CancellationToken cancellationToken = default) =>
+            await UpdateData(data => data.IsExecutionManagerRunning = false, cancellationToken);
+
+        public async Task SetExecutionManagerRunning(CancellationToken cancellationToken = default) =>
+            await UpdateData(data => data.IsExecutionManagerRunning = true, cancellationToken);
+
+        private async Task UpdateData(Action<HealthData> updateHealthData, CancellationToken cancellationToken = default)
+        {
+            var data = await GetHealthData(cancellationToken);
+            updateHealthData(data);
+            await WriteHealthData(data, cancellationToken);
+        }
+
+        public async Task<HealthData> GetHealthData(CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                await _semaphore.WaitAsync(cancellationToken);
+                if (!File.Exists(HealthFileName))
+                {
+                    return new HealthData();
+                }
+                else
+                {
+                    return JsonConvert.DeserializeObject<HealthData>(await File.ReadAllTextAsync(HealthFileName, cancellationToken))
+                        ?? new HealthData();
+                }
+            }
+            finally
+            {
+                _semaphore.Release();
+            }
+        }
+
+        private async Task WriteHealthData(HealthData healthData, CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                await _semaphore.WaitAsync(cancellationToken);
+                await File.WriteAllTextAsync(HealthFileName, JsonConvert.SerializeObject(healthData), cancellationToken);
+            }
+            finally
+            {
+                _semaphore.Release();
+            }
+        }
+
+        public async Task ResetHealthData(CancellationToken cancellationToken = default) =>
+            await WriteHealthData(new HealthData(), cancellationToken);
+
+        public void RemoveHealthData()
+        {
+            if (File.Exists(HealthFileName))
+                File.Delete(HealthFileName);
+
+            return;
+        }
+    }
+}

src/ConductorSharp.Engine/Health/IConductorSharpHealthService.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ConductorSharp.Engine.Health
+{
+    public interface IConductorSharpHealthService
+    {
+        Task<HealthData> GetHealthData(CancellationToken cancellationToken = default);
+        Task ResetHealthData(CancellationToken cancellationToken = default);
+        void RemoveHealthData();
+        Task SetExecutionManagerRunning(CancellationToken cancellationToken = default);
+        Task UnsetExecutionManagerRunning(CancellationToken cancellationToken = default);
+    }
+}

src/ConductorSharp.Engine/Health/InMemoryHealthService.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ConductorSharp.Engine.Health
+{
+    public class InMemoryHealthService : IConductorSharpHealthService
+    {
+        private static bool _isExecutionManagerRunning;
+
+        public Task<HealthData> GetHealthData(CancellationToken cancellationToken = default)
+        {
+            return Task.FromResult(new HealthData { IsExecutionManagerRunning = _isExecutionManagerRunning });
+        }
+
+        public void RemoveHealthData() { }
+
+        public Task ResetHealthData(CancellationToken cancellationToken = default)
+        {
+            _isExecutionManagerRunning = false;
+            return Task.CompletedTask;
+        }
+
+        public Task SetExecutionManagerRunning(CancellationToken cancellationToken = default)
+        {
+            _isExecutionManagerRunning = true;
+            return Task.CompletedTask;
+        }
+
+        public Task UnsetExecutionManagerRunning(CancellationToken cancellationToken = default)
+        {
+            _isExecutionManagerRunning = false;
+            return Task.CompletedTask;
+        }
+    }
+}

src/ConductorSharp.Engine/Service/DeploymentService.cs

@@ -1,12 +1,13 @@
 using ConductorSharp.Client.Service;
+using ConductorSharp.Engine.Health;
 using ConductorSharp.Engine.Interface;
 using ConductorSharp.Engine.Model;
 using Microsoft.Extensions.Logging;
 using System.Threading.Tasks;
 
 namespace ConductorSharp.Engine.Service
 {
-    public class DeploymentService : IDeploymentService
+    internal class DeploymentService : IDeploymentService
     {
         private readonly IMetadataService _metadataService;