feat(alarms): inline per-device reachability (relay + renderer + EN/FR)

HandyS11 · claude · HandyS11 · commit e870ce447ed6 · 2026-06-30T19:03:41.000+02:00
Co-Authored-By: Claude Sonnet 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/src/RustPlusBot.Features.Alarms/Hosting/AlarmsHostedService.cs b/src/RustPlusBot.Features.Alarms/Hosting/AlarmsHostedService.cs
@@ -6,10 +6,10 @@
 
 namespace RustPlusBot.Features.Alarms.Hosting;
 
-/// <summary>Runs the alarm-pairing loop, the alarm-triggered relay loop, and the connection-status relay loop.</summary>
+/// <summary>Runs the alarm-pairing loop, the alarm-triggered relay loop, the connection-status relay loop, and the per-device reachability loop.</summary>
 /// <param name="eventBus">The in-process event bus.</param>
 /// <param name="coordinator">Handles paired alarms.</param>
-/// <param name="relay">Re-renders alarms on trigger/connection changes.</param>
+/// <param name="relay">Re-renders alarms on trigger/connection/reachability changes.</param>
 /// <param name="logger">The logger.</param>
 internal sealed partial class AlarmsHostedService(
     IEventBus eventBus,
@@ -19,6 +19,7 @@ internal sealed partial class AlarmsHostedService(
 {
     private readonly CancellationTokenSource _cts = new();
     private Task? _pairedLoop;
+    private Task? _reachabilityLoop;
     private Task? _statusLoop;
     private Task? _triggeredLoop;
 
@@ -31,6 +32,7 @@ public Task StartAsync(CancellationToken cancellationToken)
         _pairedLoop = Task.Run(() => ConsumePairedAsync(_cts.Token), CancellationToken.None);
         _triggeredLoop = Task.Run(() => ConsumeTriggeredAsync(_cts.Token), CancellationToken.None);
         _statusLoop = Task.Run(() => ConsumeStatusAsync(_cts.Token), CancellationToken.None);
+        _reachabilityLoop = Task.Run(() => ConsumeReachabilityChangedAsync(_cts.Token), CancellationToken.None);
         return Task.CompletedTask;
     }
 
@@ -40,7 +42,7 @@ public async Task StopAsync(CancellationToken cancellationToken)
         await _cts.CancelAsync().ConfigureAwait(false);
         foreach (var loop in new[]
                  {
-                     _pairedLoop, _triggeredLoop, _statusLoop
+                     _pairedLoop, _triggeredLoop, _statusLoop, _reachabilityLoop
                  }.Where(t => t is not null))
         {
             try
@@ -122,6 +124,28 @@ private async Task ConsumeStatusAsync(CancellationToken cancellationToken)
         }
     }
 
+    private async Task ConsumeReachabilityChangedAsync(CancellationToken cancellationToken)
+    {
+        try
+        {
+            await foreach (var evt in eventBus.SubscribeAsync<DeviceReachabilityChangedEvent>(cancellationToken)
+                               .ConfigureAwait(false))
+            {
+                await relay.HandleReachabilityChangedAsync(evt, cancellationToken).ConfigureAwait(false);
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // Shutting down.
+        }
+#pragma warning disable CA1031 // Broad catch: a faulting consumer must not crash the host.
+        catch (Exception ex)
+#pragma warning restore CA1031
+        {
+            LogReachabilityLoopFaulted(logger, ex);
+        }
+    }
+
     [LoggerMessage(Level = LogLevel.Error, Message = "Alarm pairing loop faulted.")]
     private static partial void LogPairedLoopFaulted(ILogger logger, Exception exception);
 
@@ -130,4 +154,7 @@ private async Task ConsumeStatusAsync(CancellationToken cancellationToken)
 
     [LoggerMessage(Level = LogLevel.Error, Message = "Alarm connection-status relay loop faulted.")]
     private static partial void LogStatusLoopFaulted(ILogger logger, Exception exception);
+
+    [LoggerMessage(Level = LogLevel.Error, Message = "Alarm reachability relay loop faulted.")]
+    private static partial void LogReachabilityLoopFaulted(ILogger logger, Exception exception);
 }
diff --git a/src/RustPlusBot.Features.Alarms/Relaying/AlarmStateRelay.cs b/src/RustPlusBot.Features.Alarms/Relaying/AlarmStateRelay.cs
@@ -10,6 +10,7 @@
 using RustPlusBot.Localization;
 using RustPlusBot.Persistence.Alarms;
 using RustPlusBot.Persistence.Connections;
+using RustPlusBot.Abstractions.Connections;
 using RustPlusBot.Persistence.Workspace;
 
 namespace RustPlusBot.Features.Alarms.Relaying;
@@ -134,6 +135,39 @@ public async Task HandleConnectionStatusAsync(ConnectionStatusChangedEvent evt,
         }
     }
 
+    /// <summary>
+    /// Handles a per-device reachability change: if the entity belongs to a managed alarm, persists the new
+    /// reachability and triggers a refresh. Foreign entities are silently ignored.
+    /// </summary>
+    /// <param name="evt">The device-reachability-changed event.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>A task that completes when the embed has been re-rendered (or the entity was ignored).</returns>
+    public async Task HandleReachabilityChangedAsync(
+        DeviceReachabilityChangedEvent evt,
+        CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(evt);
+        var scope = scopeFactory.CreateAsyncScope();
+        await using (scope.ConfigureAwait(false))
+        {
+            var store = scope.ServiceProvider.GetRequiredService<IAlarmStore>();
+            if (!await store.ExistsAsync(evt.GuildId, evt.ServerId, evt.EntityId, cancellationToken)
+                    .ConfigureAwait(false))
+            {
+                return; // not an alarm this relay manages — ignore.
+            }
+
+            await store.SetReachabilityAsync(evt.GuildId, evt.ServerId, evt.EntityId, evt.Reachability,
+                    cancellationToken)
+                .ConfigureAwait(false);
+        }
+
+        // The refresher re-loads + renders; server-down 'unreachable' stays false here — the connection-status
+        // path owns that flag. The renderer reads alarm.Reachability for the per-device reason.
+        await refresher.RefreshAsync(evt.GuildId, evt.ServerId, evt.EntityId, unreachable: false, cancellationToken)
+            .ConfigureAwait(false);
+    }
+
     private async Task RelayToTeamChatSafeAsync(SmartDeviceTriggeredEvent evt, string name, CancellationToken ct)
     {
         try
diff --git a/src/RustPlusBot.Features.Alarms/Rendering/AlarmEmbedRenderer.cs b/src/RustPlusBot.Features.Alarms/Rendering/AlarmEmbedRenderer.cs
@@ -1,5 +1,6 @@
 using System.Globalization;
 using Discord;
+using RustPlusBot.Abstractions.Connections;
 using RustPlusBot.Abstractions.Time;
 using RustPlusBot.Domain.Alarms;
 using RustPlusBot.Localization;
@@ -22,7 +23,19 @@ internal sealed class AlarmEmbedRenderer(ILocalizer localizer, IClock clock)
 
         string statusKey;
 #pragma warning disable IDE0045 // Collapsing to a nested ternary trips RCS1238/S3358 (nested conditional); the if/else chain is intentional.
-        if (unreachable)
+        if (alarm.Reachability == DeviceReachability.Removed)
+        {
+            statusKey = "alarm.status.removed";
+        }
+        else if (alarm.Reachability == DeviceReachability.NoPrivilege)
+        {
+            statusKey = "alarm.status.noprivilege";
+        }
+        else if (alarm.Reachability == DeviceReachability.NoResponse)
+        {
+            statusKey = "alarm.status.noresponse";
+        }
+        else if (unreachable)
         {
             statusKey = "alarm.status.unreachable";
         }
@@ -36,6 +49,11 @@ internal sealed class AlarmEmbedRenderer(ILocalizer localizer, IClock clock)
         }
 #pragma warning restore IDE0045
 
+        // Removed and NoPrivilege disable controls (device is gone or locked); NoResponse leaves them enabled
+        // so the user can still interact while the device is temporarily unresponsive.
+        var blocked = alarm.Reachability is DeviceReachability.Removed or DeviceReachability.NoPrivilege;
+        var disableButtons = unreachable || blocked;
+
         var triggered = alarm.LastTriggeredUtc is { } t
             ? localizer.Get("alarm.embed.lasttriggered", culture, CompactDuration(clock.UtcNow - t))
             : localizer.Get("alarm.embed.nevertriggered", culture);
@@ -51,11 +69,11 @@ internal sealed class AlarmEmbedRenderer(ILocalizer localizer, IClock clock)
         var relayKey = alarm.RelayToTeamChat ? "alarm.button.relay.on" : "alarm.button.relay.off";
         var components = new ComponentBuilder()
             .WithButton(localizer.Get(pingKey, culture), AlarmComponentIds.PingTogglePrefix + tail,
-                alarm.PingEveryone ? ButtonStyle.Success : ButtonStyle.Secondary, disabled: unreachable)
+                alarm.PingEveryone ? ButtonStyle.Success : ButtonStyle.Secondary, disabled: disableButtons)
             .WithButton(localizer.Get(relayKey, culture), AlarmComponentIds.RelayTogglePrefix + tail,
-                alarm.RelayToTeamChat ? ButtonStyle.Success : ButtonStyle.Secondary, disabled: unreachable)
+                alarm.RelayToTeamChat ? ButtonStyle.Success : ButtonStyle.Secondary, disabled: disableButtons)
             .WithButton(localizer.Get("alarm.button.rename", culture), AlarmComponentIds.RenamePrefix + tail,
-                ButtonStyle.Secondary, disabled: unreachable)
+                ButtonStyle.Secondary, disabled: disableButtons)
             .Build();
 
         return (embed, components);
diff --git a/src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs b/src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs
@@ -263,7 +263,8 @@ public async Task<IReadOnlyList<MonumentSnapshot>> GetMonumentsAsync(
             return null;
         }
 
-        var reading = await live.Connection.GetSmartDeviceInfoAsync(entityId, _options.HeartbeatTimeout, cancellationToken)
+        var reading = await live.Connection
+            .GetSmartDeviceInfoAsync(entityId, _options.HeartbeatTimeout, cancellationToken)
             .ConfigureAwait(false);
         return reading.IsActive;
     }
diff --git a/src/RustPlusBot.Localization/Strings.fr.resx b/src/RustPlusBot.Localization/Strings.fr.resx
@@ -60,6 +60,15 @@
   <data name="alarm.status.armed" xml:space="preserve">
     <value>🔔 Armée</value>
   </data>
+  <data name="alarm.status.noprivilege" xml:space="preserve">
+    <value>⛔ Aucun privilège de construction</value>
+  </data>
+  <data name="alarm.status.noresponse" xml:space="preserve">
+    <value>⚠️ Aucune réponse</value>
+  </data>
+  <data name="alarm.status.removed" xml:space="preserve">
+    <value>❌ Supprimé en jeu</value>
+  </data>
   <data name="alarm.status.unreachable" xml:space="preserve">
     <value>⚠️ Injoignable</value>
   </data>
diff --git a/src/RustPlusBot.Localization/Strings.resx b/src/RustPlusBot.Localization/Strings.resx
@@ -60,6 +60,15 @@
   <data name="alarm.status.armed" xml:space="preserve">
     <value>🔔 Armed</value>
   </data>
+  <data name="alarm.status.noprivilege" xml:space="preserve">
+    <value>⛔ No building privilege</value>
+  </data>
+  <data name="alarm.status.noresponse" xml:space="preserve">
+    <value>⚠️ No response</value>
+  </data>
+  <data name="alarm.status.removed" xml:space="preserve">
+    <value>❌ Removed in-game</value>
+  </data>
   <data name="alarm.status.unreachable" xml:space="preserve">
     <value>⚠️ Unreachable</value>
   </data>
diff --git a/tests/RustPlusBot.Features.Alarms.Tests/AlarmEmbedRendererTests.cs b/tests/RustPlusBot.Features.Alarms.Tests/AlarmEmbedRendererTests.cs
@@ -1,5 +1,6 @@
 using Discord;
 using NSubstitute;
+using RustPlusBot.Abstractions.Connections;
 using RustPlusBot.Abstractions.Time;
 using RustPlusBot.Domain.Alarms;
 using RustPlusBot.Features.Alarms.Rendering;
@@ -272,6 +273,65 @@ public void RenderPrompt_french_uses_french_strings()
         Assert.Contains("détectée", embed.Title ?? string.Empty, StringComparison.Ordinal);
     }
 
+    // ── Per-device reachability reason ───────────────────────────────────────
+
+    [Theory]
+    [InlineData(DeviceReachability.Removed, "Removed")]
+    [InlineData(DeviceReachability.NoPrivilege, "privilege")]
+    [InlineData(DeviceReachability.NoResponse, "response")]
+    public void RenderAlarm_non_reachable_shows_reason_status(DeviceReachability reachability, string expectedFragment)
+    {
+        var alarm = new SmartAlarm
+        {
+            GuildId = 10UL,
+            ServerId = Guid.Parse("11111111-1111-1111-1111-111111111111"),
+            EntityId = 42UL,
+            Name = "Trap",
+            Reachability = reachability,
+        };
+        var (embed, _) = Create().RenderAlarm(alarm, unreachable: false, "en");
+
+        Assert.Contains(expectedFragment, embed.Description ?? string.Empty, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Theory]
+    [InlineData(DeviceReachability.Removed)]
+    [InlineData(DeviceReachability.NoPrivilege)]
+    public void RenderAlarm_removed_or_noprivilege_disables_buttons(DeviceReachability reachability)
+    {
+        var alarm = new SmartAlarm
+        {
+            GuildId = 10UL,
+            ServerId = Guid.Parse("11111111-1111-1111-1111-111111111111"),
+            EntityId = 42UL,
+            Name = "Trap",
+            Reachability = reachability,
+        };
+        var (_, components) = Create().RenderAlarm(alarm, unreachable: false, "en");
+        var buttons = Buttons(components);
+
+        Assert.NotEmpty(buttons);
+        Assert.All(buttons, b => Assert.True(b.IsDisabled));
+    }
+
+    [Fact]
+    public void RenderAlarm_noresponse_leaves_buttons_enabled()
+    {
+        var alarm = new SmartAlarm
+        {
+            GuildId = 10UL,
+            ServerId = Guid.Parse("11111111-1111-1111-1111-111111111111"),
+            EntityId = 42UL,
+            Name = "Trap",
+            Reachability = DeviceReachability.NoResponse,
+        };
+        var (_, components) = Create().RenderAlarm(alarm, unreachable: false, "en");
+        var buttons = Buttons(components);
+
+        Assert.NotEmpty(buttons);
+        Assert.All(buttons, b => Assert.False(b.IsDisabled));
+    }
+
     [Fact]
     public void RenderAlarm_null_alarm_throws_argument_null()
     {
diff --git a/tests/RustPlusBot.Features.Alarms.Tests/AlarmStateRelayTests.cs b/tests/RustPlusBot.Features.Alarms.Tests/AlarmStateRelayTests.cs
@@ -2,6 +2,7 @@
 using Microsoft.Extensions.Logging.Abstractions;
 using NSubstitute;
 using NSubstitute.ExceptionExtensions;
+using RustPlusBot.Abstractions.Connections;
 using RustPlusBot.Abstractions.Events;
 using RustPlusBot.Abstractions.Time;
 using RustPlusBot.Domain.Alarms;
@@ -336,6 +337,53 @@ await h.Refresher.DidNotReceive()
             .RefreshAsync(Arg.Any<SmartAlarm>(), Arg.Any<bool>(), Arg.Any<CancellationToken>());
     }
 
+    // ──────────────────────────────────────────────────────────────────────────
+    // Reachability changed
+    // ──────────────────────────────────────────────────────────────────────────
+
+    /// <summary>A reachability change for an owned alarm persists the new value and triggers a refresh.</summary>
+    [Fact]
+    public async Task ReachabilityChanged_owned_alarm_persists_and_refreshes()
+    {
+        var serverId = Guid.NewGuid();
+        var h = Create();
+
+        h.Store.ExistsAsync(10UL, serverId, 42UL, Arg.Any<CancellationToken>()).Returns(true);
+
+        await h.Relay.HandleReachabilityChangedAsync(
+            new DeviceReachabilityChangedEvent(10UL, serverId, 42UL, DeviceReachability.NoPrivilege),
+            CancellationToken.None);
+
+        await h.Store.Received(1)
+            .SetReachabilityAsync(10UL, serverId, 42UL, DeviceReachability.NoPrivilege,
+                Arg.Any<CancellationToken>());
+        await h.Refresher.Received(1)
+            .RefreshAsync(10UL, serverId, 42UL, unreachable: false, Arg.Any<CancellationToken>());
+    }
+
+    /// <summary>A reachability change for a foreign entity (not in the alarm store) is silently ignored.</summary>
+    [Fact]
+    public async Task ReachabilityChanged_foreign_entity_is_ignored()
+    {
+        var serverId = Guid.NewGuid();
+        var h = Create();
+
+        // ExistsAsync returns false by default for unknown entities.
+        h.Store.ExistsAsync(Arg.Any<ulong>(), Arg.Any<Guid>(), Arg.Any<ulong>(), Arg.Any<CancellationToken>())
+            .Returns(false);
+
+        await h.Relay.HandleReachabilityChangedAsync(
+            new DeviceReachabilityChangedEvent(10UL, serverId, 99UL, DeviceReachability.Removed),
+            CancellationToken.None);
+
+        await h.Store.DidNotReceive()
+            .SetReachabilityAsync(Arg.Any<ulong>(), Arg.Any<Guid>(), Arg.Any<ulong>(),
+                Arg.Any<DeviceReachability>(), Arg.Any<CancellationToken>());
+        await h.Refresher.DidNotReceive()
+            .RefreshAsync(Arg.Any<ulong>(), Arg.Any<Guid>(), Arg.Any<ulong>(),
+                Arg.Any<bool>(), Arg.Any<CancellationToken>());
+    }
+
     private sealed record Harness(
         AlarmStateRelay Relay,
         IAlarmStore Store,
diff --git a/tests/RustPlusBot.Features.Connections.Tests/Fakes/FakeRustSocketSource.cs b/tests/RustPlusBot.Features.Connections.Tests/Fakes/FakeRustSocketSource.cs
@@ -20,9 +20,9 @@ internal sealed class FakeRustSocketSource : IRustSocketSource
 {
     private readonly ConcurrentQueue<SocketConnectOutcome> _connectOutcomes = new();
     private readonly ConcurrentQueue<HeartbeatResult> _heartbeats = new();
+    private readonly Dictionary<ulong, DeviceReachability> _pendingDeviceReachabilityOverrides = [];
     private readonly ConcurrentQueue<IReadOnlyList<MapMarkerSnapshot>> _pendingMarkerScript = new();
     private readonly Dictionary<ulong, StorageContentsSnapshot?> _pendingStorageContents = [];
-    private readonly Dictionary<ulong, DeviceReachability> _pendingDeviceReachabilityOverrides = [];
     private int _createCount;
 
     private HeartbeatResult _lastHeartbeat = HeartbeatResult.Ok(0);
@@ -245,9 +245,12 @@ public Task<DeviceReading> GetSmartDeviceInfoAsync(ulong entityId,
             TimeSpan timeout,
             CancellationToken cancellationToken)
         {
-            var reachability = DeviceReachabilityOverrides.TryGetValue(entityId, out var r) ? r : DeviceReachability.Reachable;
+            var reachability = DeviceReachabilityOverrides.TryGetValue(entityId, out var r)
+                ? r
+                : DeviceReachability.Reachable;
             var state = SwitchStates.TryGetValue(entityId, out var s) ? s : null;
-            return Task.FromResult(new DeviceReading(reachability == DeviceReachability.Reachable ? state : null, reachability));
+            return Task.FromResult(new DeviceReading(reachability == DeviceReachability.Reachable ? state : null,
+                reachability));
         }
 #pragma warning restore RCS1163
 
@@ -256,9 +259,12 @@ public Task<StorageReading> GetStorageMonitorInfoAsync(ulong entityId,
             TimeSpan timeout,
             CancellationToken cancellationToken)
         {
-            var reachability = DeviceReachabilityOverrides.TryGetValue(entityId, out var r) ? r : DeviceReachability.Reachable;
+            var reachability = DeviceReachabilityOverrides.TryGetValue(entityId, out var r)
+                ? r
+                : DeviceReachability.Reachable;
             var contents = StorageContents.TryGetValue(entityId, out var c) ? c : null;
-            return Task.FromResult(new StorageReading(reachability == DeviceReachability.Reachable ? contents : null, reachability));
+            return Task.FromResult(new StorageReading(reachability == DeviceReachability.Reachable ? contents : null,
+                reachability));
         }
 #pragma warning restore RCS1163
 
diff --git a/tests/RustPlusBot.Features.Connections.Tests/ReachabilitySweepTests.cs b/tests/RustPlusBot.Features.Connections.Tests/ReachabilitySweepTests.cs
diff --git a/tests/RustPlusBot.Localization.Tests/StringsResourceParityTests.cs b/tests/RustPlusBot.Localization.Tests/StringsResourceParityTests.cs

Original file line number	Diff line number	Diff line change
`@@ -263,7 +263,8 @@ public async Task<IReadOnlyList<MonumentSnapshot>> GetMonumentsAsync(`
`263`	`263`	`return null;`
`264`	`264`	`}`
`265`	`265`
`266`		`- var reading = await live.Connection.GetSmartDeviceInfoAsync(entityId, _options.HeartbeatTimeout, cancellationToken)`
	`266`	`+ var reading = await live.Connection`
	`267`	`+ .GetSmartDeviceInfoAsync(entityId, _options.HeartbeatTimeout, cancellationToken)`
`267`	`268`	`.ConfigureAwait(false);`
`268`	`269`	`return reading.IsActive;`
`269`	`270`	`}`