refactor(discord): extract shared poster boilerplate into DiscordChannelMessenger

HandyS11 · claude · HandyS11 · commit f33fed4228e8 · 2026-06-23T17:31:04.000+02:00
Co-Authored-By: Claude Opus 4.8 &lt;noreply@anthropic.com&gt;
diff --git a/Directory.Packages.props b/Directory.Packages.props
@@ -10,6 +10,7 @@
     <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.9" />
     <PackageVersion Include="Microsoft.Extensions.Hosting" Version="10.0.9" />
     <PackageVersion Include="Microsoft.Extensions.Hosting.Abstractions" Version="10.0.9" />
+    <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.9" />
     <PackageVersion Include="Persistord.Core" Version="1.0.0-beta.1" />
     <PackageVersion Include="RustPlusApi" Version="2.0.0-beta.3" />
     <PackageVersion Include="RustPlusApi.Fcm" Version="2.0.0-beta.3" />
diff --git a/src/RustPlusBot.Discord/Posting/DiscordChannelMessenger.cs b/src/RustPlusBot.Discord/Posting/DiscordChannelMessenger.cs
@@ -0,0 +1,132 @@
+using Discord;
+using Discord.Net;
+using Discord.WebSocket;
+using Microsoft.Extensions.Logging;
+
+namespace RustPlusBot.Discord.Posting;
+
+/// <summary>Shared Discord channel post/edit boilerplate: fetch, options, self-heal, broad-catch.</summary>
+public static class DiscordChannelMessenger
+{
+    /// <summary>
+    ///     Edits the message by id (self-healing on 404 by reposting) or posts a new one.
+    ///     Returns the message id, or null on failure.
+    /// </summary>
+    /// <param name="client">The Discord socket client.</param>
+    /// <param name="channelId">The target channel id.</param>
+    /// <param name="messageId">The existing message id to edit, or null to post a new one.</param>
+    /// <param name="embed">The embed to post or update.</param>
+    /// <param name="components">The message components to post or update.</param>
+    /// <param name="logger">The caller's logger.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    public static async Task<ulong?> EnsureAsync(
+        DiscordSocketClient client,
+        ulong channelId,
+        ulong? messageId,
+        Embed embed,
+        MessageComponent components,
+        ILogger logger,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            var options = new RequestOptions
+            {
+                CancelToken = cancellationToken
+            };
+            if (await client.GetChannelAsync(channelId, options).ConfigureAwait(false)
+                is not ITextChannel channel)
+            {
+                return null;
+            }
+
+            if (messageId is { } id)
+            {
+                // Inner try: some Discord.Net versions THROW (HttpException 404/Unknown Message)
+                // rather than return null for a deleted message. Catch it and fall through to repost
+                // so the self-heal path always runs.
+                try
+                {
+                    var existing = await channel.GetMessageAsync(id, options: options).ConfigureAwait(false);
+                    if (existing is IUserMessage userMessage)
+                    {
+                        await userMessage.ModifyAsync(m =>
+                        {
+                            m.Embed = embed;
+                            m.Components = components;
+                        }, options).ConfigureAwait(false);
+                        return userMessage.Id;
+                    }
+
+                    // Message was deleted (returned null / not a user message); fall through to repost.
+                }
+                catch (HttpException ex) when (ex.HttpCode == System.Net.HttpStatusCode.NotFound)
+                {
+                    // Deleted/unknown message; fall through to repost and return the new id.
+#pragma warning disable CA1848, CA1873 // Use LoggerMessage delegates / avoid expensive log-arg evaluation — plain logger.Log is fine for a shared helper (no source-gen partial context); ulong boxing is negligible vs. the caught exception.
+                    logger.LogDebug(ex, "Embed {MessageId} in channel {ChannelId} was deleted; reposting.", id,
+                        channelId);
+#pragma warning restore CA1848, CA1873
+                }
+            }
+
+            var posted = await channel
+                .SendMessageAsync(embed: embed, options: options, components: components)
+                .ConfigureAwait(false);
+            return posted.Id;
+        }
+        catch (OperationCanceledException)
+        {
+            throw; // Shutdown — let the loop unwind.
+        }
+#pragma warning disable CA1031 // Broad catch: a Discord hiccup must not crash the relay; report failure as null.
+        catch (Exception ex)
+#pragma warning restore CA1031
+        {
+#pragma warning disable CA1848, CA1873 // Use LoggerMessage delegates / avoid expensive log-arg evaluation — plain logger.Log is fine for a shared helper (no source-gen partial context); ulong boxing is negligible vs. the caught exception.
+            logger.LogWarning(ex, "Posting/editing an embed in channel {ChannelId} failed.", channelId);
+#pragma warning restore CA1848, CA1873
+            return null;
+        }
+    }
+
+    /// <summary>Posts an embed fire-and-forget; Discord hiccups are logged and swallowed.</summary>
+    /// <param name="client">The Discord socket client.</param>
+    /// <param name="channelId">The target channel id.</param>
+    /// <param name="embed">The embed to post.</param>
+    /// <param name="logger">The caller's logger.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    public static async Task PostAsync(
+        DiscordSocketClient client,
+        ulong channelId,
+        Embed embed,
+        ILogger logger,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            var options = new RequestOptions
+            {
+                CancelToken = cancellationToken
+            };
+            if (await client.GetChannelAsync(channelId, options).ConfigureAwait(false) is not ITextChannel channel)
+            {
+                return;
+            }
+
+            await channel.SendMessageAsync(embed: embed, options: options).ConfigureAwait(false);
+        }
+        catch (OperationCanceledException)
+        {
+            throw; // Cancellation (shutdown) is not a post failure; let the relay loop unwind cleanly.
+        }
+#pragma warning disable CA1031 // Broad catch: a Discord hiccup must not crash the relay.
+        catch (Exception ex)
+#pragma warning restore CA1031
+        {
+#pragma warning disable CA1848, CA1873 // Use LoggerMessage delegates / avoid expensive log-arg evaluation — plain logger.Log is fine for a shared helper (no source-gen partial context); ulong boxing is negligible vs. the caught exception.
+            logger.LogWarning(ex, "Posting an embed to channel {ChannelId} failed.", channelId);
+#pragma warning restore CA1848, CA1873
+        }
+    }
+}
diff --git a/src/RustPlusBot.Discord/RustPlusBot.Discord.csproj b/src/RustPlusBot.Discord/RustPlusBot.Discord.csproj
@@ -9,6 +9,7 @@
   <ItemGroup>
     <PackageReference Include="Discord.Net" />
     <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
   </ItemGroup>
 
 </Project>
diff --git a/src/RustPlusBot.Features.Alarms/Posting/DiscordAlarmChannelPoster.cs b/src/RustPlusBot.Features.Alarms/Posting/DiscordAlarmChannelPoster.cs
@@ -1,6 +1,7 @@
-using Discord.Net;
+using Discord;
 using Discord.WebSocket;
 using Microsoft.Extensions.Logging;
+using RustPlusBot.Discord.Posting;
 
 namespace RustPlusBot.Features.Alarms.Posting;
 
@@ -12,89 +13,34 @@ internal sealed partial class DiscordAlarmChannelPoster(
     ILogger<DiscordAlarmChannelPoster> logger) : IAlarmChannelPoster
 {
     /// <inheritdoc />
-    public async Task<ulong?> EnsureAsync(
+    public Task<ulong?> EnsureAsync(
         ulong channelId,
         ulong? messageId,
-        global::Discord.Embed embed,
-        global::Discord.MessageComponent components,
+        Embed embed,
+        MessageComponent components,
         CancellationToken cancellationToken)
-    {
-        try
-        {
-            var options = new global::Discord.RequestOptions
-            {
-                CancelToken = cancellationToken
-            };
-            if (await client.GetChannelAsync(channelId, options).ConfigureAwait(false)
-                is not global::Discord.ITextChannel channel)
-            {
-                return null;
-            }
-
-            if (messageId is { } id)
-            {
-                // Inner try: some Discord.Net versions THROW (HttpException 404/Unknown Message)
-                // rather than return null for a deleted message. Catch it and fall through to repost
-                // so the self-heal path always runs.
-                try
-                {
-                    var existing = await channel.GetMessageAsync(id, options: options).ConfigureAwait(false);
-                    if (existing is global::Discord.IUserMessage userMessage)
-                    {
-                        await userMessage.ModifyAsync(m =>
-                        {
-                            m.Embed = embed;
-                            m.Components = components;
-                        }, options).ConfigureAwait(false);
-                        return userMessage.Id;
-                    }
-
-                    // Message was deleted (returned null / not a user message); fall through to repost.
-                }
-                catch (HttpException ex) when (ex.HttpCode == System.Net.HttpStatusCode.NotFound)
-                {
-                    // Deleted/unknown message; fall through to repost and return the new id.
-                    LogMessageMissing(logger, ex, channelId, id);
-                }
-            }
-
-            var posted = await channel
-                .SendMessageAsync(embed: embed, options: options, components: components)
-                .ConfigureAwait(false);
-            return posted.Id;
-        }
-        catch (OperationCanceledException)
-        {
-            throw; // Shutdown — let the loop unwind.
-        }
-#pragma warning disable CA1031 // Broad catch: a Discord hiccup must not crash the relay; report failure as null.
-        catch (Exception ex)
-#pragma warning restore CA1031
-        {
-            LogEnsureFailed(logger, ex, channelId);
-            return null;
-        }
-    }
+        => DiscordChannelMessenger.EnsureAsync(client, channelId, messageId, embed, components, logger,
+            cancellationToken);
 
     /// <inheritdoc />
     public async Task SendEveryonePingAsync(ulong channelId, string content, CancellationToken cancellationToken)
     {
         try
         {
-            var options = new global::Discord.RequestOptions
+            var options = new RequestOptions
             {
                 CancelToken = cancellationToken
             };
             if (await client.GetChannelAsync(channelId, options).ConfigureAwait(false)
-                is not global::Discord.ITextChannel channel)
+                is not ITextChannel channel)
             {
                 return;
             }
 
             await channel.SendMessageAsync(
                     content,
                     options: options,
-                    allowedMentions: global::Discord.AllowedMentions.All)
+                    allowedMentions: AllowedMentions.All)
                 .ConfigureAwait(false);
         }
         catch (OperationCanceledException)
@@ -109,14 +55,6 @@ await channel.SendMessageAsync(
         }
     }
 
-    [LoggerMessage(Level = LogLevel.Warning, Message = "Posting/editing an alarm embed in channel {ChannelId} failed.")]
-    private static partial void LogEnsureFailed(ILogger logger, Exception exception, ulong channelId);
-
-    [LoggerMessage(Level = LogLevel.Debug,
-        Message = "Alarm embed {MessageId} in channel {ChannelId} was deleted; reposting.")]
-    private static partial void
-        LogMessageMissing(ILogger logger, Exception exception, ulong channelId, ulong messageId);
-
     [LoggerMessage(Level = LogLevel.Warning,
         Message = "Sending @everyone ping in channel {ChannelId} failed.")]
     private static partial void LogPingFailed(ILogger logger, Exception exception, ulong channelId);
diff --git a/src/RustPlusBot.Features.Events/Posting/DiscordEventChannelPoster.cs b/src/RustPlusBot.Features.Events/Posting/DiscordEventChannelPoster.cs
@@ -1,45 +1,19 @@
 using Discord;
 using Discord.WebSocket;
 using Microsoft.Extensions.Logging;
+using RustPlusBot.Discord.Posting;
 
 namespace RustPlusBot.Features.Events.Posting;
 
 /// <summary>Posts event embeds to Discord text channels via the gateway client.</summary>
 /// <param name="client">The Discord socket client.</param>
 /// <param name="logger">The logger.</param>
-internal sealed partial class DiscordEventChannelPoster(
+internal sealed class DiscordEventChannelPoster(
     DiscordSocketClient client,
     ILogger<DiscordEventChannelPoster> logger)
     : IEventChannelPoster
 {
     /// <inheritdoc />
-    public async Task PostAsync(ulong channelId, Embed embed, CancellationToken cancellationToken)
-    {
-        try
-        {
-            var options = new RequestOptions
-            {
-                CancelToken = cancellationToken
-            };
-            if (await client.GetChannelAsync(channelId, options).ConfigureAwait(false) is not ITextChannel channel)
-            {
-                return;
-            }
-
-            await channel.SendMessageAsync(embed: embed, options: options).ConfigureAwait(false);
-        }
-        catch (OperationCanceledException)
-        {
-            throw; // Cancellation (shutdown) is not a post failure; let the relay loop unwind cleanly.
-        }
-#pragma warning disable CA1031 // Broad catch: a Discord hiccup must not crash the relay.
-        catch (Exception ex)
-#pragma warning restore CA1031
-        {
-            LogPostFailed(logger, ex, channelId);
-        }
-    }
-
-    [LoggerMessage(Level = LogLevel.Warning, Message = "Posting an event embed to channel {ChannelId} failed.")]
-    private static partial void LogPostFailed(ILogger logger, Exception exception, ulong channelId);
+    public Task PostAsync(ulong channelId, Embed embed, CancellationToken cancellationToken)
+        => DiscordChannelMessenger.PostAsync(client, channelId, embed, logger, cancellationToken);
 }
diff --git a/src/RustPlusBot.Features.Players/Posting/DiscordPlayerChannelPoster.cs b/src/RustPlusBot.Features.Players/Posting/DiscordPlayerChannelPoster.cs
@@ -1,45 +1,19 @@
 using Discord;
 using Discord.WebSocket;
 using Microsoft.Extensions.Logging;
+using RustPlusBot.Discord.Posting;
 
 namespace RustPlusBot.Features.Players.Posting;
 
 /// <summary>Posts player-event embeds to Discord text channels via the gateway client.</summary>
 /// <param name="client">The Discord socket client.</param>
 /// <param name="logger">The logger.</param>
-internal sealed partial class DiscordPlayerChannelPoster(
+internal sealed class DiscordPlayerChannelPoster(
     DiscordSocketClient client,
     ILogger<DiscordPlayerChannelPoster> logger)
     : IPlayerChannelPoster
 {
     /// <inheritdoc />
-    public async Task PostAsync(ulong channelId, Embed embed, CancellationToken cancellationToken)
-    {
-        try
-        {
-            var options = new RequestOptions
-            {
-                CancelToken = cancellationToken
-            };
-            if (await client.GetChannelAsync(channelId, options).ConfigureAwait(false) is not ITextChannel channel)
-            {
-                return;
-            }
-
-            await channel.SendMessageAsync(embed: embed, options: options).ConfigureAwait(false);
-        }
-        catch (OperationCanceledException)
-        {
-            throw; // Cancellation (shutdown) is not a post failure; let the relay loop unwind cleanly.
-        }
-#pragma warning disable CA1031 // Broad catch: a Discord hiccup must not crash the relay.
-        catch (Exception ex)
-#pragma warning restore CA1031
-        {
-            LogPostFailed(logger, ex, channelId);
-        }
-    }
-
-    [LoggerMessage(Level = LogLevel.Warning, Message = "Posting a player-event embed to channel {ChannelId} failed.")]
-    private static partial void LogPostFailed(ILogger logger, Exception exception, ulong channelId);
+    public Task PostAsync(ulong channelId, Embed embed, CancellationToken cancellationToken)
+        => DiscordChannelMessenger.PostAsync(client, channelId, embed, logger, cancellationToken);
 }
diff --git a/src/RustPlusBot.Features.Switches/Posting/DiscordSwitchChannelPoster.cs b/src/RustPlusBot.Features.Switches/Posting/DiscordSwitchChannelPoster.cs
