gatus-to-mona/Helpers/HelperGatusToMona.cs

using System.Collections.ObjectModel;
using System.Net.Http.Headers;

using Gatus.To.MonA.Infineon.Monitoring.MonA;
using Gatus.To.MonA.Models;

namespace Gatus.To.MonA.Helpers;

internal static partial class HelperGatusToMona {

    private static IMonIn? _MonIn;
    private static HttpClient? _HttpClient;

    private static string GetFile(AppSettings appSettings) =>
        Path.Combine(appSettings.GatusToMonaConfiguration.Directory, appSettings.GatusConfiguration.FileName);

    internal static void Heartbeat(AppSettings appSettings, IHttpClientFactory httpClientFactory, ILogger<Worker> logger, State state, CancellationToken cancellationToken) {
        CreateEmptyFile(appSettings);
        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) {
        if (!Directory.Exists(appSettings.GatusToMonaConfiguration.Directory))
            _ = Directory.CreateDirectory(appSettings.GatusToMonaConfiguration.Directory);
        string file = GetFile(appSettings);
        File.WriteAllText(file, string.Empty);
    }

    internal static bool UpdateCount(AppSettings appSettings, IHttpClientFactory httpClientFactory, ILogger<Worker> logger, CancellationToken cancellationToken) {
        _HttpClient ??= httpClientFactory.CreateClient();
        if (appSettings.MonAConfiguration.Use) {
            _MonIn ??= MonIn.GetInstance(httpClientFactory);
            Heartbeat(appSettings, httpClientFactory, logger, State.Up, 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> 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;
        foreach (string line in lines) {
            if (!line.StartsWith(appSettings.GatusConfiguration.Metric))
                continue;
            segments = line.Split('{');
            if (segments.Length != 2)
                continue;
            value = segments[1];
            if (value.Length < 2)
                continue;
            if (value[^1] is not '0' and not '1')
                continue;
            logger.LogInformation("Line {line}: {value}",
                                  115,
                                  value);
            if (line.EndsWith('1'))
                results.Add(string.Concat('{', value));
        }
        logger.LogInformation("Line {line}: {results}",
                              121,
                              string.Join(Environment.NewLine, results));
        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, double value, CancellationToken cancellationToken) {
        string performanceName = string.Concat(appSettings.MonAConfiguration.Resource, appSettings.MonAConfiguration.Suffix);
        Task<HttpResponseMessage> httpResponseMessage = _MonIn.SendPerformanceMessage(appSettings.MonAConfiguration.Site,
                                                                                      appSettings.MonAConfiguration.Resource,
                                                                                      performanceName,
                                                                                      value,
                                                                                      description: string.Empty);
        httpResponseMessage.Wait(cancellationToken);
        logger.LogInformation("Line {line}: {OriginalString} => {Resource} : {performanceName} ; {value}",
                              142,
                              httpResponseMessage.Result.RequestMessage.RequestUri.OriginalString,
                              appSettings.MonAConfiguration.Resource,
                              performanceName,
                              value);
        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}",
                              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());
        }
    }

}