Implement Lame Duck Mode Event Handler

src/NATS.Client.Core/INatsConnection.cs

@@ -25,6 +25,11 @@ public interface INatsConnection : INatsClient
     /// </summary>
     event AsyncEventHandler<NatsMessageDroppedEventArgs>? MessageDropped;
 
+    /// <summary>
+    /// Event that is raised when server goes into Lame Duck Mode.
+    /// </summary>
+    public event AsyncEventHandler<NatsLameDuckModeActivatedEventArgs>? LameDuckModeActivated;
+
     /// <summary>
     /// Server information received from the NATS server.
     /// </summary>

src/NATS.Client.Core/NatsConnection.cs

@@ -24,14 +24,13 @@ internal enum NatsEvent
     ConnectionDisconnected,
     ReconnectFailed,
     MessageDropped,
+    LameDuckModeActivated,
 }
 
 public partial class NatsConnection : INatsConnection
 {
 #pragma warning disable SA1401
     internal readonly ConnectionStatsCounter Counter; // allow to call from external sources
-    internal volatile ServerInfo? WritableServerInfo;
-
 #pragma warning restore SA1401
     private readonly object _gate = new object();
     private readonly ILogger<NatsConnection> _logger;
@@ -44,6 +43,7 @@ public partial class NatsConnection : INatsConnection
     private readonly ClientOpts _clientOpts;
     private readonly SubscriptionManager _subscriptionManager;
 
+    private ServerInfo? _writableServerInfo;
     private int _pongCount;
     private int _connectionState;
     private int _isDisposed;
@@ -109,6 +109,8 @@ public NatsConnection(NatsOpts opts)
 
     public event AsyncEventHandler<NatsMessageDroppedEventArgs>? MessageDropped;
 
+    public event AsyncEventHandler<NatsLameDuckModeActivatedEventArgs>? LameDuckModeActivated;
+
     public INatsConnection Connection => this;
 
     public NatsOpts Opts { get; }
@@ -134,6 +136,20 @@ private set
 
     public Func<ISocketConnection, ValueTask<ISocketConnection>>? OnSocketAvailableAsync { get; set; }
 
+    internal ServerInfo? WritableServerInfo
+    {
+        get => Interlocked.CompareExchange(ref _writableServerInfo, null, null);
+        set
+        {
+            if (value?.LameDuckMode == true)
+            {
+                _eventChannel.Writer.TryWrite((NatsEvent.LameDuckModeActivated, new NatsLameDuckModeActivatedEventArgs(_currentConnectUri!.Uri)));
+            }
+
+            Interlocked.Exchange(ref _writableServerInfo, value);
+        }
+    }
+
     internal bool IsDisposed
     {
         get => Interlocked.CompareExchange(ref _isDisposed, 0, 0) == 1;
@@ -762,6 +778,9 @@ private async Task PublishEventsAsync()
                     case NatsEvent.MessageDropped when MessageDropped != null && args is NatsMessageDroppedEventArgs error:
                         await MessageDropped.InvokeAsync(this, error).ConfigureAwait(false);
                         break;
+                    case NatsEvent.LameDuckModeActivated when LameDuckModeActivated != null && args is NatsLameDuckModeActivatedEventArgs uri:
+                        await LameDuckModeActivated.InvokeAsync(this, uri).ConfigureAwait(false);
+                        break;
                     }
                 }
             }

src/NATS.Client.Core/NatsEventArgs.cs

@@ -33,3 +33,11 @@ public NatsMessageDroppedEventArgs(NatsSubBase subscription, int pending, string
 
     public object? Data { get; }
 }
+
+public class NatsLameDuckModeActivatedEventArgs : NatsEventArgs
+{
+    public NatsLameDuckModeActivatedEventArgs(Uri uri)
+        : base("Lame duck mode activated") => Uri = uri;
+
+    public Uri Uri { get; }
+}

tests/NATS.Client.Core.Tests/NatsConnectionTest.cs

@@ -505,6 +505,61 @@ public async Task ReconnectOnOpenConnection_ShouldDisconnectAndOpenNewConnection
         openedCount.ShouldBe(1);
         disconnectedCount.ShouldBe(1);
     }
+
+    [SkipIfNatsServer(versionEarlierThan: "2.10")]
+    public async Task LameDuckModeActivated_EventHandlerShouldBeInvokedWhenInfoWithLDMReceived()
+    {
+        await using var natsServer = NatsServer.Start(
+            _output,
+            new NatsServerOptsBuilder()
+                .AddServerConfigText("""
+                                     accounts: {
+                                       SYS: {
+                                         users: [
+                                           {user: "sys", password: "password"}
+                                         ]
+                                       },
+                                     }
+
+                                     system_account: SYS
+                                     """)
+                .UseTransport(_transportType)
+                .Build());
+
+        var natsOpts = new NatsOpts
+        {
+            Url = natsServer.ClientUrl,
+            AuthOpts = new NatsAuthOpts
+            {
+                Username = "sys",
+                Password = "password",
+            },
+        };
+
+        await using var connection = natsServer.CreateClientConnection(natsOpts);
+        await connection.ConnectAsync();
+
+        var invocationCount = 0;
+        var ldmSignal = new WaitSignal();
+
+        connection.LameDuckModeActivated += (_, _) =>
+        {
+            Interlocked.Increment(ref invocationCount);
+            ldmSignal.Pulse();
+            return default;
+        };
+
+        var subject = $"$SYS.REQ.SERVER.{connection.ServerInfo!.Id}.LDM";
+
+        // Act
+        await connection.RequestAsync<string, string>(
+            subject: subject,
+            data: $$"""{"cid":{{connection.ServerInfo!.ClientId}}}""");
+        await ldmSignal;
+
+        // Assert
+        invocationCount.ShouldBe(1);
+    }
 }
 
 [JsonSerializable(typeof(SampleClass))]

tests/NATS.Client.JetStream.Tests/NatsJsContextFactoryTest.cs

@@ -92,6 +92,8 @@ public class MockConnection : INatsConnection
         public event AsyncEventHandler<NatsEventArgs>? ReconnectFailed;
 
         public event AsyncEventHandler<NatsMessageDroppedEventArgs>? MessageDropped;
+
+        public event AsyncEventHandler<NatsLameDuckModeActivatedEventArgs>? LameDuckModeActivated;
 #pragma warning restore CS0067
 
         public INatsServerInfo? ServerInfo { get; } = null;