Refactor HelperGatusToMona to conditionally execute heartbeat and update performance message logic; update project dependencies and configuration models

.vscode/tasks.json

@@ -50,9 +50,7 @@
                 "build",
                 "-r",
                 "win-x64",
-                "${workspaceFolder}/Gatus-to-MonA.csproj",
-                "/property:GenerateFullPaths=true",
-                "/consoleloggerparameters:NoSummary"
+                "${workspaceFolder}/Gatus-to-MonA.csproj"
             ],
             "problemMatcher": "$msCompile"
         },
@@ -64,9 +62,7 @@
                 "build",
                 "-r",
                 "linux-x64",
-                "${workspaceFolder}/Gatus-to-MonA.csproj",
-                "/property:GenerateFullPaths=true",
-                "/consoleloggerparameters:NoSummary"
+                "${workspaceFolder}/Gatus-to-MonA.csproj"
             ],
             "problemMatcher": "$msCompile"
         },
@@ -91,9 +87,7 @@
                 "-c",
                 "Release",
                 "-p:PublishAot=true",
-                "${workspaceFolder}/Gatus-to-MonA.csproj",
-                "/property:GenerateFullPaths=true",
-                "/consoleloggerparameters:NoSummary"
+                "${workspaceFolder}/Gatus-to-MonA.csproj"
             ],
             "problemMatcher": "$msCompile"
         },
@@ -108,9 +102,7 @@
                 "-c",
                 "Release",
                 "-p:PublishAot=true",
-                "${workspaceFolder}/Gatus-to-MonA.csproj",
-                "/property:GenerateFullPaths=true",
-                "/consoleloggerparameters:NoSummary"
+                "${workspaceFolder}/Gatus-to-MonA.csproj"
             ],
             "problemMatcher": "$msCompile"
         },

Gatus-to-MonA.csproj

@@ -16,7 +16,7 @@
     <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.1" />
     <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="8.0.1" />
     <PackageReference Include="Microsoft.Extensions.Logging.EventLog" Version="8.0.1" />
-    <PackageReference Include="runtime.win-x64.Microsoft.DotNet.ILCompiler" Version="8.0.15" />
+    <PackageReference Include="runtime.win-x64.Microsoft.DotNet.ILCompiler" Version="8.0.21" />
     <PackageReference Include="System.Text.Json" Version="9.0.2" />
   </ItemGroup>
 </Project>

Helpers/HelperGatusToMona.cs

@@ -15,26 +15,28 @@ internal static partial class HelperGatusToMona {
         Path.Combine(appSettings.GatusToMonaConfiguration.Directory, appSettings.GatusConfiguration.FileName);
 
     internal static void Heartbeat(AppSettings appSettings, IHttpClientFactory httpClientFactory, ILogger<Worker> logger, State state, CancellationToken cancellationToken) {
-        _MonIn ??= MonIn.GetInstance(httpClientFactory);
         CreateEmptyFile(appSettings);
-        Task<HttpResponseMessage> httpResponseMessage = _MonIn.SendStatus(appSettings.MonAConfiguration.Site,
-                                                                          appSettings.MonAConfiguration.Resource,
-                                                                          appSettings.MonAConfiguration.StateName,
-                                                                          state);
-        httpResponseMessage.Wait(cancellationToken);
-        logger.LogInformation("Line {line}: {OriginalString} => {Resource} : {StateName} ; {state}",
-                              99,
-                              httpResponseMessage.Result.RequestMessage.RequestUri.OriginalString,
-                              appSettings.MonAConfiguration.Resource,
-                              appSettings.MonAConfiguration.StateName,
-                              state);
-        if (httpResponseMessage.Result.StatusCode != System.Net.HttpStatusCode.OK)
-            throw new Exception(httpResponseMessage.Result.StatusCode.ToString());
-        Task<string> body = httpResponseMessage.Result.Content.ReadAsStringAsync(cancellationToken);
-        body.Wait(cancellationToken);
-        logger.LogInformation("Line {line}: {Result}",
-                              10,
-                              body.Result);
+        if (appSettings.MonAConfiguration.Use) {
+            _MonIn ??= MonIn.GetInstance(httpClientFactory);
+            Task<HttpResponseMessage> httpResponseMessage = _MonIn.SendStatus(appSettings.MonAConfiguration.Site,
+                                                                              appSettings.MonAConfiguration.Resource,
+                                                                              appSettings.MonAConfiguration.StateName,
+                                                                              state);
+            httpResponseMessage.Wait(cancellationToken);
+            logger.LogInformation("Line {line}: {OriginalString} => {Resource} : {StateName} ; {state}",
+                                  27,
+                                  httpResponseMessage.Result.RequestMessage.RequestUri.OriginalString,
+                                  appSettings.MonAConfiguration.Resource,
+                                  appSettings.MonAConfiguration.StateName,
+                                  state);
+            if (httpResponseMessage.Result.StatusCode != System.Net.HttpStatusCode.OK)
+                throw new Exception(httpResponseMessage.Result.StatusCode.ToString());
+            Task<string> body = httpResponseMessage.Result.Content.ReadAsStringAsync(cancellationToken);
+            body.Wait(cancellationToken);
+            logger.LogInformation("Line {line}: {Result}",
+                                  37,
+                                  body.Result);
+        }
     }
 
     private static void CreateEmptyFile(AppSettings appSettings) {
@@ -45,27 +47,59 @@ internal static partial class HelperGatusToMona {
     }
 
     internal static bool UpdateCount(AppSettings appSettings, IHttpClientFactory httpClientFactory, ILogger<Worker> logger, CancellationToken cancellationToken) {
-        _MonIn ??= MonIn.GetInstance(httpClientFactory);
-        if (_HttpClient is null) {
-            _HttpClient = httpClientFactory.CreateClient();
-            _HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", appSettings.GatusConfiguration.Token);
+        _HttpClient ??= httpClientFactory.CreateClient();
+        if (appSettings.MonAConfiguration.Use) {
+            _MonIn ??= MonIn.GetInstance(httpClientFactory);
+            Heartbeat(appSettings, httpClientFactory, logger, State.Up, cancellationToken);
         }
-        Task<HttpResponseMessage> httpResponseMessage = _HttpClient.PostAsync($"{appSettings.GatusConfiguration.BaseUniformResourceLocator}/api/v1/endpoints/{appSettings.GatusConfiguration.Key}/external?success=true&error=", null, cancellationToken);
-        httpResponseMessage.Wait(cancellationToken);
-        if (httpResponseMessage.Result.StatusCode != System.Net.HttpStatusCode.OK)
-            logger.LogWarning("Result is {statusCode}", httpResponseMessage.Result.StatusCode);
-        Heartbeat(appSettings, httpClientFactory, logger, State.Up, cancellationToken);
-        ReadOnlyCollection<string> successMatches = GetSuccessMatches(appSettings, logger, cancellationToken);
-        SendPerformanceMessage(appSettings, logger, successMatches, cancellationToken);
+        ReadOnlyCollection<string> lines = DownloadThenReadAllLinesMaybeSync(appSettings, logger, cancellationToken);
+        ReadOnlyCollection<string> successMatches = GetSuccessMatches(appSettings, logger, lines);
+        double value = (double)GetValue(appSettings, successMatches);
+        if (appSettings.MonAConfiguration.Use) {
+            SendPerformanceMessage(appSettings, logger, value, cancellationToken);
+        }
+        SendPerformanceMessage(appSettings, logger, _HttpClient, value, cancellationToken);
         return true;
     }
 
-    private static ReadOnlyCollection<string> GetSuccessMatches(AppSettings appSettings, ILogger<Worker> logger, CancellationToken cancellationToken) {
+    private static ReadOnlyCollection<string> DownloadThenReadAllLinesMaybeSync(AppSettings appSettings, ILogger<Worker> logger, CancellationToken cancellationToken) {
+        string[] results;
+        string file = GetFile(appSettings);
+        DownloadLines(appSettings, file, cancellationToken);
+        results = File.ReadAllLines(file);
+        if (!string.IsNullOrEmpty(appSettings.GatusToMonaConfiguration.SyncDirectory)) {
+            string text = string.Join(Environment.NewLine, results);
+            string path = Path.Combine(appSettings.GatusToMonaConfiguration.SyncDirectory, appSettings.GatusConfiguration.FileName);
+            try {
+                if (!Directory.Exists(appSettings.GatusToMonaConfiguration.SyncDirectory))
+                    _ = Directory.CreateDirectory(appSettings.GatusToMonaConfiguration.SyncDirectory);
+                File.WriteAllText(path, text);
+                Directory.SetLastWriteTime(appSettings.GatusToMonaConfiguration.SyncDirectory, DateTime.Now);
+            } catch (Exception ex) {
+                logger.LogInformation("Exception {ex}: {ex}",
+                                      80,
+                                      $"{ex.Message}{Environment.NewLine}{ex.StackTrace}");
+            }
+        }
+        return results.AsReadOnly();
+    }
+
+    private static void DownloadLines(AppSettings appSettings, string file, CancellationToken cancellationToken) {
+        FileStream fileStream = new(file, FileMode.Truncate);
+        HttpClient httpClient = new();
+        Task<Stream> streamTask = httpClient.GetStreamAsync($"{appSettings.GatusConfiguration.BaseUniformResourceLocator}/metrics", cancellationToken);
+        streamTask.Wait(cancellationToken);
+        Task task = streamTask.Result.CopyToAsync(fileStream, cancellationToken);
+        task.Wait(cancellationToken);
+        fileStream.Dispose();
+        streamTask.Dispose();
+        httpClient.Dispose();
+    }
+
+    private static ReadOnlyCollection<string> GetSuccessMatches(AppSettings appSettings, ILogger<Worker> logger, ReadOnlyCollection<string> lines) {
         List<string> results = [];
         string value;
         string[] segments;
-        string file = GetFile(appSettings);
-        ReadOnlyCollection<string> lines = GetLines(appSettings, file, cancellationToken);
         foreach (string line in lines) {
             if (!line.StartsWith(appSettings.GatusConfiguration.Metric))
                 continue;
@@ -78,36 +112,26 @@ internal static partial class HelperGatusToMona {
             if (value[^1] is not '0' and not '1')
                 continue;
             logger.LogInformation("Line {line}: {value}",
-                                  39,
+                                  115,
                                   value);
             if (line.EndsWith('1'))
                 results.Add(string.Concat('{', value));
         }
         logger.LogInformation("Line {line}: {results}",
-                              45,
+                              121,
                               string.Join(Environment.NewLine, results));
         return results.AsReadOnly();
     }
 
-    private static ReadOnlyCollection<string> GetLines(AppSettings appSettings, string file, CancellationToken cancellationToken) {
-        string[] results;
-        FileStream fileStream = new(file, FileMode.Truncate);
-        HttpClient httpClient = new();
-        Task<Stream> streamTask = httpClient.GetStreamAsync($"{appSettings.GatusConfiguration.BaseUniformResourceLocator}/metrics", cancellationToken);
-        streamTask.Wait(cancellationToken);
-        Task task = streamTask.Result.CopyToAsync(fileStream, cancellationToken);
-        task.Wait(cancellationToken);
-        fileStream.Dispose();
-        streamTask.Dispose();
-        httpClient.Dispose();
-        results = File.ReadAllLines(file);
-        return results.AsReadOnly();
+    private static decimal GetValue(AppSettings appSettings, ReadOnlyCollection<string> successMatches) {
+        decimal result;
+        decimal v = successMatches.Count / appSettings.MonAConfiguration.Expected;
+        result = Math.Round(v, 3) * 100;
+        return result;
     }
 
-    private static void SendPerformanceMessage(AppSettings appSettings, ILogger<Worker> logger, ReadOnlyCollection<string> successMatches, CancellationToken cancellationToken) {
+    private static void SendPerformanceMessage(AppSettings appSettings, ILogger<Worker> logger, double value, CancellationToken cancellationToken) {
         string performanceName = string.Concat(appSettings.MonAConfiguration.Resource, appSettings.MonAConfiguration.Suffix);
-        double v = successMatches.Count / appSettings.MonAConfiguration.Expected;
-        double value = Math.Round(v, 3) * 100;
         Task<HttpResponseMessage> httpResponseMessage = _MonIn.SendPerformanceMessage(appSettings.MonAConfiguration.Site,
                                                                                       appSettings.MonAConfiguration.Resource,
                                                                                       performanceName,
@@ -115,7 +139,7 @@ internal static partial class HelperGatusToMona {
                                                                                       description: string.Empty);
         httpResponseMessage.Wait(cancellationToken);
         logger.LogInformation("Line {line}: {OriginalString} => {Resource} : {performanceName} ; {value}",
-                              76,
+                              142,
                               httpResponseMessage.Result.RequestMessage.RequestUri.OriginalString,
                               appSettings.MonAConfiguration.Resource,
                               performanceName,
@@ -125,8 +149,40 @@ internal static partial class HelperGatusToMona {
         Task<string> body = httpResponseMessage.Result.Content.ReadAsStringAsync(cancellationToken);
         body.Wait(cancellationToken);
         logger.LogInformation("Line {line}: {Result}",
-                              86,
+                              152,
                               body.Result);
     }
 
+    private static void SendPerformanceMessage(AppSettings appSettings, ILogger<Worker> logger, HttpClient httpClient, double value, CancellationToken cancellationToken) {
+        Task<HttpResponseMessage> httpResponseMessage;
+        string success = value == 100 ? "true" : "false";
+        string error = value == 100 ? string.Empty : $"value: {value}%;";
+        httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", appSettings.GatusConfiguration.Token);
+        httpResponseMessage = httpClient.PostAsync($"{appSettings.GatusConfiguration.BaseUniformResourceLocator}/api/v1/endpoints/{appSettings.GatusConfiguration.Key}/external?success={success}&error={error}", null, cancellationToken);
+        httpResponseMessage.Wait(cancellationToken);
+        logger.LogInformation("Line {line}: {OriginalString} => {Resource} : {Key} ; {value}",
+                              164,
+                              httpResponseMessage.Result.RequestMessage.RequestUri.OriginalString,
+                              appSettings.MonAConfiguration.Resource,
+                              appSettings.GatusConfiguration.Key,
+                              value);
+        if (httpResponseMessage.Result.StatusCode != System.Net.HttpStatusCode.OK)
+            throw new Exception(httpResponseMessage.Result.StatusCode.ToString());
+        if (!string.IsNullOrEmpty(appSettings.GatusToGatusConfiguration.BaseUniformResourceLocator)
+            && !string.IsNullOrEmpty(appSettings.GatusToGatusConfiguration.Key)
+            && !string.IsNullOrEmpty(appSettings.GatusToGatusConfiguration.Token)) {
+            httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", appSettings.GatusToGatusConfiguration.Token);
+            httpResponseMessage = httpClient.PostAsync($"{appSettings.GatusToGatusConfiguration.BaseUniformResourceLocator}/api/v1/endpoints/{appSettings.GatusToGatusConfiguration.Key}/external?success={success}&error={error}", null, cancellationToken);
+            httpResponseMessage.Wait(cancellationToken);
+            logger.LogInformation("Line {line}: {OriginalString} => {Resource} : {Key} ; {value}",
+                                  178,
+                                  httpResponseMessage.Result.RequestMessage.RequestUri.OriginalString,
+                                  appSettings.MonAConfiguration.Resource,
+                                  appSettings.GatusToGatusConfiguration.Key,
+                                  value);
+            if (httpResponseMessage.Result.StatusCode != System.Net.HttpStatusCode.OK)
+                throw new Exception(httpResponseMessage.Result.StatusCode.ToString());
+        }
+    }
+
 }

Models/AppSettings.cs

@@ -4,6 +4,7 @@ using System.Text.Json.Serialization;
 namespace Gatus.To.MonA.Models;
 
 public record AppSettings(GatusConfiguration GatusConfiguration,
+                          GatusToGatusConfiguration GatusToGatusConfiguration,
                           GatusToMonaConfiguration GatusToMonaConfiguration,
                           MonAConfiguration MonAConfiguration) {
 
@@ -11,10 +12,12 @@ public record AppSettings(GatusConfiguration GatusConfiguration,
         AppSettings result;
 #pragma warning disable IL3050, IL2026
         GatusConfiguration? gatusConfiguration = configurationRoot.GetSection(nameof(GatusConfiguration)).Get<GatusConfiguration>();
+        GatusToGatusConfiguration? gatusToGatusConfiguration = configurationRoot.GetSection(nameof(GatusToGatusConfiguration)).Get<GatusToGatusConfiguration>();
         GatusToMonaConfiguration? gatusToMonaConfiguration = configurationRoot.GetSection(nameof(GatusToMonaConfiguration)).Get<GatusToMonaConfiguration>();
         MonAConfiguration? monAConfiguration = configurationRoot.GetSection(nameof(MonAConfiguration)).Get<MonAConfiguration>();
 #pragma warning restore IL3050, IL2026
         if (gatusConfiguration is null
+            || gatusToGatusConfiguration is null
             || gatusToMonaConfiguration is null
             || monAConfiguration is null
             || gatusToMonaConfiguration?.Company is null) {
@@ -29,6 +32,7 @@ public record AppSettings(GatusConfiguration GatusConfiguration,
             throw new NotSupportedException($"Not found!{Environment.NewLine}{string.Join(Environment.NewLine, paths.Distinct())}");
         }
         result = new(gatusConfiguration,
+                     gatusToGatusConfiguration,
                      gatusToMonaConfiguration,
                      monAConfiguration);
         Verify(result);

Models/GatusToGatusConfiguration.cs

@@ -0,0 +1,20 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Gatus.To.MonA.Models;
+
+public record GatusToGatusConfiguration(string? BaseUniformResourceLocator,
+                                        string? Key,
+                                        string? Token) {
+
+    public override string ToString() {
+        string result = JsonSerializer.Serialize(this, GatusToGatusConfigurationSourceGenerationContext.Default.GatusToGatusConfiguration);
+        return result;
+    }
+
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(GatusToGatusConfiguration))]
+internal partial class GatusToGatusConfigurationSourceGenerationContext : JsonSerializerContext {
+}

Models/GatusToMonaConfiguration.cs

@@ -6,7 +6,8 @@ namespace Gatus.To.MonA.Models;
 public record GatusToMonaConfiguration(string Company,
                                        string Directory,
                                        string Helper,
-                                       int MillisecondsDelay) {
+                                       int MillisecondsDelay,
+                                       string? SyncDirectory) {
 
     public override string ToString() {
         string result = JsonSerializer.Serialize(this, GatusToMonaConfigurationSourceGenerationContext.Default.GatusToMonaConfiguration);

Models/MonAConfiguration.cs

@@ -3,12 +3,13 @@ using System.Text.Json.Serialization;
 
 namespace Gatus.To.MonA.Models;
 
-public record MonAConfiguration(int Expected,
+public record MonAConfiguration(decimal Expected,
                                 int Minutes,
                                 string Resource,
                                 string Site,
                                 string StateName,
-                                string Suffix) {
+                                string Suffix,
+                                bool Use) {
 
     public override string ToString() {
         string result = JsonSerializer.Serialize(this, MonAConfigurationSourceGenerationContext.Default.MonAConfiguration);

Worker.cs

@@ -23,7 +23,7 @@ public partial class Worker : BackgroundService {
     }
 
     public override Task StopAsync(CancellationToken cancellationToken) {
-        if (_AppSettings.GatusToMonaConfiguration.Helper == nameof(Helpers.HelperGatusToMona))
+        if (_AppSettings.GatusToMonaConfiguration.Helper is nameof(Helpers.HelperGatusToMona))
             Helpers.HelperGatusToMona.Heartbeat(_AppSettings, _HttpClientFactory, _Logger, Infineon.Monitoring.MonA.State.Down, cancellationToken);
         return base.StopAsync(cancellationToken);
     }
@@ -31,6 +31,7 @@ public partial class Worker : BackgroundService {
     private async Task Body(CancellationToken cancellationToken) {
         if (!_IsWindowsService) {
             _Logger.LogInformation("Set break point and skip to run {_AppSettings.GatusToMonaConfiguration.Helper}!", _AppSettings.GatusToMonaConfiguration.Helper);
+            BodyInner(cancellationToken);
             throw new EvaluateException($"Set break point and skip to run {_AppSettings.GatusToMonaConfiguration.Helper}!");
         }
         if (!_IsWindowsService) {