* Move ICredentialsProvider back to RabbitMQ.Client

lukebakken · lukebakken · commit 94173b710f5e · 2024-08-01T10:20:09.000-07:00
* Use `ICredentialsProvider` in the auth mechanisms, async * Pass `CancellationToken` around and correctly dispose Http objects (thanks @Tornhoof) * Use `SemaphoreSlim`
diff --git a/projects/RabbitMQ.Client.OAuth2/OAuth2Client.cs b/projects/RabbitMQ.Client.OAuth2/OAuth2Client.cs
@@ -34,14 +34,15 @@
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Net.Http.Json;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace RabbitMQ.Client.OAuth2
 {
     public interface IOAuth2Client
     {
-        Task<IToken> RequestTokenAsync();
-        Task<IToken> RefreshTokenAsync(IToken token);
+        Task<IToken> RequestTokenAsync(CancellationToken cancellationToken = default);
+        Task<IToken> RefreshTokenAsync(IToken token, CancellationToken cancellationToken = default);
     }
 
     public interface IToken
@@ -196,12 +197,12 @@ public OAuth2Client(string clientId, string clientSecret, Uri tokenEndpoint,
             _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
         }
 
-        public async Task<IToken> RequestTokenAsync()
+        public async Task<IToken> RequestTokenAsync(CancellationToken cancellationToken = default)
         {
-            var req = new HttpRequestMessage(HttpMethod.Post, _tokenEndpoint);
+            using HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Post, _tokenEndpoint);
             req.Content = new FormUrlEncodedContent(buildRequestParameters());
 
-            HttpResponseMessage response = await _httpClient.SendAsync(req)
+            using HttpResponseMessage response = await _httpClient.SendAsync(req)
                 .ConfigureAwait(false);
 
             response.EnsureSuccessStatusCode();
@@ -220,19 +221,20 @@ public async Task<IToken> RequestTokenAsync()
             }
         }
 
-        public async Task<IToken> RefreshTokenAsync(IToken token)
+        public async Task<IToken> RefreshTokenAsync(IToken token,
+            CancellationToken cancellationToken = default)
         {
             if (token.RefreshToken == null)
             {
                 throw new InvalidOperationException("Token has no Refresh Token");
             }
 
-            var req = new HttpRequestMessage(HttpMethod.Post, _tokenEndpoint)
+            using HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Post, _tokenEndpoint)
             {
                 Content = new FormUrlEncodedContent(buildRefreshParameters(token))
             };
 
-            HttpResponseMessage response = await _httpClient.SendAsync(req)
+            using HttpResponseMessage response = await _httpClient.SendAsync(req)
                 .ConfigureAwait(false);
 
             response.EnsureSuccessStatusCode();
diff --git a/projects/RabbitMQ.Client.OAuth2/OAuth2CredentialsProvider.cs b/projects/RabbitMQ.Client.OAuth2/OAuth2CredentialsProvider.cs
@@ -35,10 +35,9 @@
 
 namespace RabbitMQ.Client.OAuth2
 {
-    public class OAuth2ClientCredentialsProvider : ICredentialsProvider
+    public class OAuth2ClientCredentialsProvider : ICredentialsProvider, IDisposable
     {
-        // TODO Dispose
-        private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
+        private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
 
         private readonly string _name;
         private readonly IOAuth2Client _oAuth2Client;
@@ -55,7 +54,8 @@ public OAuth2ClientCredentialsProvider(string name, IOAuth2Client oAuth2Client)
         public async Task<Credentials> GetCredentialsAsync(CancellationToken cancellationToken = default)
         {
             bool mustRetrieveToken = false;
-            _lock.EnterReadLock();
+            await _semaphore.WaitAsync(cancellationToken)
+                .ConfigureAwait(false);
             try
             {
                 if (_token is null || _token.HasExpired)
@@ -65,14 +65,14 @@ public async Task<Credentials> GetCredentialsAsync(CancellationToken cancellatio
             }
             finally
             {
-                _lock.ExitReadLock();
+                _semaphore.Release();
             }
 
             cancellationToken.ThrowIfCancellationRequested();
 
             if (mustRetrieveToken)
             {
-                await RetrieveTokenAsync().ConfigureAwait(false);
+                await RetrieveTokenAsync(cancellationToken).ConfigureAwait(false);
             }
 
             if (_token is null)
@@ -86,25 +86,31 @@ public async Task<Credentials> GetCredentialsAsync(CancellationToken cancellatio
             }
         }
 
-        private async Task RetrieveTokenAsync()
+        public void Dispose()
         {
-            _lock.EnterWriteLock();
+            _semaphore.Dispose();
+        }
+
+        private async Task RetrieveTokenAsync(CancellationToken cancellationToken)
+        {
+            await _semaphore.WaitAsync(cancellationToken)
+                .ConfigureAwait(false);
             try
             {
                 if (_token == null || _token.RefreshToken == null)
                 {
-                    _token = await _oAuth2Client.RequestTokenAsync()
+                    _token = await _oAuth2Client.RequestTokenAsync(cancellationToken)
                         .ConfigureAwait(false);
                 }
                 else
                 {
-                    _token = await _oAuth2Client.RefreshTokenAsync(_token)
+                    _token = await _oAuth2Client.RefreshTokenAsync(_token, cancellationToken)
                         .ConfigureAwait(false);
                 }
             }
             finally
             {
-                _lock.ExitWriteLock();
+                _semaphore.Release();
             }
         }
     }
diff --git a/projects/RabbitMQ.Client.OAuth2/PublicAPI.Unshipped.txt b/projects/RabbitMQ.Client.OAuth2/PublicAPI.Unshipped.txt
@@ -1,23 +1,12 @@
-RabbitMQ.Client.OAuth2.BasicCredentialsProvider
-RabbitMQ.Client.OAuth2.BasicCredentialsProvider.BasicCredentialsProvider(string! name, string! userName, string! password) -> void
-RabbitMQ.Client.OAuth2.BasicCredentialsProvider.GetCredentialsAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<RabbitMQ.Client.OAuth2.Credentials!>!
-RabbitMQ.Client.OAuth2.BasicCredentialsProvider.Name.get -> string!
-RabbitMQ.Client.OAuth2.Credentials
-RabbitMQ.Client.OAuth2.Credentials.Credentials(string! name, string! userName, string! password, System.TimeSpan? validUntil) -> void
-RabbitMQ.Client.OAuth2.Credentials.Name.get -> string!
-RabbitMQ.Client.OAuth2.Credentials.Password.get -> string!
-RabbitMQ.Client.OAuth2.Credentials.UserName.get -> string!
-RabbitMQ.Client.OAuth2.Credentials.ValidUntil.get -> System.TimeSpan?
 RabbitMQ.Client.OAuth2.CredentialsRefresher
-RabbitMQ.Client.OAuth2.CredentialsRefresher.CredentialsRefresher(RabbitMQ.Client.OAuth2.ICredentialsProvider! credentialsProvider, RabbitMQ.Client.OAuth2.NotifyCredentialsRefreshedAsync! onRefreshed, System.Threading.CancellationToken cancellationToken) -> void
+RabbitMQ.Client.OAuth2.CredentialsRefresher.Credentials.get -> RabbitMQ.Client.Credentials?
+RabbitMQ.Client.OAuth2.CredentialsRefresher.CredentialsRefresher(RabbitMQ.Client.ICredentialsProvider! credentialsProvider, RabbitMQ.Client.OAuth2.NotifyCredentialsRefreshedAsync! onRefreshed, System.Threading.CancellationToken cancellationToken) -> void
 RabbitMQ.Client.OAuth2.CredentialsRefresher.Dispose() -> void
-RabbitMQ.Client.OAuth2.ICredentialsProvider
-RabbitMQ.Client.OAuth2.ICredentialsProvider.GetCredentialsAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<RabbitMQ.Client.OAuth2.Credentials!>!
-RabbitMQ.Client.OAuth2.ICredentialsProvider.Name.get -> string!
-RabbitMQ.Client.OAuth2.IOAuth2Client.RefreshTokenAsync(RabbitMQ.Client.OAuth2.IToken! token) -> System.Threading.Tasks.Task<RabbitMQ.Client.OAuth2.IToken!>!
-RabbitMQ.Client.OAuth2.IOAuth2Client.RequestTokenAsync() -> System.Threading.Tasks.Task<RabbitMQ.Client.OAuth2.IToken!>!
+RabbitMQ.Client.OAuth2.IOAuth2Client.RefreshTokenAsync(RabbitMQ.Client.OAuth2.IToken! token, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<RabbitMQ.Client.OAuth2.IToken!>!
+RabbitMQ.Client.OAuth2.IOAuth2Client.RequestTokenAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<RabbitMQ.Client.OAuth2.IToken!>!
 RabbitMQ.Client.OAuth2.NotifyCredentialsRefreshedAsync
-RabbitMQ.Client.OAuth2.OAuth2ClientCredentialsProvider.GetCredentialsAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<RabbitMQ.Client.OAuth2.Credentials!>!
+RabbitMQ.Client.OAuth2.OAuth2ClientCredentialsProvider.Dispose() -> void
+RabbitMQ.Client.OAuth2.OAuth2ClientCredentialsProvider.GetCredentialsAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<RabbitMQ.Client.Credentials!>!
 RabbitMQ.Client.OAuth2.TimerBasedCredentialRefresherEventSource
 RabbitMQ.Client.OAuth2.TimerBasedCredentialRefresherEventSource.TimerBasedCredentialRefresherEventSource() -> void
 virtual RabbitMQ.Client.OAuth2.CredentialsRefresher.Dispose(bool disposing) -> void
diff --git a/projects/RabbitMQ.Client/PublicAPI.Shipped.txt b/projects/RabbitMQ.Client/PublicAPI.Shipped.txt
@@ -360,7 +360,6 @@ RabbitMQ.Client.Exceptions.WireFormattingException.WireFormattingException(strin
 RabbitMQ.Client.ExchangeType
 RabbitMQ.Client.ExternalMechanism
 RabbitMQ.Client.ExternalMechanism.ExternalMechanism() -> void
-RabbitMQ.Client.ExternalMechanism.handleChallenge(byte[] challenge, RabbitMQ.Client.ConnectionConfig config) -> byte[]
 RabbitMQ.Client.ExternalMechanismFactory
 RabbitMQ.Client.ExternalMechanismFactory.ExternalMechanismFactory() -> void
 RabbitMQ.Client.ExternalMechanismFactory.GetInstance() -> RabbitMQ.Client.IAuthMechanism
@@ -379,7 +378,6 @@ RabbitMQ.Client.IAsyncBasicConsumer.HandleBasicConsumeOkAsync(string consumerTag
 RabbitMQ.Client.IAsyncBasicConsumer.HandleBasicDeliverAsync(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, RabbitMQ.Client.IReadOnlyBasicProperties properties, System.ReadOnlyMemory<byte> body) -> System.Threading.Tasks.Task
 RabbitMQ.Client.IAsyncBasicConsumer.HandleChannelShutdownAsync(object channel, RabbitMQ.Client.ShutdownEventArgs reason) -> System.Threading.Tasks.Task
 RabbitMQ.Client.IAuthMechanism
-RabbitMQ.Client.IAuthMechanism.handleChallenge(byte[] challenge, RabbitMQ.Client.ConnectionConfig config) -> byte[]
 RabbitMQ.Client.IAuthMechanismFactory
 RabbitMQ.Client.IAuthMechanismFactory.GetInstance() -> RabbitMQ.Client.IAuthMechanism
 RabbitMQ.Client.IAuthMechanismFactory.Name.get -> string
@@ -584,7 +582,6 @@ RabbitMQ.Client.Logging.RabbitMqExceptionDetail.RabbitMqExceptionDetail(System.E
 RabbitMQ.Client.Logging.RabbitMqExceptionDetail.StackTrace.get -> string
 RabbitMQ.Client.Logging.RabbitMqExceptionDetail.Type.get -> string
 RabbitMQ.Client.PlainMechanism
-RabbitMQ.Client.PlainMechanism.handleChallenge(byte[] challenge, RabbitMQ.Client.ConnectionConfig config) -> byte[]
 RabbitMQ.Client.PlainMechanism.PlainMechanism() -> void
 RabbitMQ.Client.PlainMechanismFactory
 RabbitMQ.Client.PlainMechanismFactory.GetInstance() -> RabbitMQ.Client.IAuthMechanism
diff --git a/projects/RabbitMQ.Client/PublicAPI.Unshipped.txt b/projects/RabbitMQ.Client/PublicAPI.Unshipped.txt
@@ -1 +1,20 @@
+RabbitMQ.Client.BasicCredentialsProvider
+RabbitMQ.Client.BasicCredentialsProvider.BasicCredentialsProvider(string? name, string! userName, string! password) -> void
+RabbitMQ.Client.BasicCredentialsProvider.GetCredentialsAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<RabbitMQ.Client.Credentials!>!
+RabbitMQ.Client.BasicCredentialsProvider.Name.get -> string!
 RabbitMQ.Client.BasicProperties.BasicProperties(RabbitMQ.Client.IReadOnlyBasicProperties! input) -> void
+RabbitMQ.Client.ConnectionFactory.CredentialsProvider.get -> RabbitMQ.Client.ICredentialsProvider?
+RabbitMQ.Client.ConnectionFactory.CredentialsProvider.set -> void
+RabbitMQ.Client.Credentials
+RabbitMQ.Client.Credentials.Credentials(string! name, string! userName, string! password, System.TimeSpan? validUntil) -> void
+RabbitMQ.Client.Credentials.Name.get -> string!
+RabbitMQ.Client.Credentials.Password.get -> string!
+RabbitMQ.Client.Credentials.UserName.get -> string!
+RabbitMQ.Client.Credentials.ValidUntil.get -> System.TimeSpan?
+RabbitMQ.Client.ExternalMechanism.HandleChallengeAsync(byte[]? challenge, RabbitMQ.Client.ConnectionConfig! config, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<byte[]!>!
+RabbitMQ.Client.IAuthMechanism.HandleChallengeAsync(byte[]? challenge, RabbitMQ.Client.ConnectionConfig! config, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<byte[]!>!
+RabbitMQ.Client.ICredentialsProvider
+RabbitMQ.Client.ICredentialsProvider.GetCredentialsAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<RabbitMQ.Client.Credentials!>!
+RabbitMQ.Client.ICredentialsProvider.Name.get -> string!
+RabbitMQ.Client.PlainMechanism.HandleChallengeAsync(byte[]? challenge, RabbitMQ.Client.ConnectionConfig! config, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<byte[]!>!
+readonly RabbitMQ.Client.ConnectionConfig.CredentialsProvider -> RabbitMQ.Client.ICredentialsProvider!
diff --git a/projects/RabbitMQ.Client/client/api/BasicCredentialsProvider.cs b/projects/RabbitMQ.Client/client/api/BasicCredentialsProvider.cs
@@ -33,26 +33,28 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace RabbitMQ.Client.OAuth2
+namespace RabbitMQ.Client
 {
     public class BasicCredentialsProvider : ICredentialsProvider
     {
         private readonly string _name;
         private readonly string _userName;
         private readonly string _password;
+        private readonly Credentials _credentials;
 
-        public BasicCredentialsProvider(string name, string userName, string password)
+        public BasicCredentialsProvider(string? name, string userName, string password)
         {
-            _name = name ?? string.Empty;
+            _name = name ?? typeof(BasicCredentialsProvider).Name;
             _userName = userName ?? throw new ArgumentNullException(nameof(userName));
             _password = password ?? throw new ArgumentNullException(nameof(password));
+            _credentials = new Credentials(_name, _userName, _password, null);
         }
 
         public string Name => _name;
 
         public Task<Credentials> GetCredentialsAsync(CancellationToken cancellationToken = default)
         {
-            return Task.FromResult(new Credentials(_name, _userName, _password, null));
+            return Task.FromResult(_credentials);
         }
     }
 }
diff --git a/projects/RabbitMQ.Client/client/api/ConnectionConfig.cs b/projects/RabbitMQ.Client/client/api/ConnectionConfig.cs
@@ -57,6 +57,12 @@ public sealed class ConnectionConfig
         /// </summary>
         public readonly string Password;
 
+        /// <summary>
+        /// Default ICredentialsProvider implementation. If set, this
+        /// overrides UserName / Password
+        /// </summary>
+        public readonly ICredentialsProvider CredentialsProvider;
+
         /// <summary>
         ///  SASL auth mechanisms to use.
         /// </summary>
@@ -138,6 +144,7 @@ public sealed class ConnectionConfig
         internal readonly Func<AmqpTcpEndpoint, CancellationToken, Task<IFrameHandler>> FrameHandlerFactoryAsync;
 
         internal ConnectionConfig(string virtualHost, string userName, string password,
+            ICredentialsProvider? credentialsProvider,
             IEnumerable<IAuthMechanismFactory> authMechanisms,
             IDictionary<string, object?> clientProperties, string? clientProvidedName,
             ushort maxChannelCount, uint maxFrameSize, uint maxInboundMessageBodySize, bool topologyRecoveryEnabled,
@@ -148,6 +155,7 @@ internal ConnectionConfig(string virtualHost, string userName, string password,
             VirtualHost = virtualHost;
             UserName = userName;
             Password = password;
+            CredentialsProvider = credentialsProvider ?? new BasicCredentialsProvider(clientProvidedName, userName, password);
             AuthMechanisms = authMechanisms;
             ClientProperties = clientProperties;
             ClientProvidedName = clientProvidedName;
diff --git a/projects/RabbitMQ.Client/client/api/ConnectionFactory.cs b/projects/RabbitMQ.Client/client/api/ConnectionFactory.cs
@@ -312,6 +312,11 @@ public AmqpTcpEndpoint Endpoint
         /// </summary>
         public string Password { get; set; } = DefaultPass;
 
+        /// <summary>
+        /// ICredentialsProvider used to obtain username and password.
+        /// </summary>
+        public ICredentialsProvider? CredentialsProvider { get; set; }
+
         /// <summary>
         /// Maximum channel number to ask for.
         /// </summary>
@@ -578,6 +583,7 @@ private ConnectionConfig CreateConfig(string? clientProvidedName)
                 VirtualHost,
                 UserName,
                 Password,
+                CredentialsProvider,
                 AuthMechanisms,
                 ClientProperties,
                 EnsureClientProvidedNameLength(clientProvidedName),
diff --git a/projects/RabbitMQ.Client/client/api/ExternalMechanism.cs b/projects/RabbitMQ.Client/client/api/ExternalMechanism.cs
@@ -30,6 +30,8 @@
 //---------------------------------------------------------------------------
 
 using System;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace RabbitMQ.Client
 {
@@ -38,9 +40,10 @@ public class ExternalMechanism : IAuthMechanism
         /// <summary>
         /// Handle one round of challenge-response.
         /// </summary>
-        public byte[] handleChallenge(byte[]? challenge, ConnectionConfig config)
+        public Task<byte[]> HandleChallengeAsync(byte[]? challenge, ConnectionConfig config,
+            CancellationToken cancellationToken = default)
         {
-            return Array.Empty<byte>();
+            return Task.FromResult(Array.Empty<byte>());
         }
     }
 }
diff --git a/projects/RabbitMQ.Client/client/api/IAuthMechanism.cs b/projects/RabbitMQ.Client/client/api/IAuthMechanism.cs
@@ -29,6 +29,9 @@
 //  Copyright (c) 2007-2024 Broadcom. All Rights Reserved.
 //---------------------------------------------------------------------------
 
+using System.Threading;
+using System.Threading.Tasks;
+
 namespace RabbitMQ.Client
 {
     /// <summary>
@@ -39,6 +42,7 @@ public interface IAuthMechanism
         /// <summary>
         /// Handle one round of challenge-response.
         /// </summary>
-        byte[] handleChallenge(byte[]? challenge, ConnectionConfig config);
+        Task<byte[]> HandleChallengeAsync(byte[]? challenge, ConnectionConfig config,
+            CancellationToken cancellationToken = default);
     }
 }
diff --git a/projects/RabbitMQ.Client/client/api/ICredentialsProvider.cs b/projects/RabbitMQ.Client/client/api/ICredentialsProvider.cs
@@ -33,7 +33,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace RabbitMQ.Client.OAuth2
+namespace RabbitMQ.Client
 {
     public interface ICredentialsProvider
     {
diff --git a/projects/RabbitMQ.Client/client/api/PlainMechanism.cs b/projects/RabbitMQ.Client/client/api/PlainMechanism.cs
@@ -30,18 +30,20 @@
 //---------------------------------------------------------------------------
 
 using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace RabbitMQ.Client
 {
     public class PlainMechanism : IAuthMechanism
     {
-        /*
-         * TODO rabbitmq-dotnet-client-1639
-         * Integrate with `ICredentialsProvider` via `config` (ugh)
-         */
-        public byte[] handleChallenge(byte[]? challenge, ConnectionConfig config)
+        public async Task<byte[]> HandleChallengeAsync(byte[]? challenge, ConnectionConfig config,
+            CancellationToken cancellationToken = default)
         {
-            return Encoding.UTF8.GetBytes($"\0{config.UserName}\0{config.Password}");
+            ICredentialsProvider credentialsProvider = config.CredentialsProvider;
+            Credentials credentials = await credentialsProvider.GetCredentialsAsync(cancellationToken)
+                .ConfigureAwait(false);
+            return Encoding.UTF8.GetBytes($"\0{credentials.UserName}\0{credentials.Password}");
         }
     }
 }
diff --git a/projects/RabbitMQ.Client/client/impl/Connection.Commands.cs b/projects/RabbitMQ.Client/client/impl/Connection.Commands.cs
@@ -133,7 +133,8 @@ await FinishCloseAsync(cancellationToken)
                 byte[]? challenge = null;
                 do
                 {
-                    byte[] response = mechanism.handleChallenge(challenge, _config);
+                    byte[] response = await mechanism.HandleChallengeAsync(challenge, _config)
+                        .ConfigureAwait(false);
                     ConnectionSecureOrTune res;
                     if (challenge is null)
                     {
diff --git a/projects/Test/OAuth2/TestCredentialsRefresher.cs b/projects/Test/OAuth2/TestCredentialsRefresher.cs
@@ -32,6 +32,7 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
+using RabbitMQ.Client;
 using RabbitMQ.Client.OAuth2;
 using Xunit;
 using Xunit.Abstractions;

Original file line number	Diff line number	Diff line change
`@@ -34,14 +34,15 @@`
`34`	`34`	`using System.Net.Http;`
`35`	`35`	`using System.Net.Http.Headers;`
`36`	`36`	`using System.Net.Http.Json;`
	`37`	`+using System.Threading;`
`37`	`38`	`using System.Threading.Tasks;`
`38`	`39`
`39`	`40`	`namespace RabbitMQ.Client.OAuth2`
`40`	`41`	`{`
`41`	`42`	`public interface IOAuth2Client`
`42`	`43`	`{`
`43`		`- Task<IToken> RequestTokenAsync();`
`44`		`- Task<IToken> RefreshTokenAsync(IToken token);`
	`44`	`+ Task<IToken> RequestTokenAsync(CancellationToken cancellationToken = default);`
	`45`	`+ Task<IToken> RefreshTokenAsync(IToken token, CancellationToken cancellationToken = default);`
`45`	`46`	`}`
`46`	`47`
`47`	`48`	`public interface IToken`
`@@ -196,12 +197,12 @@ public OAuth2Client(string clientId, string clientSecret, Uri tokenEndpoint,`
`196`	`197`	`_httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));`
`197`	`198`	`}`
`198`	`199`
`199`		`- public async Task<IToken> RequestTokenAsync()`
	`200`	`+ public async Task<IToken> RequestTokenAsync(CancellationToken cancellationToken = default)`
`200`	`201`	`{`
`201`		`- var req = new HttpRequestMessage(HttpMethod.Post, _tokenEndpoint);`
	`202`	`+ using HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Post, _tokenEndpoint);`
`202`	`203`	`req.Content = new FormUrlEncodedContent(buildRequestParameters());`
`203`	`204`
`204`		`- HttpResponseMessage response = await _httpClient.SendAsync(req)`
	`205`	`+ using HttpResponseMessage response = await _httpClient.SendAsync(req)`
`205`	`206`	`.ConfigureAwait(false);`
`206`	`207`
`207`	`208`	`response.EnsureSuccessStatusCode();`
`@@ -220,19 +221,20 @@ public async Task<IToken> RequestTokenAsync()`
`220`	`221`	`}`
`221`	`222`	`}`
`222`	`223`
`223`		`- public async Task<IToken> RefreshTokenAsync(IToken token)`
	`224`	`+ public async Task<IToken> RefreshTokenAsync(IToken token,`
	`225`	`+ CancellationToken cancellationToken = default)`
`224`	`226`	`{`
`225`	`227`	`if (token.RefreshToken == null)`
`226`	`228`	`{`
`227`	`229`	`throw new InvalidOperationException("Token has no Refresh Token");`
`228`	`230`	`}`
`229`	`231`
`230`		`- var req = new HttpRequestMessage(HttpMethod.Post, _tokenEndpoint)`
	`232`	`+ using HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Post, _tokenEndpoint)`
`231`	`233`	`{`
`232`	`234`	`Content = new FormUrlEncodedContent(buildRefreshParameters(token))`
`233`	`235`	`};`
`234`	`236`
`235`		`- HttpResponseMessage response = await _httpClient.SendAsync(req)`
	`237`	`+ using HttpResponseMessage response = await _httpClient.SendAsync(req)`
`236`	`238`	`.ConfigureAwait(false);`
`237`	`239`
`238`	`240`	`response.EnsureSuccessStatusCode();`
Original file line number	Diff line number	Diff line change
`@@ -35,10 +35,9 @@`
`35`	`35`
`36`	`36`	`namespace RabbitMQ.Client.OAuth2`
`37`	`37`	`{`
`38`		`- public class OAuth2ClientCredentialsProvider : ICredentialsProvider`
	`38`	`+ public class OAuth2ClientCredentialsProvider : ICredentialsProvider, IDisposable`
`39`	`39`	`{`
`40`		`- // TODO Dispose`
`41`		`- private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();`
	`40`	`+ private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);`
`42`	`41`
`43`	`42`	`private readonly string _name;`
`44`	`43`	`private readonly IOAuth2Client _oAuth2Client;`
`@@ -55,7 +54,8 @@ public OAuth2ClientCredentialsProvider(string name, IOAuth2Client oAuth2Client)`
`55`	`54`	`public async Task<Credentials> GetCredentialsAsync(CancellationToken cancellationToken = default)`
`56`	`55`	`{`
`57`	`56`	`bool mustRetrieveToken = false;`
`58`		`- _lock.EnterReadLock();`
	`57`	`+ await _semaphore.WaitAsync(cancellationToken)`
	`58`	`+ .ConfigureAwait(false);`
`59`	`59`	`try`
`60`	`60`	`{`
`61`	`61`	`if (_token is null \|\| _token.HasExpired)`
`@@ -65,14 +65,14 @@ public async Task<Credentials> GetCredentialsAsync(CancellationToken cancellatio`
`65`	`65`	`}`
`66`	`66`	`finally`
`67`	`67`	`{`
`68`		`- _lock.ExitReadLock();`
	`68`	`+ _semaphore.Release();`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`cancellationToken.ThrowIfCancellationRequested();`
`72`	`72`
`73`	`73`	`if (mustRetrieveToken)`
`74`	`74`	`{`
`75`		`- await RetrieveTokenAsync().ConfigureAwait(false);`
	`75`	`+ await RetrieveTokenAsync(cancellationToken).ConfigureAwait(false);`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`if (_token is null)`
`@@ -86,25 +86,31 @@ public async Task<Credentials> GetCredentialsAsync(CancellationToken cancellatio`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`
`89`		`- private async Task RetrieveTokenAsync()`
	`89`	`+ public void Dispose()`
`90`	`90`	`{`
`91`		`- _lock.EnterWriteLock();`
	`91`	`+ _semaphore.Dispose();`
	`92`	`+ }`
	`93`	`+`
	`94`	`+ private async Task RetrieveTokenAsync(CancellationToken cancellationToken)`
	`95`	`+ {`
	`96`	`+ await _semaphore.WaitAsync(cancellationToken)`
	`97`	`+ .ConfigureAwait(false);`
`92`	`98`	`try`
`93`	`99`	`{`
`94`	`100`	`if (_token == null \|\| _token.RefreshToken == null)`
`95`	`101`	`{`
`96`		`- _token = await _oAuth2Client.RequestTokenAsync()`
	`102`	`+ _token = await _oAuth2Client.RequestTokenAsync(cancellationToken)`
`97`	`103`	`.ConfigureAwait(false);`
`98`	`104`	`}`
`99`	`105`	`else`
`100`	`106`	`{`
`101`		`- _token = await _oAuth2Client.RefreshTokenAsync(_token)`
	`107`	`+ _token = await _oAuth2Client.RefreshTokenAsync(_token, cancellationToken)`
`102`	`108`	`.ConfigureAwait(false);`
`103`	`109`	`}`
`104`	`110`	`}`
`105`	`111`	`finally`
`106`	`112`	`{`
`107`		`- _lock.ExitWriteLock();`
	`113`	`+ _semaphore.Release();`
`108`	`114`	`}`
`109`	`115`	`}`
`110`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,26 +33,28 @@`
`33`	`33`	`using System.Threading;`
`34`	`34`	`using System.Threading.Tasks;`
`35`	`35`
`36`		`-namespace RabbitMQ.Client.OAuth2`
	`36`	`+namespace RabbitMQ.Client`
`37`	`37`	`{`
`38`	`38`	`public class BasicCredentialsProvider : ICredentialsProvider`
`39`	`39`	`{`
`40`	`40`	`private readonly string _name;`
`41`	`41`	`private readonly string _userName;`
`42`	`42`	`private readonly string _password;`
	`43`	`+ private readonly Credentials _credentials;`
`43`	`44`
`44`		`- public BasicCredentialsProvider(string name, string userName, string password)`
	`45`	`+ public BasicCredentialsProvider(string? name, string userName, string password)`
`45`	`46`	`{`
`46`		`- _name = name ?? string.Empty;`
	`47`	`+ _name = name ?? typeof(BasicCredentialsProvider).Name;`
`47`	`48`	`_userName = userName ?? throw new ArgumentNullException(nameof(userName));`
`48`	`49`	`_password = password ?? throw new ArgumentNullException(nameof(password));`
	`50`	`+ _credentials = new Credentials(_name, _userName, _password, null);`
`49`	`51`	`}`
`50`	`52`
`51`	`53`	`public string Name => _name;`
`52`	`54`
`53`	`55`	`public Task<Credentials> GetCredentialsAsync(CancellationToken cancellationToken = default)`
`54`	`56`	`{`
`55`		`- return Task.FromResult(new Credentials(_name, _userName, _password, null));`
	`57`	`+ return Task.FromResult(_credentials);`
`56`	`58`	`}`
`57`	`59`	`}`
`58`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,8 @@`
`30`	`30`	`//---------------------------------------------------------------------------`
`31`	`31`
`32`	`32`	`using System;`
	`33`	`+using System.Threading;`
	`34`	`+using System.Threading.Tasks;`
`33`	`35`
`34`	`36`	`namespace RabbitMQ.Client`
`35`	`37`	`{`
`@@ -38,9 +40,10 @@ public class ExternalMechanism : IAuthMechanism`
`38`	`40`	`/// <summary>`
`39`	`41`	`/// Handle one round of challenge-response.`
`40`	`42`	`/// </summary>`
`41`		`- public byte[] handleChallenge(byte[]? challenge, ConnectionConfig config)`
	`43`	`+ public Task<byte[]> HandleChallengeAsync(byte[]? challenge, ConnectionConfig config,`
	`44`	`+ CancellationToken cancellationToken = default)`
`42`	`45`	`{`
`43`		`- return Array.Empty<byte>();`
	`46`	`+ return Task.FromResult(Array.Empty<byte>());`
`44`	`47`	`}`
`45`	`48`	`}`
`46`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,9 @@`
`29`	`29`	`// Copyright (c) 2007-2024 Broadcom. All Rights Reserved.`
`30`	`30`	`//---------------------------------------------------------------------------`
`31`	`31`
	`32`	`+using System.Threading;`
	`33`	`+using System.Threading.Tasks;`
	`34`	`+`
`32`	`35`	`namespace RabbitMQ.Client`
`33`	`36`	`{`
`34`	`37`	`/// <summary>`
`@@ -39,6 +42,7 @@ public interface IAuthMechanism`
`39`	`42`	`/// <summary>`
`40`	`43`	`/// Handle one round of challenge-response.`
`41`	`44`	`/// </summary>`
`42`		`- byte[] handleChallenge(byte[]? challenge, ConnectionConfig config);`
	`45`	`+ Task<byte[]> HandleChallengeAsync(byte[]? challenge, ConnectionConfig config,`
	`46`	`+ CancellationToken cancellationToken = default);`
`43`	`47`	`}`
`44`	`48`	`}`