psp-7417 add health checks for Major pims services.

source/backend/api/Helpers/Healthchecks/PimsCdogsHealthCheck.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Pims.Api.Repositories.Cdogs;
+
+namespace Pims.Api.Helpers.Healthchecks
+{
+    public class PimsCdogsHealthcheck : IHealthCheck
+    {
+        private readonly IDocumentGenerationRepository _generationRepository;
+
+        public PimsCdogsHealthcheck(IDocumentGenerationRepository generationRepository)
+        {
+            _generationRepository = generationRepository;
+        }
+
+        public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
+        {
+            try
+            {
+
+                var fileTypes = await _generationRepository.TryGetFileTypesAsync();
+                if (fileTypes.HttpStatusCode != System.Net.HttpStatusCode.OK || fileTypes.Payload == null || fileTypes.Payload.Dictionary.Count == 0)
+                {
+                    return new HealthCheckResult(HealthStatus.Unhealthy, $"received invalid file types response from CDOGS");
+                }
+            }
+            catch (Exception e)
+            {
+                return new HealthCheckResult(HealthStatus.Degraded, $"Cdogs error response: {e.Message} {e.StackTrace}");
+            }
+            return HealthCheckResult.Healthy();
+        }
+    }
+}

source/backend/api/Helpers/Healthchecks/PimsDatabaseHealtcheck.cs → source/backend/api/Helpers/Healthchecks/PimsDatabaseHealthcheck.cs

@@ -6,16 +6,16 @@
 
 namespace Pims.Api.Helpers.Healthchecks
 {
-    public class PimsDatabaseHealtcheck : IHealthCheck
+    public class PimsDatabaseHealthcheck : IHealthCheck
     {
         private const string DefaultProbeExpectedResult = "SQL_Latin1_General_CP1_CI_AS";
 
-        public PimsDatabaseHealtcheck(string connectionString)
+        public PimsDatabaseHealthcheck(string connectionString)
             : this(connectionString, probeExpectedResult: DefaultProbeExpectedResult)
         {
         }
 
-        public PimsDatabaseHealtcheck(string connectionString, string probeExpectedResult)
+        public PimsDatabaseHealthcheck(string connectionString, string probeExpectedResult)
         {
             ConnectionString = connectionString;
             ProbeExpectedResult = probeExpectedResult;

source/backend/api/Helpers/Healthchecks/PimsExternalApiHealthcheck.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Pims.Core.Exceptions;
+
+namespace Pims.Api.Helpers.Healthchecks
+{
+    public class PimsExternalApiHealthcheck : IHealthCheck
+    {
+        private readonly string url;
+        private readonly int statusCode;
+
+        public PimsExternalApiHealthcheck(string url)
+            : this(url, statusCode: (int)HttpStatusCode.OK)
+        {
+        }
+
+        public PimsExternalApiHealthcheck(IConfigurationSection section)
+        {
+            this.url = section["Url"];
+            this.statusCode = int.Parse(section["StatusCode"]);
+        }
+
+        public PimsExternalApiHealthcheck(string url, int statusCode)
+        {
+            this.url = url;
+            this.statusCode = statusCode;
+        }
+
+        public string ConnectionString { get; }
+
+        public string ProbeExpectedResult { get; }
+
+        public Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
+        {
+            return CheckExternalApi(context, cancellationToken);
+        }
+
+        protected async Task<HealthCheckResult> CheckExternalApi(HealthCheckContext context, CancellationToken cancellationToken = default)
+        {
+            using (var client = new HttpClient())
+            {
+                try
+                {
+                    var result = await client.GetAsync(url, cancellationToken);
+
+                    if ((int)result.StatusCode != statusCode)
+                    {
+                        string errorContent = await result.Content.ReadAsStringAsync(cancellationToken);
+                        return new HealthCheckResult(HealthStatus.Degraded, $"http response: {result.StatusCode} does not match: {statusCode}. message: {errorContent}");
+                    }
+                }
+                catch (HttpClientRequestException ex)
+                {
+                    return new HealthCheckResult(status: context.Registration.FailureStatus, exception: ex);
+                }
+            }
+
+            return HealthCheckResult.Healthy();
+        }
+    }
+}

source/backend/api/Helpers/Healthchecks/PimsGeocoderHealthCheck.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Pims.Geocoder;
+
+namespace Pims.Api.Helpers.Healthchecks
+{
+    public class PimsGeocoderHealthcheck : IHealthCheck
+    {
+        private readonly IGeocoderService _geocoderService;
+        private readonly string _address;
+
+        public PimsGeocoderHealthcheck(IConfiguration configuration, IGeocoderService geocoderService)
+        {
+            _geocoderService = geocoderService;
+            _address = configuration.GetSection("HealthChecks:Geocoder:Address").Value;
+        }
+
+        public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                var sites = await _geocoderService.GetSiteAddressesAsync(_address);
+                if (sites == null || !sites.Features.Any())
+                {
+                    return new HealthCheckResult(HealthStatus.Unhealthy, $"received invalid file types response from Geocoder");
+                }
+            }
+            catch (Exception e)
+            {
+                return new HealthCheckResult(HealthStatus.Degraded, $"Mayan error response: {e.Message}");
+            }
+            return HealthCheckResult.Healthy();
+        }
+    }
+}

source/backend/api/Helpers/Healthchecks/PimsGeoserverHealthcheck.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Pims.Core.Exceptions;
+
+namespace Pims.Api.Helpers.Healthchecks
+{
+    public class PimsGeoserverHealthCheck : IHealthCheck
+    {
+        private readonly IConfiguration _proxyOptions;
+        private readonly string _url;
+        private readonly int _statusCode;
+
+        public PimsGeoserverHealthCheck(IConfiguration section)
+        {
+            _proxyOptions = section.GetSection("Geoserver");
+            _url = section.GetValue<string>("HealthChecks:Geoserver:Url");
+            _statusCode = section.GetValue<int>("HealthChecks:Geoserver:StatusCode");
+        }
+
+        public PimsGeoserverHealthCheck(IConfiguration section, string url, int statusCode)
+        {
+            _proxyOptions = section;
+            _url = url;
+            _statusCode = statusCode;
+        }
+
+        public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
+        {
+            using (var client = new HttpClient())
+            {
+                try
+                {
+                    var basicAuth = Convert.ToBase64String(Encoding.GetEncoding("ISO-8859-1").GetBytes($"{_proxyOptions.GetValue<string>("ServiceUser")}:{_proxyOptions.GetValue<string>("ServicePassword")}"));
+                    client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", basicAuth);
+                    var result = await client.GetAsync($"{_proxyOptions.GetValue<string>("ProxyUrl")}{_url}", cancellationToken);
+
+                    if (result.StatusCode != HttpStatusCode.OK)
+                    {
+                        string errorContent = await result.Content.ReadAsStringAsync(cancellationToken);
+                        return new HealthCheckResult(HealthStatus.Degraded, $"http response: {result.StatusCode} does not match: {_statusCode}. message: {errorContent}");
+                    }
+                }
+                catch (HttpClientRequestException ex)
+                {
+                    return new HealthCheckResult(status: context.Registration.FailureStatus, exception: ex);
+                }
+            }
+
+            return HealthCheckResult.Healthy();
+        }
+    }
+}

source/backend/api/Helpers/Healthchecks/PimsLtsaHealthcheck.cs

@@ -0,0 +1,38 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Pims.Core.Exceptions;
+using Pims.Ltsa;
+
+namespace Pims.Api.Helpers.Healthchecks
+{
+    public class PimsLtsaHealthcheck : IHealthCheck
+    {
+        private readonly int _pid;
+        private readonly ILtsaService _ltsaService;
+
+        public PimsLtsaHealthcheck(IConfiguration configuration, ILtsaService ltsaService)
+        {
+            _pid = int.Parse(configuration.GetSection("HealthChecks:Ltsa:Pid").Value);
+            _ltsaService = ltsaService;
+        }
+
+        public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                var titleSummary = await _ltsaService.GetTitleSummariesAsync(_pid);
+                if (titleSummary.TitleSummaries.Count == 0)
+                {
+                    return new HealthCheckResult(HealthStatus.Unhealthy, $"received invalid title summary response for pid: {_pid}");
+                }
+            }
+            catch(LtsaException e)
+            {
+                return new HealthCheckResult(HealthStatus.Degraded, $"LTSA error response: {e.Message}");
+            }
+            return HealthCheckResult.Healthy();
+        }
+    }
+}

source/backend/api/Helpers/Healthchecks/PimsMayanHealthCheck.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Pims.Api.Repositories.Mayan;
+
+namespace Pims.Api.Helpers.Healthchecks
+{
+    public class PimsMayanHealthcheck : IHealthCheck
+    {
+        private readonly IEdmsDocumentRepository _documentRepository;
+
+        public PimsMayanHealthcheck(IEdmsDocumentRepository documentRepository)
+        {
+            _documentRepository = documentRepository;
+        }
+
+        public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                var documentTypes = await _documentRepository.TryGetDocumentTypesAsync(string.Empty, 1, 1);
+                if (documentTypes.HttpStatusCode != System.Net.HttpStatusCode.OK || documentTypes.Payload == null || documentTypes.Payload.Count == 0)
+                {
+                    return new HealthCheckResult(HealthStatus.Unhealthy, $"received invalid mayan response for document types");
+                }
+            }
+            catch (Exception e)
+            {
+                return new HealthCheckResult(HealthStatus.Degraded, $"Mayan error response: {e.Message}");
+            }
+            return HealthCheckResult.Healthy();
+        }
+    }
+}

source/backend/api/Helpers/Healthchecks/PimsMetricsHealthCheck.cs

@@ -7,11 +7,11 @@
 
 namespace Pims.Api.Helpers.HealthChecks
 {
-    public class PimsMetricsHealthCheck : IHealthCheck
+    public class PimsMetricsHealthcheck : IHealthCheck
     {
         private static readonly Gauge AppDeploymentInfo = Metrics.CreateGauge("api_deployment_info", "Deployment information of the running PSP application", labelNames: new[] { "app_version", "db_version", "runtime_version" });
 
-        public PimsMetricsHealthCheck(string connectionString)
+        public PimsMetricsHealthcheck(string connectionString)
         {
             ConnectionString = connectionString;
         }

source/backend/api/Services/DocumentGenerationService.cs

@@ -7,13 +7,15 @@
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 using Pims.Api.Constants;
 using Pims.Api.Models.Cdogs;
 using Pims.Api.Models.CodeTypes;
 
 using Pims.Api.Models.Requests.Http;
 using Pims.Api.Repositories.Cdogs;
 using Pims.Av;
+using Pims.Core.Http.Configuration;
 using Pims.Dal.Helpers.Extensions;
 using Pims.Dal.Security;
 
@@ -28,19 +30,21 @@ public class DocumentGenerationService : BaseService, IDocumentGenerationService
         private readonly IFormDocumentService _formDocumentService;
         private readonly IDocumentService _documentService;
         private readonly IAvService avService;
+        private readonly IOptionsMonitor<AuthClientOptions> keycloakOptions;
 
         public DocumentGenerationService(
             ClaimsPrincipal user,
             ILogger<DocumentGenerationService> logger,
             IDocumentGenerationRepository documentGenerationRepository,
             IFormDocumentService formDocumentService,
             IDocumentService documentService,
-            IAvService avService)
+            IAvService avService,
+            IOptionsMonitor<AuthClientOptions> options)
             : base(user, logger)
         {
             this._documentGenerationRepository = documentGenerationRepository;
             this.avService = avService;
-
+            this.keycloakOptions = options;
             this._formDocumentService = formDocumentService;
             this._documentService = documentService;
         }
@@ -49,7 +53,7 @@ public async Task<ExternalResponse<FileTypes>> GetSupportedFileTypes()
         {
             this.Logger.LogInformation("Getting supported file Types");
 
-            this.User.ThrowIfNotAuthorized(Permissions.GenerateDocuments);
+            this.User.ThrowIfNotAuthorizedOrServiceAccount(Permissions.GenerateDocuments, keycloakOptions);
             ExternalResponse<FileTypes> result = await _documentGenerationRepository.TryGetFileTypesAsync();
             return result;
         }