Merge remote-tracking branch 'Torch/master'

Author: Bishbash777

Torch.API/WebAPI/PluginQuery.cs

@@ -12,13 +12,14 @@ namespace Torch.API.WebAPI
 {
     public class PluginQuery
     {
+        public static bool IsApiReachable;
+        
 #if DEBUG
-        private const string ALL_QUERY = "https://torchapi.com/api/plugins?includeArchived=true";
+        private const string ALL_QUERY = "https://torchapi.com/api/plugins?inclcudeArchived=true";
 #else
         private const string ALL_QUERY = "https://torchapi.com/api/plugins";
 #endif
 
-
         private const string PLUGIN_QUERY = "https://torchapi.com/api/plugins/search/{0}";
         private readonly HttpClient _client;
         private static readonly Logger Log = LogManager.GetCurrentClassLogger();
@@ -55,6 +56,45 @@ public async Task<PluginResponse> QueryAll()
             return response;
         }
 
+        public static async Task<bool> TestApiConnection()
+        {
+            Log.Warn("Testing connection to API");
+
+            try
+            {
+                using (HttpClient client = new HttpClient())
+                {
+                    client.Timeout = TimeSpan.FromSeconds(5);
+                    HttpResponseMessage response = await client.GetAsync(ALL_QUERY);
+            
+                    if (!response.IsSuccessStatusCode)
+                    {
+                        Log.Warn($"API responded with status: {response.StatusCode}");
+                        return false;
+                    }
+
+                    IsApiReachable = true;
+                    return true;
+                }
+            }
+            catch (HttpRequestException e)
+            {
+                Log.Error("Error testing API connection.");
+                return false;
+            }
+            catch (TaskCanceledException)
+            {
+                Log.Error("API request timed out.");
+                return false;
+            }
+            catch (Exception)
+            {
+                Log.Error("Unexpected error testing API connection.");
+                return false;
+            }
+        }
+
+
         public async Task<PluginFullItem> QueryOne(Guid guid)
         {
             return await QueryOne(guid.ToString());

Torch/Plugins/PluginManager.cs

@@ -21,6 +21,7 @@
 using Torch.Collections;
 using Torch.Commands;
 using Torch.Utils;
+using static Torch.API.WebAPI.PluginQuery;
 
 namespace Torch.Managers
 {
@@ -61,6 +62,8 @@ private class PluginItem
 
         public PluginManager(ITorchBase torchInstance) : base(torchInstance)
         {
+            Task.Run(async () => await TestApiConnection()).Wait();
+
             if (!Directory.Exists(PluginDir))
                 Directory.CreateDirectory(PluginDir);
         }
@@ -164,28 +167,33 @@ public void LoadPlugins()
 
                 pluginsToLoad.Add(pluginItem);
             }
-
-
-            if (Torch.Config.ShouldUpdatePlugins)
+            
+            _log.Info($"Is plugin API reachable: {IsApiReachable}");
+            if (IsApiReachable)
             {
-                if (DownloadPluginUpdates(pluginsToLoad))
+
+                if (Torch.Config.ShouldUpdatePlugins)
                 {
-                    // Resort the plugins just in case updates changed load hints.
-                    pluginItems = GetLocalPlugins(PluginDir);
-                    pluginsToLoad.Clear();
-                    foreach (var item in pluginItems)
+                    if (DownloadPluginUpdates(pluginsToLoad))
                     {
-                        var pluginItem = item;
-                        if (!TryValidatePluginDependencies(pluginItems, ref pluginItem, out var missingPlugins))
+                        // Resort the plugins just in case updates changed load hints.
+                        pluginItems = GetLocalPlugins(PluginDir);
+                        pluginsToLoad.Clear();
+                        foreach (var item in pluginItems)
                         {
-                            foreach (var missingPlugin in missingPlugins)
-                                _log.Warn($"{item.Manifest.Name} is missing dependency {missingPlugin}. Skipping plugin.");
-                            continue;
-                        }
+                            var pluginItem = item;
+                            if (!TryValidatePluginDependencies(pluginItems, ref pluginItem, out var missingPlugins))
+                            {
+                                foreach (var missingPlugin in missingPlugins)
+                                    _log.Warn(
+                                        $"{item.Manifest.Name} is missing dependency {missingPlugin}. Skipping plugin.");
+                                continue;
+                            }
 
-                        pluginsToLoad.Add(pluginItem);
+                            pluginsToLoad.Add(pluginItem);
+                        }
                     }
-                }   
+                }
             }
 
             // Sort based on dependencies.
@@ -317,7 +325,7 @@ private bool DownloadPluginUpdates(List<PluginItem> plugins)
                         return;
                     }
                     item.Manifest.Version.TryExtractVersion(out Version currentVersion);
-                    var latest = await PluginQuery.Instance.QueryOne(item.Manifest.Guid);
+                    var latest = await Instance.QueryOne(item.Manifest.Guid);
 
                     if (latest?.LatestVersion == null)
                     {
@@ -340,7 +348,7 @@ private bool DownloadPluginUpdates(List<PluginItem> plugins)
                     }
 
                     _log.Info($"Updating plugin '{item.Manifest.Name}' from {currentVersion} to {newVersion}.");
-                    await PluginQuery.Instance.DownloadPlugin(latest, item.Path);
+                    await Instance.DownloadPlugin(latest, item.Path);
                     Interlocked.Increment(ref count);
                 }
                 catch (Exception e)