Rename RecoverySucceeded to RecoverySucceededAsync

lukebakken · lukebakken · commit 209fc7d04b28 · 2024-09-17T10:26:39.000-07:00
diff --git a/projects/RabbitMQ.Client/PublicAPI.Shipped.txt b/projects/RabbitMQ.Client/PublicAPI.Shipped.txt
@@ -459,7 +459,6 @@ RabbitMQ.Client.IConnection.IsOpen.get -> bool
 RabbitMQ.Client.IConnection.Protocol.get -> RabbitMQ.Client.IProtocol
 RabbitMQ.Client.IConnection.QueueNameChangedAfterRecovery -> RabbitMQ.Client.Events.AsyncEventHandler<RabbitMQ.Client.Events.QueueNameChangedAfterRecoveryEventArgs>
 RabbitMQ.Client.IConnection.RecoveringConsumer -> RabbitMQ.Client.Events.AsyncEventHandler<RabbitMQ.Client.Events.RecoveringConsumerEventArgs>
-RabbitMQ.Client.IConnection.RecoverySucceeded -> RabbitMQ.Client.Events.AsyncEventHandler<System.EventArgs>
 RabbitMQ.Client.IConnection.ServerProperties.get -> System.Collections.Generic.IDictionary<string, object>
 RabbitMQ.Client.IConnection.ShutdownReport.get -> System.Collections.Generic.IEnumerable<RabbitMQ.Client.ShutdownReportEntry>
 RabbitMQ.Client.IConnectionExtensions
@@ -895,3 +894,4 @@ RabbitMQ.Client.IConnection.CreateChannelAsync(ushort? consumerDispatchConcurren
 RabbitMQ.Client.IConnection.CallbackExceptionAsync -> RabbitMQ.Client.Events.AsyncEventHandler<RabbitMQ.Client.Events.CallbackExceptionEventArgs!>!
 RabbitMQ.Client.IConnection.ConnectionBlockedAsync -> RabbitMQ.Client.Events.AsyncEventHandler<RabbitMQ.Client.Events.ConnectionBlockedEventArgs!>!
 RabbitMQ.Client.IConnection.ConnectionShutdownAsync -> RabbitMQ.Client.Events.AsyncEventHandler<RabbitMQ.Client.ShutdownEventArgs!>!
+RabbitMQ.Client.IConnection.RecoverySucceededAsync -> RabbitMQ.Client.Events.AsyncEventHandler<System.EventArgs!>!
diff --git a/projects/RabbitMQ.Client/client/api/IConnection.cs b/projects/RabbitMQ.Client/client/api/IConnection.cs
@@ -163,7 +163,7 @@ public interface IConnection : INetworkConnection, IDisposable
         /// <remarks>
         /// This event will never fire for connections that disable automatic recovery.
         /// </remarks>
-        event AsyncEventHandler<EventArgs> RecoverySucceeded;
+        event AsyncEventHandler<EventArgs> RecoverySucceededAsync;
 
         /// <summary>
         /// Raised when the connection recovery fails, e.g. because reconnection or topology
diff --git a/projects/RabbitMQ.Client/client/impl/AutorecoveringConnection.Recovery.cs b/projects/RabbitMQ.Client/client/impl/AutorecoveringConnection.Recovery.cs
@@ -206,7 +206,7 @@ await RecoverChannelsAndItsConsumersAsync(recordedEntitiesSemaphoreHeld: true, c
 
                     ESLog.Info("Connection recovery completed");
                     ThrowIfDisposed();
-                    await _recoverySucceededWrapper.InvokeAsync(this, EventArgs.Empty)
+                    await _recoverySucceededAsyncWrapper.InvokeAsync(this, EventArgs.Empty)
                         .ConfigureAwait(false);
 
                     return true;
diff --git a/projects/RabbitMQ.Client/client/impl/AutorecoveringConnection.cs b/projects/RabbitMQ.Client/client/impl/AutorecoveringConnection.cs
@@ -67,7 +67,7 @@ internal AutorecoveringConnection(ConnectionConfig config, IEndpointResolver end
             _innerConnection = innerConnection;
 
             ConnectionShutdownAsync += HandleConnectionShutdown;
-            _recoverySucceededWrapper = new AsyncEventingWrapper<EventArgs>("OnConnectionRecovery", onExceptionAsync);
+            _recoverySucceededAsyncWrapper = new AsyncEventingWrapper<EventArgs>("OnConnectionRecovery", onExceptionAsync);
             _connectionRecoveryErrorWrapper = new AsyncEventingWrapper<ConnectionRecoveryErrorEventArgs>("OnConnectionRecoveryError", onExceptionAsync);
             _consumerTagChangeAfterRecoveryWrapper = new AsyncEventingWrapper<ConsumerTagChangedAfterRecoveryEventArgs>("OnConsumerRecovery", onExceptionAsync);
             _queueNameChangedAfterRecoveryWrapper = new AsyncEventingWrapper<QueueNameChangedAfterRecoveryEventArgs>("OnQueueRecovery", onExceptionAsync);
@@ -88,12 +88,12 @@ await innerConnection.OpenAsync(cancellationToken)
             return connection;
         }
 
-        public event AsyncEventHandler<EventArgs> RecoverySucceeded
+        public event AsyncEventHandler<EventArgs> RecoverySucceededAsync
         {
-            add => _recoverySucceededWrapper.AddHandler(value);
-            remove => _recoverySucceededWrapper.RemoveHandler(value);
+            add => _recoverySucceededAsyncWrapper.AddHandler(value);
+            remove => _recoverySucceededAsyncWrapper.RemoveHandler(value);
         }
-        private AsyncEventingWrapper<EventArgs> _recoverySucceededWrapper;
+        private AsyncEventingWrapper<EventArgs> _recoverySucceededAsyncWrapper;
 
         public event AsyncEventHandler<ConnectionRecoveryErrorEventArgs> ConnectionRecoveryError
         {
diff --git a/projects/RabbitMQ.Client/client/impl/Connection.cs b/projects/RabbitMQ.Client/client/impl/Connection.cs
@@ -172,7 +172,7 @@ public event AsyncEventHandler<ShutdownEventArgs> ConnectionShutdownAsync
         /// <summary>
         /// This event is never fired by non-recovering connections but it is a part of the <see cref="IConnection"/> interface.
         /// </summary>
-        public event AsyncEventHandler<EventArgs> RecoverySucceeded
+        public event AsyncEventHandler<EventArgs> RecoverySucceededAsync
         {
             add { }
             remove { }
diff --git a/projects/Test/Common/IntegrationFixture.cs b/projects/Test/Common/IntegrationFixture.cs
@@ -629,7 +629,7 @@ protected static TaskCompletionSource<bool> PrepareForRecovery(IConnection conn)
             var tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
 
             AutorecoveringConnection aconn = conn as AutorecoveringConnection;
-            aconn.RecoverySucceeded += (source, ea) =>
+            aconn.RecoverySucceededAsync += (source, ea) =>
             {
                 tcs.TrySetResult(true);
                 return Task.CompletedTask;
diff --git a/projects/Test/Integration/ConnectionRecovery/EventHandlerRecovery/Connection/TestRecoverySucceededEventHandlers.cs b/projects/Test/Integration/ConnectionRecovery/EventHandlerRecovery/Connection/TestRecoverySucceededEventHandlers.cs
@@ -47,7 +47,7 @@ public TestRecoverySucceededEventHandlers(ITestOutputHelper output) : base(outpu
         public async Task TestRecoverySucceededEventHandlers_Called()
         {
             int counter = 0;
-            ((AutorecoveringConnection)_conn).RecoverySucceeded += (source, ea) =>
+            ((AutorecoveringConnection)_conn).RecoverySucceededAsync += (source, ea) =>
             {
                 Interlocked.Increment(ref counter);
                 return Task.CompletedTask;
diff --git a/projects/Test/Integration/ConnectionRecovery/TestQueueRecovery.cs b/projects/Test/Integration/ConnectionRecovery/TestQueueRecovery.cs
@@ -76,7 +76,7 @@ public async Task TestServerNamedQueueRecovery()
 
             var tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
             var connection = (AutorecoveringConnection)_conn;
-            connection.RecoverySucceeded += (source, ea) =>
+            connection.RecoverySucceededAsync += (source, ea) =>
             {
                 tcs.SetResult(true);
                 return Task.CompletedTask;
diff --git a/projects/Test/Integration/TestConnectionRecoveryWithoutSetup.cs b/projects/Test/Integration/TestConnectionRecoveryWithoutSetup.cs
@@ -290,7 +290,7 @@ public async Task TestTopologyRecoveryConsumerFilter()
 
             using (AutorecoveringConnection conn = await CreateAutorecoveringConnectionWithTopologyRecoveryFilterAsync(filter))
             {
-                conn.RecoverySucceeded += (source, ea) =>
+                conn.RecoverySucceededAsync += (source, ea) =>
                 {
                     connectionRecoveryTcs.SetResult(true);
                     return Task.CompletedTask;
diff --git a/projects/Test/Integration/TestConnectionTopologyRecovery.cs b/projects/Test/Integration/TestConnectionTopologyRecovery.cs
@@ -96,7 +96,7 @@ public async Task TestTopologyRecoveryQueueFilter()
             };
 
             AutorecoveringConnection conn = await CreateAutorecoveringConnectionWithTopologyRecoveryFilterAsync(filter);
-            conn.RecoverySucceeded += (source, ea) =>
+            conn.RecoverySucceededAsync += (source, ea) =>
             {
                 tcs.SetResult(true);
                 return Task.CompletedTask;
@@ -146,7 +146,7 @@ public async Task TestTopologyRecoveryExchangeFilter()
             };
 
             AutorecoveringConnection conn = await CreateAutorecoveringConnectionWithTopologyRecoveryFilterAsync(filter);
-            conn.RecoverySucceeded += (source, ea) =>
+            conn.RecoverySucceededAsync += (source, ea) =>
             {
                 tcs.SetResult(true);
                 return Task.CompletedTask;
@@ -194,7 +194,7 @@ public async Task TestTopologyRecoveryBindingFilter()
             };
 
             AutorecoveringConnection conn = await CreateAutorecoveringConnectionWithTopologyRecoveryFilterAsync(filter);
-            conn.RecoverySucceeded += (source, ea) =>
+            conn.RecoverySucceededAsync += (source, ea) =>
             {
                 tcs.SetResult(true);
                 return Task.CompletedTask;
@@ -249,7 +249,7 @@ public async Task TestTopologyRecoveryDefaultFilterRecoversAllEntities()
             var connectionRecoveryTcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
             var filter = new TopologyRecoveryFilter();
             AutorecoveringConnection conn = await CreateAutorecoveringConnectionWithTopologyRecoveryFilterAsync(filter);
-            conn.RecoverySucceeded += (source, ea) =>
+            conn.RecoverySucceededAsync += (source, ea) =>
             {
                 connectionRecoveryTcs.SetResult(true);
                 return Task.CompletedTask;
@@ -356,7 +356,7 @@ await channel.QueueDeclareAsync(rq.Name, false, false, false,
             };
 
             AutorecoveringConnection conn = await CreateAutorecoveringConnectionWithTopologyRecoveryExceptionHandlerAsync(exceptionHandler);
-            conn.RecoverySucceeded += (source, ea) =>
+            conn.RecoverySucceededAsync += (source, ea) =>
             {
                 tcs.SetResult(true);
                 return Task.CompletedTask;
@@ -416,7 +416,7 @@ public async Task TestTopologyRecoveryExchangeExceptionHandler()
             };
 
             AutorecoveringConnection conn = await CreateAutorecoveringConnectionWithTopologyRecoveryExceptionHandlerAsync(exceptionHandler);
-            conn.RecoverySucceeded += (source, ea) =>
+            conn.RecoverySucceededAsync += (source, ea) =>
             {
                 tcs.SetResult(true);
                 return Task.CompletedTask;
@@ -481,7 +481,7 @@ public async Task TestTopologyRecoveryBindingExceptionHandler()
             };
 
             AutorecoveringConnection conn = await CreateAutorecoveringConnectionWithTopologyRecoveryExceptionHandlerAsync(exceptionHandler);
-            conn.RecoverySucceeded += (source, ea) =>
+            conn.RecoverySucceededAsync += (source, ea) =>
             {
                 connectionRecoveryTcs.SetResult(true);
                 return Task.CompletedTask;
@@ -547,7 +547,7 @@ public async Task TestTopologyRecoveryConsumerExceptionHandler()
             };
 
             AutorecoveringConnection conn = await CreateAutorecoveringConnectionWithTopologyRecoveryExceptionHandlerAsync(exceptionHandler);
-            conn.RecoverySucceeded += (source, ea) =>
+            conn.RecoverySucceededAsync += (source, ea) =>
             {
                 connectionRecoveryTcs.SetResult(true);
                 return Task.CompletedTask;
diff --git a/projects/Test/Integration/TestToxiproxy.cs b/projects/Test/Integration/TestToxiproxy.cs
@@ -114,7 +114,7 @@ public async Task TestCloseConnection()
                             return Task.CompletedTask;
                         };
 
-                        conn.RecoverySucceeded += (s, ea) =>
+                        conn.RecoverySucceededAsync += (s, ea) =>
                         {
                             if (IsVerbose)
                             {
diff --git a/projects/Test/OAuth2/TestOAuth2.cs b/projects/Test/OAuth2/TestOAuth2.cs
@@ -96,7 +96,7 @@ public async Task InitializeAsync()
                 return Task.CompletedTask;
             };
 
-            _connection.RecoverySucceeded += (sender, ea) =>
+            _connection.RecoverySucceededAsync += (sender, ea) =>
             {
                 _testOutputHelper.WriteLine("{0} [INFO] connection recovery succeeded", DateTime.Now);
                 return Task.CompletedTask;

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ internal AutorecoveringConnection(ConnectionConfig config, IEndpointResolver end`
`67`	`67`	`_innerConnection = innerConnection;`
`68`	`68`
`69`	`69`	`ConnectionShutdownAsync += HandleConnectionShutdown;`
`70`		`- _recoverySucceededWrapper = new AsyncEventingWrapper<EventArgs>("OnConnectionRecovery", onExceptionAsync);`
	`70`	`+ _recoverySucceededAsyncWrapper = new AsyncEventingWrapper<EventArgs>("OnConnectionRecovery", onExceptionAsync);`
`71`	`71`	`_connectionRecoveryErrorWrapper = new AsyncEventingWrapper<ConnectionRecoveryErrorEventArgs>("OnConnectionRecoveryError", onExceptionAsync);`
`72`	`72`	`_consumerTagChangeAfterRecoveryWrapper = new AsyncEventingWrapper<ConsumerTagChangedAfterRecoveryEventArgs>("OnConsumerRecovery", onExceptionAsync);`
`73`	`73`	`_queueNameChangedAfterRecoveryWrapper = new AsyncEventingWrapper<QueueNameChangedAfterRecoveryEventArgs>("OnQueueRecovery", onExceptionAsync);`
`@@ -88,12 +88,12 @@ await innerConnection.OpenAsync(cancellationToken)`
`88`	`88`	`return connection;`
`89`	`89`	`}`
`90`	`90`
`91`		`- public event AsyncEventHandler<EventArgs> RecoverySucceeded`
	`91`	`+ public event AsyncEventHandler<EventArgs> RecoverySucceededAsync`
`92`	`92`	`{`
`93`		`- add => _recoverySucceededWrapper.AddHandler(value);`
`94`		`- remove => _recoverySucceededWrapper.RemoveHandler(value);`
	`93`	`+ add => _recoverySucceededAsyncWrapper.AddHandler(value);`
	`94`	`+ remove => _recoverySucceededAsyncWrapper.RemoveHandler(value);`
`95`	`95`	`}`
`96`		`- private AsyncEventingWrapper<EventArgs> _recoverySucceededWrapper;`
	`96`	`+ private AsyncEventingWrapper<EventArgs> _recoverySucceededAsyncWrapper;`
`97`	`97`
`98`	`98`	`public event AsyncEventHandler<ConnectionRecoveryErrorEventArgs> ConnectionRecoveryError`
`99`	`99`	`{`
Original file line number	Diff line number	Diff line change
`@@ -172,7 +172,7 @@ public event AsyncEventHandler<ShutdownEventArgs> ConnectionShutdownAsync`
`172`	`172`	`/// <summary>`
`173`	`173`	`/// This event is never fired by non-recovering connections but it is a part of the <see cref="IConnection"/> interface.`
`174`	`174`	`/// </summary>`
`175`		`- public event AsyncEventHandler<EventArgs> RecoverySucceeded`
	`175`	`+ public event AsyncEventHandler<EventArgs> RecoverySucceededAsync`
`176`	`176`	`{`
`177`	`177`	`add { }`
`178`	`178`	`remove { }`
Original file line number	Diff line number	Diff line change
`@@ -629,7 +629,7 @@ protected static TaskCompletionSource<bool> PrepareForRecovery(IConnection conn)`
`629`	`629`	`var tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);`
`630`	`630`
`631`	`631`	`AutorecoveringConnection aconn = conn as AutorecoveringConnection;`
`632`		`- aconn.RecoverySucceeded += (source, ea) =>`
	`632`	`+ aconn.RecoverySucceededAsync += (source, ea) =>`
`633`	`633`	`{`
`634`	`634`	`tcs.TrySetResult(true);`
`635`	`635`	`return Task.CompletedTask;`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ public TestRecoverySucceededEventHandlers(ITestOutputHelper output) : base(outpu`
`47`	`47`	`public async Task TestRecoverySucceededEventHandlers_Called()`
`48`	`48`	`{`
`49`	`49`	`int counter = 0;`
`50`		`- ((AutorecoveringConnection)_conn).RecoverySucceeded += (source, ea) =>`
	`50`	`+ ((AutorecoveringConnection)_conn).RecoverySucceededAsync += (source, ea) =>`
`51`	`51`	`{`
`52`	`52`	`Interlocked.Increment(ref counter);`
`53`	`53`	`return Task.CompletedTask;`
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ public async Task TestServerNamedQueueRecovery()`
`76`	`76`
`77`	`77`	`var tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);`
`78`	`78`	`var connection = (AutorecoveringConnection)_conn;`
`79`		`- connection.RecoverySucceeded += (source, ea) =>`
	`79`	`+ connection.RecoverySucceededAsync += (source, ea) =>`
`80`	`80`	`{`
`81`	`81`	`tcs.SetResult(true);`
`82`	`82`	`return Task.CompletedTask;`
Original file line number	Diff line number	Diff line change
`@@ -290,7 +290,7 @@ public async Task TestTopologyRecoveryConsumerFilter()`
`290`	`290`
`291`	`291`	`using (AutorecoveringConnection conn = await CreateAutorecoveringConnectionWithTopologyRecoveryFilterAsync(filter))`
`292`	`292`	`{`
`293`		`- conn.RecoverySucceeded += (source, ea) =>`
	`293`	`+ conn.RecoverySucceededAsync += (source, ea) =>`
`294`	`294`	`{`
`295`	`295`	`connectionRecoveryTcs.SetResult(true);`
`296`	`296`	`return Task.CompletedTask;`