JobsHubGroupMapper.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.AspNetCore.SignalR;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
 
using Tgstation.Server.Api.Hubs;
using Tgstation.Server.Host.Database;
using Tgstation.Server.Host.Models;
using Tgstation.Server.Host.Security;
using Tgstation.Server.Host.Utils.SignalR;
 
namespace Tgstation.Server.Host.Jobs
{
    sealed class JobsHubGroupMapper : IPermissionsUpdateNotifyee, IHostedService
    {
        readonly IConnectionMappedHubContext<JobsHub, IJobsHub> hub;
 
        readonly IDatabaseContextFactory databaseContextFactory;
 
        readonly IJobsHubUpdater jobsHubUpdater;
 
        readonly ILogger<JobsHubGroupMapper> logger;
 
        public JobsHubGroupMapper(
            IConnectionMappedHubContext<JobsHub, IJobsHub> hub,
            IDatabaseContextFactory databaseContextFactory,
            IJobsHubUpdater jobsHubUpdater,
            ILogger<JobsHubGroupMapper> logger)
        {
            this.hub = hub ?? throw new ArgumentNullException(nameof(hub));
            this.databaseContextFactory = databaseContextFactory ?? throw new ArgumentNullException(nameof(databaseContextFactory));
            this.jobsHubUpdater = jobsHubUpdater ?? throw new ArgumentNullException(nameof(jobsHubUpdater));
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
 
            hub.OnConnectionMapGroups += MapConnectionGroups;
        }
 
        public ValueTask InstancePermissionSetCreated(InstancePermissionSet instancePermissionSet, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(instancePermissionSet);
            var permissionSetId = instancePermissionSet.PermissionSetId;
 
            logger.LogTrace("InstancePermissionSetCreated");
            return RefreshHubGroups(
                permissionSetId,
                cancellationToken);
        }
 
        public ValueTask UserDisabled(User user, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(user);
            if (!user.Id.HasValue)
                throw new InvalidOperationException("user.Id was null!");
 
            logger.LogTrace("UserDisabled");
            hub.AbortUnauthedConnections(user);
            return ValueTask.CompletedTask;
        }
 
        public ValueTask InstancePermissionSetDeleted(PermissionSet permissionSet, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(permissionSet);
            logger.LogTrace("InstancePermissionSetDeleted");
            return RefreshHubGroups(
                permissionSet.Id ?? throw new InvalidOperationException("permissionSet?.Id was null!"),
                cancellationToken);
        }
 
        public Task StartAsync(CancellationToken cancellationToken) => Task.CompletedTask;
 
        public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
 
        async ValueTask MapConnectionGroups(
            IAuthenticationContext authenticationContext,
            Func<IEnumerable<string>, Task> mappingFunc,
            CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(authenticationContext);
 
            var pid = authenticationContext.PermissionSet.Require(x => x.Id);
            logger.LogTrace(
                "MapConnectionGroups UID: {uid} PID: {pid}",
                authenticationContext.User.Require(x => x.Id),
                pid);
 
            List<long>? permedInstanceIds = null;
            await databaseContextFactory.UseContext(
                async databaseContext =>
                    permedInstanceIds = await databaseContext
                        .InstancePermissionSets
                        .AsQueryable()
                        .Where(ips => ips.PermissionSetId == pid)
                        .Select(ips => ips.InstanceId)
                        .ToListAsync(cancellationToken));
 
            await mappingFunc(
                permedInstanceIds!.Select(
                    JobsHub.HubGroupName));
 
            jobsHubUpdater.QueueActiveJobUpdates();
        }
 
        ValueTask RefreshHubGroups(long permissionSetId, CancellationToken cancellationToken)
            => databaseContextFactory.UseContext(
                async databaseContext =>
                {
                    logger.LogTrace("RefreshHubGroups");
                    var permissionSetUsers = await databaseContext
                        .Users
                        .Where(x => x.PermissionSet!.Id == permissionSetId)
                        .ToListAsync(cancellationToken);
                    var allInstanceIds = await databaseContext
                        .Instances
                        .Select(
                            instance => instance.Id!.Value)
                        .ToListAsync(cancellationToken);
                    var permissionSetAccessibleInstanceIds = await databaseContext
                        .InstancePermissionSets
                        .AsQueryable()
                        .Where(ips => ips.PermissionSetId == permissionSetId)
                        .Select(ips => ips.InstanceId)
                        .ToListAsync(cancellationToken);
 
                    var groupsToRemove = allInstanceIds
                        .Except(permissionSetAccessibleInstanceIds)
                        .Select(JobsHub.HubGroupName);
 
                    var groupsToAdd = permissionSetAccessibleInstanceIds
                        .Select(JobsHub.HubGroupName);
 
                    var connectionIds = permissionSetUsers
                        .SelectMany(user => hub.UserConnectionIds(user))
                        .ToList();
 
                    logger.LogTrace(
                        "Updating groups for the {connectionCount} hub connections of permission set {permissionSetId}. They may access {allowed}/{total} instances.",
                        connectionIds.Count,
                        permissionSetId,
                        permissionSetAccessibleInstanceIds.Count,
                        allInstanceIds.Count);
 
                    var removeTasks = connectionIds
                        .SelectMany(connectionId => groupsToRemove
                            .Select(groupName => hub
                                .Groups
                                .RemoveFromGroupAsync(connectionId, groupName, cancellationToken)));
 
                    var addTasks = connectionIds
                        .SelectMany(connectionId => groupsToAdd
                            .Select(groupName => hub
                                .Groups
                                .AddToGroupAsync(connectionId, groupName, cancellationToken)));
 
                    // Checked internally, the default implementations for these tasks complete synchronously
                    // https://github.com/dotnet/aspnetcore/blob/ce330d9d12f7676ff35c2223bd8a3b1e252a4e86/src/SignalR/server/Core/src/DefaultHubLifetimeManager.cs#L34-L70
                    await Task.WhenAll(removeTasks.Concat(addTasks));
                });
    }
}