feat(workspace): re-render #info on ConnectionStatusChangedEvent

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: HandyS11

src/RustPlusBot.Features.Workspace/Hosting/WorkspaceHostedService.cs

@@ -20,7 +20,8 @@ internal sealed class WorkspaceHostedService(
     ILogger<WorkspaceHostedService> logger) : IHostedService, IDisposable
 {
     private readonly CancellationTokenSource _cts = new();
-    private Task? _eventLoop;
+    private Task? _serverRegisteredLoop;
+    private Task? _connectionStatusLoop;
     private bool _startupDone;
 
     /// <inheritdoc />
@@ -31,7 +32,8 @@ public Task StartAsync(CancellationToken cancellationToken)
     {
         client.Ready += OnReadyAsync;
         client.ChannelDestroyed += OnChannelDestroyedAsync;
-        _eventLoop = Task.Run(() => ConsumeServerRegisteredAsync(_cts.Token), CancellationToken.None);
+        _serverRegisteredLoop = Task.Run(() => ConsumeServerRegisteredAsync(_cts.Token), CancellationToken.None);
+        _connectionStatusLoop = Task.Run(() => ConsumeConnectionStatusAsync(_cts.Token), CancellationToken.None);
         return Task.CompletedTask;
     }
 
@@ -41,12 +43,17 @@ public async Task StopAsync(CancellationToken cancellationToken)
         client.Ready -= OnReadyAsync;
         client.ChannelDestroyed -= OnChannelDestroyedAsync;
         await _cts.CancelAsync().ConfigureAwait(false);
-        if (_eventLoop is not null)
+        foreach (var loop in new[] { _serverRegisteredLoop, _connectionStatusLoop })
         {
+            if (loop is null)
+            {
+                continue;
+            }
+
             try
             {
-#pragma warning disable VSTHRD003 // Avoid awaiting or returning a Task representing work that was not started within your context
-                await _eventLoop.ConfigureAwait(false);
+#pragma warning disable VSTHRD003 // Avoid awaiting foreign Tasks — these are our own loop tasks, joined on stop.
+                await loop.ConfigureAwait(false);
 #pragma warning restore VSTHRD003
             }
             catch (OperationCanceledException)
@@ -98,6 +105,34 @@ private async Task OnChannelDestroyedAsync(SocketChannel channel)
         }
     }
 
+    private async Task ConsumeConnectionStatusAsync(CancellationToken cancellationToken)
+    {
+        // If this loop faults (broad catch), the consumer exits permanently and info channels stop
+        // updating until the host restarts. Acceptable: the reconciler is idempotent and a restart heals.
+        try
+        {
+            await foreach (var changed in eventBus.SubscribeAsync<ConnectionStatusChangedEvent>(cancellationToken)
+                               .ConfigureAwait(false))
+            {
+                var scope = scopeFactory.CreateAsyncScope();
+                await using (scope.ConfigureAwait(false))
+                {
+                    var reconciler = scope.ServiceProvider.GetRequiredService<IWorkspaceReconciler>();
+                    await reconciler.ReconcileServerAsync(changed.GuildId, changed.ServerId, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // Shutting down.
+        }
+        catch (Exception ex) // Broad catch is intentional: a faulting consumer must not crash the host.
+        {
+            logger.LogError(ex, "ConnectionStatusChanged consumer faulted.");
+        }
+    }
+
     private async Task ConsumeServerRegisteredAsync(CancellationToken cancellationToken)
     {
         // Subscription is registered when this loop first calls SubscribeAsync; the in-process bus does

src/RustPlusBot.Features.Workspace/RustPlusBot.Features.Workspace.csproj

@@ -2,6 +2,7 @@
 
   <ItemGroup>
     <InternalsVisibleTo Include="RustPlusBot.Features.Workspace.Tests" />
+    <InternalsVisibleTo Include="DynamicProxyGenAssembly2" />
   </ItemGroup>
 
   <ItemGroup>

tests/RustPlusBot.Features.Workspace.Tests/Hosting/WorkspaceConnectionStatusTests.cs

@@ -0,0 +1,43 @@
+using Discord.WebSocket;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging.Abstractions;
+using NSubstitute;
+using RustPlusBot.Abstractions.Events;
+using RustPlusBot.Features.Workspace.Hosting;
+using RustPlusBot.Features.Workspace.Reconciler;
+
+namespace RustPlusBot.Features.Workspace.Tests.Hosting;
+
+public sealed class WorkspaceConnectionStatusTests
+{
+    [Fact]
+    public async Task ConnectionStatusChanged_ReconcilesThatServer()
+    {
+        var reconciler = Substitute.For<IWorkspaceReconciler>();
+        var services = new ServiceCollection();
+        services.AddScoped(_ => reconciler);
+        await using var provider = services.BuildServiceProvider();
+
+        var bus = new InMemoryEventBus();
+        var client = new DiscordSocketClient();
+        var service = new WorkspaceHostedService(client, bus,
+            provider.GetRequiredService<IServiceScopeFactory>(),
+            NullLogger<WorkspaceHostedService>.Instance);
+
+        await service.StartAsync(default);
+        var serverId = Guid.NewGuid();
+        // The in-process bus does not replay; re-publish until the consumer has reconciled (or deadline).
+        var deadline = DateTimeOffset.UtcNow.AddSeconds(20);
+        while (DateTimeOffset.UtcNow < deadline
+               && !reconciler.ReceivedCalls().Any(c =>
+                   c.GetMethodInfo().Name == nameof(IWorkspaceReconciler.ReconcileServerAsync)))
+        {
+            await bus.PublishAsync(new ConnectionStatusChangedEvent(10UL, serverId));
+            await Task.Delay(20);
+        }
+
+        await reconciler.Received().ReconcileServerAsync(10UL, serverId, Arg.Any<CancellationToken>());
+
+        await service.StopAsync(default);
+    }
+}