More detailed health checks in standalone & leave --dump-config avail…

…able in Release builds as well

extensions/Redis/CustomRedisCacheService.cs

@@ -6,7 +6,7 @@
 
 namespace SimpleCDN.Extensions.Redis
 {
-	internal sealed class CustomRedisCacheService(IOptionsMonitor<RedisCacheConfiguration> options, IOptionsMonitor<CacheConfiguration> cacheOptions)
+	public sealed class CustomRedisCacheService(IOptionsMonitor<RedisCacheConfiguration> options, IOptionsMonitor<CacheConfiguration> cacheOptions)
 		: IDistributedCache, IAsyncDisposable, IDisposable
 	{
 		private readonly IOptionsMonitor<RedisCacheConfiguration> options = options;
@@ -21,7 +21,7 @@ internal sealed class CustomRedisCacheService(IOptionsMonitor<RedisCacheConfigur
 		/// <summary>
 		/// Checks if the Redis connection is still valid and creates a new one if necessary.
 		/// </summary>
-		private ConnectionMultiplexer GetRedisConnection()
+		public ConnectionMultiplexer GetRedisConnection()
 		{
 			_redisConnectionLock.Wait();
 
@@ -42,12 +42,15 @@ private ConnectionMultiplexer GetRedisConnection()
 				_redisConnectionLock.Release();
 			}
 		}
-		private async Task<ConnectionMultiplexer> GetRedisConnectionAsync()
+
+		/// <summary>
+		/// Checks if the Redis connection is still valid and creates a new one if necessary.
+		/// </summary>
+		public async Task<ConnectionMultiplexer> GetRedisConnectionAsync()
 		{
 			await _redisConnectionLock.WaitAsync();
 			try
 			{
-
 				if (_redisConnection is not { IsConnected: true } or { IsConnecting: true })
 				{
 					_redisConnection?.Dispose();

extensions/Redis/RedisCacheConfiguration.cs

@@ -10,7 +10,7 @@ public class RedisCacheConfiguration
 		/// <summary>
 		/// The connection string to the Redis server. Default is <c>localhost:6379</c>.
 		/// </summary>
-		public string ConnectionString { get; set; } = "localhost:6379";
+		public string ConnectionString { get; set; } = null!;
 
 		/// <summary>
 		/// How this client should be identified to Redis. Default is <c>SimpleCDN</c>.

extensions/Redis/SimpleCDNBuilderExtensions.cs

@@ -2,6 +2,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using SimpleCDN.Configuration;
+using StackExchange.Redis;
 
 namespace SimpleCDN.Extensions.Redis
 {
@@ -17,7 +18,10 @@ public static class SimpleCDNBuilderExtensions
 		/// </summary>
 		public static ISimpleCDNBuilder AddRedisCache(this ISimpleCDNBuilder builder, Action<RedisCacheConfiguration> configure)
 		{
-			builder.Services.AddSingleton<IDistributedCache, CustomRedisCacheService>();
+			builder.Services.AddSingleton<CustomRedisCacheService>();
+
+			builder.Services.AddSingleton<IDistributedCache>(sp => sp.GetRequiredService<CustomRedisCacheService>());
+
 			builder.Services.AddOptionsWithValidateOnStart<RedisCacheConfiguration>()
 				.Configure(configure)
 				.Validate<ILogger<RedisCacheConfiguration>>((config, logger) => config.Validate(logger), InvalidConfigurationMessage);

src/core/Configuration/ConfigurationExtensions.cs

@@ -62,6 +62,7 @@ public SimpleCDNBuilder(IServiceCollection services)
 				Services.AddSingleton<IDistributedCache, DisabledCache>();
 				Services.AddSingleton<ICacheManager, CacheManager>();
 				Services.AddSingleton<ICacheImplementationResolver>(sp => new CacheImplementationResolver(sp, _cacheImplementationType));
+				Services.ConfigureHttpJsonOptions(options => options.SerializerOptions.TypeInfoResolverChain.Add(SourceGenerationContext.Default));
 			}
 
 			public IServiceCollection Services { get; }

src/standalone/AdditionalEndpoints.cs

@@ -1,6 +1,11 @@
-using SimpleCDN.Endpoints;
+using Microsoft.AspNetCore.Diagnostics.HealthChecks;
+using Microsoft.AspNetCore.Http.Json;
+using Microsoft.Extensions.Options;
+using SimpleCDN.Endpoints;
 using SimpleCDN.Services.Caching;
 using SimpleCDN.Services.Caching.Implementations;
+using System.Net.Mime;
+using System.Text.Json.Serialization;
 
 namespace SimpleCDN.Standalone
 {
@@ -9,7 +14,6 @@ public static class AdditionalEndpoints
 		public static WebApplication MapEndpoints(this WebApplication app)
 		{
 			app.MapSimpleCDN();
-
 #if DEBUG
 			if (app.Configuration.GetSection("Cache:Type").Get<CacheType>() == CacheType.InMemory)
 			{
@@ -28,18 +32,37 @@ public static WebApplication MapEndpoints(this WebApplication app)
 						// force garbage collection to make sure all memory
 						// used by the cached files is properly released
 						GC.Collect();
+
 						return Results.Ok();
 					}
+
 					return Results.NotFound();
 				});
 			}
 #endif
-			// health check endpoint
-			app.MapGet("/" + GlobalConstants.SystemFilesRelativePath + "/server/health", () => "healthy");
+			app.MapHealthChecks();
 
 			app.MapGet("/favicon.ico", () => Results.Redirect("/" + GlobalConstants.SystemFilesRelativePath + "/logo.ico", true));
 
 			return app;
 		}
+
+		private static WebApplication MapHealthChecks(this WebApplication app)
+		{
+			app.MapHealthChecks("/" + GlobalConstants.SystemFilesRelativePath + "/server/health", new HealthCheckOptions
+			{
+				ResponseWriter = async (ctx, health) =>
+				{
+					JsonOptions jsonOptions = ctx.RequestServices.GetRequiredService<IOptionsSnapshot<JsonOptions>>().Value;
+					ctx.Response.ContentType = MediaTypeNames.Application.Json;
+#pragma warning disable IL2026, IL3050 // it thinks it requires unreferenced code,
+					// but the TypeInfoResolverChain actually provides the necessary context
+					await ctx.Response.WriteAsJsonAsync(health);
+#pragma warning restore IL2026, IL3050
+				}
+			});
+
+			return app;
+		}
 	}
 }

src/standalone/ApplicationBuilderExtensions.cs

@@ -25,10 +25,24 @@ internal static ISimpleCDNBuilder MapConfiguration(this ISimpleCDNBuilder builde
 			switch (configuration.GetSection("Cache:Type").Get<CacheType>())
 			{
 				case CacheType.Redis:
-					builder.AddRedisCache(config => redisSection.Bind(config));
+					builder.AddRedisCache(config =>
+					{
+						if (redisSection.Exists())
+						{
+							redisSection.Bind(config);
+						}
+					});
+					builder.Services.AddHealthChecks()
+						.AddRedis(sp => sp.GetRequiredService<CustomRedisCacheService>().GetRedisConnection(), "Redis");
 					break;
 				case CacheType.InMemory:
-					builder.AddInMemoryCache(config => inMemorySection.Bind(config));
+					builder.AddInMemoryCache(config =>
+					{
+						if (inMemorySection.Exists())
+						{
+							inMemorySection.Bind(config);
+						}
+					});
 					break;
 				case CacheType.Unspecified:
 					// if no provider is explicitly specified, we look at what is configured,

src/standalone/Dockerfile

@@ -72,7 +72,7 @@ USER app
 
 COPY --from=publish /app/publish .
 
-HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 CMD curl --silent --fail http://localhost:8080/_cdn/server/health || exit 1
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 CMD curl http://localhost:8080/_cdn/server/health -s | grep -v "Unhealthy"
 
 EXPOSE 8080
 

src/standalone/GlobalConstants.cs

@@ -2,17 +2,17 @@
  * This file is basically AssemblyInfo.cs, but with the option to add global suppressions,
  * or global constants.
 */
+using Microsoft.Extensions.Diagnostics.HealthChecks;
 using SimpleCDN.Configuration;
 using SimpleCDN.Extensions.Redis;
 using System.Runtime.CompilerServices;
 using System.Text.Json.Serialization;
 
 [assembly: InternalsVisibleTo("SimpleCDN.Tests.Integration")]
 
-#if DEBUG // only generate serializers for debug views in debug mode
 [JsonSerializable(typeof(CacheConfiguration))]
 [JsonSerializable(typeof(CDNConfiguration))]
 [JsonSerializable(typeof(RedisCacheConfiguration))]
 [JsonSerializable(typeof(InMemoryCacheConfiguration))]
+[JsonSerializable(typeof(HealthReport))]
 internal partial class ExtraSourceGenerationContext : JsonSerializerContext;
-#endif

src/standalone/Program.cs

@@ -1,9 +1,12 @@
+using Microsoft.AspNetCore.Http.Json;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
 using Microsoft.Extensions.Options;
 using SimpleCDN.Configuration;
 using SimpleCDN.Extensions.Redis;
 using SimpleCDN.Services.Caching;
 using System.Runtime.CompilerServices;
 using System.Text.Json;
+using System.Text.Json.Serialization;
 using TomLonghurst.ReadableTimeSpan;
 
 namespace SimpleCDN.Standalone
@@ -28,56 +31,60 @@ private static void Main(string[] args)
 			builder.Services.AddSimpleCDN()
 				.MapConfiguration(builder.Configuration);
 
-#if DEBUG
-			builder.Services.ConfigureHttpJsonOptions(options => options.SerializerOptions.TypeInfoResolverChain.Add(ExtraSourceGenerationContext.Default));
-#endif
+			builder.Services.ConfigureHttpJsonOptions(options =>
+			{
+				options.SerializerOptions.TypeInfoResolverChain.Add(ExtraSourceGenerationContext.Default);
+				options.SerializerOptions.Converters.Add(new JsonStringEnumConverter<HealthStatus>());
+			});
+
+			builder.Services.AddHealthChecks()
+				.AddCheck("Self", () => HealthCheckResult.Healthy());
 
 			WebApplication app = builder
 				.Build();
-#if DEBUG
+
 			// useful for debugging configuration issues
 			if (args.Contains("--dump-config"))
 			{
-				if (RuntimeFeature.IsDynamicCodeSupported)
-				{
-					DumpConfiguration(app);
-				}
+				DumpConfiguration(app);
 				return;
 			}
-#endif
 
 			app
 				.MapEndpoints()
 				.Run();
 		}
 
-#if DEBUG
 		private static void DumpConfiguration(WebApplication app)
 		{
 			IOptions<CDNConfiguration> cdnConfig = app.Services.GetRequiredService<IOptions<CDNConfiguration>>();
 			IOptions<CacheConfiguration> cacheConfig = app.Services.GetRequiredService<IOptions<CacheConfiguration>>();
 			IOptions<InMemoryCacheConfiguration> inMemoryConfig = app.Services.GetRequiredService<IOptions<InMemoryCacheConfiguration>>();
 			IOptions<RedisCacheConfiguration> redisConfig = app.Services.GetRequiredService<IOptions<RedisCacheConfiguration>>();
+			IOptions<JsonOptions> jsonOptions = app.Services.GetRequiredService<IOptions<JsonOptions>>();
 
-			var jsonConfig = new JsonSerializerOptions { WriteIndented = true };
+			var jsonConfig = new JsonSerializerOptions(jsonOptions.Value.SerializerOptions)
+			{
+				WriteIndented = true
+			};
 
+#pragma warning disable IL2026, IL3050 // requires unreferenced code, but the TypeInfoResolverChain actually provides the necessary context
 			Console.WriteLine("CDN Configuration:");
-			Console.WriteLine(JsonSerializer.Serialize(cdnConfig.Value, ExtraSourceGenerationContext.Default.CDNConfiguration));
+			Console.WriteLine(JsonSerializer.Serialize(cdnConfig.Value, jsonConfig));
 			Console.WriteLine("Cache Configuration:");
-			Console.WriteLine(JsonSerializer.Serialize(cacheConfig.Value, ExtraSourceGenerationContext.Default.CacheConfiguration));
+			Console.WriteLine(JsonSerializer.Serialize(cacheConfig.Value, jsonConfig));
 			Console.WriteLine("InMemory Cache Configuration:");
-			Console.WriteLine(JsonSerializer.Serialize(inMemoryConfig.Value, ExtraSourceGenerationContext.Default.InMemoryCacheConfiguration));
+			Console.WriteLine(JsonSerializer.Serialize(inMemoryConfig.Value, jsonConfig));
 			Console.WriteLine("Redis Cache Configuration:");
-			Console.WriteLine(JsonSerializer.Serialize(redisConfig.Value, ExtraSourceGenerationContext.Default.RedisCacheConfiguration));
+			Console.WriteLine(JsonSerializer.Serialize(redisConfig.Value, jsonConfig));
+#pragma warning restore IL2026, IL3050
 
 			Console.WriteLine();
 			Console.Write("Selected cache implementation: ");
 
 			var cache = app.Services.GetRequiredService<ICacheImplementationResolver>().Implementation.GetType().Name;
 			Console.WriteLine(cache);
 		}
-#endif
-
 	}
 }
 #pragma warning restore RCS1102 // Make class static

src/standalone/SimpleCDN.Standalone.csproj

@@ -35,6 +35,7 @@
 
 
 	<ItemGroup>
+		<PackageReference Include="AspNetCore.HealthChecks.Redis" Version="9.0.0" />
 		<PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.21.0" />
 		<PackageReference Include="TomLonghurst.ReadableTimeSpan" Version="1.0.5" />
 	</ItemGroup>