TokenManagerCredentialsProvider -> CachedCredentialsProvider

KirillKurdyukov · KirillKurdyukov · commit 4e3c924617de · 2025-03-26T12:54:58.000+03:00
diff --git a/src/Ydb.Sdk/src/Auth/CachedCredentialsProvider.cs b/src/Ydb.Sdk/src/Auth/CachedCredentialsProvider.cs
@@ -3,16 +3,16 @@
 
 namespace Ydb.Sdk.Auth;
 
-public class TokenManagerCredentialsProvider : ICredentialsProvider
+public class CachedCredentialsProvider : ICredentialsProvider
 {
     private readonly IClock _clock;
     private readonly IAuthClient _authClient;
 
-    private ILogger<TokenManagerCredentialsProvider> Logger { get; }
+    private ILogger<CachedCredentialsProvider> Logger { get; }
 
     private volatile ITokenState _tokenState;
 
-    public TokenManagerCredentialsProvider(
+    public CachedCredentialsProvider(
         IAuthClient authClient,
         ILoggerFactory? loggerFactory = null
     )
@@ -23,10 +23,10 @@ public TokenManagerCredentialsProvider(
         _tokenState.Init();
 
         loggerFactory ??= new NullLoggerFactory();
-        Logger = loggerFactory.CreateLogger<TokenManagerCredentialsProvider>();
+        Logger = loggerFactory.CreateLogger<CachedCredentialsProvider>();
     }
 
-    internal TokenManagerCredentialsProvider(IAuthClient authClient, IClock clock) : this(authClient)
+    internal CachedCredentialsProvider(IAuthClient authClient, IClock clock) : this(authClient)
     {
         _clock = clock;
     }
@@ -59,12 +59,12 @@ void Init()
 
     private class ActiveState : ITokenState
     {
-        private readonly TokenManagerCredentialsProvider _tokenManagerCredentialsProvider;
+        private readonly CachedCredentialsProvider _cachedCredentialsProvider;
 
-        public ActiveState(TokenResponse tokenResponse, TokenManagerCredentialsProvider tokenManagerCredentialsProvider)
+        public ActiveState(TokenResponse tokenResponse, CachedCredentialsProvider cachedCredentialsProvider)
         {
             TokenResponse = tokenResponse;
-            _tokenManagerCredentialsProvider = tokenManagerCredentialsProvider;
+            _cachedCredentialsProvider = cachedCredentialsProvider;
         }
 
         public TokenResponse TokenResponse { get; }
@@ -74,34 +74,34 @@ public async ValueTask<ITokenState> Validate(DateTime now)
             if (now < TokenResponse.ExpiredAt)
             {
                 return now >= TokenResponse.RefreshAt
-                    ? _tokenManagerCredentialsProvider.UpdateState(
+                    ? _cachedCredentialsProvider.UpdateState(
                         this,
-                        new BackgroundState(TokenResponse, _tokenManagerCredentialsProvider)
+                        new BackgroundState(TokenResponse, _cachedCredentialsProvider)
                     )
                     : this;
             }
 
-            _tokenManagerCredentialsProvider.Logger.LogWarning(
+            _cachedCredentialsProvider.Logger.LogWarning(
                 "Token has expired. ExpiredAt: {ExpiredAt}, CurrentTime: {CurrentTime}. " +
                 "Switching to synchronous state to fetch a new token",
                 TokenResponse.ExpiredAt, now
             );
 
-            return await _tokenManagerCredentialsProvider
-                .UpdateState(this, new SyncState(_tokenManagerCredentialsProvider))
+            return await _cachedCredentialsProvider
+                .UpdateState(this, new SyncState(_cachedCredentialsProvider))
                 .Validate(now);
         }
     }
 
     private class SyncState : ITokenState
     {
-        private readonly TokenManagerCredentialsProvider _tokenManagerCredentialsProvider;
+        private readonly CachedCredentialsProvider _cachedCredentialsProvider;
 
         private volatile Task<TokenResponse> _fetchTokenTask = null!;
 
-        public SyncState(TokenManagerCredentialsProvider tokenManagerCredentialsProvider)
+        public SyncState(CachedCredentialsProvider cachedCredentialsProvider)
         {
-            _tokenManagerCredentialsProvider = tokenManagerCredentialsProvider;
+            _cachedCredentialsProvider = cachedCredentialsProvider;
         }
 
         public TokenResponse TokenResponse =>
@@ -113,37 +113,37 @@ public async ValueTask<ITokenState> Validate(DateTime now)
             {
                 var tokenResponse = await _fetchTokenTask;
 
-                _tokenManagerCredentialsProvider.Logger.LogDebug(
+                _cachedCredentialsProvider.Logger.LogDebug(
                     "Successfully fetched token at {Timestamp}. ExpiredAt: {ExpiredAt}, RefreshAt: {RefreshAt}",
                     DateTime.Now, tokenResponse.ExpiredAt, tokenResponse.RefreshAt
                 );
 
-                return _tokenManagerCredentialsProvider.UpdateState(this,
-                    new ActiveState(tokenResponse, _tokenManagerCredentialsProvider));
+                return _cachedCredentialsProvider.UpdateState(this,
+                    new ActiveState(tokenResponse, _cachedCredentialsProvider));
             }
             catch (Exception e)
             {
-                _tokenManagerCredentialsProvider.Logger.LogCritical(e, "Error on authentication token update");
+                _cachedCredentialsProvider.Logger.LogCritical(e, "Error on authentication token update");
 
-                return _tokenManagerCredentialsProvider.UpdateState(this,
-                    new ErrorState(e, _tokenManagerCredentialsProvider));
+                return _cachedCredentialsProvider.UpdateState(this,
+                    new ErrorState(e, _cachedCredentialsProvider));
             }
         }
 
-        public void Init() => _fetchTokenTask = _tokenManagerCredentialsProvider.FetchToken();
+        public void Init() => _fetchTokenTask = _cachedCredentialsProvider.FetchToken();
     }
 
     private class BackgroundState : ITokenState
     {
-        private readonly TokenManagerCredentialsProvider _tokenManagerCredentialsProvider;
+        private readonly CachedCredentialsProvider _cachedCredentialsProvider;
 
         private volatile Task<TokenResponse> _fetchTokenTask = null!;
 
         public BackgroundState(TokenResponse tokenResponse,
-            TokenManagerCredentialsProvider tokenManagerCredentialsProvider)
+            CachedCredentialsProvider cachedCredentialsProvider)
         {
             TokenResponse = tokenResponse;
-            _tokenManagerCredentialsProvider = tokenManagerCredentialsProvider;
+            _cachedCredentialsProvider = cachedCredentialsProvider;
         }
 
         public TokenResponse TokenResponse { get; }
@@ -152,22 +152,22 @@ public async ValueTask<ITokenState> Validate(DateTime now)
         {
             if (_fetchTokenTask.IsCanceled || _fetchTokenTask.IsFaulted)
             {
-                _tokenManagerCredentialsProvider.Logger.LogWarning(
+                _cachedCredentialsProvider.Logger.LogWarning(
                     "Fetching token task failed. Status: {Status}, Retrying login...",
                     _fetchTokenTask.IsCanceled ? "Canceled" : "Faulted"
                 );
 
                 return now >= TokenResponse.ExpiredAt
-                    ? _tokenManagerCredentialsProvider
-                        .UpdateState(this, new SyncState(_tokenManagerCredentialsProvider))
-                    : _tokenManagerCredentialsProvider
-                        .UpdateState(this, new BackgroundState(TokenResponse, _tokenManagerCredentialsProvider));
+                    ? _cachedCredentialsProvider
+                        .UpdateState(this, new SyncState(_cachedCredentialsProvider))
+                    : _cachedCredentialsProvider
+                        .UpdateState(this, new BackgroundState(TokenResponse, _cachedCredentialsProvider));
             }
 
             if (_fetchTokenTask.IsCompleted)
             {
-                return _tokenManagerCredentialsProvider
-                    .UpdateState(this, new ActiveState(await _fetchTokenTask, _tokenManagerCredentialsProvider));
+                return _cachedCredentialsProvider
+                    .UpdateState(this, new ActiveState(await _fetchTokenTask, _cachedCredentialsProvider));
             }
 
             if (now < TokenResponse.ExpiredAt)
@@ -179,32 +179,32 @@ public async ValueTask<ITokenState> Validate(DateTime now)
             {
                 var tokenResponse = await _fetchTokenTask;
 
-                _tokenManagerCredentialsProvider.Logger.LogDebug(
+                _cachedCredentialsProvider.Logger.LogDebug(
                     "Successfully fetched token. ExpiredAt: {ExpiredAt}, RefreshAt: {RefreshAt}",
                     tokenResponse.ExpiredAt, tokenResponse.RefreshAt
                 );
 
-                return _tokenManagerCredentialsProvider.UpdateState(this,
-                    new ActiveState(tokenResponse, _tokenManagerCredentialsProvider));
+                return _cachedCredentialsProvider.UpdateState(this,
+                    new ActiveState(tokenResponse, _cachedCredentialsProvider));
             }
             catch (Exception e)
             {
-                _tokenManagerCredentialsProvider.Logger.LogCritical(e, "Error on authentication token update");
+                _cachedCredentialsProvider.Logger.LogCritical(e, "Error on authentication token update");
 
-                return _tokenManagerCredentialsProvider.UpdateState(this,
-                    new ErrorState(e, _tokenManagerCredentialsProvider));
+                return _cachedCredentialsProvider.UpdateState(this,
+                    new ErrorState(e, _cachedCredentialsProvider));
             }
         }
 
-        public void Init() => _fetchTokenTask = _tokenManagerCredentialsProvider.FetchToken();
+        public void Init() => _fetchTokenTask = _cachedCredentialsProvider.FetchToken();
     }
 
     private class ErrorState : ITokenState
     {
         private readonly Exception _exception;
-        private readonly TokenManagerCredentialsProvider _managerCredentialsProvider;
+        private readonly CachedCredentialsProvider _managerCredentialsProvider;
 
-        public ErrorState(Exception exception, TokenManagerCredentialsProvider managerCredentialsProvider)
+        public ErrorState(Exception exception, CachedCredentialsProvider managerCredentialsProvider)
         {
             _exception = exception;
             _managerCredentialsProvider = managerCredentialsProvider;
diff --git a/src/Ydb.Sdk/src/Driver.cs b/src/Ydb.Sdk/src/Driver.cs
@@ -40,7 +40,7 @@ public Driver(DriverConfig config, ILoggerFactory? loggerFactory = null)
         _sdkInfo = $"ydb-dotnet-sdk/{versionStr}";
 
         CredentialsProvider = Config.User != null
-            ? new TokenManagerCredentialsProvider(
+            ? new CachedCredentialsProvider(
                 new StaticCredentialsAuthClient(config, _grpcChannelFactory, LoggerFactory),
                 LoggerFactory
             )
diff --git a/src/Ydb.Sdk/tests/Auth/CachedCredentialsProviderTests.cs b/src/Ydb.Sdk/tests/Auth/CachedCredentialsProviderTests.cs
@@ -5,7 +5,7 @@
 namespace Ydb.Sdk.Tests.Auth;
 
 [Trait("Category", "Unit")]
-public class TokenManagerCredentialsProviderTests
+public class CachedCredentialsProviderTests
 {
     private const string Token = "SomeToken";
 
@@ -24,7 +24,7 @@ public async Task SyncState_To_ErrorState_To_SyncState_To_ActiveState()
             )
             .ReturnsAsync(new TokenResponse(Token, now.Add(TimeSpan.FromSeconds(2))));
         _mockClock.Setup(clock => clock.UtcNow).Returns(now);
-        var credentialsProvider = new TokenManagerCredentialsProvider(_mockAuthClient.Object, _mockClock.Object);
+        var credentialsProvider = new CachedCredentialsProvider(_mockAuthClient.Object, _mockClock.Object);
 
         await Assert.ThrowsAsync<StatusUnsuccessfulException>(() => credentialsProvider.GetAuthInfoAsync().AsTask());
         Assert.Equal(Token, await credentialsProvider.GetAuthInfoAsync());
@@ -52,7 +52,7 @@ public async Task SyncState_To_ActiveState_To_BackgroundState_To_ActiveState()
             .Returns(now.Add(TimeSpan.FromSeconds(3)))
             .Returns(now.Add(TimeSpan.FromSeconds(3)))
             .Returns(now.Add(TimeSpan.FromSeconds(4)));
-        var credentialsProvider = new TokenManagerCredentialsProvider(_mockAuthClient.Object, _mockClock.Object);
+        var credentialsProvider = new CachedCredentialsProvider(_mockAuthClient.Object, _mockClock.Object);
 
         Assert.Equal(Token, await credentialsProvider.GetAuthInfoAsync());
         Assert.Equal(Token, await credentialsProvider.GetAuthInfoAsync());
@@ -78,7 +78,7 @@ public async Task SyncState_To_ActiveState_To_SyncState_To_ActiveState()
             .Returns(now)
             .Returns(now.Add(TimeSpan.FromSeconds(4)))
             .Returns(now.Add(TimeSpan.FromSeconds(4)));
-        var credentialsProvider = new TokenManagerCredentialsProvider(_mockAuthClient.Object, _mockClock.Object);
+        var credentialsProvider = new CachedCredentialsProvider(_mockAuthClient.Object, _mockClock.Object);
 
         Assert.Equal(Token, await credentialsProvider.GetAuthInfoAsync());
         Assert.Equal(Token + "1", await credentialsProvider.GetAuthInfoAsync());

Original file line number	Diff line number	Diff line change
`@@ -3,16 +3,16 @@`
`3`	`3`
`4`	`4`	`namespace Ydb.Sdk.Auth;`
`5`	`5`
`6`		`-public class TokenManagerCredentialsProvider : ICredentialsProvider`
	`6`	`+public class CachedCredentialsProvider : ICredentialsProvider`
`7`	`7`	`{`
`8`	`8`	`private readonly IClock _clock;`
`9`	`9`	`private readonly IAuthClient _authClient;`
`10`	`10`
`11`		`- private ILogger<TokenManagerCredentialsProvider> Logger { get; }`
	`11`	`+ private ILogger<CachedCredentialsProvider> Logger { get; }`
`12`	`12`
`13`	`13`	`private volatile ITokenState _tokenState;`
`14`	`14`
`15`		`- public TokenManagerCredentialsProvider(`
	`15`	`+ public CachedCredentialsProvider(`
`16`	`16`	`IAuthClient authClient,`
`17`	`17`	`ILoggerFactory? loggerFactory = null`
`18`	`18`	`)`
`@@ -23,10 +23,10 @@ public TokenManagerCredentialsProvider(`
`23`	`23`	`_tokenState.Init();`
`24`	`24`
`25`	`25`	`loggerFactory ??= new NullLoggerFactory();`
`26`		`- Logger = loggerFactory.CreateLogger<TokenManagerCredentialsProvider>();`
	`26`	`+ Logger = loggerFactory.CreateLogger<CachedCredentialsProvider>();`
`27`	`27`	`}`
`28`	`28`
`29`		`- internal TokenManagerCredentialsProvider(IAuthClient authClient, IClock clock) : this(authClient)`
	`29`	`+ internal CachedCredentialsProvider(IAuthClient authClient, IClock clock) : this(authClient)`
`30`	`30`	`{`
`31`	`31`	`_clock = clock;`
`32`	`32`	`}`
`@@ -59,12 +59,12 @@ void Init()`
`59`	`59`
`60`	`60`	`private class ActiveState : ITokenState`
`61`	`61`	`{`
`62`		`- private readonly TokenManagerCredentialsProvider _tokenManagerCredentialsProvider;`
	`62`	`+ private readonly CachedCredentialsProvider _cachedCredentialsProvider;`
`63`	`63`
`64`		`- public ActiveState(TokenResponse tokenResponse, TokenManagerCredentialsProvider tokenManagerCredentialsProvider)`
	`64`	`+ public ActiveState(TokenResponse tokenResponse, CachedCredentialsProvider cachedCredentialsProvider)`
`65`	`65`	`{`
`66`	`66`	`TokenResponse = tokenResponse;`
`67`		`- _tokenManagerCredentialsProvider = tokenManagerCredentialsProvider;`
	`67`	`+ _cachedCredentialsProvider = cachedCredentialsProvider;`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`public TokenResponse TokenResponse { get; }`
`@@ -74,34 +74,34 @@ public async ValueTask<ITokenState> Validate(DateTime now)`
`74`	`74`	`if (now < TokenResponse.ExpiredAt)`
`75`	`75`	`{`
`76`	`76`	`return now >= TokenResponse.RefreshAt`
`77`		`- ? _tokenManagerCredentialsProvider.UpdateState(`
	`77`	`+ ? _cachedCredentialsProvider.UpdateState(`
`78`	`78`	`this,`
`79`		`- new BackgroundState(TokenResponse, _tokenManagerCredentialsProvider)`
	`79`	`+ new BackgroundState(TokenResponse, _cachedCredentialsProvider)`
`80`	`80`	`)`
`81`	`81`	`: this;`
`82`	`82`	`}`
`83`	`83`
`84`		`- _tokenManagerCredentialsProvider.Logger.LogWarning(`
	`84`	`+ _cachedCredentialsProvider.Logger.LogWarning(`
`85`	`85`	`"Token has expired. ExpiredAt: {ExpiredAt}, CurrentTime: {CurrentTime}. " +`
`86`	`86`	`"Switching to synchronous state to fetch a new token",`
`87`	`87`	`TokenResponse.ExpiredAt, now`
`88`	`88`	`);`
`89`	`89`
`90`		`- return await _tokenManagerCredentialsProvider`
`91`		`- .UpdateState(this, new SyncState(_tokenManagerCredentialsProvider))`
	`90`	`+ return await _cachedCredentialsProvider`
	`91`	`+ .UpdateState(this, new SyncState(_cachedCredentialsProvider))`
`92`	`92`	`.Validate(now);`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`private class SyncState : ITokenState`
`97`	`97`	`{`
`98`		`- private readonly TokenManagerCredentialsProvider _tokenManagerCredentialsProvider;`
	`98`	`+ private readonly CachedCredentialsProvider _cachedCredentialsProvider;`
`99`	`99`
`100`	`100`	`private volatile Task<TokenResponse> _fetchTokenTask = null!;`
`101`	`101`
`102`		`- public SyncState(TokenManagerCredentialsProvider tokenManagerCredentialsProvider)`
	`102`	`+ public SyncState(CachedCredentialsProvider cachedCredentialsProvider)`
`103`	`103`	`{`
`104`		`- _tokenManagerCredentialsProvider = tokenManagerCredentialsProvider;`
	`104`	`+ _cachedCredentialsProvider = cachedCredentialsProvider;`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`public TokenResponse TokenResponse =>`
`@@ -113,37 +113,37 @@ public async ValueTask<ITokenState> Validate(DateTime now)`
`113`	`113`	`{`
`114`	`114`	`var tokenResponse = await _fetchTokenTask;`
`115`	`115`
`116`		`- _tokenManagerCredentialsProvider.Logger.LogDebug(`
	`116`	`+ _cachedCredentialsProvider.Logger.LogDebug(`
`117`	`117`	`"Successfully fetched token at {Timestamp}. ExpiredAt: {ExpiredAt}, RefreshAt: {RefreshAt}",`
`118`	`118`	`DateTime.Now, tokenResponse.ExpiredAt, tokenResponse.RefreshAt`
`119`	`119`	`);`
`120`	`120`
`121`		`- return _tokenManagerCredentialsProvider.UpdateState(this,`
`122`		`- new ActiveState(tokenResponse, _tokenManagerCredentialsProvider));`
	`121`	`+ return _cachedCredentialsProvider.UpdateState(this,`
	`122`	`+ new ActiveState(tokenResponse, _cachedCredentialsProvider));`
`123`	`123`	`}`
`124`	`124`	`catch (Exception e)`
`125`	`125`	`{`
`126`		`- _tokenManagerCredentialsProvider.Logger.LogCritical(e, "Error on authentication token update");`
	`126`	`+ _cachedCredentialsProvider.Logger.LogCritical(e, "Error on authentication token update");`
`127`	`127`
`128`		`- return _tokenManagerCredentialsProvider.UpdateState(this,`
`129`		`- new ErrorState(e, _tokenManagerCredentialsProvider));`
	`128`	`+ return _cachedCredentialsProvider.UpdateState(this,`
	`129`	`+ new ErrorState(e, _cachedCredentialsProvider));`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`
`133`		`- public void Init() => _fetchTokenTask = _tokenManagerCredentialsProvider.FetchToken();`
	`133`	`+ public void Init() => _fetchTokenTask = _cachedCredentialsProvider.FetchToken();`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`private class BackgroundState : ITokenState`
`137`	`137`	`{`
`138`		`- private readonly TokenManagerCredentialsProvider _tokenManagerCredentialsProvider;`
	`138`	`+ private readonly CachedCredentialsProvider _cachedCredentialsProvider;`
`139`	`139`
`140`	`140`	`private volatile Task<TokenResponse> _fetchTokenTask = null!;`
`141`	`141`
`142`	`142`	`public BackgroundState(TokenResponse tokenResponse,`
`143`		`- TokenManagerCredentialsProvider tokenManagerCredentialsProvider)`
	`143`	`+ CachedCredentialsProvider cachedCredentialsProvider)`
`144`	`144`	`{`
`145`	`145`	`TokenResponse = tokenResponse;`
`146`		`- _tokenManagerCredentialsProvider = tokenManagerCredentialsProvider;`
	`146`	`+ _cachedCredentialsProvider = cachedCredentialsProvider;`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`public TokenResponse TokenResponse { get; }`
`@@ -152,22 +152,22 @@ public async ValueTask<ITokenState> Validate(DateTime now)`
`152`	`152`	`{`
`153`	`153`	`if (_fetchTokenTask.IsCanceled \|\| _fetchTokenTask.IsFaulted)`
`154`	`154`	`{`
`155`		`- _tokenManagerCredentialsProvider.Logger.LogWarning(`
	`155`	`+ _cachedCredentialsProvider.Logger.LogWarning(`
`156`	`156`	`"Fetching token task failed. Status: {Status}, Retrying login...",`
`157`	`157`	`_fetchTokenTask.IsCanceled ? "Canceled" : "Faulted"`
`158`	`158`	`);`
`159`	`159`
`160`	`160`	`return now >= TokenResponse.ExpiredAt`
`161`		`- ? _tokenManagerCredentialsProvider`
`162`		`- .UpdateState(this, new SyncState(_tokenManagerCredentialsProvider))`
`163`		`- : _tokenManagerCredentialsProvider`
`164`		`- .UpdateState(this, new BackgroundState(TokenResponse, _tokenManagerCredentialsProvider));`
	`161`	`+ ? _cachedCredentialsProvider`
	`162`	`+ .UpdateState(this, new SyncState(_cachedCredentialsProvider))`
	`163`	`+ : _cachedCredentialsProvider`
	`164`	`+ .UpdateState(this, new BackgroundState(TokenResponse, _cachedCredentialsProvider));`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`if (_fetchTokenTask.IsCompleted)`
`168`	`168`	`{`
`169`		`- return _tokenManagerCredentialsProvider`
`170`		`- .UpdateState(this, new ActiveState(await _fetchTokenTask, _tokenManagerCredentialsProvider));`
	`169`	`+ return _cachedCredentialsProvider`
	`170`	`+ .UpdateState(this, new ActiveState(await _fetchTokenTask, _cachedCredentialsProvider));`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`if (now < TokenResponse.ExpiredAt)`
`@@ -179,32 +179,32 @@ public async ValueTask<ITokenState> Validate(DateTime now)`
`179`	`179`	`{`
`180`	`180`	`var tokenResponse = await _fetchTokenTask;`
`181`	`181`
`182`		`- _tokenManagerCredentialsProvider.Logger.LogDebug(`
	`182`	`+ _cachedCredentialsProvider.Logger.LogDebug(`
`183`	`183`	`"Successfully fetched token. ExpiredAt: {ExpiredAt}, RefreshAt: {RefreshAt}",`
`184`	`184`	`tokenResponse.ExpiredAt, tokenResponse.RefreshAt`
`185`	`185`	`);`
`186`	`186`
`187`		`- return _tokenManagerCredentialsProvider.UpdateState(this,`
`188`		`- new ActiveState(tokenResponse, _tokenManagerCredentialsProvider));`
	`187`	`+ return _cachedCredentialsProvider.UpdateState(this,`
	`188`	`+ new ActiveState(tokenResponse, _cachedCredentialsProvider));`
`189`	`189`	`}`
`190`	`190`	`catch (Exception e)`
`191`	`191`	`{`
`192`		`- _tokenManagerCredentialsProvider.Logger.LogCritical(e, "Error on authentication token update");`
	`192`	`+ _cachedCredentialsProvider.Logger.LogCritical(e, "Error on authentication token update");`
`193`	`193`
`194`		`- return _tokenManagerCredentialsProvider.UpdateState(this,`
`195`		`- new ErrorState(e, _tokenManagerCredentialsProvider));`
	`194`	`+ return _cachedCredentialsProvider.UpdateState(this,`
	`195`	`+ new ErrorState(e, _cachedCredentialsProvider));`
`196`	`196`	`}`
`197`	`197`	`}`
`198`	`198`
`199`		`- public void Init() => _fetchTokenTask = _tokenManagerCredentialsProvider.FetchToken();`
	`199`	`+ public void Init() => _fetchTokenTask = _cachedCredentialsProvider.FetchToken();`
`200`	`200`	`}`
`201`	`201`
`202`	`202`	`private class ErrorState : ITokenState`
`203`	`203`	`{`
`204`	`204`	`private readonly Exception _exception;`
`205`		`- private readonly TokenManagerCredentialsProvider _managerCredentialsProvider;`
	`205`	`+ private readonly CachedCredentialsProvider _managerCredentialsProvider;`
`206`	`206`
`207`		`- public ErrorState(Exception exception, TokenManagerCredentialsProvider managerCredentialsProvider)`
	`207`	`+ public ErrorState(Exception exception, CachedCredentialsProvider managerCredentialsProvider)`
`208`	`208`	`{`
`209`	`209`	`_exception = exception;`
`210`	`210`	`_managerCredentialsProvider = managerCredentialsProvider;`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ public Driver(DriverConfig config, ILoggerFactory? loggerFactory = null)`
`40`	`40`	`_sdkInfo = $"ydb-dotnet-sdk/{versionStr}";`
`41`	`41`
`42`	`42`	`CredentialsProvider = Config.User != null`
`43`		`- ? new TokenManagerCredentialsProvider(`
	`43`	`+ ? new CachedCredentialsProvider(`
`44`	`44`	`new StaticCredentialsAuthClient(config, _grpcChannelFactory, LoggerFactory),`
`45`	`45`	`LoggerFactory`
`46`	`46`	`)`