gatus-to-mona/Helpers/HelperGatusToMona.cs

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

using Gatus.To.MonA.Models;

namespace Gatus.To.MonA.Helpers;

internal static partial class HelperGatusToMona {

    private static HttpClient? _HttpClient;

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

    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();
        ReadOnlyCollection<string> successMatches = GetSuccessMatches(appSettings, logger, cancellationToken);
        decimal value = GetValue(appSettings, successMatches);
        SendPerformanceMessage(appSettings, logger, _HttpClient, value, 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}",
                                  76,
                                  value);
            if (line.EndsWith('1'))
                results.Add(string.Concat('{', value));
        }
        logger.LogInformation("Line {line}: {results}",
                              82,
                              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, HttpClient httpClient, decimal value, CancellationToken cancellationToken) {
        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}",
        //                       140,
        //                       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);
        Task<HttpResponseMessage> 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}",
                              154,
                              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());
    }

}