Plugin async model

Flow.Launcher.Core/Plugin/PluginAssemblyLoader.cs

@@ -20,7 +20,7 @@ internal PluginAssemblyLoader(string assemblyFilePath)
             dependencyResolver = new AssemblyDependencyResolver(assemblyFilePath);
             assemblyName = new AssemblyName(Path.GetFileNameWithoutExtension(assemblyFilePath));
 
-            referencedPluginPackageDependencyResolver = 
+            referencedPluginPackageDependencyResolver =
                 new AssemblyDependencyResolver(Path.Combine(Constant.ProgramDirectory, "Flow.Launcher.Plugin.dll"));
         }
 
@@ -38,15 +38,15 @@ protected override Assembly Load(AssemblyName assemblyName)
             // that use Newtonsoft.Json
             if (assemblyPath == null || ExistsInReferencedPluginPackage(assemblyName))
                 return null;
-            
+
             return LoadFromAssemblyPath(assemblyPath);
         }
 
-        internal Type FromAssemblyGetTypeOfInterface(Assembly assembly, Type type)
+        internal Type FromAssemblyGetTypeOfInterface(Assembly assembly, params Type[] types)
         {
             var allTypes = assembly.ExportedTypes;
 
-            return allTypes.First(o => o.IsClass && !o.IsAbstract && o.GetInterfaces().Contains(type));
+            return allTypes.First(o => o.IsClass && !o.IsAbstract && o.GetInterfaces().Intersect(types).Any());
         }
 
         internal bool ExistsInReferencedPluginPackage(AssemblyName assemblyName)

Flow.Launcher.Core/Plugin/PluginManager.cs

@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Flow.Launcher.Infrastructure;
 using Flow.Launcher.Infrastructure.Logger;
@@ -52,13 +53,14 @@ public static void Save()
             }
         }
 
-        public static void ReloadData()
+        public static async Task ReloadData()
         {
-            foreach(var plugin in AllPlugins)
+            await Task.WhenAll(AllPlugins.Select(plugin => plugin.Plugin switch
             {
-                var reloadablePlugin = plugin.Plugin as IReloadable;
-                reloadablePlugin?.ReloadData();
-            }
+                IReloadable p => Task.Run(p.ReloadData),
+                IAsyncReloadable p => p.ReloadDataAsync(),
+                _ => Task.CompletedTask,
+            }).ToArray());
         }
 
         static PluginManager()
@@ -86,50 +88,62 @@ public static void LoadPlugins(PluginsSettings settings)
         /// Call initialize for all plugins
         /// </summary>
         /// <returns>return the list of failed to init plugins or null for none</returns>
-        public static void InitializePlugins(IPublicAPI api)
+        public static async Task InitializePlugins(IPublicAPI api)
         {
             API = api;
             var failedPlugins = new ConcurrentQueue<PluginPair>();
-            Parallel.ForEach(AllPlugins, pair =>
+
+            var InitTasks = AllPlugins.Select(pair => Task.Run(async delegate
             {
                 try
                 {
-                    var milliseconds = Stopwatch.Debug($"|PluginManager.InitializePlugins|Init method time cost for <{pair.Metadata.Name}>", () =>
+                    var milliseconds = pair.Plugin switch
                     {
-                        pair.Plugin.Init(new PluginInitContext
-                        {
-                            CurrentPluginMetadata = pair.Metadata,
-                            API = API
-                        });
-                    });
+                        IAsyncPlugin plugin
+                            => await Stopwatch.DebugAsync($"|PluginManager.InitializePlugins|Init method time cost for <{pair.Metadata.Name}>",
+                                                        () => plugin.InitAsync(new PluginInitContext(pair.Metadata, API))),
+                        IPlugin plugin
+                            => Stopwatch.Debug($"|PluginManager.InitializePlugins|Init method time cost for <{pair.Metadata.Name}>",
+                                        () => plugin.Init(new PluginInitContext(pair.Metadata, API))),
+                        _ => throw new ArgumentException(),
+                    };
                     pair.Metadata.InitTime += milliseconds;
-                    Log.Info($"|PluginManager.InitializePlugins|Total init cost for <{pair.Metadata.Name}> is <{pair.Metadata.InitTime}ms>");
+                    Log.Info(
+                        $"|PluginManager.InitializePlugins|Total init cost for <{pair.Metadata.Name}> is <{pair.Metadata.InitTime}ms>");
                 }
                 catch (Exception e)
                 {
                     Log.Exception(nameof(PluginManager), $"Fail to Init plugin: {pair.Metadata.Name}", e);
-                    pair.Metadata.Disabled = true; 
+                    pair.Metadata.Disabled = true;
                     failedPlugins.Enqueue(pair);
                 }
-            });
+            }));
+
+            await Task.WhenAll(InitTasks);
 
             _contextMenuPlugins = GetPluginsForInterface<IContextMenu>();
             foreach (var plugin in AllPlugins)
             {
-                if (IsGlobalPlugin(plugin.Metadata))
-                    GlobalPlugins.Add(plugin);
-
-                // Plugins may have multiple ActionKeywords, eg. WebSearch
-                plugin.Metadata.ActionKeywords
-                    .Where(x => x != Query.GlobalPluginWildcardSign)
-                    .ToList()
-                    .ForEach(x => NonGlobalPlugins[x] = plugin);
+                foreach (var actionKeyword in plugin.Metadata.ActionKeywords)
+                {
+                    switch (actionKeyword)
+                    {
+                        case Query.GlobalPluginWildcardSign:
+                            GlobalPlugins.Add(plugin);
+                            break;
+                        default:
+                            NonGlobalPlugins[actionKeyword] = plugin;
+                            break;
+                    }
+                }
             }
 
             if (failedPlugins.Any())
             {
                 var failed = string.Join(",", failedPlugins.Select(x => x.Metadata.Name));
-                API.ShowMsg($"Fail to Init Plugins", $"Plugins: {failed} - fail to load and would be disabled, please contact plugin creator for help", "", false);
+                API.ShowMsg($"Fail to Init Plugins",
+                    $"Plugins: {failed} - fail to load and would be disabled, please contact plugin creator for help",
+                    "", false);
             }
         }
 
@@ -146,24 +160,46 @@ public static List<PluginPair> ValidPluginsForQuery(Query query)
             }
         }
 
-        public static List<Result> QueryForPlugin(PluginPair pair, Query query)
+        public static async Task<List<Result>> QueryForPlugin(PluginPair pair, Query query, CancellationToken token)
         {
             var results = new List<Result>();
             try
             {
                 var metadata = pair.Metadata;
-                var milliseconds = Stopwatch.Debug($"|PluginManager.QueryForPlugin|Cost for {metadata.Name}", () =>
+
+                long milliseconds = -1L;
+
+                switch (pair.Plugin)
                 {
-                    results = pair.Plugin.Query(query) ?? new List<Result>();
-                    UpdatePluginMetadata(results, metadata, query);
-                });
+                    case IAsyncPlugin plugin:
+                        milliseconds = await Stopwatch.DebugAsync($"|PluginManager.QueryForPlugin|Cost for {metadata.Name}",
+                            async () => results = await plugin.QueryAsync(query, token).ConfigureAwait(false));
+                        break;
+                    case IPlugin plugin:
+                        await Task.Run(() => milliseconds = Stopwatch.Debug($"|PluginManager.QueryForPlugin|Cost for {metadata.Name}",
+                            () => results = plugin.Query(query)), token).ConfigureAwait(false);
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+                token.ThrowIfCancellationRequested();
+                UpdatePluginMetadata(results, metadata, query);
+
                 metadata.QueryCount += 1;
-                metadata.AvgQueryTime = metadata.QueryCount == 1 ? milliseconds : (metadata.AvgQueryTime + milliseconds) / 2;
+                metadata.AvgQueryTime =
+                    metadata.QueryCount == 1 ? milliseconds : (metadata.AvgQueryTime + milliseconds) / 2;
+                token.ThrowIfCancellationRequested();
+            }
+            catch (OperationCanceledException)
+            {
+                // null will be fine since the results will only be added into queue if the token hasn't been cancelled
+                return results = null;
             }
             catch (Exception e)
             {
                 Log.Exception($"|PluginManager.QueryForPlugin|Exception for plugin <{pair.Metadata.Name}> when query <{query}>", e);
             }
+
             return results;
         }
 
@@ -182,11 +218,6 @@ public static void UpdatePluginMetadata(List<Result> results, PluginMetadata met
             }
         }
 
-        private static bool IsGlobalPlugin(PluginMetadata metadata)
-        {
-            return metadata.ActionKeywords.Contains(Query.GlobalPluginWildcardSign);
-        }
-
         /// <summary>
         /// get specified plugin, return null if not found
         /// </summary>
@@ -222,16 +253,19 @@ public static List<Result> GetContextMenusForPlugin(Result result)
                 }
                 catch (Exception e)
                 {
-                    Log.Exception($"|PluginManager.GetContextMenusForPlugin|Can't load context menus for plugin <{pluginPair.Metadata.Name}>", e);
+                    Log.Exception(
+                        $"|PluginManager.GetContextMenusForPlugin|Can't load context menus for plugin <{pluginPair.Metadata.Name}>",
+                        e);
                 }
             }
+
             return results;
         }
 
         public static bool ActionKeywordRegistered(string actionKeyword)
         {
             return actionKeyword != Query.GlobalPluginWildcardSign
-                && NonGlobalPlugins.ContainsKey(actionKeyword);
+                   && NonGlobalPlugins.ContainsKey(actionKeyword);
         }
 
         /// <summary>
@@ -249,6 +283,7 @@ public static void AddActionKeyword(string id, string newActionKeyword)
             {
                 NonGlobalPlugins[newActionKeyword] = plugin;
             }
+
             plugin.Metadata.ActionKeywords.Add(newActionKeyword);
         }
 
@@ -262,16 +297,16 @@ public static void RemoveActionKeyword(string id, string oldActionkeyword)
             if (oldActionkeyword == Query.GlobalPluginWildcardSign
                 && // Plugins may have multiple ActionKeywords that are global, eg. WebSearch
                 plugin.Metadata.ActionKeywords
-                                    .Where(x => x == Query.GlobalPluginWildcardSign)
-                                    .ToList()
-                                    .Count == 1)
+                    .Where(x => x == Query.GlobalPluginWildcardSign)
+                    .ToList()
+                    .Count == 1)
             {
                 GlobalPlugins.Remove(plugin);
             }
-            
+
             if (oldActionkeyword != Query.GlobalPluginWildcardSign)
                 NonGlobalPlugins.Remove(oldActionkeyword);
-            
+
 
             plugin.Metadata.ActionKeywords.Remove(oldActionkeyword);
         }

Flow.Launcher.Core/Plugin/PluginsLoader.cs

@@ -37,56 +37,59 @@ public static IEnumerable<PluginPair> DotNetPlugins(List<PluginMetadata> source)
 
             foreach (var metadata in metadatas)
             {
-                var milliseconds = Stopwatch.Debug($"|PluginsLoader.DotNetPlugins|Constructor init cost for {metadata.Name}", () =>
-                {
-
-#if DEBUG
-                    var assemblyLoader = new PluginAssemblyLoader(metadata.ExecuteFilePath);
-                    var assembly = assemblyLoader.LoadAssemblyAndDependencies();
-                    var type = assemblyLoader.FromAssemblyGetTypeOfInterface(assembly, typeof(IPlugin));
-                    var plugin = (IPlugin)Activator.CreateInstance(type);
-#else
-                    Assembly assembly = null;
-                    IPlugin plugin = null;
-
-                    try
+                var milliseconds = Stopwatch.Debug(
+                    $"|PluginsLoader.DotNetPlugins|Constructor init cost for {metadata.Name}", () =>
                     {
+#if DEBUG
                         var assemblyLoader = new PluginAssemblyLoader(metadata.ExecuteFilePath);
-                        assembly = assemblyLoader.LoadAssemblyAndDependencies();
-
-                        var type = assemblyLoader.FromAssemblyGetTypeOfInterface(assembly, typeof(IPlugin));
-
-                        plugin = (IPlugin)Activator.CreateInstance(type);
-                    }
-                    catch (Exception e) when (assembly == null)
-                    {
-                        Log.Exception($"|PluginsLoader.DotNetPlugins|Couldn't load assembly for the plugin: {metadata.Name}", e);
-                    }
-                    catch (InvalidOperationException e)
-                    {
-                        Log.Exception($"|PluginsLoader.DotNetPlugins|Can't find the required IPlugin interface for the plugin: <{metadata.Name}>", e);
-                    }
-                    catch (ReflectionTypeLoadException e)
-                    {
-                        Log.Exception($"|PluginsLoader.DotNetPlugins|The GetTypes method was unable to load assembly types for the plugin: <{metadata.Name}>", e);
-                    }
-                    catch (Exception e)
-                    {
-                        Log.Exception($"|PluginsLoader.DotNetPlugins|The following plugin has errored and can not be loaded: <{metadata.Name}>", e);
-                    }
+                        var assembly = assemblyLoader.LoadAssemblyAndDependencies();
+                        var type = assemblyLoader.FromAssemblyGetTypeOfInterface(assembly, typeof(IPlugin),
+                            typeof(IAsyncPlugin));
 
-                    if (plugin == null)
-                    {
-                        erroredPlugins.Add(metadata.Name);
-                        return;
-                    }
+                        var plugin = Activator.CreateInstance(type);
+#else
+                        Assembly assembly = null;
+                        object plugin = null;
+
+                        try
+                        {
+                            var assemblyLoader = new PluginAssemblyLoader(metadata.ExecuteFilePath);
+                            assembly = assemblyLoader.LoadAssemblyAndDependencies();
+
+                            var type = assemblyLoader.FromAssemblyGetTypeOfInterface(assembly, typeof(IPlugin), 
+                                typeof(IAsyncPlugin));
+
+                            plugin = Activator.CreateInstance(type);
+                        }
+                        catch (Exception e) when (assembly == null)
+                        {
+                            Log.Exception($"|PluginsLoader.DotNetPlugins|Couldn't load assembly for the plugin: {metadata.Name}", e);
+                        }
+                        catch (InvalidOperationException e)
+                        {
+                            Log.Exception($"|PluginsLoader.DotNetPlugins|Can't find the required IPlugin interface for the plugin: <{metadata.Name}>", e);
+                        }
+                        catch (ReflectionTypeLoadException e)
+                        {
+                            Log.Exception($"|PluginsLoader.DotNetPlugins|The GetTypes method was unable to load assembly types for the plugin: <{metadata.Name}>", e);
+                        }
+                        catch (Exception e)
+                        {
+                            Log.Exception($"|PluginsLoader.DotNetPlugins|The following plugin has errored and can not be loaded: <{metadata.Name}>", e);
+                        }
+
+                        if (plugin == null)
+                        {
+                            erroredPlugins.Add(metadata.Name);
+                            return;
+                        }
 #endif
-                    plugins.Add(new PluginPair
-                    {
-                        Plugin = plugin,
-                        Metadata = metadata
+                        plugins.Add(new PluginPair
+                        {
+                            Plugin = plugin,
+                            Metadata = metadata
+                        });
                     });
-                });
                 metadata.InitTime += milliseconds;
             }
 
@@ -95,15 +98,15 @@ public static IEnumerable<PluginPair> DotNetPlugins(List<PluginMetadata> source)
                 var errorPluginString = String.Join(Environment.NewLine, erroredPlugins);
 
                 var errorMessage = "The following "
-                                    + (erroredPlugins.Count > 1 ? "plugins have " : "plugin has ")
-                                    + "errored and cannot be loaded:";
+                                   + (erroredPlugins.Count > 1 ? "plugins have " : "plugin has ")
+                                   + "errored and cannot be loaded:";
 
                 Task.Run(() =>
                 {
                     MessageBox.Show($"{errorMessage}{Environment.NewLine}{Environment.NewLine}" +
-                                        $"{errorPluginString}{Environment.NewLine}{Environment.NewLine}" +
-                                        $"Please refer to the logs for more information","",
-                                        MessageBoxButtons.OK, MessageBoxIcon.Warning);
+                                    $"{errorPluginString}{Environment.NewLine}{Environment.NewLine}" +
+                                    $"Please refer to the logs for more information", "",
+                        MessageBoxButtons.OK, MessageBoxIcon.Warning);
                 });
             }
 
@@ -179,6 +182,5 @@ public static IEnumerable<PluginPair> ExecutablePlugins(IEnumerable<PluginMetada
                     Metadata = metadata
                 });
         }
-
     }
-}
+}