Dramatically increase terminal performance.

1 files changed, 262 insertions, 234 deletions

diff --git a/ShiftOS_TheReturn/TerminalBackend.cs b/ShiftOS_TheReturn/TerminalBackend.cs
index 79c6349..6a15d3e 100644
--- a/ShiftOS_TheReturn/TerminalBackend.cs
+++ b/ShiftOS_TheReturn/TerminalBackend.cs
@@ -24,6 +24,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
 using System.Text;
@@ -136,6 +137,218 @@ namespace ShiftOS.Engine
             return JsonConvert.SerializeObject(args);
         }
 
+        public class TerminalCommand
+        {
+            public override int GetHashCode()
+            {
+                int hash = 0;
+                foreach (char c in ToString())
+                {
+                    hash += (int)c;
+                }
+                return hash;
+            }
+
+            public Namespace NamespaceInfo { get; set; }
+            public Command CommandInfo { get; set; }
+
+            public List<string> RequiredArguments { get; set; }
+            public string Dependencies { get; set; }
+
+            public MethodInfo CommandHandler;
+
+            public Type CommandType;
+
+            public override string ToString()
+            {
+                StringBuilder sb = new StringBuilder();
+                sb.Append(this.NamespaceInfo.name);
+                sb.Append(".");
+                sb.Append(this.CommandInfo.name);
+                if (this.RequiredArguments.Count > 0)
+                {
+                    sb.Append("{");
+                    foreach (var arg in RequiredArguments)
+                    {
+                        sb.Append(arg);
+                        sb.Append(":");
+                        if (RequiredArguments.IndexOf(arg) < RequiredArguments.Count - 1)
+                            sb.Append(',');
+                    }
+                    sb.Append("}");
+                }
+                sb.Append("|");
+                sb.Append(CommandHandler.Name + "()");
+                return sb.ToString();
+            }
+
+            public bool RequiresElevation { get; set; }
+
+            public void Invoke(Dictionary<string, object> args)
+            {
+                List<string> errors = new List<string>();
+                bool requiresAuth = false;
+                if (!KernelWatchdog.IsSafe(this))
+                {
+                    if (SaveSystem.CurrentUser.Permissions == Objects.UserPermissions.Admin)
+                        requiresAuth = true;
+                    else
+                        errors.Add("You can't run this command - you do not have permission.");
+                }
+                if (errors.Count > 0)
+                {
+                    foreach (var error in errors)
+                    {
+                        Console.WriteLine("Command error: " + error);
+                    }
+                    return;
+                }
+                if (requiresAuth)
+                {
+                    Infobox.PromptText("Enter your password.", "This command requires you to have elevated permissions. Please enter your password to confirm this action.", (pass) =>
+                    {
+                        if (pass == SaveSystem.CurrentUser.Password)
+                        {
+                            var uname = SaveSystem.CurrentUser.Username;
+                            SaveSystem.CurrentUser = SaveSystem.CurrentSave.Users.FirstOrDefault(x => x.Username == "root");
+                            try
+                            {
+                                var h = CommandHandler;
+                                h.Invoke(null, new[] { args });
+                            }
+                            catch
+                            {
+                                var h = CommandHandler;
+                                h.Invoke(null, null);
+                            }
+                            SaveSystem.CurrentUser = SaveSystem.CurrentSave.Users.FirstOrDefault(x => x.Username == uname);
+                        }
+                        else
+                        {
+                            Infobox.Show("Access denied.", "Incorrect password provided. The command will not run.");
+                        }
+                    }, true);
+                }
+
+                try
+                {
+                    CommandHandler.Invoke(null, new[] { args });
+                }
+                catch
+                {
+                    CommandHandler.Invoke(null, null);
+                }
+            }
+        }
+
+        public class MemoryTextWriter : System.IO.TextWriter
+        {
+            public override Encoding Encoding
+            {
+                get
+                {
+                    return Encoding.Unicode;
+                }
+            }
+
+            private StringBuilder sb = null;
+
+            public MemoryTextWriter()
+            {
+                sb = new StringBuilder();
+            }
+
+            public override string ToString()
+            {
+                return sb.ToString();
+            }
+
+            public override void Write(char value)
+            {
+                sb.Append(value);
+            }
+
+            public override void WriteLine()
+            {
+                sb.AppendLine();
+            }
+
+            public override void Write(string value)
+            {
+                sb.Append(value);
+            }
+
+            public override void Close()
+            {
+                sb.Clear();
+                sb = null;
+                base.Close();
+            }
+
+            public override void WriteLine(string value)
+            {
+                sb.AppendLine(value);
+            }
+        }
+
+        public static List<TerminalCommand> Commands { get; private set; }
+
+        public static void PopulateTerminalCommands()
+        {
+            Commands = new List<TerminalCommand>();
+            foreach(var exec in System.IO.Directory.GetFiles(Environment.CurrentDirectory))
+            {
+                if(exec.ToLower().EndsWith(".exe") || exec.ToLower().EndsWith(".dll"))
+                {
+                    try
+                    {
+                        var asm = Assembly.LoadFile(exec);
+                        foreach(var type in asm.GetTypes())
+                        {
+                            var ns = type.GetCustomAttributes(false).FirstOrDefault(x => x is Namespace) as Namespace;
+                            if(ns != null)
+                            {
+                                foreach(var mth in type.GetMethods(BindingFlags.Public | BindingFlags.Static))
+                                {
+                                    var cmd = mth.GetCustomAttributes(false).FirstOrDefault(x => x is Command);
+                                    if(cmd != null)
+                                    {
+                                        var tc = new TerminalCommand();
+                                        tc.RequiresElevation = !(type.GetCustomAttributes(false).FirstOrDefault(x => x is KernelModeAttribute) == null);
+
+                                        tc.NamespaceInfo = ns;
+
+                                        tc.CommandInfo = cmd as Command;
+                                        tc.RequiresElevation = tc.RequiresElevation || !(mth.GetCustomAttributes(false).FirstOrDefault(x => x is KernelModeAttribute) == null);
+                                        tc.RequiredArguments = new List<string>();
+                                        foreach (var arg in mth.GetCustomAttributes(false).Where(x=>x is RequiresArgument))
+                                        {
+                                            var rarg = arg as RequiresArgument;
+                                            tc.RequiredArguments.Add(rarg.argument);
+                                        }
+                                        var rupg = mth.GetCustomAttributes(false).FirstOrDefault(x => x is RequiresUpgradeAttribute) as RequiresUpgradeAttribute;
+                                        if (rupg != null)
+                                            tc.Dependencies = rupg.Upgrade;
+                                        else
+                                            tc.Dependencies = "";
+                                        tc.CommandType = type;
+                                        tc.CommandHandler = mth;
+                                        if (!Commands.Contains(tc))
+                                            Commands.Add(tc);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    catch(Exception e)
+                    {
+                        Console.WriteLine("[termdb] Error: " + e.ToString());
+                    }
+                }
+            }
+            Console.WriteLine("[termdb] " + Commands.Count + " commands found.");
+        }
+
         /// <summary>
         /// Invokes a ShiftOS terminal command.
         /// </summary>
@@ -150,19 +363,27 @@ namespace ShiftOS.Engine
 
                 var args = GetArgs(ref text);
 
+                Stopwatch debugger = new Stopwatch();
+                debugger.Start();
                 bool commandWasClient = RunClient(text, args, isRemote);
 
                 if (!commandWasClient)
                 {
-                    PrefixEnabled = false;
-
-                    ServerManager.SendMessage("script", $@"{{
-    user: ""{text.Split('.')[0]}"",
-    script: ""{text.Split('.')[1]}"",
-    args: ""{GetSentArgs(args)}""
-}}");
+                    Console.WriteLine("Command not found.");
+                    debugger.Stop();
+                    return;
                 }
                 CommandProcessed?.Invoke(text, GetSentArgs(args));
+                debugger.Stop();
+                ConsoleEx.ForegroundColor = ConsoleColor.White;
+                Console.Write("<");
+                ConsoleEx.Bold = true;
+                ConsoleEx.ForegroundColor = ConsoleColor.Blue;
+                Console.Write("debugger");
+                ConsoleEx.ForegroundColor = ConsoleColor.White;
+                ConsoleEx.Bold = false;
+                Console.Write("> ");
+                Console.WriteLine("Command " + text + " took " + debugger.Elapsed.ToString() + " to execute.");
             }
             catch (Exception ex)
             {
@@ -263,237 +484,44 @@ namespace ShiftOS.Engine
 
             //Console.WriteLine(text + " " + "{" + string.Join(",", args.Select(kv => kv.Key + "=" + kv.Value).ToArray()) + "}" + " " + isRemote);
 
-            foreach (var asmExec in System.IO.Directory.GetFiles(Environment.CurrentDirectory))
+            var tw = new MemoryTextWriter();
+            Console.SetOut(tw);
+
+            string[] split = text.Split('.');
+            var cmd = Commands.FirstOrDefault(x => x.NamespaceInfo.name == split[0] && x.CommandInfo.name == split[1]);
+            if (cmd == null)
+                return false;
+            if (!Shiftorium.UpgradeInstalled(cmd.Dependencies))
+                return false;
+            if(cmd.RequiredArguments.Count != args.Count)
             {
-                try
+                Console.WriteLine("Command error: Argument count mismatch! You supplied " + args.Count + " arguments to a command that expects " + cmd.RequiredArguments.Count + ".");
+                return true;
+            }
+            bool res = false;
+            foreach (var arg in cmd.RequiredArguments)
+            {
+                if (!args.ContainsKey(arg))
                 {
-                    var asm = Assembly.LoadFile(asmExec);
-
-                    var types = asm.GetTypes();
-                    foreach (var type in types)
-                    {
-                        if (Shiftorium.UpgradeAttributesUnlocked(type))
-                        {
-                            foreach (var a in type.GetCustomAttributes(false))
-                            {
-                                if (a is Namespace)
-                                {
-                                    var ns = a as Namespace;
-                                    if (text.Split('.')[0] == ns.name)
-                                    {
-                                        if (KernelWatchdog.IsSafe(type))
-                                        {
-                                            if (KernelWatchdog.CanRunOffline(type))
-                                            {
-                                                foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.Static))
-                                                {
-                                                    if (Shiftorium.UpgradeAttributesUnlocked(method))
-                                                    {
-                                                        foreach (var ma in method.GetCustomAttributes(false))
-                                                        {
-                                                            if (ma is Command)
-                                                            {
-                                                                var cmd = ma as Command;
-                                                                if (text.Split('.')[1] == cmd.name)
-                                                                {
-                                                                    if (KernelWatchdog.IsSafe(method))
-                                                                    {
-                                                                        if (KernelWatchdog.CanRunOffline(method))
-                                                                        {
-                                                                            var attr = method.GetCustomAttribute<CommandObsolete>();
-
-                                                                            if (attr != null)
-                                                                            {
-                                                                                string newcommand = attr.newcommand;
-                                                                                if (attr.warn)
-                                                                                {
-                                                                                    Console.WriteLine(Localization.Parse((newcommand == "" ? "{ERROR}" : "{WARN}") + attr.reason, new Dictionary<string, string>() {
-                                                                {"%newcommand", newcommand}
-                                                            }));
-                                                                                }
-                                                                                if (newcommand != "")
-                                                                                {
-                                                                                    // redo the entire process running newcommand
-
-                                                                                    return RunClient(newcommand, args);
-                                                                                }
-                                                                            }
-
-                                                                            var requiresArgs = method.GetCustomAttributes<RequiresArgument>();
-                                                                            bool error = false;
-                                                                            bool providedusage = false;
-
-                                                                            foreach (RequiresArgument argument in requiresArgs)
-                                                                            {
-                                                                                if (!args.ContainsKey(argument.argument))
-                                                                                {
-
-                                                                                    if (!providedusage)
-                                                                                    {
-                                                                                        string usageparse = "{COMMAND_" + ns.name.ToUpper() + "_" + cmd.name.ToUpper() + "_USAGE}";
-                                                                                        if (usageparse == Localization.Parse(usageparse))
-                                                                                            usageparse = "";
-                                                                                        else
-                                                                                            usageparse = Shiftorium.UpgradeInstalled("help_usage") ? Localization.Parse("{ERROR}{USAGE}" + usageparse, new Dictionary<string, string>() {
-                                                                        {"%ns", ns.name},
-                                                                        {"%cmd", cmd.name}
-                                                                    }) : "";
-
-                                                                                        Console.WriteLine(usageparse);
-
-                                                                                        providedusage = true;
-                                                                                    }
-                                                                                    if (Shiftorium.UpgradeInstalled("help_usage"))
-                                                                                    {
-                                                                                        Console.WriteLine(Localization.Parse("{ERROR_ARGUMENT_REQUIRED}", new Dictionary<string, string>() {
-                                                                    {"%argument", argument.argument}
-                                                                }));
-                                                                                    }
-                                                                                    else
-                                                                                    {
-                                                                                        Console.WriteLine(Localization.Parse("{ERROR_ARGUMENT_REQUIRED_NO_USAGE}"));
-                                                                                    }
-
-                                                                                    error = true;
-                                                                                }
-                                                                            }
-
-                                                                            if (error)
-                                                                            {
-                                                                                throw new Exception("{ERROR_COMMAND_WRONG}");
-                                                                            }
-
-                                                                            try
-                                                                            {
-                                                                                return (bool)method.Invoke(null, new[] { args });
-                                                                            }
-                                                                            catch (TargetInvocationException e)
-                                                                            {
-                                                                                Console.WriteLine(Localization.Parse("{ERROR_EXCEPTION_THROWN_IN_METHOD}"));
-                                                                                Console.WriteLine(e.InnerException.Message);
-                                                                                Console.WriteLine(e.InnerException.StackTrace);
-                                                                                return true;
-                                                                            }
-                                                                            catch
-                                                                            {
-                                                                                return (bool)method.Invoke(null, new object[] { });
-                                                                            }
-                                                                        }
-                                                                        else
-                                                                        {
-                                                                            Console.Write("<");
-                                                                            ConsoleEx.Bold = true;
-                                                                            ConsoleEx.ForegroundColor = ConsoleColor.DarkRed;
-                                                                            Console.Write("session_mgr");
-                                                                            ConsoleEx.ForegroundColor = SkinEngine.LoadedSkin.TerminalForeColorCC;
-                                                                            ConsoleEx.Bold = false;
-                                                                            Console.Write(">");
-                                                                            ConsoleEx.Italic = true;
-                                                                            ConsoleEx.ForegroundColor = ConsoleColor.DarkYellow;
-                                                                            Console.WriteLine(" You cannot run this command while disconnected from the multi-user domain..");
-                                                                            return true;
-
-                                                                        }
-                                                                    }
-                                                                    else
-                                                                    {
-                                                                        if (SaveSystem.CurrentUser.Permissions == Objects.UserPermissions.Admin)
-                                                                        {
-                                                                            Infobox.PromptText("Elevate to root mode", "This command cannot be run as a regular user. To run this command, please enter your password to elevate to root mode temporarily.", (pass) =>
-                                                                            {
-                                                                                if (pass == SaveSystem.CurrentUser.Password)
-                                                                                {
-                                                                                    KernelWatchdog.EnterKernelMode();
-                                                                                    RunClient(text, args, isRemote);
-                                                                                    KernelWatchdog.LeaveKernelMode();
-                                                                                }
-                                                                                else
-                                                                                {
-                                                                                    Infobox.Show("Access denied.", "You did not type in the correct password.");
-                                                                                }
-                                                                            }, true);
-                                                                            return true;
-                                                                        }
-                                                                        Console.Write("<");
-                                                                        ConsoleEx.Bold = true;
-                                                                        ConsoleEx.ForegroundColor = ConsoleColor.DarkRed;
-                                                                        Console.Write("watchdog");
-                                                                        ConsoleEx.ForegroundColor = SkinEngine.LoadedSkin.TerminalForeColorCC;
-                                                                        ConsoleEx.Bold = false;
-                                                                        Console.Write(">");
-                                                                        ConsoleEx.Italic = true;
-                                                                        ConsoleEx.ForegroundColor = ConsoleColor.DarkYellow;
-                                                                        Console.WriteLine(" You cannot run this command. You do not have permission. Incident reported.");
-                                                                        KernelWatchdog.Log("potential_sys_breach", "user attempted to run kernel mode command " + text + " - watchdog has prevented this, good sir.");
-                                                                        return true;
-                                                                    }
-                                                                }
-                                                            }
-
-
-                                                        }
-                                                    }
-
-                                                    else
-                                                    {
-                                                        Console.Write("<");
-                                                        ConsoleEx.Bold = true;
-                                                        ConsoleEx.ForegroundColor = ConsoleColor.DarkRed;
-                                                        Console.Write("session_mgr");
-                                                        ConsoleEx.ForegroundColor = SkinEngine.LoadedSkin.TerminalForeColorCC;
-                                                        ConsoleEx.Bold = false;
-                                                        Console.Write(">");
-                                                        ConsoleEx.Italic = true;
-                                                        ConsoleEx.ForegroundColor = ConsoleColor.DarkYellow;
-                                                        Console.WriteLine(" You cannot run this command while disconnected from the multi-user domain..");
-                                                        return true;
-
-                                                    }
-
-                                                }
-                                            } 
-                                            else
-                                            {
-                                                if (SaveSystem.CurrentUser.Permissions == Objects.UserPermissions.Admin)
-                                                {
-                                                    Infobox.PromptText("Elevate to root mode", "This command cannot be run as a regular user. To run this command, please enter your password to elevate to root mode temporarily.", (pass) =>
-                                                    {
-                                                        if (pass == SaveSystem.CurrentUser.Password)
-                                                        {
-                                                            KernelWatchdog.EnterKernelMode();
-                                                            RunClient(text, args, isRemote);
-                                                            KernelWatchdog.LeaveKernelMode();
-                                                        }
-                                                        else
-                                                        {
-                                                            Infobox.Show("Access denied.", "You did not type in the correct password.");
-                                                        }
-                                                    }, true);
-                                                    return true;
-                                                }
-                                                Console.Write("<");
-                                                ConsoleEx.Bold = true;
-                                                ConsoleEx.ForegroundColor = ConsoleColor.DarkRed;
-                                                Console.Write("watchdog");
-                                                ConsoleEx.ForegroundColor = SkinEngine.LoadedSkin.TerminalForeColorCC;
-                                                ConsoleEx.Bold = false;
-                                                Console.Write(">");
-                                                ConsoleEx.Italic = true;
-                                                ConsoleEx.ForegroundColor = ConsoleColor.DarkYellow;
-                                                Console.WriteLine(" You cannot run this command. You do not have permission. Incident reported.");
-                                                KernelWatchdog.Log("potential_sys_breach", "user attempted to run kernel mode command " + text + " - watchdog has prevented this, good sir.");
-                                                return true;
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
+                    res = true;
+                    Console.WriteLine("You are missing an argument with the key \"" + arg + "\".");
                 }
-                catch { }
             }
-            return false;
+            if (res == true)
+                return true;
+            try
+            {
+                cmd.Invoke(args);
+            }
+            catch(Exception ex)
+            {
+                Console.WriteLine("Command error: " + ex.Message);
+            }
+
+            string buffer = tw.ToString();
+            Console.SetOut(new TerminalTextWriter());
+            Console.Write(buffer);
+            return true;
         }
 
         /// <summary>