gatus-to-mona/Helpers/HelperGatusToMona.cs

using System.Collections.ObjectModel;

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 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) {
        _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);
    }

    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) {
        _MonIn ??= MonIn.GetInstance(httpClientFactory);
        Heartbeat(appSettings, httpClientFactory, logger, State.Up, cancellationToken);
        ReadOnlyCollection<string> successMatches = GetSuccessMatches(appSettings, logger, cancellationToken);
        SendPerformanceMessage(appSettings, logger, successMatches, cancellationToken);
        return true;
    }

    private static ReadOnlyCollection<string> GetSuccessMatches(AppSettings appSettings, ILogger<Worker> logger, CancellationToken cancellationToken) {
        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;
            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}",
                                  39,
                                  value);
            if (line.EndsWith('1'))
                results.Add(string.Concat('{', value));
        }
        logger.LogInformation("Line {line}: {results}",
                              45,
                              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.URL, 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 void SendPerformanceMessage(AppSettings appSettings, ILogger<Worker> logger, ReadOnlyCollection<string> successMatches, 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,
                                                                                      value,
                                                                                      description: string.Empty);
        httpResponseMessage.Wait(cancellationToken);
        logger.LogInformation("Line {line}: {OriginalString} => {Resource} : {performanceName} ; {value}",
                              76,
                              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}",
                              86,
                              body.Result);
    }

}