[2.1.6] | Fix async deadlock issue when sending attention fails due to network errors (#1767)

cheenamalhotra · web-flow · commit 872a9bc588df · 2023-04-24T10:02:05.000-07:00
diff --git a/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/TdsParserStateObject.cs b/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/TdsParserStateObject.cs
@@ -55,7 +55,7 @@ public TimeoutState(int value)
 
         private const int AttentionTimeoutSeconds = 5;
 
-        private static readonly ContextCallback s_readAdyncCallbackComplete = ReadAsyncCallbackComplete;
+        private static readonly ContextCallback s_readAsyncCallbackComplete = ReadAsyncCallbackComplete;
 
         // Ticks to consider a connection "good" after a successful I/O (10,000 ticks = 1 ms)
         // The resolution of the timer is typically in the range 10 to 16 milliseconds according to msdn.
@@ -2308,9 +2308,9 @@ private void OnTimeoutAsync(object state)
             }
         }
 
-        private bool OnTimeoutSync()
+        private bool OnTimeoutSync(bool asyncClose = false)
         {
-            return OnTimeoutCore(TimeoutState.Running, TimeoutState.ExpiredSync);
+            return OnTimeoutCore(TimeoutState.Running, TimeoutState.ExpiredSync, asyncClose);
         }
 
         /// <summary>
@@ -2319,8 +2319,9 @@ private bool OnTimeoutSync()
         /// </summary>
         /// <param name="expectedState">the state that is the expected current state, state will change only if this is correct</param>
         /// <param name="targetState">the state that will be changed to if the expected state is correct</param>
+        /// <param name="asyncClose">any close action to be taken by an async task to avoid deadlock.</param>
         /// <returns>boolean value indicating whether the call changed the timeout state</returns>
-        private bool OnTimeoutCore(int expectedState, int targetState)
+        private bool OnTimeoutCore(int expectedState, int targetState, bool asyncClose = false)
         {
             Debug.Assert(targetState == TimeoutState.ExpiredAsync || targetState == TimeoutState.ExpiredSync, "OnTimeoutCore must have an expiry state as the targetState");
 
@@ -2353,7 +2354,7 @@ private bool OnTimeoutCore(int expectedState, int targetState)
                         {
                             try
                             {
-                                SendAttention(mustTakeWriteLock: true);
+                                SendAttention(mustTakeWriteLock: true, asyncClose);
                             }
                             catch (Exception e)
                             {
@@ -2893,7 +2894,7 @@ public void ReadAsyncCallback(IntPtr key, PacketHandle packet, uint error)
                 // synchrnously and then call OnTimeoutSync to force an atomic change of state. 
                 if (TimeoutHasExpired)
                 {
-                    OnTimeoutSync();
+                    OnTimeoutSync(true);
                 }
 
                 // try to change to the stopped state but only do so if currently in the running state
@@ -2924,7 +2925,7 @@ public void ReadAsyncCallback(IntPtr key, PacketHandle packet, uint error)
                     {
                         if (_executionContext != null)
                         {
-                            ExecutionContext.Run(_executionContext, s_readAdyncCallbackComplete, source);
+                            ExecutionContext.Run(_executionContext, s_readAsyncCallbackComplete, source);
                         }
                         else
                         {
@@ -3407,7 +3408,7 @@ private void CancelWritePacket()
 
 #pragma warning disable 0420 // a reference to a volatile field will not be treated as volatile
 
-        private Task SNIWritePacket(PacketHandle packet, out uint sniError, bool canAccumulate, bool callerHasConnectionLock)
+        private Task SNIWritePacket(PacketHandle packet, out uint sniError, bool canAccumulate, bool callerHasConnectionLock, bool asyncClose = false)
         {
             // Check for a stored exception
             var delayedException = Interlocked.Exchange(ref _delayedWriteAsyncCallbackException, null);
@@ -3500,7 +3501,7 @@ private Task SNIWritePacket(PacketHandle packet, out uint sniError, bool canAccu
                         {
                             SqlClientEventSource.Log.TryTraceEvent("<sc.TdsParser.WritePacket|Info> write async returned error code {0}", (int)error);
                             AddError(_parser.ProcessSNIError(this));
-                            ThrowExceptionAndWarning();
+                            ThrowExceptionAndWarning(false, asyncClose);
                         }
                         AssertValidState();
                         completion.SetResult(null);
@@ -3535,7 +3536,7 @@ private Task SNIWritePacket(PacketHandle packet, out uint sniError, bool canAccu
                 {
                     SqlClientEventSource.Log.TryTraceEvent("<sc.TdsParser.WritePacket|Info> write async returned error code {0}", (int)sniError);
                     AddError(_parser.ProcessSNIError(this));
-                    ThrowExceptionAndWarning(callerHasConnectionLock);
+                    ThrowExceptionAndWarning(callerHasConnectionLock, asyncClose);
                 }
                 AssertValidState();
             }
@@ -3547,7 +3548,7 @@ private Task SNIWritePacket(PacketHandle packet, out uint sniError, bool canAccu
         internal abstract uint WritePacket(PacketHandle packet, bool sync);
 
         // Sends an attention signal - executing thread will consume attn.
-        internal void SendAttention(bool mustTakeWriteLock = false)
+        internal void SendAttention(bool mustTakeWriteLock = false, bool asyncClose = false)
         {
             if (!_attentionSent)
             {
@@ -3589,7 +3590,7 @@ internal void SendAttention(bool mustTakeWriteLock = false)
 
                             uint sniError;
                             _parser._asyncWrite = false; // stop async write 
-                            SNIWritePacket(attnPacket, out sniError, canAccumulate: false, callerHasConnectionLock: false);
+                            SNIWritePacket(attnPacket, out sniError, canAccumulate: false, callerHasConnectionLock: false, asyncClose);
                             SqlClientEventSource.Log.TryTraceEvent("<sc.TdsParser.SendAttention|INFO> Send Attention ASync.");
                         }
                         finally
diff --git a/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/TdsParserStateObject.cs b/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/TdsParserStateObject.cs
@@ -2390,9 +2390,9 @@ private void OnTimeoutAsync(object state)
             }
         }
 
-        private bool OnTimeoutSync()
+        private bool OnTimeoutSync(bool asyncClose = false)
         {
-            return OnTimeoutCore(TimeoutState.Running, TimeoutState.ExpiredSync);
+            return OnTimeoutCore(TimeoutState.Running, TimeoutState.ExpiredSync, asyncClose);
         }
 
         /// <summary>
@@ -2401,8 +2401,9 @@ private bool OnTimeoutSync()
         /// </summary>
         /// <param name="expectedState">the state that is the expected current state, state will change only if this is correct</param>
         /// <param name="targetState">the state that will be changed to if the expected state is correct</param>
+        /// <param name="asyncClose">any close action to be taken by an async task to avoid deadlock.</param>
         /// <returns>boolean value indicating whether the call changed the timeout state</returns>
-        private bool OnTimeoutCore(int expectedState, int targetState)
+        private bool OnTimeoutCore(int expectedState, int targetState, bool asyncClose = false)
         {
             Debug.Assert(targetState == TimeoutState.ExpiredAsync || targetState == TimeoutState.ExpiredSync, "OnTimeoutCore must have an expiry state as the targetState");
 
@@ -2436,7 +2437,7 @@ private bool OnTimeoutCore(int expectedState, int targetState)
                         {
                             try
                             {
-                                SendAttention(mustTakeWriteLock: true);
+                                SendAttention(mustTakeWriteLock: true, asyncClose);
                             }
                             catch (Exception e)
                             {
@@ -2978,7 +2979,7 @@ public void ReadAsyncCallback(IntPtr key, IntPtr packet, UInt32 error)
                 // synchrnously and then call OnTimeoutSync to force an atomic change of state.
                 if (TimeoutHasExpired)
                 {
-                    OnTimeoutSync();
+                    OnTimeoutSync(asyncClose: true);
                 }
 
                 // try to change to the stopped state but only do so if currently in the running state
@@ -3464,7 +3465,7 @@ private void CancelWritePacket()
 
 #pragma warning disable 420 // a reference to a volatile field will not be treated as volatile
 
-        private Task SNIWritePacket(SNIHandle handle, SNIPacket packet, out UInt32 sniError, bool canAccumulate, bool callerHasConnectionLock)
+        private Task SNIWritePacket(SNIHandle handle, SNIPacket packet, out UInt32 sniError, bool canAccumulate, bool callerHasConnectionLock, bool asyncClose = false)
         {
             // Check for a stored exception
             var delayedException = Interlocked.Exchange(ref _delayedWriteAsyncCallbackException, null);
@@ -3555,7 +3556,7 @@ private Task SNIWritePacket(SNIHandle handle, SNIPacket packet, out UInt32 sniEr
                             SqlClientEventSource.Log.TryTraceEvent("<sc.TdsParser.WritePacket|Info> write async returned error code {0}", (int)error);
 
                             AddError(_parser.ProcessSNIError(this));
-                            ThrowExceptionAndWarning();
+                            ThrowExceptionAndWarning(false, asyncClose);
                         }
                         AssertValidState();
                         completion.SetResult(null);
@@ -3592,7 +3593,7 @@ private Task SNIWritePacket(SNIHandle handle, SNIPacket packet, out UInt32 sniEr
                 {
                     SqlClientEventSource.Log.TryTraceEvent("<sc.TdsParser.WritePacket|Info> write async returned error code {0}", (int)sniError);
                     AddError(_parser.ProcessSNIError(this));
-                    ThrowExceptionAndWarning(callerHasConnectionLock);
+                    ThrowExceptionAndWarning(callerHasConnectionLock, false);
                 }
                 AssertValidState();
             }
@@ -3602,7 +3603,7 @@ private Task SNIWritePacket(SNIHandle handle, SNIPacket packet, out UInt32 sniEr
 #pragma warning restore 420 
 
         // Sends an attention signal - executing thread will consume attn.
-        internal void SendAttention(bool mustTakeWriteLock = false)
+        internal void SendAttention(bool mustTakeWriteLock = false, bool asyncClose = false)
         {
             if (!_attentionSent)
             {
@@ -3649,7 +3650,7 @@ internal void SendAttention(bool mustTakeWriteLock = false)
 
                             UInt32 sniError;
                             _parser._asyncWrite = false; // stop async write 
-                            SNIWritePacket(Handle, attnPacket, out sniError, canAccumulate: false, callerHasConnectionLock: false);
+                            SNIWritePacket(Handle, attnPacket, out sniError, canAccumulate: false, callerHasConnectionLock: false, asyncClose);
                             SqlClientEventSource.Log.TryTraceEvent("<sc.TdsParser.SendAttention|{0}> Send Attention ASync.", "Info");
                         }
                         finally

Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ public TimeoutState(int value)`
`55`	`55`
`56`	`56`	`private const int AttentionTimeoutSeconds = 5;`
`57`	`57`
`58`		`- private static readonly ContextCallback s_readAdyncCallbackComplete = ReadAsyncCallbackComplete;`
	`58`	`+ private static readonly ContextCallback s_readAsyncCallbackComplete = ReadAsyncCallbackComplete;`
`59`	`59`
`60`	`60`	`// Ticks to consider a connection "good" after a successful I/O (10,000 ticks = 1 ms)`
`61`	`61`	`// The resolution of the timer is typically in the range 10 to 16 milliseconds according to msdn.`
`@@ -2308,9 +2308,9 @@ private void OnTimeoutAsync(object state)`
`2308`	`2308`	`}`
`2309`	`2309`	`}`
`2310`	`2310`
`2311`		`- private bool OnTimeoutSync()`
	`2311`	`+ private bool OnTimeoutSync(bool asyncClose = false)`
`2312`	`2312`	`{`
`2313`		`- return OnTimeoutCore(TimeoutState.Running, TimeoutState.ExpiredSync);`
	`2313`	`+ return OnTimeoutCore(TimeoutState.Running, TimeoutState.ExpiredSync, asyncClose);`
`2314`	`2314`	`}`
`2315`	`2315`
`2316`	`2316`	`/// <summary>`
`@@ -2319,8 +2319,9 @@ private bool OnTimeoutSync()`
`2319`	`2319`	`/// </summary>`
`2320`	`2320`	`/// <param name="expectedState">the state that is the expected current state, state will change only if this is correct</param>`
`2321`	`2321`	`/// <param name="targetState">the state that will be changed to if the expected state is correct</param>`
	`2322`	`+ /// <param name="asyncClose">any close action to be taken by an async task to avoid deadlock.</param>`
`2322`	`2323`	`/// <returns>boolean value indicating whether the call changed the timeout state</returns>`
`2323`		`- private bool OnTimeoutCore(int expectedState, int targetState)`
	`2324`	`+ private bool OnTimeoutCore(int expectedState, int targetState, bool asyncClose = false)`
`2324`	`2325`	`{`
`2325`	`2326`	`Debug.Assert(targetState == TimeoutState.ExpiredAsync \|\| targetState == TimeoutState.ExpiredSync, "OnTimeoutCore must have an expiry state as the targetState");`
`2326`	`2327`
`@@ -2353,7 +2354,7 @@ private bool OnTimeoutCore(int expectedState, int targetState)`
`2353`	`2354`	`{`
`2354`	`2355`	`try`
`2355`	`2356`	`{`
`2356`		`- SendAttention(mustTakeWriteLock: true);`
	`2357`	`+ SendAttention(mustTakeWriteLock: true, asyncClose);`
`2357`	`2358`	`}`
`2358`	`2359`	`catch (Exception e)`
`2359`	`2360`	`{`
`@@ -2893,7 +2894,7 @@ public void ReadAsyncCallback(IntPtr key, PacketHandle packet, uint error)`
`2893`	`2894`	`// synchrnously and then call OnTimeoutSync to force an atomic change of state.`
`2894`	`2895`	`if (TimeoutHasExpired)`
`2895`	`2896`	`{`
`2896`		`- OnTimeoutSync();`
	`2897`	`+ OnTimeoutSync(true);`
`2897`	`2898`	`}`
`2898`	`2899`
`2899`	`2900`	`// try to change to the stopped state but only do so if currently in the running state`
`@@ -2924,7 +2925,7 @@ public void ReadAsyncCallback(IntPtr key, PacketHandle packet, uint error)`
`2924`	`2925`	`{`
`2925`	`2926`	`if (_executionContext != null)`
`2926`	`2927`	`{`
`2927`		`- ExecutionContext.Run(_executionContext, s_readAdyncCallbackComplete, source);`
	`2928`	`+ ExecutionContext.Run(_executionContext, s_readAsyncCallbackComplete, source);`
`2928`	`2929`	`}`
`2929`	`2930`	`else`
`2930`	`2931`	`{`
`@@ -3407,7 +3408,7 @@ private void CancelWritePacket()`
`3407`	`3408`
`3408`	`3409`	`#pragma warning disable 0420 // a reference to a volatile field will not be treated as volatile`
`3409`	`3410`
`3410`		`- private Task SNIWritePacket(PacketHandle packet, out uint sniError, bool canAccumulate, bool callerHasConnectionLock)`
	`3411`	`+ private Task SNIWritePacket(PacketHandle packet, out uint sniError, bool canAccumulate, bool callerHasConnectionLock, bool asyncClose = false)`
`3411`	`3412`	`{`
`3412`	`3413`	`// Check for a stored exception`
`3413`	`3414`	`var delayedException = Interlocked.Exchange(ref _delayedWriteAsyncCallbackException, null);`
`@@ -3500,7 +3501,7 @@ private Task SNIWritePacket(PacketHandle packet, out uint sniError, bool canAccu`
`3500`	`3501`	`{`
`3501`	`3502`	`SqlClientEventSource.Log.TryTraceEvent("<sc.TdsParser.WritePacket\|Info> write async returned error code {0}", (int)error);`
`3502`	`3503`	`AddError(_parser.ProcessSNIError(this));`
`3503`		`- ThrowExceptionAndWarning();`
	`3504`	`+ ThrowExceptionAndWarning(false, asyncClose);`
`3504`	`3505`	`}`
`3505`	`3506`	`AssertValidState();`
`3506`	`3507`	`completion.SetResult(null);`
`@@ -3535,7 +3536,7 @@ private Task SNIWritePacket(PacketHandle packet, out uint sniError, bool canAccu`
`3535`	`3536`	`{`
`3536`	`3537`	`SqlClientEventSource.Log.TryTraceEvent("<sc.TdsParser.WritePacket\|Info> write async returned error code {0}", (int)sniError);`
`3537`	`3538`	`AddError(_parser.ProcessSNIError(this));`
`3538`		`- ThrowExceptionAndWarning(callerHasConnectionLock);`
	`3539`	`+ ThrowExceptionAndWarning(callerHasConnectionLock, asyncClose);`
`3539`	`3540`	`}`
`3540`	`3541`	`AssertValidState();`
`3541`	`3542`	`}`
`@@ -3547,7 +3548,7 @@ private Task SNIWritePacket(PacketHandle packet, out uint sniError, bool canAccu`
`3547`	`3548`	`internal abstract uint WritePacket(PacketHandle packet, bool sync);`
`3548`	`3549`
`3549`	`3550`	`// Sends an attention signal - executing thread will consume attn.`
`3550`		`- internal void SendAttention(bool mustTakeWriteLock = false)`
	`3551`	`+ internal void SendAttention(bool mustTakeWriteLock = false, bool asyncClose = false)`
`3551`	`3552`	`{`
`3552`	`3553`	`if (!_attentionSent)`
`3553`	`3554`	`{`
`@@ -3589,7 +3590,7 @@ internal void SendAttention(bool mustTakeWriteLock = false)`
`3589`	`3590`
`3590`	`3591`	`uint sniError;`
`3591`	`3592`	`_parser._asyncWrite = false; // stop async write`
`3592`		`- SNIWritePacket(attnPacket, out sniError, canAccumulate: false, callerHasConnectionLock: false);`
	`3593`	`+ SNIWritePacket(attnPacket, out sniError, canAccumulate: false, callerHasConnectionLock: false, asyncClose);`
`3593`	`3594`	`SqlClientEventSource.Log.TryTraceEvent("<sc.TdsParser.SendAttention\|INFO> Send Attention ASync.");`
`3594`	`3595`	`}`
`3595`	`3596`	`finally`
Original file line number	Diff line number	Diff line change
`@@ -2390,9 +2390,9 @@ private void OnTimeoutAsync(object state)`
`2390`	`2390`	`}`
`2391`	`2391`	`}`
`2392`	`2392`
`2393`		`- private bool OnTimeoutSync()`
	`2393`	`+ private bool OnTimeoutSync(bool asyncClose = false)`
`2394`	`2394`	`{`
`2395`		`- return OnTimeoutCore(TimeoutState.Running, TimeoutState.ExpiredSync);`
	`2395`	`+ return OnTimeoutCore(TimeoutState.Running, TimeoutState.ExpiredSync, asyncClose);`
`2396`	`2396`	`}`
`2397`	`2397`
`2398`	`2398`	`/// <summary>`
`@@ -2401,8 +2401,9 @@ private bool OnTimeoutSync()`
`2401`	`2401`	`/// </summary>`
`2402`	`2402`	`/// <param name="expectedState">the state that is the expected current state, state will change only if this is correct</param>`
`2403`	`2403`	`/// <param name="targetState">the state that will be changed to if the expected state is correct</param>`
	`2404`	`+ /// <param name="asyncClose">any close action to be taken by an async task to avoid deadlock.</param>`
`2404`	`2405`	`/// <returns>boolean value indicating whether the call changed the timeout state</returns>`
`2405`		`- private bool OnTimeoutCore(int expectedState, int targetState)`
	`2406`	`+ private bool OnTimeoutCore(int expectedState, int targetState, bool asyncClose = false)`
`2406`	`2407`	`{`
`2407`	`2408`	`Debug.Assert(targetState == TimeoutState.ExpiredAsync \|\| targetState == TimeoutState.ExpiredSync, "OnTimeoutCore must have an expiry state as the targetState");`
`2408`	`2409`
`@@ -2436,7 +2437,7 @@ private bool OnTimeoutCore(int expectedState, int targetState)`
`2436`	`2437`	`{`
`2437`	`2438`	`try`
`2438`	`2439`	`{`
`2439`		`- SendAttention(mustTakeWriteLock: true);`
	`2440`	`+ SendAttention(mustTakeWriteLock: true, asyncClose);`
`2440`	`2441`	`}`
`2441`	`2442`	`catch (Exception e)`
`2442`	`2443`	`{`
`@@ -2978,7 +2979,7 @@ public void ReadAsyncCallback(IntPtr key, IntPtr packet, UInt32 error)`
`2978`	`2979`	`// synchrnously and then call OnTimeoutSync to force an atomic change of state.`
`2979`	`2980`	`if (TimeoutHasExpired)`
`2980`	`2981`	`{`
`2981`		`- OnTimeoutSync();`
	`2982`	`+ OnTimeoutSync(asyncClose: true);`
`2982`	`2983`	`}`
`2983`	`2984`
`2984`	`2985`	`// try to change to the stopped state but only do so if currently in the running state`
`@@ -3464,7 +3465,7 @@ private void CancelWritePacket()`
`3464`	`3465`
`3465`	`3466`	`#pragma warning disable 420 // a reference to a volatile field will not be treated as volatile`
`3466`	`3467`
`3467`		`- private Task SNIWritePacket(SNIHandle handle, SNIPacket packet, out UInt32 sniError, bool canAccumulate, bool callerHasConnectionLock)`
	`3468`	`+ private Task SNIWritePacket(SNIHandle handle, SNIPacket packet, out UInt32 sniError, bool canAccumulate, bool callerHasConnectionLock, bool asyncClose = false)`
`3468`	`3469`	`{`
`3469`	`3470`	`// Check for a stored exception`
`3470`	`3471`	`var delayedException = Interlocked.Exchange(ref _delayedWriteAsyncCallbackException, null);`
`@@ -3555,7 +3556,7 @@ private Task SNIWritePacket(SNIHandle handle, SNIPacket packet, out UInt32 sniEr`
`3555`	`3556`	`SqlClientEventSource.Log.TryTraceEvent("<sc.TdsParser.WritePacket\|Info> write async returned error code {0}", (int)error);`
`3556`	`3557`
`3557`	`3558`	`AddError(_parser.ProcessSNIError(this));`
`3558`		`- ThrowExceptionAndWarning();`
	`3559`	`+ ThrowExceptionAndWarning(false, asyncClose);`
`3559`	`3560`	`}`
`3560`	`3561`	`AssertValidState();`
`3561`	`3562`	`completion.SetResult(null);`
`@@ -3592,7 +3593,7 @@ private Task SNIWritePacket(SNIHandle handle, SNIPacket packet, out UInt32 sniEr`
`3592`	`3593`	`{`
`3593`	`3594`	`SqlClientEventSource.Log.TryTraceEvent("<sc.TdsParser.WritePacket\|Info> write async returned error code {0}", (int)sniError);`
`3594`	`3595`	`AddError(_parser.ProcessSNIError(this));`
`3595`		`- ThrowExceptionAndWarning(callerHasConnectionLock);`
	`3596`	`+ ThrowExceptionAndWarning(callerHasConnectionLock, false);`
`3596`	`3597`	`}`
`3597`	`3598`	`AssertValidState();`
`3598`	`3599`	`}`
`@@ -3602,7 +3603,7 @@ private Task SNIWritePacket(SNIHandle handle, SNIPacket packet, out UInt32 sniEr`
`3602`	`3603`	`#pragma warning restore 420`
`3603`	`3604`
`3604`	`3605`	`// Sends an attention signal - executing thread will consume attn.`
`3605`		`- internal void SendAttention(bool mustTakeWriteLock = false)`
	`3606`	`+ internal void SendAttention(bool mustTakeWriteLock = false, bool asyncClose = false)`
`3606`	`3607`	`{`
`3607`	`3608`	`if (!_attentionSent)`
`3608`	`3609`	`{`
`@@ -3649,7 +3650,7 @@ internal void SendAttention(bool mustTakeWriteLock = false)`
`3649`	`3650`
`3650`	`3651`	`UInt32 sniError;`
`3651`	`3652`	`_parser._asyncWrite = false; // stop async write`
`3652`		`- SNIWritePacket(Handle, attnPacket, out sniError, canAccumulate: false, callerHasConnectionLock: false);`
	`3653`	`+ SNIWritePacket(Handle, attnPacket, out sniError, canAccumulate: false, callerHasConnectionLock: false, asyncClose);`
`3653`	`3654`	`SqlClientEventSource.Log.TryTraceEvent("<sc.TdsParser.SendAttention\|{0}> Send Attention ASync.", "Info");`
`3654`	`3655`	`}`
`3655`	`3656`	`finally`