Renames

Author: lukebakken

projects/RabbitMQ.Client/IConnection.cs

@@ -240,10 +240,10 @@ Task CloseAsync(ushort reasonCode, string reasonText, TimeSpan timeout, bool abo
         /// <summary>
         /// Asynchronously create and return a fresh channel, session, and channel.
         /// </summary>
-        /// <param name="publisherConfirmations">
+        /// <param name="publisherConfirmationsEnabled">
         /// Enable or disable publisher confirmations on this channel. Defaults to <c>false</c>
         /// </param>
-        /// <param name="publisherConfirmationTracking">
+        /// <param name="publisherConfirmationTrackingEnabled">
         /// Should this library track publisher confirmations for you? Defaults to <c>false</c>
         /// </param>
         /// <param name="consumerDispatchConcurrency">
@@ -257,7 +257,8 @@ Task CloseAsync(ushort reasonCode, string reasonText, TimeSpan timeout, bool abo
         /// In addition to that consumers need to be thread/concurrency safe.
         /// </param>
         /// <param name="cancellationToken">Cancellation token</param>
-        Task<IChannel> CreateChannelAsync(bool publisherConfirmations = false, bool publisherConfirmationTracking = false,
+        Task<IChannel> CreateChannelAsync(bool publisherConfirmationsEnabled = false,
+            bool publisherConfirmationTrackingEnabled = false,
             ushort? consumerDispatchConcurrency = null,
             CancellationToken cancellationToken = default);
     }

projects/RabbitMQ.Client/Impl/AutorecoveringChannel.cs

@@ -49,8 +49,8 @@ internal sealed class AutorecoveringChannel : IChannel, IRecoverable
 
         private ushort _prefetchCountConsumer;
         private ushort _prefetchCountGlobal;
-        private bool _usesPublisherConfirms;
-        private bool _tracksPublisherConfirmations;
+        private bool _publisherConfirmationsEnabled = false;
+        private bool _publisherConfirmationTrackingEnabled = false;
         private bool _usesTransactions;
         private ushort _consumerDispatchConcurrency;
 
@@ -161,8 +161,9 @@ internal async Task<bool> AutomaticallyRecoverAsync(AutorecoveringConnection con
 
             _connection = conn;
 
-            RecoveryAwareChannel newChannel = await conn.CreateNonRecoveringChannelAsync(_consumerDispatchConcurrency,
-                cancellationToken: cancellationToken)
+            RecoveryAwareChannel newChannel = await conn.CreateNonRecoveringChannelAsync(
+                _publisherConfirmationsEnabled, _publisherConfirmationTrackingEnabled,
+                _consumerDispatchConcurrency, cancellationToken)
                 .ConfigureAwait(false);
             newChannel.TakeOver(_innerChannel);
 
@@ -178,9 +179,9 @@ await newChannel.BasicQosAsync(0, _prefetchCountGlobal, true, cancellationToken)
                     .ConfigureAwait(false);
             }
 
-            if (_usesPublisherConfirms)
+            if (_publisherConfirmationsEnabled)
             {
-                await newChannel.ConfirmSelectAsync(_tracksPublisherConfirmations, cancellationToken)
+                await newChannel.ConfirmSelectAsync(_publisherConfirmationTrackingEnabled, cancellationToken)
                     .ConfigureAwait(false);
             }
 
@@ -347,12 +348,12 @@ public Task BasicQosAsync(uint prefetchSize, ushort prefetchCount, bool global,
             return _innerChannel.BasicQosAsync(prefetchSize, prefetchCount, global, cancellationToken);
         }
 
-        public async Task ConfirmSelectAsync(bool trackConfirmations = true, CancellationToken cancellationToken = default)
+        public async Task ConfirmSelectAsync(bool publisherConfirmationTrackingEnabled = false, CancellationToken cancellationToken = default)
         {
-            await InnerChannel.ConfirmSelectAsync(trackConfirmations, cancellationToken)
+            _publisherConfirmationsEnabled = true;
+            _publisherConfirmationTrackingEnabled = publisherConfirmationTrackingEnabled;
+            await InnerChannel.ConfirmSelectAsync(publisherConfirmationTrackingEnabled, cancellationToken)
                 .ConfigureAwait(false);
-            _usesPublisherConfirms = true;
-            _tracksPublisherConfirmations = trackConfirmations;
         }
 
         public async Task ExchangeBindAsync(string destination, string source, string routingKey,

projects/RabbitMQ.Client/Impl/AutorecoveringConnection.cs

@@ -184,12 +184,17 @@ public event AsyncEventHandler<RecoveringConsumerEventArgs> RecoveringConsumerAs
 
         public IProtocol Protocol => Endpoint.Protocol;
 
-        public async ValueTask<RecoveryAwareChannel> CreateNonRecoveringChannelAsync(ushort consumerDispatchConcurrency,
+        public async ValueTask<RecoveryAwareChannel> CreateNonRecoveringChannelAsync(
+            bool publisherConfirmationsEnabled = false,
+            bool publisherConfirmationTrackingEnabled = false,
+            ushort? consumerDispatchConcurrency = null,
             CancellationToken cancellationToken = default)
         {
             ISession session = InnerConnection.CreateSession();
             var result = new RecoveryAwareChannel(_config, session, consumerDispatchConcurrency);
-            return (RecoveryAwareChannel)await result.OpenAsync(cancellationToken).ConfigureAwait(false);
+            return (RecoveryAwareChannel)await result.OpenAsync(
+                publisherConfirmationsEnabled, publisherConfirmationTrackingEnabled, cancellationToken)
+                .ConfigureAwait(false);
         }
 
         public override string ToString()
@@ -251,27 +256,29 @@ await CloseInnerConnectionAsync()
             }
         }
 
-        public async Task<IChannel> CreateChannelAsync(bool publisherConfirmations = false, bool publisherConfirmationTracking = false,
-            ushort? consumerDispatchConcurrency = null, CancellationToken cancellationToken = default)
+        public async Task<IChannel> CreateChannelAsync(bool publisherConfirmationsEnabled = false,
+            bool publisherConfirmationTrackingEnabled = false,
+            ushort? consumerDispatchConcurrency = null,
+            CancellationToken cancellationToken = default)
         {
             EnsureIsOpen();
 
             ushort cdc = consumerDispatchConcurrency.GetValueOrDefault(_config.ConsumerDispatchConcurrency);
 
-            RecoveryAwareChannel recoveryAwareChannel = await CreateNonRecoveringChannelAsync(cdc, cancellationToken)
+            RecoveryAwareChannel recoveryAwareChannel = await CreateNonRecoveringChannelAsync(
+                publisherConfirmationsEnabled, publisherConfirmationTrackingEnabled, cdc, cancellationToken)
                 .ConfigureAwait(false);
 
-            AutorecoveringChannel channel = new AutorecoveringChannel(this, recoveryAwareChannel, cdc);
-            if (publisherConfirmations)
+            var autorecoveringChannel = new AutorecoveringChannel(this, recoveryAwareChannel, cdc);
+            if (publisherConfirmationsEnabled)
             {
-                await channel.ConfirmSelectAsync(trackConfirmations: publisherConfirmationTracking,
-                    cancellationToken: cancellationToken).ConfigureAwait(false);
+                // TODO yes, this is necessary, not sure why
+                await autorecoveringChannel.ConfirmSelectAsync(publisherConfirmationTrackingEnabled, cancellationToken)
+                    .ConfigureAwait(false);
             }
-
-            await RecordChannelAsync(channel, channelsSemaphoreHeld: false, cancellationToken: cancellationToken)
+            await RecordChannelAsync(autorecoveringChannel, channelsSemaphoreHeld: false, cancellationToken: cancellationToken)
                 .ConfigureAwait(false);
-
-            return channel;
+            return autorecoveringChannel;
         }
 
         public void Dispose() => DisposeAsync().AsTask().GetAwaiter().GetResult();