TonOptions: ConcurrencyTimeout and TonClientSyncTimeout added

Author: justdmitry

TonLibDotNet/TonClient.cs

@@ -65,19 +65,21 @@ public static void RegisterAssembly(System.Reflection.Assembly assembly)
             {
                 logger.LogDebug("Reinitializing...");
 
-                if (await syncRoot.WaitAsync(tonOptions.TonClientTimeout))
+                if (!await syncRoot.WaitAsync(tonOptions.ConcurrencyTimeout))
                 {
-                    if (client != null)
-                    {
-                        tonlib_client_json_destroy(client.Value);
-                        client = null;
-                    }
-
-                    initialized = false;
-                    needReinit = false;
+                    throw new TimeoutException("Failed while waiting for semaphore");
+                }
 
-                    syncRoot.Release();
+                if (client != null)
+                {
+                    tonlib_client_json_destroy(client.Value);
+                    client = null;
                 }
+
+                initialized = false;
+                needReinit = false;
+
+                syncRoot.Release();
             }
 
             if (initialized)
@@ -112,15 +114,22 @@ public async Task<TResponse> Execute<TResponse>(RequestBase<TResponse> request)
         {
             if (client == null)
             {
-                if (await syncRoot.WaitAsync(tonOptions.TonClientTimeout))
+                if (!await syncRoot.WaitAsync(tonOptions.ConcurrencyTimeout))
+                {
+                    throw new TimeoutException("Failed while waiting for semaphore");
+                }
+
+                try
                 {
                     if (client == null)
                     {
                         tonlib_client_set_verbosity_level(tonOptions.VerbosityLevel);
                         client = tonlib_client_json_create();
                         initialized = false;
                     }
-
+                }
+                finally
+                {
                     syncRoot.Release();
                 }
             }
@@ -135,26 +144,26 @@ public async Task<TResponse> Execute<TResponse>(RequestBase<TResponse> request)
                 throw new InvalidOperationException($"Must call {nameof(InitIfNeeded)}() first");
             }
 
-            if (await syncRoot.WaitAsync(tonOptions.TonClientTimeout))
+            if (!await syncRoot.WaitAsync(tonOptions.ConcurrencyTimeout))
             {
-                try
-                {
-                    var res = await ExecuteInternalAsync(request);
+                throw new TimeoutException("Failed while waiting for semaphore");
+            }
 
-                    if (request is Init)
-                    {
-                        initialized = true;
-                    }
+            try
+            {
+                var res = await ExecuteInternalAsync(request);
 
-                    return res;
-                }
-                finally
+                if (request is Init)
                 {
-                    syncRoot.Release();
+                    initialized = true;
                 }
-            }
 
-            throw new TimeoutException("Failed while waiting for semaphore");
+                return res;
+            }
+            finally
+            {
+                syncRoot.Release();
+            }
         }
 
         public decimal ConvertFromNanoTon(long nano)
@@ -235,7 +244,7 @@ protected async Task<TResponse> ExecuteInternalAsync<TResponse>(RequestBase<TRes
 
             tonlib_client_json_send(client.Value, reqText);
 
-            var endOfLoop = DateTimeOffset.UtcNow.Add(tonOptions.TonClientTimeout);
+            var endOfLoop = DateTimeOffset.UtcNow.Add(request is Sync ? tonOptions.TonClientSyncTimeout : tonOptions.TonClientTimeout);
 
             while (true)
             {

TonLibDotNet/TonOptions.cs

@@ -21,10 +21,29 @@ public class TonOptions
         public bool UseMainnet { get; set; } = true;
 
         /// <summary>
-        /// Max amount of time TonClient will wait for valid (synced!) response from tonlib.
+        /// Max amount of time TonClient will wait for access to tonlib when used as singleton in multithreaded scenarios.
         /// </summary>
+        /// <remarks>See also <see cref="TonClientTimeout"/> and <see cref="TonClientSyncTimeout"/>.</remarks>
+        /// <seealso cref="TonClientTimeout"/>
+        /// <seealso cref="TonClientSyncTimeout"/>
+        public TimeSpan ConcurrencyTimeout { get; set; } = TimeSpan.FromSeconds(21); // A bit more than TonClientTimeout
+
+        /// <summary>
+        /// Max amount of time TonClient will wait for valid (synced!) response from tonlib (except <see cref="Requests.Sync"/> request).
+        /// </summary>
+        /// <remarks>See also <see cref="TonClientSyncTimeout"/> and <see cref="SemaphoreTimeout"/>.</remarks>
+        /// <seealso cref="TonClientSyncTimeout"/>
+        /// <seealso cref="SemaphoreTimeout"/>
         public TimeSpan TonClientTimeout { get; set; } = TimeSpan.FromSeconds(20);
 
+        /// <summary>
+        /// Max amount of time TonClient will wait for valid (synced!) response from tonlib for <see cref="Requests.Sync"/> request.
+        /// </summary>
+        /// <remarks>See also <see cref="TonClientTimeout"/> and <see cref="SemaphoreTimeout"/>.</remarks>
+        /// <seealso cref="TonClientTimeout"/>
+        /// <seealso cref="SemaphoreTimeout"/>
+        public TimeSpan TonClientSyncTimeout { get; set; } = TimeSpan.FromSeconds(60);
+
         /// <summary>
         /// TonLib timeout when making calls to tonlib/LiteServer.
         /// </summary>