dev: Added PoolingSessionTests.cs (#479)

KirillKurdyukov · web-flow · commit 81190ade2b24 · 2025-07-18T16:28:05.000+03:00
diff --git a/src/Ydb.Sdk/src/Ado/Session/ISessionSource.cs b/src/Ydb.Sdk/src/Ado/Session/ISessionSource.cs
@@ -2,7 +2,7 @@ namespace Ydb.Sdk.Ado.Session;
 
 internal interface ISessionSource<TSession> where TSession : ISession
 {
-    ValueTask<TSession> OpenSession(CancellationToken cancellationToken = default);
+    ValueTask<TSession> OpenSession(CancellationToken cancellationToken);
 
     void Return(TSession session);
 }
diff --git a/src/Ydb.Sdk/src/Ado/Session/PoolingSession.cs b/src/Ydb.Sdk/src/Ado/Session/PoolingSession.cs
@@ -17,10 +17,11 @@ internal class PoolingSession : IPoolingSession
 
     private readonly IDriver _driver;
     private readonly PoolingSessionSource _poolingSessionSource;
-    private readonly YdbConnectionStringBuilder _settings;
     private readonly ILogger<PoolingSession> _logger;
 
-    private volatile bool _isBroken;
+    private volatile bool _isBroken = true;
+
+    private readonly bool _disableServerBalancer;
 
     private string SessionId { get; set; } = string.Empty;
     private long NodeId { get; set; }
@@ -30,13 +31,13 @@ internal class PoolingSession : IPoolingSession
     internal PoolingSession(
         IDriver driver,
         PoolingSessionSource poolingSessionSource,
-        YdbConnectionStringBuilder settings,
+        bool disableServerBalancer,
         ILogger<PoolingSession> logger
     )
     {
         _driver = driver;
         _poolingSessionSource = poolingSessionSource;
-        _settings = settings;
+        _disableServerBalancer = disableServerBalancer;
         _logger = logger;
     }
 
@@ -96,18 +97,16 @@ public async Task RollbackTransaction(
         }
     }
 
-    public void OnNotSuccessStatusCode(StatusCode code)
+    public void OnNotSuccessStatusCode(StatusCode statusCode)
     {
-        if (code is
-            StatusCode.Cancelled or
+        if (statusCode is
             StatusCode.BadSession or
             StatusCode.SessionBusy or
-            StatusCode.InternalError or
+            StatusCode.SessionExpired or
             StatusCode.ClientTransportTimeout or
-            StatusCode.Unavailable or
             StatusCode.ClientTransportUnavailable)
         {
-            _logger.LogWarning("Session[{SessionId}] is deactivated. Reason StatusCode: {Code}", SessionId, code);
+            _logger.LogWarning("Session[{SessionId}] is deactivated. Reason Status: {Status}", SessionId, statusCode);
 
             _isBroken = true;
         }
@@ -117,7 +116,7 @@ public async Task Open(CancellationToken cancellationToken)
     {
         var requestSettings = new GrpcRequestSettings { CancellationToken = cancellationToken };
 
-        if (!_settings.DisableServerBalancer)
+        if (!_disableServerBalancer)
         {
             requestSettings.ClientCapabilities.Add(SessionBalancer);
         }
@@ -133,6 +132,7 @@ public async Task Open(CancellationToken cancellationToken)
 
         SessionId = response.SessionId;
         NodeId = response.NodeId;
+        _isBroken = false;
 
         _ = Task.Run(async () =>
         {
@@ -188,7 +188,7 @@ public async Task Open(CancellationToken cancellationToken)
                 }
                 catch (YdbException e)
                 {
-                    if (e.Code == StatusCode.Cancelled)
+                    if (e.Code == StatusCode.ClientTransportTimeout)
                     {
                         _logger.LogDebug("AttachStream is cancelled (possible grpcChannel is closing)");
 
diff --git a/src/Ydb.Sdk/src/Ado/Session/PoolingSessionFactory.cs b/src/Ydb.Sdk/src/Ado/Session/PoolingSessionFactory.cs
@@ -5,16 +5,16 @@ namespace Ydb.Sdk.Ado.Session;
 internal class PoolingSessionFactory : IPoolingSessionFactory
 {
     private readonly IDriver _driver;
-    private readonly YdbConnectionStringBuilder _settings;
+    private readonly bool _disableServerBalancer;
     private readonly ILogger<PoolingSession> _logger;
 
-    public PoolingSessionFactory(IDriver driver, YdbConnectionStringBuilder settings, ILogger<PoolingSession> logger)
+    public PoolingSessionFactory(IDriver driver, YdbConnectionStringBuilder settings, ILoggerFactory loggerFactory)
     {
         _driver = driver;
-        _settings = settings;
-        _logger = logger;
+        _disableServerBalancer = settings.DisableServerBalancer;
+        _logger = loggerFactory.CreateLogger<PoolingSession>();
     }
 
     public IPoolingSession NewSession(PoolingSessionSource source) =>
-        new PoolingSession(_driver, source, _settings, _logger);
+        new PoolingSession(_driver, source, _disableServerBalancer, _logger);
 }
diff --git a/src/Ydb.Sdk/src/Ado/Session/PoolingSessionSource.cs b/src/Ydb.Sdk/src/Ado/Session/PoolingSessionSource.cs
@@ -31,7 +31,7 @@ internal sealed class PoolingSessionSource : ISessionSource<IPoolingSession>
     private volatile bool _pruningTimerEnabled;
     private int _pruningSampleIndex;
 
-    private volatile int _numConnectors;
+    private volatile int _numSessions;
     private volatile int _idleCount;
 
     public PoolingSessionSource(
@@ -111,15 +111,15 @@ private async ValueTask<IPoolingSession> RentAsync(CancellationToken cancellatio
                     return session;
                 }
 
-                // If we're here, our waiting attempt on the idle connector channel was released with a null
-                // (or bad connector), or we're in sync mode. Check again if a new idle connector has appeared since we last checked.
+                // If we're here, our waiting attempt on the idle session channel was released with a null
+                // (or bad session), or we're in sync mode. Check again if a new idle session has appeared since we last checked.
                 if (TryGetIdleSession(out session))
                 {
                     return session;
                 }
 
-                // We might have closed a connector in the meantime and no longer be at max capacity
-                // so try to open a new connector and if that fails, loop again.
+                // We might have closed a session in the meantime and no longer be at max capacity
+                // so try to open a new session and if that fails, loop again.
                 session = await OpenNewSession(finalToken).ConfigureAwait(false);
                 if (session != null)
                 {
@@ -139,9 +139,9 @@ private async ValueTask<IPoolingSession> RentAsync(CancellationToken cancellatio
 
     private async ValueTask<IPoolingSession?> OpenNewSession(CancellationToken cancellationToken)
     {
-        for (var numConnectors = _numConnectors; numConnectors < _maxSessionSize; numConnectors = _numConnectors)
+        for (var numSessions = _numSessions; numSessions < _maxSessionSize; numSessions = _numSessions)
         {
-            if (Interlocked.CompareExchange(ref _numConnectors, numConnectors + 1, numConnectors) != numConnectors)
+            if (Interlocked.CompareExchange(ref _numSessions, numSessions + 1, numSessions) != numSessions)
             {
                 continue;
             }
@@ -153,8 +153,8 @@ private async ValueTask<IPoolingSession> RentAsync(CancellationToken cancellatio
 
                 // Only start pruning if we've incremented open count past _min.
                 // Note that we don't do it only once, on equality, because the thread which incremented open count past _min might get exception
-                // on NpgsqlConnector.Open due to timeout, CancellationToken or other reasons.
-                if (numConnectors >= _minSessionSize)
+                // on NpgsqlSession.Open due to timeout, CancellationToken or other reasons.
+                if (numSessions >= _minSessionSize)
                 {
                     UpdatePruningTimer();
                 }
@@ -164,9 +164,9 @@ private async ValueTask<IPoolingSession> RentAsync(CancellationToken cancellatio
             catch
             {
                 // Physical open failed, decrement the open and busy counter back down.
-                Interlocked.Decrement(ref _numConnectors);
+                Interlocked.Decrement(ref _numSessions);
 
-                // In case there's a waiting attempt on the channel, we write a null to the idle connector channel
+                // In case there's a waiting attempt on the channel, we write a null to the idle session channel
                 // to wake it up, so it will try opening (and probably throw immediately)
                 // Statement order is important since we have synchronous completions on the channel.
                 _idleSessionWriter.TryWrite(null);
@@ -220,15 +220,15 @@ private void CloseSession(IPoolingSession session)
     {
         session.DeleteSession();
 
-        var numConnectors = Interlocked.Decrement(ref _numConnectors);
+        var numSessions = Interlocked.Decrement(ref _numSessions);
 
-        // If a connector has been closed for any reason, we write a null to the idle connector channel to wake up
+        // If a session has been closed for any reason, we write a null to the idle session channel to wake up
         // a waiter, who will open a new physical connection
         // Statement order is important since we have synchronous completions on the channel.
         _idleSessionWriter.TryWrite(null);
 
         // Only turn off the timer one time, when it was this Close that brought Open back to _min.
-        if (numConnectors == _minSessionSize)
+        if (numSessions == _minSessionSize)
         {
             UpdatePruningTimer();
         }
@@ -238,13 +238,13 @@ private void UpdatePruningTimer()
     {
         lock (_pruningTimer)
         {
-            var numConnectors = _numConnectors;
-            if (numConnectors > _minSessionSize && !_pruningTimerEnabled)
+            var numSessions = _numSessions;
+            if (numSessions > _minSessionSize && !_pruningTimerEnabled)
             {
                 _pruningTimerEnabled = true;
                 _pruningTimer.Change(_pruningSamplingInterval, Timeout.InfiniteTimeSpan);
             }
-            else if (numConnectors <= _minSessionSize && _pruningTimerEnabled)
+            else if (numSessions <= _minSessionSize && _pruningTimerEnabled)
             {
                 _pruningTimer.Change(Timeout.Infinite, Timeout.Infinite);
                 _pruningSampleIndex = 0;
@@ -285,7 +285,7 @@ private static void PruneIdleSessions(object? state)
         }
 
         while (toPrune > 0 &&
-               pool._numConnectors > pool._minSessionSize &&
+               pool._numSessions > pool._minSessionSize &&
                pool._idleSessionReader.TryRead(out var session) &&
                session != null)
         {
diff --git a/src/Ydb.Sdk/src/Pool/SessionPool.cs b/src/Ydb.Sdk/src/Pool/SessionPool.cs
@@ -231,7 +231,7 @@ StatusCode.SessionExpired or
             StatusCode.ClientTransportTimeout or
             StatusCode.ClientTransportUnavailable)
         {
-            _logger.LogWarning("Session[{SessionId}] is deactivated. Reason StatusCode: {Code}", SessionId, code);
+            _logger.LogWarning("Session[{SessionId}] is deactivated. Reason Status: {Status}", SessionId, code);
 
             IsActive = false;
         }
diff --git a/src/Ydb.Sdk/test/Ydb.Sdk.Ado.Tests/Session/PoolingSessionTests.cs b/src/Ydb.Sdk/test/Ydb.Sdk.Ado.Tests/Session/PoolingSessionTests.cs

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ namespace Ydb.Sdk.Ado.Session;`
`2`	`2`
`3`	`3`	`internal interface ISessionSource<TSession> where TSession : ISession`
`4`	`4`	`{`
`5`		`- ValueTask<TSession> OpenSession(CancellationToken cancellationToken = default);`
	`5`	`+ ValueTask<TSession> OpenSession(CancellationToken cancellationToken);`
`6`	`6`
`7`	`7`	`void Return(TSession session);`
`8`	`8`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,10 +17,11 @@ internal class PoolingSession : IPoolingSession`
`17`	`17`
`18`	`18`	`private readonly IDriver _driver;`
`19`	`19`	`private readonly PoolingSessionSource _poolingSessionSource;`
`20`		`- private readonly YdbConnectionStringBuilder _settings;`
`21`	`20`	`private readonly ILogger<PoolingSession> _logger;`
`22`	`21`
`23`		`- private volatile bool _isBroken;`
	`22`	`+ private volatile bool _isBroken = true;`
	`23`	`+`
	`24`	`+ private readonly bool _disableServerBalancer;`
`24`	`25`
`25`	`26`	`private string SessionId { get; set; } = string.Empty;`
`26`	`27`	`private long NodeId { get; set; }`
`@@ -30,13 +31,13 @@ internal class PoolingSession : IPoolingSession`
`30`	`31`	`internal PoolingSession(`
`31`	`32`	`IDriver driver,`
`32`	`33`	`PoolingSessionSource poolingSessionSource,`
`33`		`- YdbConnectionStringBuilder settings,`
	`34`	`+ bool disableServerBalancer,`
`34`	`35`	`ILogger<PoolingSession> logger`
`35`	`36`	`)`
`36`	`37`	`{`
`37`	`38`	`_driver = driver;`
`38`	`39`	`_poolingSessionSource = poolingSessionSource;`
`39`		`- _settings = settings;`
	`40`	`+ _disableServerBalancer = disableServerBalancer;`
`40`	`41`	`_logger = logger;`
`41`	`42`	`}`
`42`	`43`
`@@ -96,18 +97,16 @@ public async Task RollbackTransaction(`
`96`	`97`	`}`
`97`	`98`	`}`
`98`	`99`
`99`		`- public void OnNotSuccessStatusCode(StatusCode code)`
	`100`	`+ public void OnNotSuccessStatusCode(StatusCode statusCode)`
`100`	`101`	`{`
`101`		`- if (code is`
`102`		`- StatusCode.Cancelled or`
	`102`	`+ if (statusCode is`
`103`	`103`	`StatusCode.BadSession or`
`104`	`104`	`StatusCode.SessionBusy or`
`105`		`- StatusCode.InternalError or`
	`105`	`+ StatusCode.SessionExpired or`
`106`	`106`	`StatusCode.ClientTransportTimeout or`
`107`		`- StatusCode.Unavailable or`
`108`	`107`	`StatusCode.ClientTransportUnavailable)`
`109`	`108`	`{`
`110`		`- _logger.LogWarning("Session[{SessionId}] is deactivated. Reason StatusCode: {Code}", SessionId, code);`
	`109`	`+ _logger.LogWarning("Session[{SessionId}] is deactivated. Reason Status: {Status}", SessionId, statusCode);`
`111`	`110`
`112`	`111`	`_isBroken = true;`
`113`	`112`	`}`
`@@ -117,7 +116,7 @@ public async Task Open(CancellationToken cancellationToken)`
`117`	`116`	`{`
`118`	`117`	`var requestSettings = new GrpcRequestSettings { CancellationToken = cancellationToken };`
`119`	`118`
`120`		`- if (!_settings.DisableServerBalancer)`
	`119`	`+ if (!_disableServerBalancer)`
`121`	`120`	`{`
`122`	`121`	`requestSettings.ClientCapabilities.Add(SessionBalancer);`
`123`	`122`	`}`
`@@ -133,6 +132,7 @@ public async Task Open(CancellationToken cancellationToken)`
`133`	`132`
`134`	`133`	`SessionId = response.SessionId;`
`135`	`134`	`NodeId = response.NodeId;`
	`135`	`+ _isBroken = false;`
`136`	`136`
`137`	`137`	`_ = Task.Run(async () =>`
`138`	`138`	`{`
`@@ -188,7 +188,7 @@ public async Task Open(CancellationToken cancellationToken)`
`188`	`188`	`}`
`189`	`189`	`catch (YdbException e)`
`190`	`190`	`{`
`191`		`- if (e.Code == StatusCode.Cancelled)`
	`191`	`+ if (e.Code == StatusCode.ClientTransportTimeout)`
`192`	`192`	`{`
`193`	`193`	`_logger.LogDebug("AttachStream is cancelled (possible grpcChannel is closing)");`
`194`	`194`
Original file line number	Diff line number	Diff line change
`@@ -5,16 +5,16 @@ namespace Ydb.Sdk.Ado.Session;`
`5`	`5`	`internal class PoolingSessionFactory : IPoolingSessionFactory`
`6`	`6`	`{`
`7`	`7`	`private readonly IDriver _driver;`
`8`		`- private readonly YdbConnectionStringBuilder _settings;`
	`8`	`+ private readonly bool _disableServerBalancer;`
`9`	`9`	`private readonly ILogger<PoolingSession> _logger;`
`10`	`10`
`11`		`- public PoolingSessionFactory(IDriver driver, YdbConnectionStringBuilder settings, ILogger<PoolingSession> logger)`
	`11`	`+ public PoolingSessionFactory(IDriver driver, YdbConnectionStringBuilder settings, ILoggerFactory loggerFactory)`
`12`	`12`	`{`
`13`	`13`	`_driver = driver;`
`14`		`- _settings = settings;`
`15`		`- _logger = logger;`
	`14`	`+ _disableServerBalancer = settings.DisableServerBalancer;`
	`15`	`+ _logger = loggerFactory.CreateLogger<PoolingSession>();`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`public IPoolingSession NewSession(PoolingSessionSource source) =>`
`19`		`- new PoolingSession(_driver, source, _settings, _logger);`
	`19`	`+ new PoolingSession(_driver, source, _disableServerBalancer, _logger);`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ internal sealed class PoolingSessionSource : ISessionSource<IPoolingSession>`
`31`	`31`	`private volatile bool _pruningTimerEnabled;`
`32`	`32`	`private int _pruningSampleIndex;`
`33`	`33`
`34`		`- private volatile int _numConnectors;`
	`34`	`+ private volatile int _numSessions;`
`35`	`35`	`private volatile int _idleCount;`
`36`	`36`
`37`	`37`	`public PoolingSessionSource(`
`@@ -111,15 +111,15 @@ private async ValueTask<IPoolingSession> RentAsync(CancellationToken cancellatio`
`111`	`111`	`return session;`
`112`	`112`	`}`
`113`	`113`
`114`		`- // If we're here, our waiting attempt on the idle connector channel was released with a null`
`115`		`- // (or bad connector), or we're in sync mode. Check again if a new idle connector has appeared since we last checked.`
	`114`	`+ // If we're here, our waiting attempt on the idle session channel was released with a null`
	`115`	`+ // (or bad session), or we're in sync mode. Check again if a new idle session has appeared since we last checked.`
`116`	`116`	`if (TryGetIdleSession(out session))`
`117`	`117`	`{`
`118`	`118`	`return session;`
`119`	`119`	`}`
`120`	`120`
`121`		`- // We might have closed a connector in the meantime and no longer be at max capacity`
`122`		`- // so try to open a new connector and if that fails, loop again.`
	`121`	`+ // We might have closed a session in the meantime and no longer be at max capacity`
	`122`	`+ // so try to open a new session and if that fails, loop again.`
`123`	`123`	`session = await OpenNewSession(finalToken).ConfigureAwait(false);`
`124`	`124`	`if (session != null)`
`125`	`125`	`{`
`@@ -139,9 +139,9 @@ private async ValueTask<IPoolingSession> RentAsync(CancellationToken cancellatio`
`139`	`139`
`140`	`140`	`private async ValueTask<IPoolingSession?> OpenNewSession(CancellationToken cancellationToken)`
`141`	`141`	`{`
`142`		`- for (var numConnectors = _numConnectors; numConnectors < _maxSessionSize; numConnectors = _numConnectors)`
	`142`	`+ for (var numSessions = _numSessions; numSessions < _maxSessionSize; numSessions = _numSessions)`
`143`	`143`	`{`
`144`		`- if (Interlocked.CompareExchange(ref _numConnectors, numConnectors + 1, numConnectors) != numConnectors)`
	`144`	`+ if (Interlocked.CompareExchange(ref _numSessions, numSessions + 1, numSessions) != numSessions)`
`145`	`145`	`{`
`146`	`146`	`continue;`
`147`	`147`	`}`
`@@ -153,8 +153,8 @@ private async ValueTask<IPoolingSession> RentAsync(CancellationToken cancellatio`
`153`	`153`
`154`	`154`	`// Only start pruning if we've incremented open count past _min.`
`155`	`155`	`// Note that we don't do it only once, on equality, because the thread which incremented open count past _min might get exception`
`156`		`- // on NpgsqlConnector.Open due to timeout, CancellationToken or other reasons.`
`157`		`- if (numConnectors >= _minSessionSize)`
	`156`	`+ // on NpgsqlSession.Open due to timeout, CancellationToken or other reasons.`
	`157`	`+ if (numSessions >= _minSessionSize)`
`158`	`158`	`{`
`159`	`159`	`UpdatePruningTimer();`
`160`	`160`	`}`
`@@ -164,9 +164,9 @@ private async ValueTask<IPoolingSession> RentAsync(CancellationToken cancellatio`
`164`	`164`	`catch`
`165`	`165`	`{`
`166`	`166`	`// Physical open failed, decrement the open and busy counter back down.`
`167`		`- Interlocked.Decrement(ref _numConnectors);`
	`167`	`+ Interlocked.Decrement(ref _numSessions);`
`168`	`168`
`169`		`- // In case there's a waiting attempt on the channel, we write a null to the idle connector channel`
	`169`	`+ // In case there's a waiting attempt on the channel, we write a null to the idle session channel`
`170`	`170`	`// to wake it up, so it will try opening (and probably throw immediately)`
`171`	`171`	`// Statement order is important since we have synchronous completions on the channel.`
`172`	`172`	`_idleSessionWriter.TryWrite(null);`
`@@ -220,15 +220,15 @@ private void CloseSession(IPoolingSession session)`
`220`	`220`	`{`
`221`	`221`	`session.DeleteSession();`
`222`	`222`
`223`		`- var numConnectors = Interlocked.Decrement(ref _numConnectors);`
	`223`	`+ var numSessions = Interlocked.Decrement(ref _numSessions);`
`224`	`224`
`225`		`- // If a connector has been closed for any reason, we write a null to the idle connector channel to wake up`
	`225`	`+ // If a session has been closed for any reason, we write a null to the idle session channel to wake up`
`226`	`226`	`// a waiter, who will open a new physical connection`
`227`	`227`	`// Statement order is important since we have synchronous completions on the channel.`
`228`	`228`	`_idleSessionWriter.TryWrite(null);`
`229`	`229`
`230`	`230`	`// Only turn off the timer one time, when it was this Close that brought Open back to _min.`
`231`		`- if (numConnectors == _minSessionSize)`
	`231`	`+ if (numSessions == _minSessionSize)`
`232`	`232`	`{`
`233`	`233`	`UpdatePruningTimer();`
`234`	`234`	`}`
`@@ -238,13 +238,13 @@ private void UpdatePruningTimer()`
`238`	`238`	`{`
`239`	`239`	`lock (_pruningTimer)`
`240`	`240`	`{`
`241`		`- var numConnectors = _numConnectors;`
`242`		`- if (numConnectors > _minSessionSize && !_pruningTimerEnabled)`
	`241`	`+ var numSessions = _numSessions;`
	`242`	`+ if (numSessions > _minSessionSize && !_pruningTimerEnabled)`
`243`	`243`	`{`
`244`	`244`	`_pruningTimerEnabled = true;`
`245`	`245`	`_pruningTimer.Change(_pruningSamplingInterval, Timeout.InfiniteTimeSpan);`
`246`	`246`	`}`
`247`		`- else if (numConnectors <= _minSessionSize && _pruningTimerEnabled)`
	`247`	`+ else if (numSessions <= _minSessionSize && _pruningTimerEnabled)`
`248`	`248`	`{`
`249`	`249`	`_pruningTimer.Change(Timeout.Infinite, Timeout.Infinite);`
`250`	`250`	`_pruningSampleIndex = 0;`
`@@ -285,7 +285,7 @@ private static void PruneIdleSessions(object? state)`
`285`	`285`	`}`
`286`	`286`
`287`	`287`	`while (toPrune > 0 &&`
`288`		`- pool._numConnectors > pool._minSessionSize &&`
	`288`	`+ pool._numSessions > pool._minSessionSize &&`
`289`	`289`	`pool._idleSessionReader.TryRead(out var session) &&`
`290`	`290`	`session != null)`
`291`	`291`	`{`
Original file line number	Diff line number	Diff line change
`@@ -231,7 +231,7 @@ StatusCode.SessionExpired or`
`231`	`231`	`StatusCode.ClientTransportTimeout or`
`232`	`232`	`StatusCode.ClientTransportUnavailable)`
`233`	`233`	`{`
`234`		`- _logger.LogWarning("Session[{SessionId}] is deactivated. Reason StatusCode: {Code}", SessionId, code);`
	`234`	`+ _logger.LogWarning("Session[{SessionId}] is deactivated. Reason Status: {Status}", SessionId, code);`
`235`	`235`
`236`	`236`	`IsActive = false;`
`237`	`237`	`}`