public void TestStdOutputAndStdError()
{
using (AssemblyRunner runner = new AssemblyRunner(Exe))
{
StringWriter wtr = new StringWriter();
StringWriter err = new StringWriter();
ProcessOutputEventHandler handler =
delegate(object o, ProcessOutputEventArgs e)
{ if (e.Error)
{
err.WriteLine(e.Data);
}
else
{
wtr.WriteLine(e.Data);
} };
runner.OutputReceived += handler;
Assert.AreEqual(1, runner.Run("command-line-argrument"));
Assert.AreEqual("std-err", err.ToString().Trim());
StringReader rdr = new StringReader(wtr.ToString());
Assert.AreEqual("WorkingDirectory = " + Environment.CurrentDirectory, rdr.ReadLine());
Assert.AreEqual("argument[0] = command-line-argrument", rdr.ReadLine());
Assert.AreEqual("std-input:", rdr.ReadLine());
Assert.AreEqual(null, rdr.ReadLine());
}
}
public void TestRemoveOutputEvent()
{
using (ScriptRunner runner = new ScriptRunner(ScriptEngine.Language.Cmd, "@ECHO From CMD.exe"))
{
StringWriter sw = new StringWriter();
ProcessOutputEventHandler h = delegate(object o, ProcessOutputEventArgs e) { sw.WriteLine(e.Data); };
runner.OutputReceived += h;
runner.OutputReceived -= h;
Assert.AreEqual(0, runner.Run());
Assert.AreEqual("", sw.ToString().Trim());
}
}
public void TestOutputEventUnsubscribe()
{
ProcessRunner runner = new ProcessRunner("cmd.exe", "/C", "echo");
bool outputReceived = false;
ProcessOutputEventHandler handler =
delegate(object o, ProcessOutputEventArgs e)
{ outputReceived = true; };
runner.OutputReceived += handler;
runner.OutputReceived -= handler;
Assert.AreEqual(0, runner.Run());
Assert.IsFalse(outputReceived);
}
public void TestOutputEventUnsubscribe()
{
using (AssemblyRunner runner = new AssemblyRunner(Exe))
{
bool outputReceived = false;
ProcessOutputEventHandler handler =
delegate(object o, ProcessOutputEventArgs e)
{ outputReceived = true; };
runner.OutputReceived += handler;
runner.OutputReceived -= handler;
Assert.AreEqual(0, runner.Run());
Assert.IsFalse(outputReceived);
}
}
public void TestStdOutput()
{
using (ProcessRunner runner = new ProcessRunner("cmd.exe"))
{
StringWriter wtr = new StringWriter();
StringWriter err = new StringWriter();
ProcessOutputEventHandler handler =
delegate(object o, ProcessOutputEventArgs e)
{ if (e.Error)
{
err.WriteLine(e.Data);
}
else
{
wtr.WriteLine(e.Data);
} };
runner.OutputReceived += handler;
Assert.AreEqual(0, runner.Run("/C", "dir", "/b", "/on", "/ad-h-s", "c:\\"));
Assert.AreEqual(String.Empty, err.ToString());
Assert.AreNotEqual(0, runner.PID);
StringReader rdr = new StringReader(wtr.ToString());
List <DirectoryInfo> rootdirs = new List <DirectoryInfo>(new DirectoryInfo("C:\\").GetDirectories());
rootdirs.Sort(delegate(DirectoryInfo x, DirectoryInfo y) { return(StringComparer.OrdinalIgnoreCase.Compare(x.Name, y.Name)); });
foreach (DirectoryInfo di in rootdirs)
{
if ((di.Attributes & (FileAttributes.Hidden | FileAttributes.System)) != 0)
{
continue;
}
Assert.AreEqual(di.Name, rdr.ReadLine());
}
Assert.AreEqual(null, rdr.ReadLine());
}
}
public void Generate(IGeneratorArguments input)
{
Encoding encoding;
//auto-convert input encoding to the correct type
if (_config.InputEncoding != FileEncoding.Default)
{
encoding = _config.InputEncoding == FileEncoding.Ascii ? Encoding.ASCII : Encoding.UTF8;
using (var r = new StreamReader(input.InputPath, detectEncodingFromByteOrderMarks: true))
{
if (encoding.EncodingName != r.CurrentEncoding.EncodingName)
{
string text = r.ReadToEnd();
r.Dispose();
File.WriteAllText(input.InputPath, text, encoding);
}
}
}
encoding = _config.OutputEncoding == FileEncoding.Ascii ? Encoding.ASCII : Encoding.UTF8;
//Couple of assertions about PowerShell
if (_config.Script.Type == ScriptEngine.Language.PowerShell &&
(_config.StandardInput.Redirect || _config.Arguments.Length > 0))
{
throw new ApplicationException(
@"Currently PowerShell integration does not support input streams or arguments.
Primarily this is due to circumventing the script-signing requirements. By
using the '-Command -' argument we avoid signing or setting ExecutionPolicy.");
}
using (DebuggingOutput debug = new DebuggingOutput(_config.Debug, input.WriteLine))
{
debug.WriteLine("ConfigDir = {0}", _config.BaseDirectory);
input.ConfigDir = _config.BaseDirectory;
//Inject arguments into the script
string script = input.ReplaceVariables(Check.NotNull(_config.Script).Text.Trim());
if (!String.IsNullOrEmpty(_config.Script.Include))
{
script = File.ReadAllText(CreateFullPath(_config.Script.Include));
}
if (_config.Script.Type == ScriptEngine.Language.Exe)
{
script = CreateFullPath(script);
}
StringWriter swOutput = new StringWriter();
List <string> arguments = new List <string>();
foreach (GeneratorArgument arg in _config.Arguments)
{
arguments.Add(input.ReplaceVariables(arg.Text ?? String.Empty));
}
debug.WriteLine("Prepared Script:{0}{1}{0}{2}{0}{1}",
Environment.NewLine,
"---------------------------------------------",
script
);
using (ScriptRunner scriptEngine = new ScriptRunner(_config.Script.Type, script))
{
IRunner runner = scriptEngine;
if (input.AllowAppDomains && _config.Script.InvokeAssembly)
{
runner = AssemblyRunnerCache.Fetch(scriptEngine.ScriptEngine.Executable);
arguments.InsertRange(0, scriptEngine.ScriptArguments);
}
runner.WorkingDirectory = _config.BaseDirectory;
string lastErrorMessage = null;
ProcessOutputEventHandler handler =
delegate(object o, ProcessOutputEventArgs args)
{
if (args.Error)
{
input.WriteLine(lastErrorMessage = args.Data);
}
else if (_config.StandardOut != null)
{
debug.WriteLine("std::out: {0}", args.Data);
swOutput.WriteLine(args.Data);
}
else
{
input.WriteLine(args.Data);
}
};
int exitCode = -1;
debug.WriteLine("Executing {0} {1}", runner, ArgumentList.EscapeArguments(arguments.ToArray()));
try
{
runner.OutputReceived += handler;
if (_config.StandardInput.Redirect)
{
exitCode = runner.Run(new StringReader(File.ReadAllText(input.InputPath)), arguments.ToArray());
}
else
{
exitCode = runner.Run(arguments.ToArray());
}
}
finally
{
debug.WriteLine("Exited = {0}", exitCode);
runner.OutputReceived -= handler;
}
if (_config.StandardOut != null)
{
string target = Path.ChangeExtension(input.InputPath, _config.StandardOut.Extension);
using (TempFile file = TempFile.FromExtension(_config.StandardOut.Extension))
{
File.WriteAllText(file.TempPath, swOutput.ToString(), encoding);
File.Copy(file.TempPath, target, true);
input.AddOutputFile(target);
}
}
if (exitCode != 0)
{
string message = "The script returned a non-zero result: " + exitCode;
input.WriteLine(message);
throw new ApplicationException(String.IsNullOrEmpty(lastErrorMessage) ? message : lastErrorMessage);
}
}
EnumOutputFiles(input, input.AddOutputFile);
}
}
public TerminalMain()
{
new TerminalConfiguration(Application.ExecutablePath);
Notification = new SysTrayNotifyIcon {
Visible = true
};
if (TerminalConfiguration.TransparentConsole)
{
ConsoleUtil.TransparentConsole();
}
if (TerminalConfiguration.ConsoleCenterOnScreen)
{
ConsoleUtil.CenterConsoleWindow(TerminalConfiguration.ConsoleWidth, TerminalConfiguration.ConsoleHeight);
}
else
{
ConsoleUtil.PositionConsoleWindow(TerminalConfiguration.ConsoleLeft, TerminalConfiguration.ConsoleTop, TerminalConfiguration.ConsoleWidth, TerminalConfiguration.ConsoleHeight);
}
try
{
Console.WindowWidth = TerminalConfiguration.ConsoleWidth;
Console.WindowHeight = TerminalConfiguration.ConsoleHeight;
Console.BufferWidth = TerminalConfiguration.ConsoleWidth;
Console.BufferHeight = Int16.MaxValue - 1;
}
catch (ArgumentOutOfRangeException)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("({0}) <Terminal> Failed to initialize properly. Check Config.xml settings.", DateTime.Now.ToString("hh:mm"));
Console.ResetColor();
}
finally
{
Console.WriteLine("({0}) <Terminal> Initialized...", DateTime.Now.ToString("hh:mm"));
}
var connection = new IRCInterface
{
Nicks = new[] { IRCInterface.DefaultNick, IRCInterface.AlternateNick1, IRCInterface.AlternateNick2 },
UserName = IRCInterface.DefaultUserName,
Info = IRCInterface.DefaultInfo
};
if (IRCInterface.IRCInterfaceEnabled)
{
connection.BeginConnect(IRCInterface.DefaultServer, IRCInterface.DefaultPort);
}
else
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("({0}) <IRC Interface> Disabled", DateTime.Now.ToString("hh:mm"));
}
var webinterface = new WebInterface();
if (TerminalConfiguration.AutoStartAuthServer)
{
try
{
AuthServer = new ProcessRunner(TerminalConfiguration.AuthServerPath);
}
catch (FileNotFoundException)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("({0}) <Terminal> Failed to start AuthServer. Check Config.xml settings.", DateTime.Now.ToString("hh:mm"));
}
finally
{
ProcessOutputEventHandler AuthServerOutputHandler = delegate(object o, ProcessOutputEventArgs ex)
{
if (ex.Data.Contains("[Error]"))
{
Console.ForegroundColor = ConsoleColor.Red;
}
else if (ex.Data.Contains("[Warn]"))
{
Console.ForegroundColor = ConsoleColor.Yellow;
}
else if (ex.Data.Contains("[Debug]"))
{
Console.ForegroundColor = ConsoleColor.Gray;
}
else if (ex.Data.Contains("Unhandled Exception"))
{
Console.ForegroundColor = ConsoleColor.DarkRed;
}
else
{
Console.ForegroundColor = ConsoleColor.White;
}
Console.WriteLine("({0}) <AuthServer> {1}", DateTime.Now.ToString("hh:mm"), ex.Data);
};
try
{
AuthServer.OutputReceived += AuthServerOutputHandler;
AuthServer.Start();
}
catch (NullReferenceException)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("({0}) <Terminal> Failed to start AuthServer. Check Config.xml settings.", DateTime.Now.ToString("hh:mm"));
}
}
}
if (TerminalConfiguration.AutoStartRealmServer)
{
try
{
RealmServer = new ProcessRunner(TerminalConfiguration.RealmServerPath);
}
catch (FileNotFoundException)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("({0}) <Terminal> Failed to start RealmServer. Check Config.xml settings.", DateTime.Now.ToString("hh:mm"));
}
finally
{
ProcessOutputEventHandler RealmServerOutputHandler = delegate(object o, ProcessOutputEventArgs ex)
{
if (ex.Data.Contains("[Error]"))
{
Console.ForegroundColor = ConsoleColor.Red;
}
else if (ex.Data.Contains("[Warn]"))
{
Console.ForegroundColor = ConsoleColor.Yellow;
}
else if (ex.Data.Contains("[Debug]"))
{
Console.ForegroundColor = ConsoleColor.Gray;
}
else if (ex.Data.Contains("Unhandled Exception"))
{
Console.ForegroundColor = ConsoleColor.DarkRed;
}
else
{
Console.ForegroundColor = ConsoleColor.White;
}
Console.WriteLine("({0}) <RealmServer> {1}", DateTime.Now.ToString("hh:mm"), ex.Data);
};
try
{
RealmServer.OutputReceived += RealmServerOutputHandler;
RealmServer.Start();
}
catch (NullReferenceException)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("({0}) <Terminal> Failed to start RealmServer. Check Config.xml settings.", DateTime.Now.ToString("hh:mm"));
}
}
}
}
