DigitalData.Auth/DigitalData.Auth.Client/AuthClient.cs

using DigitalData.Auth.Abstractions;
using Microsoft.AspNetCore.SignalR.Client;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;

namespace DigitalData.Auth.Client;

public class AuthClient : IAuthClient, IAsyncDisposable
{
    private readonly HubConnection _connection;

    private readonly ILogger<AuthClient>? _logger;

    private readonly ClientParams _params;

    public AuthClient(IOptions<ClientParams> paramsOptions, HubConnectionBuilder connectionBuilder, ILogger<AuthClient>? logger = null)
    {
        _params = paramsOptions.Value;

        var cnnBuilder = connectionBuilder.WithUrl(_params.Url);

        // set RetryPolicy if it exists
        if (_params.RetryPolicy is not null)
            cnnBuilder = cnnBuilder.WithAutomaticReconnect(_params.RetryPolicy);

        _connection = cnnBuilder.Build();

        _connection.On<string, string, string>(nameof(ReceivePublicKeyAsync), ReceivePublicKeyAsync);

        _connection.Reconnected += async cnnId => await GetAllPublicKeysAsync();

        _logger = logger;
    }

    public bool IsConnected { get; private set; } = false;

    public IEnumerable<AsymmetricPublicKey> PublicKeys => _params.PublicKeys;

    public async Task StartAsync()
    {
        await _connection.StartAsync();
        IsConnected = true;
        await GetAllPublicKeysAsync();
    }

    public async Task<bool> TryStartAsync()
    {
        try
        {
            await StartAsync();
            return true;
        }
        catch(Exception ex)
        {
            _logger?.LogError(ex, "{message}", ex.Message);
            return false;
        }
    }

    public Task ReceivePublicKeyAsync(string issuer, string audience, string message) => Task.Run(() => _params.TriggerOnMessageReceived(this, issuer, audience, message, _logger));

    public Task SendPublicKeyAsync(string issuer, string audience, string message) => _connection.InvokeAsync(nameof(SendPublicKeyAsync), issuer, audience, message);

    public Task GetPublicKeyAsync(string issuer, string audience) => _connection.InvokeAsync(nameof(GetPublicKeyAsync), issuer, audience);

    public async Task GetAllPublicKeysAsync()
    {
        foreach (var publicKey in PublicKeys)
            await GetPublicKeyAsync(publicKey.Issuer, publicKey.Audience);
    }

    public virtual async ValueTask DisposeAsync()
    {
        await _connection.StopAsync();
        await _connection.DisposeAsync();
        GC.SuppressFinalize(this);
    }
}