Refactoring [WIP]

Wox.Core/Plugin/CSharpPluginLoader.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Wox.Infrastructure.Logger;
+using Wox.Plugin;
+using Wox.Plugin.SystemPlugins;
+
+namespace Wox.Core.Plugin
+{
+    internal class CSharpPluginLoader : IPluginLoader
+    {
+        public IEnumerable<PluginPair> LoadPlugin(List<PluginMetadata> pluginMetadatas)
+        {
+            var plugins = new List<PluginPair>();
+            List<PluginMetadata> CSharpPluginMetadatas = pluginMetadatas.Where(o => o.Language.ToUpper() == AllowedLanguage.CSharp.ToUpper()).ToList();
+
+            foreach (PluginMetadata metadata in CSharpPluginMetadatas)
+            {
+                try
+                {
+                    Assembly asm = Assembly.Load(AssemblyName.GetAssemblyName(metadata.ExecuteFilePath));
+                    List<Type> types = asm.GetTypes().Where(o => o.IsClass && !o.IsAbstract && (o.BaseType == typeof(BaseSystemPlugin) || o.GetInterfaces().Contains(typeof(IPlugin)))).ToList();
+                    if (types.Count == 0)
+                    {
+                        Log.Warn(string.Format("Couldn't load plugin {0}: didn't find the class that implement IPlugin", metadata.Name));
+                        continue;
+                    }
+
+                    foreach (Type type in types)
+                    {
+                        PluginPair pair = new PluginPair()
+                        {
+                            Plugin = Activator.CreateInstance(type) as IPlugin,
+                            Metadata = metadata
+                        };
+
+                        var sys = pair.Plugin as BaseSystemPlugin;
+                        if (sys != null)
+                        {
+                            sys.PluginDirectory = metadata.PluginDirectory;
+                        }
+
+                        plugins.Add(pair);
+                    }
+                }
+                catch (Exception e)
+                {
+                    Log.Error(string.Format("Couldn't load plugin {0}: {1}", metadata.Name, e.Message));
+#if (DEBUG)
+                    {
+                        throw;
+                    }
+#endif
+                }
+            }
+
+            return plugins;
+        }
+    }
+}

Wox.Core/Plugin/IPluginLoader.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using Wox.Plugin;
+
+namespace Wox.Core.Plugin
+{
+    internal interface IPluginLoader
+    {
+        IEnumerable<PluginPair> LoadPlugin(List<PluginMetadata> pluginMetadatas);
+    }
+}

Wox.Core/Plugin/JsonPRCModel.cs

@@ -0,0 +1,133 @@
+
+/* We basically follow the Json-RPC 2.0 spec (http://www.jsonrpc.org/specification) to invoke methods between Wox and other plugins, 
+ * like python or other self-execute program. But, we added addtional infos (proxy and so on) into rpc request. Also, we didn't use the
+ * "id" and "jsonrpc" in the request, since it's not so useful in our request model.
+ * 
+ * When execute a query:
+ *      Wox -------JsonRPCServerRequestModel--------> client
+ *      Wox <------JsonRPCQueryResponseModel--------- client
+ *      
+ * When execute a action (which mean user select an item in reulst item):
+ *      Wox -------JsonRPCServerRequestModel--------> client
+ *      Wox <------JsonRPCResponseModel-------------- client
+ * 
+ */
+
+using System.Collections.Generic;
+using System.Linq;
+using Wox.Plugin;
+
+namespace Wox.Core.Plugin
+{
+    public class JsonRPCErrorModel
+    {
+        public int Code { get; set; }
+
+        public string Message { get; set; }
+
+        public string Data { get; set; }
+    }
+
+    public class JsonRPCModelBase
+    {
+        public int Id { get; set; }
+    }
+
+    public class JsonRPCResponseModel : JsonRPCModelBase
+    {
+        public string Result { get; set; }
+
+        public JsonRPCErrorModel Error { get; set; }
+    }
+
+    public class JsonRPCQueryResponseModel : JsonRPCResponseModel
+    {
+        public new List<JsonRPCResult> Result { get; set; }
+    }
+
+    public class JsonRPCRequestModel : JsonRPCModelBase
+    {
+        public string Method { get; set; }
+
+        public object[] Parameters { get; set; }
+
+        public override string ToString()
+        {
+            string rpc = string.Empty;
+            if (Parameters != null && Parameters.Length > 0)
+            {
+                string parameters = Parameters.Aggregate("[", (current, o) => current + (GetParamterByType(o) + ","));
+                parameters = parameters.Substring(0, parameters.Length - 1) + "]";
+                rpc = string.Format(@"{{\""method\"":\""{0}\"",\""parameters\"":{1}", Method, parameters);
+            }
+            else
+            {
+                rpc = string.Format(@"{{\""method\"":\""{0}\"",\""parameters\"":[]", Method);
+            }
+
+            return rpc;
+
+        }
+
+        private string GetParamterByType(object paramter)
+        {
+
+            if (paramter is string)
+            {
+                return string.Format(@"\""{0}\""", paramter);
+            }
+            if (paramter is int || paramter is float || paramter is double)
+            {
+                return string.Format(@"{0}", paramter);
+            }
+            if (paramter is bool)
+            {
+                return string.Format(@"{0}", paramter.ToString().ToLower());
+            }
+            return paramter.ToString();
+        }
+    }
+
+    /// <summary>
+    /// Json RPC Request that Wox sent to client
+    /// </summary>
+    public class JsonRPCServerRequestModel : JsonRPCRequestModel
+    {
+        public IHttpProxy HttpProxy { get; set; }
+
+        public override string ToString()
+        {
+            string rpc = base.ToString();
+            if (HttpProxy != null)
+            {
+                rpc += string.Format(@",\""proxy\"":{{\""enabled\"":{0},\""server\"":\""{1}\"",\""port\"":{2},\""username\"":\""{3}\"",\""password\"":\""{4}\""}}",
+                    HttpProxy.Enabled.ToString().ToLower(), HttpProxy.Server, HttpProxy.Port, HttpProxy.UserName, HttpProxy.Password);
+            }
+            return rpc + "}";
+        }
+    }
+
+    /// <summary>
+    /// Json RPC Request(in query response) that client sent to Wox
+    /// </summary>
+    public class JsonRPCClientRequestModel : JsonRPCRequestModel
+    {
+        public bool DontHideAfterAction { get; set; }
+
+        public override string ToString()
+        {
+            string rpc = base.ToString();
+            return rpc + "}";
+        }
+    }
+
+    /// <summary>
+    /// Represent the json-rpc result item that client send to Wox
+    /// Typically, we will send back this request model to client after user select the result item
+    /// But if the request method starts with "Wox.", we will invoke the public APIs we expose.
+    /// </summary>
+    public class JsonRPCResult : Result
+    {
+        public JsonRPCClientRequestModel JsonRPCAction { get; set; }
+    }
+}

Wox.Core/Plugin/JsonRPCPlugin.cs

@@ -0,0 +1,166 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Threading;
+using Newtonsoft.Json;
+using Wox.Infrastructure.Exceptions;
+using Wox.Infrastructure.Logger;
+using Wox.Plugin;
+
+namespace Wox.Core.Plugin
+{
+    /// <summary>
+    /// Represent the plugin that using JsonPRC
+    /// </summary>
+    internal abstract class JsonRPCPlugin : IPlugin
+    {
+        protected PluginInitContext context;
+
+        /// <summary>
+        /// The language this JsonRPCPlugin support
+        /// </summary>
+        public abstract string SupportedLanguage { get; }
+
+        protected abstract string ExecuteQuery(Query query);
+        protected abstract string ExecuteCallback(JsonRPCRequestModel rpcRequest);
+
+        public List<Result> Query(Query query)
+        {
+            string output = ExecuteQuery(query);
+            if (!string.IsNullOrEmpty(output))
+            {
+                try
+                {
+                    List<Result> results = new List<Result>();
+
+                    JsonRPCQueryResponseModel queryResponseModel = JsonConvert.DeserializeObject<JsonRPCQueryResponseModel>(output);
+                    if (queryResponseModel.Result == null) return null;
+
+                    foreach (JsonRPCResult result in queryResponseModel.Result)
+                    {
+                        JsonRPCResult result1 = result;
+                        result.Action = (c) =>
+                        {
+                            if (result1.JsonRPCAction == null) return false;
+
+                            if (!string.IsNullOrEmpty(result1.JsonRPCAction.Method))
+                            {
+                                if (result1.JsonRPCAction.Method.StartsWith("Wox."))
+                                {
+                                    ExecuteWoxAPI(result1.JsonRPCAction.Method.Substring(4), result1.JsonRPCAction.Parameters);
+                                }
+                                else
+                                {
+                                    ThreadPool.QueueUserWorkItem(state =>
+                                    {
+                                        string actionReponse = ExecuteCallback(result1.JsonRPCAction);
+                                        JsonRPCRequestModel jsonRpcRequestModel = JsonConvert.DeserializeObject<JsonRPCRequestModel>(actionReponse);
+                                        if (jsonRpcRequestModel != null
+                                            && !string.IsNullOrEmpty(jsonRpcRequestModel.Method)
+                                            && jsonRpcRequestModel.Method.StartsWith("Wox."))
+                                        {
+                                            ExecuteWoxAPI(jsonRpcRequestModel.Method.Substring(4), jsonRpcRequestModel.Parameters);
+                                        }
+                                    });
+                                }
+                            }
+                            return !result1.JsonRPCAction.DontHideAfterAction;
+                        };
+                        results.Add(result);
+                    }
+                    return results;
+                }
+                catch (Exception e)
+                {
+                    ErrorReporting.TryShowErrorMessageBox(e.Message, e);
+                    Log.Error(e.Message);
+                }
+            }
+            return null;
+        }
+
+        private void ExecuteWoxAPI(string method, object[] parameters)
+        {
+            MethodInfo methodInfo = App.Window.GetType().GetMethod(method);
+            if (methodInfo != null)
+            {
+                try
+                {
+                    methodInfo.Invoke(App.Window, parameters);
+                }
+                catch (Exception)
+                {
+#if (DEBUG)
+                    {
+                        throw;
+                    }
+#endif
+                }
+            }
+        }
+
+        /// <summary>
+        /// Execute external program and return the output
+        /// </summary>
+        /// <param name="fileName"></param>
+        /// <param name="arguments"></param>
+        /// <returns></returns>
+        protected string Execute(string fileName, string arguments)
+        {
+            ProcessStartInfo start = new ProcessStartInfo();
+            start.FileName = fileName;
+            start.Arguments = arguments;
+            start.UseShellExecute = false;
+            start.CreateNoWindow = true;
+            start.RedirectStandardOutput = true;
+            start.RedirectStandardError = true;
+            return Execute(start);
+        }
+
+        protected string Execute(ProcessStartInfo startInfo)
+        {
+            try
+            {
+                using (Process process = Process.Start(startInfo))
+                {
+                    if (process != null)
+                    {
+                        using (StreamReader reader = process.StandardOutput)
+                        {
+                            string result = reader.ReadToEnd();
+                            if (result.StartsWith("DEBUG:"))
+                            {
+                                System.Windows.Forms.MessageBox.Show(new Form { TopMost = true }, result.Substring(6));
+                                return "";
+                            }
+                            if (string.IsNullOrEmpty(result))
+                            {
+                                using (StreamReader errorReader = process.StandardError)
+                                {
+                                    string error = errorReader.ReadToEnd();
+                                    if (!string.IsNullOrEmpty(error))
+                                    {
+                                        ErrorReporting.TryShowErrorMessageBox(error, new WoxJsonRPCException(error));
+                                    }
+                                }
+                            }
+                            return result;
+                        }
+                    }
+                }
+            }
+            catch
+            {
+                return null;
+            }
+            return null;
+        }
+
+        public void Init(PluginInitContext ctx)
+        {
+            context = ctx;
+        }
+    }
+}

Wox.Core/Plugin/JsonRPCPluginLoader.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.Linq;
+using Wox.Plugin;
+
+namespace Wox.Core.Plugin
+{
+    internal class JsonRPCPluginLoader<T> : IPluginLoader where T : JsonRPCPlugin, new()
+    {
+        public virtual IEnumerable<PluginPair> LoadPlugin(List<PluginMetadata> pluginMetadatas)
+        {
+            T jsonRPCPlugin = new T();
+            List<PluginMetadata> jsonRPCPluginMetadatas = pluginMetadatas.Where(o => o.Language.ToUpper() == jsonRPCPlugin.SupportedLanguage.ToUpper()).ToList();
+
+            return jsonRPCPluginMetadatas.Select(metadata => new PluginPair()
+            {
+                Plugin = jsonRPCPlugin, 
+                Metadata = metadata
+            }).ToList();
+        }
+    }
+}

Wox.Core/Plugin/PluginConfig.cs

@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using Newtonsoft.Json;
+using Wox.Infrastructure.Exceptions;
+using Wox.Infrastructure.Logger;
+using Wox.Infrastructure.Storage.UserSettings;
+using Wox.Plugin;
+
+namespace Wox.Core.Plugin
+{
+
+    internal abstract class PluginConfig
+    {
+        private const string pluginConfigName = "plugin.json";
+        private static List<PluginMetadata> pluginMetadatas = new List<PluginMetadata>();
+
+        /// <summary>
+        /// Parse plugin metadata in giving directories
+        /// </summary>
+        /// <param name="pluginDirectories"></param>
+        /// <returns></returns>
+        public static List<PluginMetadata> Parse(List<string> pluginDirectories)
+        {
+            pluginMetadatas.Clear();
+            ParseSystemPlugins();
+            foreach (string pluginDirectory in pluginDirectories)
+            {
+                ParseThirdPartyPlugins(pluginDirectory);
+            }
+
+            if (PluginManager.DebuggerMode != null)
+            {
+                PluginMetadata metadata = GetPluginMetadata(PluginManager.DebuggerMode);
+                if (metadata != null) pluginMetadatas.Add(metadata);
+            }
+            return pluginMetadatas;
+        }
+
+        private static void ParseSystemPlugins()
+        {
+            pluginMetadatas.Add(new PluginMetadata()
+            {
+                Name = "System Plugins",
+                Author = "System",
+                Description = "system plugins collection",
+                Website = "http://www.getwox.com",
+                Language = AllowedLanguage.CSharp,
+                Version = "1.0.0",
+                PluginType = PluginType.System,
+                ActionKeyword = "*",
+                ExecuteFileName = "Wox.Plugin.SystemPlugins.dll",
+                PluginDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)
+            });
+        }
+
+        private static void ParseThirdPartyPlugins(string pluginDirectory)
+        {
+
+            string[] directories = Directory.GetDirectories(pluginDirectory);
+            foreach (string directory in directories)
+            {
+                if (File.Exists((Path.Combine(directory, "NeedDelete.txt"))))
+                {
+                    Directory.Delete(directory, true);
+                    continue;
+                }
+                PluginMetadata metadata = GetPluginMetadata(directory);
+                if (metadata != null)
+                {
+                    pluginMetadatas.Add(metadata);
+                }
+            }
+        }
+
+        private static PluginMetadata GetPluginMetadata(string pluginDirectory)
+        {
+            string configPath = Path.Combine(pluginDirectory, pluginConfigName);
+            if (!File.Exists(configPath))
+            {
+                Log.Warn(string.Format("parse plugin {0} failed: didn't find config file.", configPath));
+                return null;
+            }
+
+            PluginMetadata metadata;
+            try
+            {
+                metadata = JsonConvert.DeserializeObject<PluginMetadata>(File.ReadAllText(configPath));
+                metadata.PluginType = PluginType.ThirdParty;
+                metadata.PluginDirectory = pluginDirectory;
+            }
+            catch (Exception)
+            {
+                string error = string.Format("Parse plugin config {0} failed: json format is not valid", configPath);
+                Log.Warn(error);
+#if (DEBUG)
+                {
+                    throw new WoxException(error);
+                }
+#endif
+                return null;
+            }
+
+
+            if (!AllowedLanguage.IsAllowed(metadata.Language))
+            {
+                string error = string.Format("Parse plugin config {0} failed: invalid language {1}", configPath, metadata.Language);
+                Log.Warn(error);
+#if (DEBUG)
+                {
+                    throw new WoxException(error);
+                }
+#endif
+                return null;
+            }
+
+            if (!File.Exists(metadata.ExecuteFilePath))
+            {
+                string error = string.Format("Parse plugin config {0} failed: ExecuteFile {1} didn't exist", configPath, metadata.ExecuteFilePath);
+                Log.Warn(error);
+#if (DEBUG)
+                {
+                    throw new WoxException(error);
+                }
+#endif
+                return null;
+            }
+
+            //replace action keyword if user customized it.
+            var customizedPluginConfig = UserSettingStorage.Instance.CustomizedPluginConfigs.FirstOrDefault(o => o.ID == metadata.ID);
+            if (customizedPluginConfig != null && !string.IsNullOrEmpty(customizedPluginConfig.Actionword))
+            {
+                metadata.ActionKeyword = customizedPluginConfig.Actionword;
+            }
+
+            return metadata;
+        }
+    }
+}

Wox.Core/Plugin/PluginManager.cs

@@ -0,0 +1,99 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using Wox.Infrastructure.Http;
+using Wox.Plugin;
+
+namespace Wox.Core.Plugin
+{
+    /// <summary>
+    /// The entry for managing Wox plugins
+    /// </summary>
+    public static class PluginManager
+    {
+        public static String DebuggerMode { get; private set; }
+        private static List<PluginPair> plugins = new List<PluginPair>();
+        
+        /// <summary>
+        /// Directories that will hold Wox plugin directory
+        /// </summary>
+        private static List<string> pluginDirectories = new List<string>();
+
+        static PluginManager()
+        {
+            pluginDirectories.Add(
+                Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Plugins"));
+            pluginDirectories.Add(
+                Path.Combine(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), ".Wox"),"Plugins"));
+
+            MakesurePluginDirectoriesExist();   
+        }
+
+        private static void MakesurePluginDirectoriesExist()
+        {
+            foreach (string pluginDirectory in pluginDirectories)
+            {
+                if (!Directory.Exists(pluginDirectory))
+                {
+                    Directory.CreateDirectory(pluginDirectory);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Load and init all Wox plugins
+        /// </summary>
+        public static void Init()
+        {
+            plugins.Clear();
+
+            List<PluginMetadata> pluginMetadatas = PluginConfig.Parse(pluginDirectories);
+            plugins.AddRange(new CSharpPluginLoader().LoadPlugin(pluginMetadatas));
+            plugins.AddRange(new JsonRPCPluginLoader<PythonPlugin>().LoadPlugin(pluginMetadatas));
+
+            foreach (PluginPair pluginPair in plugins)
+            {
+                PluginPair pair = pluginPair;
+                ThreadPool.QueueUserWorkItem(o => pair.Plugin.Init(new PluginInitContext()
+                {
+                    CurrentPluginMetadata = pair.Metadata,
+                    Proxy = HttpProxy.Instance,
+                    API = App.Window
+                }));
+            }
+        }
+
+        public static List<PluginPair> AllPlugins
+        {
+            get
+            {
+                return plugins;
+            }
+        }
+
+        public static bool HitThirdpartyKeyword(Query query)
+        {
+            if (string.IsNullOrEmpty(query.ActionName)) return false;
+
+            return plugins.Any(o => o.Metadata.PluginType == PluginType.ThirdParty && o.Metadata.ActionKeyword == query.ActionName);
+        }
+
+        public static void ActivatePluginDebugger(string path)
+        {
+            DebuggerMode = path;
+        }
+
+        /// <summary>
+        /// get specified plugin, return null if not found
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        public static PluginPair GetPlugin(string id)
+        {
+            return AllPlugins.FirstOrDefault(o => o.Metadata.ID == id);
+        }
+    }
+}

Wox.Core/Plugin/PythonPlugin.cs

@@ -0,0 +1,64 @@
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using Wox.Infrastructure.Http;
+using Wox.Plugin;
+
+namespace Wox.Core.Plugin
+{
+    internal class PythonPlugin : JsonRPCPlugin
+    {
+        private static string woxDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+        private ProcessStartInfo startInfo;
+
+        public override string SupportedLanguage
+        {
+            get { return AllowedLanguage.Python; }
+        }
+
+        public PythonPlugin()
+        {
+            startInfo = new ProcessStartInfo
+                {
+                    UseShellExecute = false,
+                    CreateNoWindow = true,
+                    RedirectStandardOutput = true,
+                    RedirectStandardError = true
+                };
+            string additionalPythonPath = string.Format("{0};{1}",
+                                                        Path.Combine(woxDirectory, "PythonHome\\DLLs"),
+                                                        Path.Combine(woxDirectory, "PythonHome\\Lib\\site-packages"));
+            if (!startInfo.EnvironmentVariables.ContainsKey("PYTHONPATH"))
+            {
+
+                startInfo.EnvironmentVariables.Add("PYTHONPATH", additionalPythonPath);
+            }
+            else
+            {
+                startInfo.EnvironmentVariables["PYTHONPATH"] = additionalPythonPath;
+            }
+        }
+
+        protected override string ExecuteQuery(Query query)
+        {
+            JsonRPCServerRequestModel request = new JsonRPCServerRequestModel()
+                {
+                    Method = "query",
+                    Parameters = new object[] { query.GetAllRemainingParameter() },
+                    HttpProxy = HttpProxy.Instance
+                };
+            //Add -B flag to tell python don't write .py[co] files. Because .pyc contains location infos which will prevent python portable
+            startInfo.FileName = Path.Combine(woxDirectory, "PythonHome\\pythonw.exe");
+            startInfo.Arguments = string.Format("-B \"{0}\" \"{1}\"", context.CurrentPluginMetadata.ExecuteFilePath, request);
+
+            return Execute(startInfo);
+        }
+
+        protected override string ExecuteCallback(JsonRPCRequestModel rpcRequest)
+        {
+            startInfo.FileName = Path.Combine(woxDirectory, "PythonHome\\pythonw.exe");
+            startInfo.Arguments = string.Format("-B \"{0}\" \"{1}\"", context.CurrentPluginMetadata.ExecuteFilePath, rpcRequest);
+            return Execute(startInfo);
+        }
+    }
+}