Skip to content

Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.

10.0 KB
Raw Blame
@using AliasVault.Admin.Main.Utilities
@using AliasVault.Shared.Models.Enums
@using AliasVault.WorkerStatus
@using AliasVault.WorkerStatus.Database

<div class="p-4 bg-white border border-gray-200 rounded-lg shadow-sm dark:border-gray-700 sm:p-6 dark:bg-gray-800">
    <div class="flex items-center justify-between mb-4">
        <h3 class="text-lg font-semibold text-gray-900 dark:text-white">Service status</h3>
    </div>
    @if (IsLoading)
    {
        <LoadingIndicator />
    }
    else
    {
        <div class="grid grid-cols-1 sm:grid-cols-2 gap-4">
            @foreach (var service in Services)
            {
                <div class="@TileClasses(service.Level) p-4 rounded-lg">
                    <p class="text-sm font-medium text-gray-500 dark:text-gray-400">@service.DisplayName</p>
                    <div class="flex items-center gap-2">
                        @StatusIcon(service.Level)
                        <h4 class="text-2xl font-bold text-gray-900 dark:text-white">@service.Label</h4>
                    </div>
                    <p class="text-sm text-gray-600 dark:text-gray-400" title="@service.Description">Last heartbeat: @RelativeTimeFormatter.Format(service.LastHeartbeat)</p>
                </div>
            }
        </div>
        <a href="maintenance" class="@TileClasses(Maintenance.Level) block p-4 mt-4 rounded-lg hover:opacity-90 transition-opacity">
            <p class="text-sm font-medium text-gray-500 dark:text-gray-400">Last maintenance run</p>
            <div class="flex items-center gap-2">
                @StatusIcon(Maintenance.Level)
                <h4 class="text-2xl font-bold text-gray-900 dark:text-white">@Maintenance.Label</h4>
            </div>
            <p class="text-sm text-gray-600 dark:text-gray-400" title="@Maintenance.Tooltip">@Maintenance.Description</p>
        </a>
    }
</div>

@code {
    /// <summary>
    /// A service whose last heartbeat is older than this is reported as offline.
    /// </summary>
    private static readonly TimeSpan HeartbeatTimeout = TimeSpan.FromMinutes(1);

    /// <summary>
    /// Interval at which the card polls the heartbeat records.
    /// </summary>
    private static readonly TimeSpan AutoRefreshInterval = TimeSpan.FromSeconds(10);

    /// <summary>
    /// A maintenance run that started longer ago than this is reported as overdue.
    /// </summary>
    private static readonly TimeSpan MaintenanceOverdueAfter = TimeSpan.FromHours(25);

    /// <summary>
    /// The monitored services keyed by the name they heartbeat under, with the name shown to the admin.
    /// </summary>
    private static readonly Dictionary<string, string> MonitoredServices = new()
    {
        { "AliasVault.SmtpService", "SMTP service" },
        { "AliasVault.TaskRunner", "Task runner" },
    };

    private bool IsLoading { get; set; } = true;
    private List<ServiceState> Services { get; set; } = [];
    private MaintenanceState Maintenance { get; set; } = null!;
    private CancellationTokenSource? _refreshCancellationTokenSource;

    /// <summary>
    /// Refreshes the data displayed on the card.
    /// </summary>
    public async Task RefreshData()
    {
        await using var dbContext = await DbContextFactory.CreateDbContextAsync();
        var entries = await dbContext.WorkerServiceStatuses.AsNoTracking().ToListAsync();
        var lastJob = await dbContext.TaskRunnerJobs.AsNoTracking()
            .Where(j => j.Status != TaskRunnerJobStatus.Pending)
            .OrderByDescending(j => j.RunDate)
            .ThenByDescending(j => j.StartTime)
            .FirstOrDefaultAsync();

        Services = MonitoredServices.Select(s => BuildState(s.Value, entries.Find(e => e.ServiceName == s.Key))).ToList();
        Maintenance = BuildMaintenanceState(lastJob);
        IsLoading = false;
        await InvokeAsync(StateHasChanged);
    }

    /// <inheritdoc />
    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        await base.OnAfterRenderAsync(firstRender);

        if (firstRender)
        {
            _refreshCancellationTokenSource = new CancellationTokenSource();
            _ = RunPeriodicRefreshAsync(_refreshCancellationTokenSource.Token);
        }
    }

    /// <inheritdoc />
    protected override void Dispose(bool disposing)
    {
        base.Dispose(disposing);

        if (disposing)
        {
            _refreshCancellationTokenSource?.Cancel();
            _refreshCancellationTokenSource?.Dispose();
        }
    }

    /// <summary>
    /// Derives what to show for a service from its heartbeat record.
    /// </summary>
    private static ServiceState BuildState(string displayName, WorkerServiceStatus? entry)
    {
        if (entry is null)
        {
            return new ServiceState(displayName, "Unknown", "No heartbeat has been recorded for this service yet.", null, StatusLevel.Unknown);
        }

        if (DateTime.UtcNow - entry.Heartbeat > HeartbeatTimeout)
        {
            return new ServiceState(displayName, "Offline", "The service has not sent a heartbeat recently.", entry.Heartbeat, StatusLevel.Error);
        }

        return entry.CurrentStatus switch
        {
            nameof(Status.Started) => new ServiceState(displayName, "Running", "All workers of the service are running.", entry.Heartbeat, StatusLevel.Ok),
            nameof(Status.Starting) => new ServiceState(displayName, "Starting", "The service is alive but not all of its workers are running yet.", entry.Heartbeat, StatusLevel.Warning),
            nameof(Status.Stopped) => new ServiceState(displayName, "Stopped", "The service shut down.", entry.Heartbeat, StatusLevel.Error),
            _ => new ServiceState(displayName, entry.CurrentStatus, "The service reported an unknown status.", entry.Heartbeat, StatusLevel.Unknown),
        };
    }

    /// <summary>
    /// Derives what to show for the last maintenance run. A run that is overdue or did not succeed is flagged.
    /// </summary>
    private static MaintenanceState BuildMaintenanceState(TaskRunnerJob? job)
    {
        if (job is null)
        {
            return new MaintenanceState("Never", "No maintenance run has been recorded yet.", null, StatusLevel.Error);
        }

        var startedAt = job.RunDate.Date + job.StartTime.ToTimeSpan();
        var label = RelativeTimeFormatter.Format(startedAt);
        var isOverdue = DateTime.UtcNow - startedAt > MaintenanceOverdueAfter;
        var tooltip = $"Started at {startedAt:yyyy-MM-dd HH:mm} UTC";

        return job.Status switch
        {
            TaskRunnerJobStatus.Error => new MaintenanceState(label, "The last run failed.", $"{tooltip}. {job.ErrorMessage}", StatusLevel.Error),
            TaskRunnerJobStatus.Canceled => new MaintenanceState(label, "The last run was canceled.", $"{tooltip}. {job.ErrorMessage}", StatusLevel.Warning),
            TaskRunnerJobStatus.Running when isOverdue => new MaintenanceState(label, "Running (overdue).", tooltip, StatusLevel.Error),
            TaskRunnerJobStatus.Running => new MaintenanceState(label, "A maintenance run is currently in progress.", tooltip, StatusLevel.Info),
            _ when isOverdue => new MaintenanceState(label, "Maintenance has not run in the last 24 hours.", tooltip, StatusLevel.Warning),
            _ => new MaintenanceState(label, "The last run completed successfully.", tooltip, StatusLevel.Ok),
        };
    }

    /// <summary>
    /// Tinted tile background for a status level.
    /// </summary>
    private static string TileClasses(StatusLevel level) => level switch
    {
        StatusLevel.Ok => "bg-green-50 dark:bg-green-900/20",
        StatusLevel.Warning => "bg-yellow-50 dark:bg-yellow-900/20",
        StatusLevel.Error => "bg-red-50 dark:bg-red-900/20",
        StatusLevel.Info => "bg-blue-50 dark:bg-blue-900/20",
        _ => "bg-gray-50 dark:bg-gray-700/50",
    };

    /// <summary>
    /// Icon for a status level: check, cross, exclamation, info or question mark.
    /// </summary>
    private static RenderFragment StatusIcon(StatusLevel level) => __builder =>
    {
        switch (level)
        {
            case StatusLevel.Ok:
                <UiIcon Icon="UiIcons.Check" class="w-6 h-6 shrink-0 text-green-600 dark:text-green-400" />
                break;
            case StatusLevel.Warning:
                <UiIcon Icon="UiIcons.Exclamation" class="w-6 h-6 shrink-0 text-yellow-600 dark:text-yellow-400" />
                break;
            case StatusLevel.Error:
                <UiIcon Icon="UiIcons.X" class="w-6 h-6 shrink-0 text-red-600 dark:text-red-400" />
                break;
            case StatusLevel.Info:
                <UiIcon Icon="UiIcons.InformationCircle" class="w-6 h-6 shrink-0 text-blue-600 dark:text-blue-400" />
                break;
            default:
                <UiIcon Icon="UiIcons.QuestionMarkCircle" class="w-6 h-6 shrink-0 text-gray-500 dark:text-gray-400" />
                break;
        }
    };

    /// <summary>
    /// Polls the heartbeat records until the card is disposed.
    /// </summary>
    private async Task RunPeriodicRefreshAsync(CancellationToken cancellationToken)
    {
        while (!cancellationToken.IsCancellationRequested)
        {
            try
            {
                await Task.Delay(AutoRefreshInterval, cancellationToken);
                await RefreshData();
            }
            catch (OperationCanceledException)
            {
                return;
            }
        }
    }

    /// <summary>
    /// Severity of a status, drives the tile color and icon.
    /// </summary>
    private enum StatusLevel
    {
        Ok,
        Warning,
        Error,
        Info,
        Unknown,
    }

    /// <summary>
    /// What the card shows for one service.
    /// </summary>
    private sealed record ServiceState(string DisplayName, string Label, string Description, DateTime? LastHeartbeat, StatusLevel Level);

    /// <summary>
    /// What the card shows for the last maintenance run.
    /// </summary>
    private sealed record MaintenanceState(string Label, string Description, string? Tooltip, StatusLevel Level);
}