feat(connections): failover on ServerCredentialsChangedEvent

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

Author: HandyS11

src/RustPlusBot.Features.Connections/Hosting/ConnectionHostedService.cs

@@ -50,19 +50,17 @@ public async Task StopAsync(CancellationToken cancellationToken)
 
     private async Task RunAsync(CancellationToken cancellationToken)
     {
-        // Subscription is registered when this loop first awaits the bus, after StartAllAsync completes.
+        // Subscriptions register when each loop first awaits the bus, after StartAllAsync completes.
         // The in-process bus does not replay, so events published before this point are not delivered. Safe:
-        // the server-registered event is only raised by the FCM pairing flow at runtime, long after startup.
+        // both events are only raised at runtime, long after startup.
         try
         {
             await supervisor.StartAllAsync(cancellationToken).ConfigureAwait(false);
 
-            await foreach (var registered in eventBus.SubscribeAsync<ServerRegisteredEvent>(cancellationToken)
-                               .ConfigureAwait(false))
-            {
-                await supervisor.EnsureConnectionAsync(registered.GuildId, registered.ServerId, cancellationToken)
-                    .ConfigureAwait(false);
-            }
+            await Task.WhenAll(
+                    ConsumeRegisteredAsync(cancellationToken),
+                    ConsumeCredentialsChangedAsync(cancellationToken))
+                .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -76,6 +74,26 @@ await supervisor.EnsureConnectionAsync(registered.GuildId, registered.ServerId,
 #pragma warning restore CA1031
     }
 
+    private async Task ConsumeRegisteredAsync(CancellationToken cancellationToken)
+    {
+        await foreach (var registered in eventBus.SubscribeAsync<ServerRegisteredEvent>(cancellationToken)
+                           .ConfigureAwait(false))
+        {
+            await supervisor.EnsureConnectionAsync(registered.GuildId, registered.ServerId, cancellationToken)
+                .ConfigureAwait(false);
+        }
+    }
+
+    private async Task ConsumeCredentialsChangedAsync(CancellationToken cancellationToken)
+    {
+        await foreach (var changed in eventBus.SubscribeAsync<ServerCredentialsChangedEvent>(cancellationToken)
+                           .ConfigureAwait(false))
+        {
+            await supervisor.EnsureConnectionAsync(changed.GuildId, changed.ServerId, cancellationToken)
+                .ConfigureAwait(false);
+        }
+    }
+
     [LoggerMessage(Level = LogLevel.Error, Message = "Connection hosted-service loop faulted.")]
     private static partial void LogLoopFaulted(ILogger logger, Exception exception);
 }

tests/RustPlusBot.Features.Connections.Tests/ConnectionHostedServiceTests.cs

@@ -35,4 +35,28 @@ public async Task Startup_CallsStartAll_And_ServerRegistered_EnsuresAConnection(
         await service.StopAsync(default);
         await supervisor.Received(1).StopAllAsync();
     }
+
+    [Fact]
+    public async Task ServerCredentialsChanged_EnsuresAConnection()
+    {
+        var supervisor = Substitute.For<IConnectionSupervisor>();
+        var bus = new InMemoryEventBus();
+        var service = new ConnectionHostedService(supervisor, bus, NullLogger<ConnectionHostedService>.Instance);
+
+        await service.StartAsync(default);
+
+        var serverId = Guid.NewGuid();
+        var deadline = DateTimeOffset.UtcNow.AddSeconds(20);
+        while (DateTimeOffset.UtcNow < deadline
+               && !supervisor.ReceivedCalls().Any(c =>
+                   c.GetMethodInfo().Name == nameof(IConnectionSupervisor.EnsureConnectionAsync)))
+        {
+            await bus.PublishAsync(new ServerCredentialsChangedEvent(10UL, serverId));
+            await Task.Delay(20);
+        }
+
+        await supervisor.Received().EnsureConnectionAsync(10UL, serverId, Arg.Any<CancellationToken>());
+
+        await service.StopAsync(default);
+    }
 }