feat : Add health endpoint

PluginBuilder/Controllers/HomeController.cs

@@ -4,6 +4,7 @@
 using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.RateLimiting;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
 using Newtonsoft.Json.Linq;
 using PluginBuilder.APIModels;
 using PluginBuilder.Components.PluginVersion;
@@ -33,7 +34,8 @@ public class HomeController(
     PluginBuilderOptions options,
     ServerEnvironment env,
     NostrService nostrService,
-    ILogger<HomeController> logger)
+    ILogger<HomeController> logger,
+    HealthCheckService healthCheckService)
     : Controller
 {
     [AllowAnonymous]
@@ -793,4 +795,36 @@ public IActionResult Error()
     {
         return View("Error", new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
     }
+
+    [AllowAnonymous]
+    [HttpGet("/health")]
+    [EnableRateLimiting(Policies.PublicApiRateLimit)]
+    public async Task<IActionResult> CheckHealth(CancellationToken cancellationToken)
+    {
+        var report = await healthCheckService.CheckHealthAsync(cancellationToken);
+
+        var result = new
+        {
+            status = report.Status == HealthStatus.Healthy ? "UP" : "DOWN",
+            timestamp = DateTime.UtcNow,
+            description = report.Entries.Values.FirstOrDefault(e => e.Description is not null).Description
+        };
+
+        // display page
+        var acceptHeader = Request.Headers.Accept.ToString();
+        if (acceptHeader.Contains("text/html"))
+        {
+            var hcvm = new HealthCheckViewModel { Healthy = result.status, Description = result.description ?? "" };
+
+            var view = View("HealthPage", hcvm);
+            view.StatusCode = report.Status == HealthStatus.Unhealthy
+                ? StatusCodes.Status503ServiceUnavailable
+                : StatusCodes.Status200OK;
+
+            return view;
+        }
+
+        // send JSON result
+        return report.Status == HealthStatus.Healthy ? Ok(result) : StatusCode(StatusCodes.Status503ServiceUnavailable, result);
+    }
 }

PluginBuilder/HostedServices/AzureStartupHostedService.cs

@@ -4,6 +4,9 @@ namespace PluginBuilder.HostedServices;
 
 public class AzureStartupHostedService : IHostedService
 {
+    public static bool AzureStartupCompleted { get; private set; }
+    public static Exception? AzureStartupError { get; private set; }
+
     public AzureStartupHostedService(AzureStorageClient azureStorageClient)
     {
         AzureStorageClient = azureStorageClient;
@@ -13,7 +16,19 @@ public AzureStartupHostedService(AzureStorageClient azureStorageClient)
 
     public async Task StartAsync(CancellationToken cancellationToken)
     {
-        await AzureStorageClient.EnsureDefaultContainerExists(cancellationToken);
+        AzureStartupCompleted = false;
+        AzureStartupError = null;
+
+        try
+        {
+            await AzureStorageClient.EnsureDefaultContainerExists(cancellationToken);
+            AzureStartupCompleted = true;
+        }
+        catch (Exception ex)
+        {
+            AzureStartupError = ex;
+            throw;
+        }
     }
 
     public Task StopAsync(CancellationToken cancellationToken)

PluginBuilder/HostedServices/DatabaseStartupHostedService.cs

@@ -13,6 +13,9 @@ public class DatabaseStartupHostedService : IHostedService
 {
     private readonly AdminSettingsCache _adminSettingsCache;
 
+    public static bool DatabaseStartupCompleted { get; private set; }
+    public static Exception? DatabaseStartupError { get; private set; }
+
     public DatabaseStartupHostedService(ILogger<DatabaseStartupHostedService> logger, DBConnectionFactory connectionFactory,
         AdminSettingsCache adminSettingsCache)
     {
@@ -27,6 +30,9 @@ public DatabaseStartupHostedService(ILogger<DatabaseStartupHostedService> logger
 
     public async Task StartAsync(CancellationToken cancellationToken)
     {
+        DatabaseStartupCompleted = false;
+        DatabaseStartupError = null;
+
         retry:
         try
         {
@@ -36,6 +42,8 @@ public async Task StartAsync(CancellationToken cancellationToken)
 
             await conn.SettingsInitialize();
             await _adminSettingsCache.RefreshAllAdminSettings(conn);
+
+            DatabaseStartupCompleted = true;
         }
         catch (NpgsqlException pgex) when (pgex.SqlState == "3D000")
         {
@@ -52,6 +60,11 @@ public async Task StartAsync(CancellationToken cancellationToken)
 
             goto retry;
         }
+        catch (Exception ex)
+        {
+            DatabaseStartupError = ex;
+            throw;
+        }
     }
 
     public Task StopAsync(CancellationToken cancellationToken)

PluginBuilder/HostedServices/DockerStartupHostedService.cs

@@ -5,6 +5,26 @@ public class DockerStartupException : Exception
     public DockerStartupException(string message) : base(message)
     {
     }
+
+    public static bool DockerStartupCompleted { get; private set; }
+    public static Exception? DockerStartupError { get; private set; }
+
+    public static void ResetStartupState()
+    {
+        DockerStartupCompleted = false;
+        DockerStartupError = null;
+    }
+
+    public static void MarkStartupCompleted()
+    {
+        DockerStartupCompleted = true;
+    }
+
+    public static void MarkStartupFailed(Exception ex)
+    {
+        DockerStartupError = ex;
+        DockerStartupCompleted = false;
+    }
 }
 
 public class DockerStartupHostedService : IHostedService
@@ -24,33 +44,45 @@ public DockerStartupHostedService(ILogger<DockerStartupHostedService> logger, IW
 
     public async Task StartAsync(CancellationToken cancellationToken)
     {
+        DockerStartupException.ResetStartupState();
+
         var skipBuildValue = Environment.GetEnvironmentVariable(SkipBuildEnvVar);
         var skipBuild = string.Equals(skipBuildValue, "1", StringComparison.OrdinalIgnoreCase) ||
                         string.Equals(skipBuildValue, "true", StringComparison.OrdinalIgnoreCase);
 
         if (skipBuild)
         {
             Logger.LogInformation("Skipping docker image build because {SkipBuildEnvVar}=true", SkipBuildEnvVar);
+            DockerStartupException.MarkStartupCompleted();
             return;
         }
 
-        Logger.LogInformation("Building the PluginBuilder docker image");
-
-        var buildResult = await ProcessRunner.RunAsync(new ProcessSpec
+        try
         {
-            Executable = "docker",
-            EnvironmentVariables =
+            Logger.LogInformation("Building the PluginBuilder docker image");
+
+            var buildResult = await ProcessRunner.RunAsync(new ProcessSpec
             {
-                // Somehow we get permission problem when buildkit isn't used
-                ["DOCKER_BUILDKIT"] = "1"
-            },
-            Arguments = new[] { "build", "-f", "PluginBuilder.Dockerfile", "-t", "plugin-builder", "." },
-            WorkingDirectory = ContentRootPath
-        }, cancellationToken);
-        if (buildResult != 0)
-            throw new DockerStartupException("The build of PluginBuilder.Dockerfile failed");
-
-        await CleanupDanglingBuildVolumes(cancellationToken);
+                Executable = "docker",
+                EnvironmentVariables =
+                {
+                    // Somehow we get permission problem when buildkit isn't used
+                    ["DOCKER_BUILDKIT"] = "1"
+                },
+                Arguments = new[] { "build", "-f", "PluginBuilder.Dockerfile", "-t", "plugin-builder", "." },
+                WorkingDirectory = ContentRootPath
+            }, cancellationToken);
+            if (buildResult != 0)
+                throw new DockerStartupException("The build of PluginBuilder.Dockerfile failed");
+
+            await CleanupDanglingBuildVolumes(cancellationToken);
+            DockerStartupException.MarkStartupCompleted();
+        }
+        catch (Exception ex)
+        {
+            DockerStartupException.MarkStartupFailed(ex);
+            throw;
+        }
     }
 
     public Task StopAsync(CancellationToken cancellationToken)

PluginBuilder/PluginBuilder.csproj

@@ -123,6 +123,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <Folder Include="wwwroot\img\healthpage\" />
     <Folder Include="wwwroot\vendor\highlight.js\"/>
     <Folder Include="wwwroot\vendor\signalr\"/>
   </ItemGroup>

PluginBuilder/Program.cs

@@ -81,6 +81,8 @@
         if (!verbose)
             builder.Logging.AddFilter("Events", LogLevel.Warning);
 
+        builder.Services.AddHealthChecks().AddCheck<HealthService>("Dependencies");
+
         // Uncomment this to see EF queries
         // builder.Logging.AddFilter("Microsoft.EntityFrameworkCore.Database.Command", LogLevel.Trace);
         builder.Logging.AddFilter("Microsoft.EntityFrameworkCore.Migrations", LogLevel.Information);
@@ -101,7 +103,7 @@
         // 2. PB_ALLOWEDHOSTS env var restricting accepted hostnames via HostFilteringMiddleware
         // https://github.com/btcpayserver/btcpayserver-plugin-builder-infra/pull/2
         ForwardedHeadersOptions forwardingOptions = new() { ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto };
         forwardingOptions.KnownNetworks.Clear();
         forwardingOptions.KnownProxies.Clear();
         forwardingOptions.ForwardedHeaders = ForwardedHeaders.All;
         app.UseForwardedHeaders(forwardingOptions);
@@ -192,6 +194,7 @@
         services.AddSingleton<AzureStorageClient>();
         services.AddSingleton<ServerEnvironment>();
         services.AddSingleton<EventAggregator>();
+        services.AddSingleton<HealthService>();
         services.AddHttpClient(HttpClientNames.GitHub, client =>
         {
             client.BaseAddress = new Uri("https://api.github.com/");
@@ -212,11 +215,11 @@
         services.AddTransient<UserVerifiedLogic>();
         services.AddScoped<ReferrerNavigationService>();
         services.AddHttpContextAccessor();
         services.AddSingleton<IActionContextAccessor, ActionContextAccessor>();
         services.AddScoped<IUrlHelper>(sp =>
         {
             var actionContext = sp.GetRequiredService<IActionContextAccessor>().ActionContext;
             return new UrlHelper(actionContext);
         });
         services.AddScoped<PluginOwnershipService>();
         services.AddScoped<VersionLifecycleService>();

PluginBuilder/Services/AzureStorageClient.cs

@@ -62,6 +62,22 @@ public async Task<bool> EnsureDefaultContainerExists(CancellationToken cancellat
         return ToJson(output)["created"]!.Value<bool>();
     }
 
+    public async Task<bool> IsDefaultContainerAccessible(CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            cts.CancelAfter(TimeSpan.FromSeconds(15));
+
+            var container = blobClient.GetContainerReference(DefaultContainer);
+            return await container.ExistsAsync(null, null, cts.Token);
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
     public async Task<string> UploadImageFile(IFormFile file, string blobName)
     {
         var container = blobClient.GetContainerReference(DefaultContainer);

PluginBuilder/Services/HealthService.cs

@@ -0,0 +1,74 @@
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Npgsql;
+
+namespace PluginBuilder.Services;
+
+public class HealthService : IHealthCheck
+{
+    public HealthService(DBConnectionFactory dbConnectionFactory, AzureStorageClient azureStorageClient, ProcessRunner processRunner, IHostApplicationLifetime lifetime)
+    {
+        DbConnectionFactory = dbConnectionFactory;
+        AzureStorageClient = azureStorageClient;
+        ProcessRunner = processRunner;
+
+        _lifetime = lifetime;
+    }
+
+    private readonly IHostApplicationLifetime _lifetime;
+
+    private DBConnectionFactory DbConnectionFactory { get; }
+    private AzureStorageClient AzureStorageClient { get; }
+    private ProcessRunner ProcessRunner { get; }
+
+    public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
+    {
+        if (!_lifetime.ApplicationStarted.IsCancellationRequested)
+            return HealthCheckResult.Unhealthy("Startup incomplete");
+
+        var dbTask = IsDatabaseHealthy(cancellationToken);
+        var dockerTask = IsDockerHealthy(cancellationToken);
+        var azureTask = AzureStorageClient.IsDefaultContainerAccessible(cancellationToken);
+
+        await Task.WhenAll(dbTask, dockerTask, azureTask);
+
+        var isHealthy = dbTask.Result && dockerTask.Result && azureTask.Result;
+
+        return isHealthy
+            ? HealthCheckResult.Healthy()
+            : HealthCheckResult.Unhealthy("Critical dependency unavailable");
+    }
+
+    private async Task<bool> IsDatabaseHealthy(CancellationToken cancellationToken)
+    {
+        try
+        {
+            await using var conn = await DbConnectionFactory.Open(cancellationToken);
+            await using var cmd = new NpgsqlCommand("SELECT 1", conn);
+            var result = await cmd.ExecuteScalarAsync(cancellationToken);
+            return result is 1;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    private async Task<bool> IsDockerHealthy(CancellationToken cancellationToken)
+    {
+        try
+        {
+            var code = await ProcessRunner.RunAsync(new ProcessSpec
+            {
+                Executable = "docker",
+                Arguments = ["info", "--format", "{{ .ServerVersion }}"],
+                OutputCapture = new OutputCapture(),
+                ErrorCapture = new OutputCapture()
+            }, cancellationToken);
+            return code == 0;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+}

PluginBuilder/ViewModels/Home/HealthCheckViewModel.cs

@@ -0,0 +1,8 @@
+namespace PluginBuilder.ViewModels.Home;
+
+public class HealthCheckViewModel
+{
+    public string Healthy { get; set; } = string.Empty;
+
+    public string Description { get; set; } = string.Empty;
+}