Auto-pruning of syncshell, added metrics for pruning, return of count of users in fullgroupdto.

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Groups.cs

@@ -264,7 +264,7 @@ public partial class LightlessHub
         var self = await DbContext.Users.SingleAsync(u => u.UID == UserUID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
 
         await Clients.User(UserUID).Client_GroupSendFullInfo(new GroupFullInfoDto(newGroup.ToGroupData(), self.ToUserData(),
-            newGroup.ToEnum(), initialPrefPermissions.ToEnum(), initialPair.ToEnum(), new(StringComparer.Ordinal)))
+            newGroup.ToEnum(), initialPrefPermissions.ToEnum(), initialPair.ToEnum(), new(StringComparer.Ordinal), 1))
             .ConfigureAwait(false);
         
         _logger.LogCallInfo(LightlessHubLogger.Args(gid));
@@ -454,9 +454,14 @@ public partial class LightlessHub
         await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
 
         var groupInfos = await DbContext.GroupPairs.Where(u => u.GroupGID == group.GID && (u.IsPinned || u.IsModerator)).ToListAsync(cancellationToken: RequestAbortedToken).ConfigureAwait(false);
+        var totalUserCount = await DbContext.GroupPairs
+            .AsNoTracking()
+            .CountAsync(u => u.GroupGID == group.GID, RequestAbortedToken)
+            .ConfigureAwait(false);
+
         await Clients.User(UserUID).Client_GroupSendFullInfo(new GroupFullInfoDto(group.ToGroupData(), group.Owner.ToUserData(),
             group.ToEnum(), preferredPermissions.ToEnum(), newPair.ToEnum(),
-            groupInfos.ToDictionary(u => u.GroupUserUID, u => u.ToEnum(), StringComparer.Ordinal))).ConfigureAwait(false);
+            groupInfos.ToDictionary(u => u.GroupUserUID, u => u.ToEnum(), StringComparer.Ordinal), totalUserCount)).ConfigureAwait(false);
 
         var self = DbContext.Users.Single(u => u.UID == UserUID);
 
@@ -678,30 +683,38 @@ public partial class LightlessHub
     {
         _logger.LogCallInfo(LightlessHubLogger.Args(dto, days, execute));
 
-        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
+        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID)
+            .ConfigureAwait(false);
         if (!hasRights) return -1;
 
-        var allGroupUsers = await DbContext.GroupPairs.Include(p => p.GroupUser).Include(p => p.Group)
-            .Where(g => g.GroupGID == dto.Group.GID)
-            .ToListAsync().ConfigureAwait(false);
-        var usersToPrune = allGroupUsers.Where(p => !p.IsPinned && !p.IsModerator
-            && !string.Equals(p.GroupUserUID, UserUID, StringComparison.Ordinal)
-            && !string.Equals(p.Group.OwnerUID, p.GroupUserUID, StringComparison.Ordinal)
-            && p.GroupUser.LastLoggedIn.AddDays(days) < DateTime.UtcNow);
-
-        if (!execute) return usersToPrune.Count();
-
-        DbContext.GroupPairs.RemoveRange(usersToPrune);
-
-        foreach (var pair in usersToPrune)
+        if (!execute)
         {
-            await Clients.Users(allGroupUsers.Where(p => !usersToPrune.Contains(p)).Select(g => g.GroupUserUID))
-                .Client_GroupPairLeft(new GroupPairDto(dto.Group, pair.GroupUser.ToUserData())).ConfigureAwait(false);
+            var count = await _pruneService.CountPrunableUsersAsync(dto.Group.GID, days, RequestAbortedToken).ConfigureAwait(false);
+            return count;
         }
 
-        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
+        var allGroupUsers = await DbContext.GroupPairs
+            .Include(p => p.GroupUser)
+            .Include(p => p.Group)
+            .Where(g => g.GroupGID == dto.Group.GID)
+            .ToListAsync(RequestAbortedToken).ConfigureAwait(false);
 
-        return usersToPrune.Count();
+        var prunedPairs = await _pruneService.ExecutePruneAsync(dto.Group.GID, days, RequestAbortedToken).ConfigureAwait(false);
+
+        var remainingUserIds = allGroupUsers
+            .Where(p => !prunedPairs.Any(x => string.Equals(x.GroupUserUID, p.GroupUserUID, StringComparison.Ordinal)))
+            .Select(p => p.GroupUserUID)
+            .Distinct(StringComparer.Ordinal)
+            .ToList();
+
+        foreach (var pair in prunedPairs)
+        {
+            await Clients.Users(remainingUserIds)
+                .Client_GroupPairLeft(new GroupPairDto(dto.Group, pair.GroupUser.ToUserData()))
+                .ConfigureAwait(false);
+        }
+
+        return prunedPairs.Count;
     }
 
     [Authorize(Policy = "Identified")]
@@ -910,6 +923,44 @@ public partial class LightlessHub
         await Clients.Users(groupPairs).Client_GroupPairChangeUserInfo(new GroupPairUserInfoDto(dto.Group, dto.User, userPair.ToEnum())).ConfigureAwait(false);
     }
 
+    [Authorize(Policy = "Identified")]
+    public async Task<GroupPruneSettingsDto?> GroupGetPruneSettings(GroupDto dto)
+    {
+        _logger.LogCallInfo(LightlessHubLogger.Args(dto));
+
+        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.GID)
+            .ConfigureAwait(false);
+        if (!hasRights || group == null)
+            return null;
+
+        return new GroupPruneSettingsDto(
+            Group: group.ToGroupData(),
+            AutoPruneEnabled: group.AutoPruneEnabled,
+            AutoPruneDays: group.AutoPruneDays
+        );
+    }
+
+    [Authorize(Policy = "Identified")]
+    public async Task GroupSetPruneSettings(GroupPruneSettingsDto dto)
+    {
+        _logger.LogCallInfo(LightlessHubLogger.Args(dto));
+
+        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID)
+            .ConfigureAwait(false);
+        if (!hasRights || group == null)
+            return;
+
+        // if days == 0, auto prune is OFF
+        var days = dto.AutoPruneDays;
+        var enabled = dto.AutoPruneEnabled && days > 0;
+
+        group.AutoPruneEnabled = enabled;
+        group.AutoPruneDays = enabled ? days : 0;
+
+        await DbContext.SaveChangesAsync(RequestAbortedToken)
+            .ConfigureAwait(false);
+    }
+
     [Authorize(Policy = "Identified")]
     public async Task<List<GroupFullInfoDto>> GroupsGetAll()
     {
@@ -932,6 +983,8 @@ public partial class LightlessHub
                     .Where(x => x.GroupGID == gp.GroupGID && (x.IsPinned || x.IsModerator))
                     .Select(x => new { x.GroupUserUID, EnumValue = x.ToEnum() })
                     .ToList(),
+                UserCount = DbContext.GroupPairs
+                    .Count(x => x.GroupGID == gp.GroupGID),
             })
             .AsNoTracking()
             .ToListAsync()
@@ -944,7 +997,6 @@ public partial class LightlessHub
         var groupInfoDict = r.GroupInfos
             .ToDictionary(x => x.GroupUserUID, x => x.EnumValue, StringComparer.Ordinal);
 
-
         _logger.LogCallInfo(LightlessHubLogger.Args(r));
 
         return new GroupFullInfoDto(
@@ -953,7 +1005,8 @@ public partial class LightlessHub
             r.GroupPair.Group.ToEnum(),
             r.PreferredPermission.ToEnum(),
             r.GroupPair.ToEnum(),
-                groupInfoDict
+            groupInfoDict,
+            r.UserCount
         );
         }),];
         return List;

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.cs

@@ -1,7 +1,6 @@
 using LightlessSync.API.Data;
 using LightlessSync.API.Data.Enum;
 using LightlessSync.API.Dto;
-using LightlessSync.API.Dto.Chat;
 using LightlessSync.API.SignalR;
 using LightlessSyncServer.Services;
 using LightlessSyncServer.Configuration;
@@ -17,8 +16,7 @@ using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
 using StackExchange.Redis.Extensions.Core.Abstractions;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
+using LightlessSyncServer.Services.Interfaces;
 
 namespace LightlessSyncServer.Hubs;
 
@@ -29,6 +27,7 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
     private readonly LightlessMetrics _lightlessMetrics;
     private readonly SystemInfoService _systemInfoService;
     private readonly PairService _pairService;
+    private readonly IPruneService _pruneService;
     private readonly IHttpContextAccessor _contextAccessor;
     private readonly LightlessHubLogger _logger;
     private readonly string _shardName;
@@ -55,7 +54,7 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
         IConfigurationService<ServerConfiguration> configuration, IHttpContextAccessor contextAccessor,
         IRedisDatabase redisDb, OnlineSyncedPairCacheService onlineSyncedPairCacheService, LightlessCensus lightlessCensus,
         GPoseLobbyDistributionService gPoseLobbyDistributionService, IBroadcastConfiguration broadcastConfiguration, PairService pairService,
-        ChatChannelService chatChannelService)
+        ChatChannelService chatChannelService, IPruneService pruneService)
     {
         _lightlessMetrics = lightlessMetrics;
         _systemInfoService = systemInfoService;
@@ -77,6 +76,7 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
         _broadcastConfiguration = broadcastConfiguration;
         _pairService = pairService;
         _chatChannelService = chatChannelService;
+        _pruneService = pruneService;
     }
 
     protected override void Dispose(bool disposing)

LightlessSyncServer/LightlessSyncServer/Services/Interfaces/IPruneService.cs

@@ -0,0 +1,10 @@
+using LightlessSyncShared.Models;
+
+namespace LightlessSyncServer.Services.Interfaces
+{
+    public interface IPruneService
+    {
+        Task<int> CountPrunableUsersAsync(string groupGid, int days, CancellationToken ct);
+        Task<IReadOnlyList<GroupPair>> ExecutePruneAsync(string groupGid, int days, CancellationToken ct);
+    }
+}

LightlessSyncServer/LightlessSyncServer/Services/PruneService.cs

@@ -0,0 +1,60 @@
+using LightlessSyncServer.Services.Interfaces;
+using LightlessSyncShared.Data;
+using LightlessSyncShared.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace LightlessSyncServer.Services
+{
+    public class PruneService(LightlessDbContext dbContext) : IPruneService
+    {
+        private readonly LightlessDbContext _dbContext = dbContext;
+
+        public async Task<int> CountPrunableUsersAsync(string groupGid, int days, CancellationToken ct)
+        {
+            var allGroupUsers = await _dbContext.GroupPairs
+                .Include(p => p.GroupUser)
+                .Include(p => p.Group)
+                .Where(g => g.GroupGID == groupGid)
+                .ToListAsync(ct).ConfigureAwait(false);
+
+            var inactivitySpan = GetInactivitySpan(days);
+            var now = DateTime.UtcNow;
+
+            var usersToPrune = allGroupUsers.Where(p =>
+                !p.IsPinned &&
+                !p.IsModerator &&
+                !string.Equals(p.Group.OwnerUID, p.GroupUserUID, StringComparison.Ordinal) &&
+                p.GroupUser.LastLoggedIn < now - inactivitySpan);
+
+            return usersToPrune.Count();
+        }
+
+        public async Task<IReadOnlyList<GroupPair>> ExecutePruneAsync(string groupGid, int days, CancellationToken ct)
+        {
+            var allGroupUsers = await _dbContext.GroupPairs
+                .Include(p => p.GroupUser)
+                .Include(p => p.Group)
+                .Where(g => g.GroupGID == groupGid)
+                .ToListAsync(ct).ConfigureAwait(false);
+
+            var inactivitySpan = GetInactivitySpan(days);
+            var now = DateTime.UtcNow;
+
+            var usersToPrune = allGroupUsers.Where(p =>
+                !p.IsPinned &&
+                !p.IsModerator &&
+                !string.Equals(p.Group.OwnerUID, p.GroupUserUID, StringComparison.Ordinal) &&
+                p.GroupUser.LastLoggedIn < now - inactivitySpan)
+                .ToList();
+
+            _dbContext.GroupPairs.RemoveRange(usersToPrune);
+            await _dbContext.SaveChangesAsync(ct).ConfigureAwait(false);
+
+            return usersToPrune;
+        }
+
+        private static TimeSpan GetInactivitySpan(int days) => days == 0
+                ? TimeSpan.FromMinutes(15)
+                : TimeSpan.FromDays(days);
+    }
+}

LightlessSyncServer/LightlessSyncServer/Services/SystemInfoService.cs

@@ -72,9 +72,11 @@ public sealed class SystemInfoService : BackgroundService
                     await _hubContext.Clients.All.Client_UpdateSystemInfo(SystemInfoDto).ConfigureAwait(false);
 
                     using var db = await _dbContextFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
+                    var groupsWithAutoPrune = db.Groups.AsNoTracking().Count(g => g.AutoPruneEnabled && g.AutoPruneDays > 0);
 
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeAuthorizedConnections, onlineUsers);
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeLightFinderConnections, countLightFinderUsers);
+                    _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeGroupAutoPrunesEnabled, groupsWithAutoPrune);
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugePairs, db.ClientPairs.AsNoTracking().Count());
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugePairsPaused, db.Permissions.AsNoTracking().Count(p => p.IsPaused));
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeGroups, db.Groups.AsNoTracking().Count());

LightlessSyncServer/LightlessSyncServer/Startup.cs

@@ -1,9 +1,11 @@
 using AspNetCoreRateLimit;
 using LightlessSync.API.SignalR;
-using LightlessSyncServer.Controllers;
 using LightlessSyncServer.Configuration;
+using LightlessSyncServer.Controllers;
 using LightlessSyncServer.Hubs;
 using LightlessSyncServer.Services;
+using LightlessSyncServer.Services.Interfaces;
+using LightlessSyncServer.Worker;
 using LightlessSyncShared.Data;
 using LightlessSyncShared.Metrics;
 using LightlessSyncShared.RequirementHandlers;
@@ -18,6 +20,7 @@ using Microsoft.AspNetCore.Http.Connections;
 using Microsoft.AspNetCore.Mvc.Controllers;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.IdentityModel.Tokens;
 using Prometheus;
 using StackExchange.Redis;
@@ -109,9 +112,12 @@ public class Startup
             services.AddHostedService(provider => provider.GetService<CharaDataCleanupService>());
             services.AddHostedService<ClientPairPermissionsCleanupService>();
             services.AddScoped<PairService>();
+            services.AddScoped<IPruneService, PruneService>();
         }
 
         services.AddSingleton<GPoseLobbyDistributionService>();
+
+        services.AddHostedService<AutoPruneWorker>();
         services.AddHostedService(provider => provider.GetService<GPoseLobbyDistributionService>());
     }
 
@@ -292,11 +298,12 @@ public class Startup
             MetricsAPI.CounterUserPairCacheMiss,
             MetricsAPI.CounterUserPairCacheNewEntries,
             MetricsAPI.CounterUserPairCacheUpdatedEntries,
-        }, new List<string>
-        {
+        },
+        [
             MetricsAPI.GaugeAuthorizedConnections,
             MetricsAPI.GaugeLightFinderConnections,
             MetricsAPI.GaugeLightFinderGroups,
+            MetricsAPI.GaugeGroupAutoPrunesEnabled,
             MetricsAPI.GaugeConnections,
             MetricsAPI.GaugePairs,
             MetricsAPI.GaugePairsPaused,
@@ -312,7 +319,7 @@ public class Startup
             MetricsAPI.GaugeGposeLobbyUsers,
             MetricsAPI.GaugeHubConcurrency,
             MetricsAPI.GaugeHubQueuedConcurrency,
-        }));
+        ]));
     }
 
     private static void ConfigureServicesBasedOnShardType(IServiceCollection services, IConfigurationSection lightlessConfig, bool isMainServer)

LightlessSyncServer/LightlessSyncServer/Worker/AutoPruneWorker.cs

@@ -0,0 +1,68 @@
+using LightlessSync.API.Dto.Group;
+using LightlessSyncServer.Hubs;
+using LightlessSyncServer.Services.Interfaces;
+using LightlessSyncServer.Utils;
+using LightlessSyncShared.Data;
+using Microsoft.AspNetCore.SignalR;
+using Microsoft.EntityFrameworkCore;
+
+namespace LightlessSyncServer.Worker
+{
+    public class AutoPruneWorker(IServiceProvider services, ILogger<AutoPruneWorker> logger) : BackgroundService
+    {
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        {
+            while (!stoppingToken.IsCancellationRequested)
+            {
+                try
+                {
+                    var scope = services.CreateAsyncScope();
+                    await using (scope.ConfigureAwait(false))
+                    {
+                        var db = scope.ServiceProvider.GetRequiredService<LightlessDbContext>();
+                        var pruneService = scope.ServiceProvider.GetRequiredService<IPruneService>();
+                        var hubContext = scope.ServiceProvider.GetRequiredService<IHubContext<LightlessHub>>();
+
+                        var groups = await db.Groups
+                            .Where(g => g.AutoPruneEnabled && g.AutoPruneDays > 0)
+                            .ToListAsync(stoppingToken).ConfigureAwait(false);
+
+                        foreach (var group in groups)
+                        {
+                            var allGroupUsers = await db.GroupPairs
+                                .Include(p => p.GroupUser)
+                                .Include(p => p.Group)
+                                .Where(p => p.GroupGID == group.GID)
+                                .ToListAsync(stoppingToken).ConfigureAwait(false);
+
+                            var prunedPairs = await pruneService.ExecutePruneAsync(group.GID, group.AutoPruneDays, stoppingToken).ConfigureAwait(false);
+
+                            if (prunedPairs.Count == 0)
+                                continue;
+
+                            var remainingUserIds = allGroupUsers
+                                .Where(p => !prunedPairs.Any(x => string.Equals(x.GroupUserUID, p.GroupUserUID, StringComparison.Ordinal)))
+                                .Select(p => p.GroupUserUID)
+                                .Distinct(StringComparer.Ordinal)
+                                .ToList();
+
+                            foreach (var pair in prunedPairs)
+                            {
+                                await hubContext.Clients.Users(remainingUserIds).SendAsync("Client_GroupPairLeft", new GroupPairDto(group.ToGroupData(), pair.GroupUser.ToUserData()), stoppingToken).ConfigureAwait(false);
+                            }
+
+                            logger.LogInformation("Auto-pruned {Count} users from group {GroupId}", prunedPairs.Count, group.GID);
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    logger.LogError(ex, "Error in auto-prune worker");
+                }
+
+                //Run task each hour to check for pruning
+                await Task.Delay(TimeSpan.FromHours(1), stoppingToken).ConfigureAwait(false);
+            }
+        }
+    }
+}

LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.Vanity.cs

@@ -94,7 +94,7 @@ public partial class LightlessWizardModule
         bool canAddVanityId = !db.Users.Any(u => u.UID == modal.DesiredVanityUID || u.Alias == modal.DesiredVanityUID);
         var forbiddenWords = new[] { "null", "nil" };
 
-        Regex rgx = new(@"^[_\-a-zA-Z0-9]{3,15}$", RegexOptions.ECMAScript);
+        Regex rgx = new(@"^[_\-a-zA-Z0-9\?]{3,15}$", RegexOptions.ECMAScript);
         if (!rgx.Match(desiredVanityUid).Success)
         {
             eb.WithColor(Color.Red);

LightlessSyncServer/LightlessSyncShared/Metrics/MetricsAPI.cs

@@ -11,6 +11,7 @@ public class MetricsAPI
     public const string CounterUsersRegisteredDeleted = "lightless_users_registered_deleted";
     public const string GaugeLightFinderConnections = "lightless_lightfinder_connections";
     public const string GaugeLightFinderGroups = "lightless_lightfinder_groups";
+    public const string GaugeGroupAutoPrunesEnabled = "lightless_group_autoprunes_enabled";
     public const string GaugePairs = "lightless_pairs";
     public const string GaugePairsPaused = "lightless_pairs_paused";
     public const string GaugeFilesTotal = "lightless_files";

LightlessSyncServer/LightlessSyncShared/Migrations/20251205205537_AddAutoPruneInGroup.cs

@@ -0,0 +1,40 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LightlessSyncServer.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddAutoPruneInGroup : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "auto_prune_days",
+                table: "groups",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "auto_prune_enabled",
+                table: "groups",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "auto_prune_days",
+                table: "groups");
+
+            migrationBuilder.DropColumn(
+                name: "auto_prune_enabled",
+                table: "groups");
+        }
+    }
+}

LightlessSyncServer/LightlessSyncShared/Migrations/LightlessDbContextModelSnapshot.cs

@@ -430,6 +430,14 @@ namespace LightlessSyncServer.Migrations
                         .HasColumnType("character varying(50)")
                         .HasColumnName("alias");
 
+                    b.Property<int>("AutoPruneDays")
+                        .HasColumnType("integer")
+                        .HasColumnName("auto_prune_days");
+
+                    b.Property<bool>("AutoPruneEnabled")
+                        .HasColumnType("boolean")
+                        .HasColumnName("auto_prune_enabled");
+
                     b.Property<DateTime>("CreatedDate")
                         .ValueGeneratedOnAdd()
                         .HasColumnType("timestamp with time zone")

LightlessSyncServer/LightlessSyncShared/Models/Group.cs

@@ -12,6 +12,8 @@ public class Group
     [MaxLength(50)]
     public string Alias { get; set; }
     public GroupProfile? Profile { get; set; }
+    public bool AutoPruneEnabled { get; set; } = false;
+    public int AutoPruneDays { get; set; } = 0;
     public bool InvitesEnabled { get; set; }
     public string HashedPassword { get; set; }
     public bool PreferDisableSounds { get; set; }