private MemoryStream GetThumbnailFromProcess(Process p, ref int width, ref int height)
{
Debug("Starting ffmpeg");
using (var thumb = new MemoryStream()) {
var pump = new StreamPump(p.StandardOutput.BaseStream, thumb, null, 4096);
if (!p.WaitForExit(20000)) {
p.Kill();
throw new ArgumentException("ffmpeg timed out");
}
if (p.ExitCode != 0) {
throw new ArgumentException("ffmpeg does not understand the stream");
}
Debug("Done ffmpeg");
if (!pump.Wait(2000)) {
throw new ArgumentException("stream reading timed out");
}
if (thumb.Length == 0) {
throw new ArgumentException("ffmpeg did not produce a result");
}
using (var img = Image.FromStream(thumb)) {
using (var scaled = ThumbnailMaker.ResizeImage(img, ref width, ref height)) {
var rv = new MemoryStream();
try {
scaled.Save(rv, ImageFormat.Jpeg);
return rv;
}
catch (Exception) {
rv.Dispose();
throw;
}
}
}
}
}
/// <summary>
/// Hybrid replay mode uses windbg
/// </summary>
protected void _StartDebuggerHybridReplay()
{
if (_debuggerProcess == null || _debuggerProcess.HasExited)
{
using (var p = System.Diagnostics.Process.GetCurrentProcess())
{
_debuggerChannelName = "PeachCore_" + p.Id + "_" + (ipcChannelCount++);
}
// Launch the server process
_debuggerProcess = new System.Diagnostics.Process();
_debuggerProcess.StartInfo.CreateNoWindow = true;
_debuggerProcess.StartInfo.UseShellExecute = false;
_debuggerProcess.StartInfo.Arguments = _debuggerChannelName;
_debuggerProcess.StartInfo.FileName = Path.Combine(
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),
"Peach.Core.WindowsDebugInstance.exe");
_debuggerProcess.Start();
// Let the process get started.
Thread.Sleep(2000);
}
// Try and create instance over IPC. We will continue trying for 1 minute.
DateTime startTimer = DateTime.Now;
while (true)
{
try
{
_debugger = (DebuggerInstance)Activator.GetObject(typeof(DebuggerInstance),
"ipc://" + _debuggerChannelName + "/DebuggerInstance");
_debugger.commandLine = _commandLine;
_debugger.processName = _processName;
_debugger.kernelConnectionString = _kernelConnectionString;
_debugger.service = _service;
_debugger.symbolsPath = _symbolsPath;
_debugger.startOnCall = _startOnCall;
_debugger.ignoreFirstChanceGuardPage = _ignoreFirstChanceGuardPage;
_debugger.ignoreSecondChanceGuardPage = _ignoreSecondChanceGuardPage;
_debugger.noCpuKill = _noCpuKill;
_debugger.winDbgPath = _winDbgPath;
break;
}
catch
{
if ((DateTime.Now - startTimer).Minutes >= 1)
{
_debuggerProcess.Kill();
_debuggerProcess = null;
throw;
}
}
}
_debugger.StartDebugger();
}
void OnDestroy()
{
if (process_ != null && !process_.HasExited)
{
process_.Kill();
process_.Dispose();
}
}
void OnApplicationQuit()
{
if (process_ != null && !process_.HasExited)
{
process_.Kill();
process_.Dispose();
}
}
private void TimeoutHandler(object sender, ElapsedEventArgs e)
{
if (Procs != null)
{
if (!Procs.HasExited)
{
Procs.Kill();
}
}
}
public virtual void shutdown()
{
try {
// [PM] 3.12.0 this can barf (as can process.HasExited) if
// the process did not start e.g., the path was not found.
process.Kill();
}
catch (System.Exception) {
// ignore all errors
}
}
void OnDestroy()
{
stop = true;
if (client != null)
{
client.Close();
}
if (decoderProcess != null)
{
decoderProcess.Kill();
}
}
public bool WaitForExit(int milliseconds)
{
if (_process.WaitForExit(milliseconds))
{
return(true);
}
if (HasExited)
{
_process.Kill();
}
return(false);
}
private void beginInArcadeMode(ref GameConfiguration gameConfig)
{
Boolean closed = true;
Boolean stopRunner = false;
Process game = new Process();
Process joyToKey = new Process();
GlobalMouseKeyboard globalMouseKeyboard = new GlobalMouseKeyboard();
runJoyToKey(ref gameConfig);
while (!stopRunner)
{
if (globalMouseKeyboard.F2IsPressed)
{
//restart the game
game.Kill();
closed = true;
globalMouseKeyboard.F2IsPressed = false;
}
if (globalMouseKeyboard.F4IsPressed)
{
//end arcade mode
game.Kill();
stopRunner = true;
globalMouseKeyboard.Dispose();
}
if (closed)
{
if (gameConfig.HideMouse)
Cursor.Position = new Point(2000, 2000); //work around
//another work around, set the cursor graphic to a transparent one, http://forums.whirlpool.net.au/archive/1172326
ProcessStartInfo psi = new ProcessStartInfo(gameConfig.GamePath);
if (gameConfig.FullScreen)
psi.WindowStyle = ProcessWindowStyle.Maximized; //TODO: only maximizes fully if the taskbar is set to auto-hide
game = Process.Start(psi);
closed = false;
}
game.WaitForExit(100); //? to reduce cpu usage?
if (game.HasExited)
{
closed = true;
}
}
}
public void t_Elapsed(object sender, ElapsedEventArgs e, Process p, string date)
{
Timer t = (Timer)sender;
t.Stop();
if (p.ProcessName == "java")
{
if (Utilities.scanProcess(p))
{
if (AntiPwny.PreventionMode)
{
builder.Clear();
builder.Append(p.ProcessName);
builder.Append(" Killed.");
p.Kill();
w.write(date, builder.ToString(), "Java Meterpreter");
}
else
{
builder.Clear();
builder.Append(p.ProcessName);
builder.Append(" memory contains java meterpreter signature.");
w.write(date, builder.ToString(), "Java Meterpreter Found");
}
}
}
if (Utilities.scanProcess(p))
{
if (AntiPwny.PreventionMode)
{
builder.Clear();
builder.Append(p.ProcessName);
builder.Append(" Killed.");
p.Kill();
w.write(date, builder.ToString(), "Meterpreter");
}
else
{
builder.Clear();
builder.Append(p.ProcessName);
builder.Append(" memory contains meterpreter signature.");
w.write(date, builder.ToString(), "Meterpreter Found");
}
}
}
/*外部プログラムjulisのプロセスを強制終了*/
private void kill_julius_server()
{
//プロセスの強制終了
julius_process.Kill();
if (julius_process.HasExited)
{
Debug.Log("Kill julius server.");
}
else
{
julius_process.Kill();
}
julius_process.Close();
julius_process.Dispose();
}
public static async Task<bool> Execute(Params @params)
{
var arguments = string.Join(" ",
string.Format("\"{0}\"", @params.SolutionPath),
@params.Args,
string.Format(MsBuildArgs,
@params.Configuration,
@params.Platform,
@params.Verbosity));
var process = new Process
{
StartInfo = new ProcessStartInfo(MsBuildPath)
{
Arguments = arguments,
CreateNoWindow = true,
RedirectStandardOutput = true,
UseShellExecute = false
}
};
process.OutputDataReceived += (sender, args) => @params.Callback(args.Data);
process.Start();
process.BeginOutputReadLine();
while (!process.HasExited)
{
if (@params.CancellationToken.IsCancellationRequested)
{
process.Kill();
return false;
}
await Task.Delay(50, @params.CancellationToken);
}
return process.ExitCode == 0;
}
public static bool executeProcessWithParams(string stringPathToFileToExecute,string stringArguments,bool bShowCmdWindow, ref bool bCancelProcessExecution)
{
bCancelProcessExecution = false;
try
{
Process pProcess = new Process();
pProcess.StartInfo.Arguments = stringArguments;
pProcess.StartInfo.FileName = stringPathToFileToExecute;
if (bShowCmdWindow)
pProcess.StartInfo.WindowStyle = ProcessWindowStyle.Normal;
else
pProcess.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
pProcess.Start();
while (! pProcess.HasExited)
{
pProcess.Refresh();
Thread.Sleep(100);
Application.DoEvents();
if (bCancelProcessExecution)
{
pProcess.Kill();
MessageBox.Show("Process execution canceled");
return false;
}
}
return true;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return false;
}
}
public void LoginGmail()
{
string pipename = Process.GetCurrentProcess().Id.ToString() + "_login_gmail";
var pipe = new NamedPipeServerStream(pipename, PipeDirection.InOut, 1);
System.Diagnostics.Process process = new System.Diagnostics.Process();
process.StartInfo = new ProcessStartInfo();
process.StartInfo.FileName = "3s_atc - browser.exe";
process.StartInfo.Arguments = "https://www.google.com/gmail" + " " + pipename;
process.Start();
pipe.WaitForConnection();
StreamReader reader = new StreamReader(pipe);
string str = reader.ReadLine();
if (!String.IsNullOrEmpty(str))
{
gmail_cookies = DeserializeCefCookies(str);
gmail_loggedin = true;
MessageBox.Show("Logged in!", "Success!", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
process.Kill();
}
//**********************************************************************
/// <summary>
/// Open excel file, verify content contains or not contains given string.
/// </summary>
public static void VerifyExcelfileValues(LxScriptItem item)
{
string strPath = item.getArgText();
string strFileName = strPath.Substring(strPath.LastIndexOf("/") + 1, strPath.Length - strPath.LastIndexOf("/") - 1);
string mark = item.getArg3Text(); // flag=true, contains; flag=false, not contains.
System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
startInfo.FileName = "excel.exe";
startInfo.Arguments = " " + strPath;
System.Diagnostics.Process process = System.Diagnostics.Process.Start(startInfo);
RepoItemInfo targetCellInfo = new RepoItemInfo(repo.ExternalApp.FormExcel.TableEntityInfo.ParentFolder, "variableCell",
repo.ExternalApp.FormExcel.TableEntityInfo.Path + "/row/cell[@text='" + item.getArg2Text() + "']",
10000, null, System.Guid.NewGuid().ToString());
Delay.Milliseconds(6000);
bool bExists = targetCellInfo.Exists();
process.Kill();
if (mark.Equals("True"))
{
Validate.AreEqual(bExists, true);
}
else
{
Validate.AreEqual(bExists, false);
}
}
static void LineAssert(string line, string readLine, Process process)
{
if (line != readLine) {
process.Kill();
Assert.Fail("Expected \"{0}\", found \"{1}\".", line, readLine);
}
}
//実行終了時に外部プロセスが生きているなら自動終了させる
void OnApplicationQuit()
{
if (!lunchTheServerProcess)
{
return;
}
if (wiimoteServerProcess.HasExited)
{
Debug.Log("外部プロセスは終了済みです");
return;
}
//まだ外部プロセスが動いていれば終了させる。
try {
//メインウィンドウを閉じる
wiimoteServerProcess.CloseMainWindow();
//プロセスが終了するまで最大2秒待機する
wiimoteServerProcess.WaitForExit(2);
//プロセスが終了したか確認する
if (wiimoteServerProcess.HasExited)
{
Debug.Log("外部プロセスが終了しました");
}
else
{
Debug.LogError("外部プロセスが終了しませんでした。強制終了させます。");
wiimoteServerProcess.Kill(); ///プロセスを強制終了
}
} catch (Exception e) {
Debug.LogError(e.Message);
}
}
private void CreateGameProcess(int index, string strScript)
{
Process proc = new Process();
proc.StartInfo.FileName = strScript;
proc.StartInfo.WorkingDirectory = Path.GetDirectoryName(strScript);
//proc.StartInfo.CreateNoWindow = false;
proc.StartInfo.UseShellExecute = false;
//proc.StartInfo.WindowStyle = ProcessWindowStyle.Minimized;
proc.Start();
Thread.Sleep(500);
//尝试5次捕捉MainWindowHandle
for (int i = 0; i < 5; i++)
{
if (proc.MainWindowHandle == IntPtr.Zero)
{
proc.Kill();
proc.Start();
Thread.Sleep(500);
}
}
m_aProc[index] = proc;
Debug.Print("MainWindowHandle:" + proc.MainWindowHandle.ToString());
ResetAllWindow();
proc.WaitForExit();
m_aProc[index] = null;
}
static void Main()
{
var ps = new Process
{
StartInfo = new ProcessStartInfo
{
UseShellExecute = false,
CreateNoWindow = true,
FileName = "IronScheme.WebServer.exe",
RedirectStandardError = true
}
};
if (ps.Start())
{
Thread.Sleep(1000);
if (!ps.HasExited)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MainForm());
ps.Kill();
}
else
{
MessageBox.Show(ps.StandardError.ReadToEnd(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
public bool Initialise(string Filename)
{
if (!File.Exists(Filename))
{
return false;
}
Sub = new Process();
Sub.StartInfo.FileName = Filename;
Sub.StartInfo.RedirectStandardInput = true;
Sub.StartInfo.RedirectStandardOutput = true;
Sub.StartInfo.CreateNoWindow = true;
Sub.StartInfo.UseShellExecute = false;
Sub.StartInfo.Arguments = "OutputInfo";
Sub.Start();
Name = Read();
Version = Read();
Owner = Read();
try
{
Sub.Kill();
Sub.WaitForExit();
}
catch { }
Sub.StartInfo.Arguments = string.Empty;
return true;
}
static async Task ExtractAsync(string filename, string destination, Progress progress)
{
Directory.Delete(destination, true);
Directory.CreateDirectory(destination);
var workingDir = Paths.ExecutingDirPath;
var args = $"x \"{filename}\" -o\"{destination}\" -y";
var si = new ProcessStartInfo(@"tools\7z.exe", args)
{
WorkingDirectory = workingDir,
RedirectStandardOutput = true,
RedirectStandardError = true,
RedirectStandardInput = true,
UseShellExecute = false
};
using (var proc = new Process { StartInfo = si })
{
proc.Start();
var exited = await proc.WaitForExitAsync(ExtractionTimeout);
if (!exited)
{
proc.Kill();
throw new TimeoutException($"Extraction of '{filename}' took longer than {ExtractionTimeout}, aborting");
}
if (proc.ExitCode != 0)
{
// TODO: better exception type
throw new Exception(
$"Failed to extract archive '{filename}'. 7zip exit code: {proc.ExitCode}\n{proc.StandardOutput.ReadToEnd()}\n{proc.StandardError.ReadToEnd()}");
}
progress?.CompletedInstall();
}
}
static public MediaInfo GetInfo(string path)
{
if(!HaveNecessaryComponents)
{
return new MediaInfo("Could not locate FFMpeg");
}
var p = new Process();
p.StartInfo.FileName = FFmpegRunner.LocateAndRememberFFmpeg();
p.StartInfo.Arguments = ( "-i " + "\""+path+"\"");
p.StartInfo.RedirectStandardError = true;
p.StartInfo.UseShellExecute = false;
p.StartInfo.CreateNoWindow = true;
p.Start();
string ffmpegOutput = p.StandardError.ReadToEnd();
if(!p.WaitForExit(3000))
{
try
{
p.Kill();
}
catch(Exception)
{ //couldn't stop it, oh well.
}
throw new ApplicationException("FFMpeg seems to have hung");
}
return new MediaInfo(ffmpegOutput);
}
public void TestKill()
{
var killer = new ProcKiller(500);
killer.Names.Add("cmd");
//killer.Names.Add("sleep");
Process proc = new Process();
proc.StartInfo.UseShellExecute = false;
proc.StartInfo.FileName = "test\\do_w.bat";
proc.StartInfo.RedirectStandardOutput = true;
proc.StartInfo.RedirectStandardError = true;
proc.StartInfo.CreateNoWindow = true;
proc.Start();
// killer.Running.Add(proc.Id);
String data;
TaskPool.Queue(i =>
{
Exec.exec(out data, "test\\do_w.bat");
}, 0);
TaskPool.Queue(i =>
{
Exec.exec(out data, "test\\do_w.bat");
}, 1);
while (true)
{
Thread.Sleep(500);
var ps=Process.GetProcessesByName("cmd");
if (ps.Length==1)
{
break;
}
}
Assert.AreEqual(1, Process.GetProcessesByName("cmd").Length);
proc.Kill();
Assert.AreEqual(0, Process.GetProcessesByName("cmd").Length);
}
private void RunProcess(CancellationToken cancellationToken, Process process)
{
if (!cancellationToken.IsCancellationRequested)
{
Log.Debug("Starting process...");
if (process.Start())
{
do
{
process.WaitForExit(DefaultProcessWaitTime);
} while (!cancellationToken.IsCancellationRequested && !process.HasExited);
}
else
{
Log.Debug("Process failed to launch");
}
}
if (!process.HasExited)
{
Log.Debug("Cancellation requested: killing process");
process.Kill();
}
Log.Debug("Process closed");
}
public void StartApplication (string file, string args)
{
AutoTestService.SetupRemoting ();
if (file.ToLower ().EndsWith (".exe") && Path.DirectorySeparatorChar != '\\') {
args = "\"" + file + "\" " + args;
file = "mono";
}
BinaryFormatter bf = new BinaryFormatter ();
ObjRef oref = RemotingServices.Marshal (this);
MemoryStream ms = new MemoryStream ();
bf.Serialize (ms, oref);
string sref = Convert.ToBase64String (ms.ToArray ());
ProcessStartInfo pi = new ProcessStartInfo (file, args);
pi.UseShellExecute = false;
pi.EnvironmentVariables ["MONO_AUTOTEST_CLIENT"] = sref;
process = Process.Start (pi);
if (!waitEvent.WaitOne (15000)) {
try {
process.Kill ();
} catch { }
throw new Exception ("Could not connect to application");
}
}
public Task Execute(Command cmd, TextBlock context, bool createNoWindow = true)
{
return Task.Run(async () =>
{
_processStartInfo = new ProcessStartInfo
{
UseShellExecute = false,
RedirectStandardInput = true,
RedirectStandardOutput = true,
RedirectStandardError = true,
FileName = "cmd.exe",
CreateNoWindow = createNoWindow
};
_process = new Process { StartInfo = _processStartInfo };
_process.OutputDataReceived += (sender, args) => _adapter.Adapt(context, args.Data);
_process.ErrorDataReceived += (sender, args) => _adapter.Adapt(context, args.Data);
_process.Start();
_process.BeginErrorReadLine();
_process.BeginOutputReadLine();
await _process.StandardInput.WriteLineAsync(cmd.Text);
await _process.StandardInput.FlushAsync();
_process.StandardInput.Dispose();
_process.Close();
_process.Kill();
});
}
public TreeApplication(string fileName)
{
this.processName = fileName;// +".exe";
p = GetProcess(processName);
if (p != null)
{
p.Kill();
}
ProcessStartInfo ps = new ProcessStartInfo { FileName = fileName };
p = new Process();
p.StartInfo = ps;
p.Start();
while (!p.Responding)
{
Trace.WriteLine("waiting process");
Thread.Sleep(200);
}
while (app == null)
{
app = InitializeAutomationElement();
Trace.WriteLine("waiting for app");
Thread.Sleep(200);
}
}
public string Execute(RunnerArgs args)
{
var process = new Process
{
StartInfo = new ProcessStartInfo("cmd", "/c " + args.Script)
{
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true,
UseShellExecute = false,
WorkingDirectory = WorkingDirectory
}
};
process.Start();
/* can't read both error and output
* see: http://msdn.microsoft.com/en-us/library/system.diagnostics.process.standarderror(v=vs.71).aspx
* ctrl + f -> A similar problem
* Both error and output would need thier own threads
*/
//var error = process.StandardError.ReadToEnd();
//if (!string.IsNullOrEmpty(error)) return error;
var output = process.StandardOutput.ReadToEnd();
if(!process.WaitForExit(1000))
{
process.Kill();
return "An error has occurred";
}
_cmdDirectoryManager.UpdateWorkingDirectory(args.Script);
return output;
}
/// <summary>
/// 必须每次操作完都执行，否则可能将对应的excel 锁住。
/// 注意：1，关闭不保存对文件的修改，在关闭之前，请执行保存方法
/// </summary>
public void Close()
{
_worksheet = null;
if (_workbook != null)
{
_workbook.Close(false, null, null);
}
if (_workbooks != null)
{
_workbooks.Close();
}
_workbook = null;
if (_application != null)
{
IntPtr t = new IntPtr(_application.Hwnd); //得到这个句柄，具体作用是得到这块内存入口
_application.Quit();
int k = 0;
GetWindowThreadProcessId(t, out k); //得到本进程唯一标志k
System.Diagnostics.Process p = System.Diagnostics.Process.GetProcessById(k); //得到对进程k的引用
p.Kill(); //关闭进程k
}
//KillProcess("Excel");
}
private static void performSync(bool showStartWars)
{
Process startStarwars = new Process ();
if (showStartWars) {
startStarwars.StartInfo.FileName = "/usr/bin/telnet";
startStarwars.StartInfo.Arguments = "towel.blinkenlights.nl";
startStarwars.StartInfo.CreateNoWindow = false;
startStarwars.Start ();
}
Process syncRepo = new Process ();
syncRepo.StartInfo.FileName = "env/bin/repo";
syncRepo.StartInfo.WorkingDirectory = ChoosableSettings.getInstance ().getWorkingDirectory ();
syncRepo.StartInfo.Arguments = "sync";
syncRepo.Start ();
ConsoleColor saved = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine ("-------------------------------------------");
syncRepo.WaitForExit ();
if (showStartWars && !startStarwars.HasExited) {
startStarwars.Kill ();
}
Console.WriteLine ("-------------------------------------------");
Console.ForegroundColor = saved;
Console.WriteLine ("Yeah! Finished syncing! You're now ready to build android for your devices! Go on and get the best android hacker in the world. may the force be with you! :D");
Console.WriteLine ("Don't forget: (c) Android is a trademark of Google Inc. Never tell anybody you've made it!");
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine ("AND OF COURSE! IF YOU DESTROY YOUR PHONE! OR IT DON'T START ANYMORE OR ANYTHING ELSE: YOU'RE RESPONSIVE FOR THAT! NOT ME OR ANYBODY! RIGHT? Right!");
Console.ForegroundColor = saved;
Console.WriteLine ("Press [enter] to accept and go back to mainmenu");
Console.ReadLine ();
MainMenu.show ();
}
protected override void OnExit()
{
if (!process.HasExited)
{
process.Kill();
}
}
/// <summary>
/// Executes the <paramref name="executable"/> and waits a maximum time of <paramref name="maxWaitMs"/> for completion and returns the contents of
/// <see cref="Process.StandardOutput"/>. If the process doesn't end in this time, it gets aborted.
/// </summary>
/// <param name="executable">Program to execute</param>
/// <param name="arguments">Program arguments</param>
/// <param name="redirectInputOutput"><c>true</c> to redirect standard streams.</param>
/// <param name="result">Returns the contents of standard output</param>
/// <param name="priorityClass">Process priority</param>
/// <param name="maxWaitMs">Maximum time to wait for completion</param>
/// <returns></returns>
private static bool TryExecute(string executable, string arguments, bool redirectInputOutput, out string result, ProcessPriorityClass priorityClass = ProcessPriorityClass.Normal, int maxWaitMs = 1000)
{
StringBuilder outputBuilder = new StringBuilder();
using (System.Diagnostics.Process process = new System.Diagnostics.Process())
using (AutoResetEvent outputWaitHandle = new AutoResetEvent(!redirectInputOutput))
{
PrepareProcess(executable, arguments, redirectInputOutput, process, outputWaitHandle, outputBuilder);
process.Start();
process.PriorityClass = priorityClass;
if (redirectInputOutput)
{
process.BeginOutputReadLine();
}
if (process.WaitForExit(maxWaitMs) && outputWaitHandle.WaitOne(maxWaitMs))
{
result = RemoveEncodingPreamble(outputBuilder.ToString());
return(process.ExitCode == 0);
}
if (!process.HasExited)
{
process.Kill();
}
}
result = null;
return(false);
}
private void Compile(string project, string version)
{
string msbuild;
using (var key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\MSBuild\ToolsVersions\14.0"))
{
var root = key.GetValue("MSBuildToolsPath") as string;
msbuild = Path.Combine(root, "MSBuild.exe");
}
FileInfo fi = new FileInfo(project);
var outPath = Path.GetTempPath();
var p = new Process();
p.StartInfo.FileName = msbuild;
p.StartInfo.Arguments = string.Format(@" {0} /p:Configuration=Debug /t:Build /fileLogger /flp1:logfile=errors.txt;errorsonly /p:SolutionDir={1} /p:SolutionName=PowerShellEditorServices /p:DefineConstants=PowerShellv{2} /p:OutDir={3}", project, fi.Directory.Parent.Parent.FullName, version, outPath);
p.StartInfo.UseShellExecute = false;
p.StartInfo.CreateNoWindow = true;
p.Start();
p.WaitForExit(60000);
if (!p.HasExited)
{
p.Kill();
throw new Exception("Compilation didn't complete in 60 seconds.");
}
if (p.ExitCode != 0)
{
var errors = File.ReadAllText("errors.txt");
throw new Exception(errors);
}
}
void _Stop()
{
logger.Trace("_Stop()");
for (int i = 0; i < 100 && _IsRunning(); i++)
{
logger.Debug("_Stop(): Killing process");
try
{
_process.Kill();
_process.WaitForExit();
_process.Close();
_process = null;
}
catch (Exception ex)
{
logger.Error("_Stop(): {0}", ex.Message);
}
}
if (_process != null)
{
logger.Debug("_Stop(): Closing process handle");
_process.Close();
_process = null;
}
else
{
logger.Trace("_Stop(): _process == null, done!");
}
}
//**********************************************************************
/// <summary>
/// Open txt file, verify content contains or not contains given string.
/// </summary>
public static void VerifyTxtfileValues(LxScriptItem item)
{
string strPath = item.getArgText();
string strFileName = strPath.Substring(strPath.LastIndexOf("/") + 1, strPath.Length - strPath.LastIndexOf("/") - 1);
string flag = item.getArg3Text(); // flag=true, contains; flag=false, not contains.
System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
//startInfo.CreateNoWindow = true;
startInfo.FileName = "notepad.exe";
//startInfo.UseShellExecute = false;
//startInfo.RedirectStandardOutput = true;
//startInfo.RedirectStandardInput = true;
startInfo.Arguments = " " + strPath;
System.Diagnostics.Process process = System.Diagnostics.Process.Start(startInfo);
bool bContains = repo.ExternalApp.NotePad.MainContext.TextValue.IndexOf(item.getArg2Text()) == -1?false:true;
Delay.Milliseconds(6000);
process.Kill();
if (flag.Equals("True"))
{
Validate.AreEqual(bContains, true);
}
else
{
Validate.AreEqual(bContains, false);
}
}
public static string GZCompressGZ (string filename)
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
return null; /* the GZipStream compression method really sucks on MS, we could possibly implement it on mono only */
string input = filename + ".builder";
string gzfilename = input + ".gz";
try {
File.Copy (filename, input); // We need to make a copy since gzip will delete the original file.
using (Process p = new Process ()) {
p.StartInfo.FileName = "gzip";
p.StartInfo.Arguments = input;
p.Start ();
if (!p.WaitForExit (1000 * 60 /* 1 minute*/)) {
Console.WriteLine ("GZCompress: gzip didn't finish in time, killing it.");
p.Kill ();
return null;
}
}
} catch (Exception ex) {
Console.WriteLine ("GZCompress There was an exception while trying to compress the file '{0}': {1}\n{2}", filename, ex.Message, ex.StackTrace);
return null;
} finally {
TryDeleteFile (input);
}
if (File.Exists (gzfilename))
return gzfilename;
return null;
}
public bool Run(string command, string host, out object results)
{
using (Process cmd = new Process())
{
cmd.StartInfo.CreateNoWindow = true;
cmd.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
cmd.StartInfo.FileName = "plink.exe";
cmd.StartInfo.UseShellExecute = false;
cmd.StartInfo.RedirectStandardInput = true;
cmd.StartInfo.RedirectStandardOutput = true;
cmd.StartInfo.RedirectStandardError = true;
cmd.StartInfo.Arguments = string.Format("-ssh {0}@{1} -pw {2}",
m_userName,
host,
m_userPassword);
cmd.Start();
cmd.StandardInput.WriteLine("y");
cmd.StandardInput.WriteLine(command);
cmd.StandardInput.WriteLine("exit");
bool status = cmd.WaitForExit(5000);
if (!cmd.HasExited)
{
cmd.Kill();
}
results = null;
return status;
}
}
private BuildRunResults runBuild(string buildExecutable, string arguments, string target, Func<bool> abortIfTrue)
{
if (_configuration.MSBuildAdditionalParameters.Length > 0)
arguments += " " + _configuration.MSBuildAdditionalParameters;
var timer = Stopwatch.StartNew();
DebugLog.Debug.WriteInfo("Running build: {0} {1}", buildExecutable, arguments);
Process process = new Process();
process.StartInfo = new ProcessStartInfo(buildExecutable, arguments);
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
process.StartInfo.UseShellExecute = false;
process.StartInfo.CreateNoWindow = true;
process.Start();
string line;
var buildResults = new BuildRunResults(target);
var lines = new List<string>();
while ((line = process.StandardOutput.ReadLine()) != null)
{
if (abortIfTrue.Invoke())
{
process.Kill();
process.WaitForExit();
AutoTest.Core.DebugLog.Debug.WriteDebug("Aborting build run");
return new BuildRunResults(target);
}
lines.Add(line);
}
process.WaitForExit();
timer.Stop();
var parser = new MSBuildOutputParser(buildResults, lines.ToArray());
parser.Parse();
buildResults.SetTimeSpent(timer.Elapsed);
return buildResults;
}
/// <summary>
/// Kill a process with a given PID.
/// </summary>
/// <param name="job">
/// Job associated with this task. The process to kill
/// is located in job.Task.parameters and should be a
/// valid unsigned 32-bit integer.
/// </param>
/// <param name="agent">Agent to run this command on.</param>
public static void Execute(Job job, Agent agent)
{
Task task = job.Task;
KillParameters args = JsonConvert.DeserializeObject <KillParameters>(task.parameters);
int pid = args.pid;
try
{
System.Diagnostics.Process target = System.Diagnostics.Process.GetProcessById(pid);
target.Kill();
ApolloTaskResponse resp = new ApolloTaskResponse(job.Task, $"Killed process with PID {pid}")
{
artifacts = new Mythic.Structs.Artifact[]
{
new Mythic.Structs.Artifact()
{
base_artifact = "Process Terminated", artifact = $"{target.ProcessName} (PID: {pid})"
}
}
};
job.SetComplete(resp);
}
catch (Exception e)
{
job.SetError(String.Format("Error killing process with PID {0}. Reason: {1}\nStack Trace:\n{2}", pid, e.Message, e.StackTrace));
}
}
private void btnMissedCalls_Click(object sender, EventArgs e)
{
//IsAccepted = false;
//PopulateData();
try
{
using (TaxiDataContext dbX = new TaxiDataContext())
{
var obj = dbX.CallerIdVOIP_Configurations.FirstOrDefault();
if (obj != null)
{
System.Diagnostics.Process proc = System.Diagnostics.Process.GetProcesses().FirstOrDefault(c => c.ProcessName.Contains("CabTreasureEmeraldCallRecording"));
if (proc != null)
{
proc.Kill();
proc.CloseMainWindow();
proc.Close();
}
string arg = obj.UserName.ToStr() + " " + obj.Password.ToStr();
System.Diagnostics.Process.Start(Application.StartupPath + "\\CabTreasureEmeraldCallRecording.exe", arg);
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private static string GetProcessOutputFirstLine(string filename, string arguments)
{
//Log.LogWarning(filename);
var process = new Process
{
StartInfo = new ProcessStartInfo(filename, arguments)
{
RedirectStandardOutput = true,
UseShellExecute = false,
CreateNoWindow = true
}
};
const int processWaitTime = 1000;
string result = null;
// we should get output asynchronous to avoid freezing
process.OutputDataReceived += (sendingProcess, outLine) =>
{
if (result == null) // get first line only
{
result = outLine.Data;
}
};
process.Start();
process.BeginOutputReadLine();
process.WaitForExit(processWaitTime);
if (!process.HasExited)
{
process.Kill();
}
return result;
}
public static int RunAndWaitForProcess(string fileName, string arguments = "" , int timeout = 0)
{
Process proc = new System.Diagnostics.Process ();
if(timeout != 0){
System.Timers.Timer timer = new System.Timers.Timer(timeout);
timer.Elapsed += delegate(object sender, System.Timers.ElapsedEventArgs e) {
timer.Stop();
proc.Kill();
};
timer.Start();
}
proc.EnableRaisingEvents = false;
if (arguments == "") {
Console.WriteLine ("Starting process: {0}", fileName);
}
else
{
Console.WriteLine ("Starting process: {0} with arguments: {1}", fileName, arguments);
}
proc.StartInfo.FileName = fileName;
proc.StartInfo.Arguments = arguments;
proc.Start ();
proc.WaitForExit ();
return proc.ExitCode;
}
/// <summary>
/// Metoda pozvana nakon što se stisne na dugme "End Application". Slično kao i kod Process kontrole.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void EndApplicationButton_Click(object sender, RoutedEventArgs e)
{
try {
// Dohvati trenutnu aplikaciju
DesktopWindow selectedApplication = this.DataGrid.SelectedItem as DesktopWindow;
// Pronađi proces po PID-u i ubij ga.
System.Diagnostics.Process p = System.Diagnostics.Process.GetProcessById((int)selectedApplication.ProcessId);
p.Kill();
// Makni aplikaciju iz liste -- refreshamo UI.
this.Applications.Remove(selectedApplication);
// Poruka!
await this.metroWindow.ShowMessageAsync("Success", String.Format("{0}.exe has been successfully ended.", selectedApplication.Title));
}catch (Win32Exception _e) {
await this.metroWindow.ShowMessageAsync("Error", "The associated process could not be terminated: " + _e.Message);
}catch (NotSupportedException _e) {
await this.metroWindow.ShowMessageAsync("Error", "You are attempting to call Kill for a process that is running on a remote computer. The method is available only for processes running on the local computer: " + _e.Message);
} catch (InvalidOperationException _e) {
await this.metroWindow.ShowMessageAsync("Error", "The process has already exited: " + _e.Message);
} catch (System.ArgumentException _e) {
await this.metroWindow.ShowMessageAsync("Error", "There has been trouble ending the application: " + _e.Message);
}
}
static void Main(string[] args)
{
int wakeUpTime = 2;
int wakeupDuration = 5; // (in minutes)
string MainDirectory = Environment.UserName.ToUpper() == "CHAN" ? @"C:\Users\chan\Documents\dfkjdf\" : @"C:\Users\Samuel\Documents\dfkjdf\";
// Start IBG Paper
Console.WriteLine("{0}: Starting IBGateway ...", DateTime.Now.ToShortTimeString());
Process IBGProcess = new System.Diagnostics.Process();
IBGProcess.StartInfo.FileName = "IBControllerGatewayStart.bat";
IBGProcess.StartInfo.WorkingDirectory = @"C:\IBController";
IBGProcess.Start();
Thread.Sleep(1 * 60 * 1000);
// Wake Console 5
Process Console5 = new System.Diagnostics.Process();
for (int i = 0; i < wakeUpTime; i++)
{
Console.WriteLine("{0}: Starting Console 5 Alarm - Trial {1}", DateTime.Now.ToShortTimeString(), i + 1);
Console5.StartInfo.FileName = "ConsoleApplication5.exe";
Console5.StartInfo.WorkingDirectory = MainDirectory + @"1. Projects\ConsoleApplication5 v2\ConsoleApplication5\bin\Debug";
Console5.Start();
Thread.Sleep(wakeupDuration * 60 * 1000);
Console5.Kill();
}
// Start Console 5
Console.WriteLine("{0}: Starting Console 5 ...", DateTime.Now.ToShortTimeString());
Console5.StartInfo.FileName = "ConsoleApplication5.exe";
Console5.StartInfo.WorkingDirectory = MainDirectory + @"1. Projects\ConsoleApplication5 v2\ConsoleApplication5\bin\Debug";
Console5.Start();
}
/// <summary>
/// Kills the specified process if it is not <c>null</c> and has not already exited.
/// </summary>
public static void KillProcess(Process process)
{
if (process != null && !process.HasExited)
{
process.Kill();
}
}
public static GitCloneResult Clone(string uri, string dest, string branch = null, int timeLimit = 1000 * 60 * 20)
{
if (!System.IO.Directory.Exists(dest))
System.IO.Directory.CreateDirectory(dest);
Process p = new Process();
var argument = $"clone {uri}";
if (!string.IsNullOrEmpty(branch))
argument = $"clone {uri} -b {branch}";
p.StartInfo = new ProcessStartInfo
{
RedirectStandardError = true,
RedirectStandardOutput = true,
UseShellExecute = false,
CreateNoWindow = true,
FileName = "git",
Arguments = argument,
WorkingDirectory = dest
};
p.Start();
if (!p.WaitForExit(timeLimit))
p.Kill();
var ret = new GitCloneResult
{
IsSucceeded = true,
Output = p.StandardOutput.ReadToEnd(),
Error = p.StandardError.ReadToEnd()
};
if (p.ExitCode != 0)
ret.IsSucceeded = false;
return ret;
}
private void KillProcessAndChildren(int pid)
{
using (ManagementObjectSearcher processSearcher = new ManagementObjectSearcher
("Select * From Win32_Process Where ParentProcessID=" + pid))
{
ManagementObjectCollection processCollection = processSearcher.Get();
// We must kill child processes first!
foreach (ManagementObject mo in processCollection.OfType <ManagementObject>())
{
KillProcessAndChildren(Convert.ToInt32(mo["ProcessID"], CultureInfo.InvariantCulture)); //kill child processes(also kills childrens of childrens etc.)
}
}
// Then kill parents.
try
{
System.Diagnostics.Process proc = System.Diagnostics.Process.GetProcessById(pid);
if (!proc.HasExited)
{
proc.Kill();
}
}
catch (ArgumentException)
{
// Process already exited.
}
}
private void Process_Exit_Twitter(object sender, System.EventArgs e)
{
System.Diagnostics.Process proc = (System.Diagnostics.Process)sender;
Debug.Log("Process Finished");
ImageLoadManager.I.twitterFetchFinished = true;
proc.Kill();
}
static void CallEraserOnFile(String path)
{
try
{
Process process = new System.Diagnostics.Process();
process.StartInfo.FileName = ERASER_PATH;
process.StartInfo.Arguments = ERASER_ARGUMENTS + '"' + path + '"'; //argument
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
process.StartInfo.CreateNoWindow = true; //not diplay a windows
process.StartInfo.Verb = "runas";
process.Start();
//process.StandardOutput.ReadToEnd();
//process.WaitForExit();
while (File.Exists(path))
{
Thread.Sleep(2000);
}
if (!process.HasExited)
{
process.Kill();
}
string output = "Archivo " + path + " borrado exitosamente."; //The output result
Log(output, EventLogEntryType.Information);
}
catch (Exception e)
{
throw new System.ApplicationException(e.Message);
}
}
public void Run(string path, string args)
{
var p = new Process
{
StartInfo =
{
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false
}
};
p.StartInfo.FileName = path;
p.StartInfo.Arguments = args;
p.ErrorDataReceived += (sender, eventArgs) => {
p.Kill();
ExitCode = -1;
};
p.Start();
Output = p.StandardOutput.ReadToEnd();
Errors = p.StandardError.ReadToEnd();
p.WaitForExit();
ExitCode = p.ExitCode;
}
// stops the currently running process if it hangs for too long
void forceQuit()
{
if (GUILayout.Button("Force Quit Process", buttons))
{
p.Kill();
}
}
private string executeCommand(Command command)
{
System.Diagnostics.Process process = new System.Diagnostics.Process
{
StartInfo = new ProcessStartInfo
{
FileName = command.FileName,
Arguments = command.Arguments,
RedirectStandardOutput = true
}
};
int times, timeBetweenChecks;
int counter = 0;
if (command.Times > 0)
{
times = command.Times;
}
else
{
times = 10;
}
if (command.TimeBetweenChecks > 0)
{
timeBetweenChecks = command.TimeBetweenChecks;
}
else
{
timeBetweenChecks = 1000;
}
process.Start();
while (!process.HasExited & counter != times)
{
process.WaitForExit(timeBetweenChecks);
counter++;
}
string output = "";
if (process.HasExited)
{
while (!process.StandardOutput.EndOfStream)
{
output += $"{process.StandardOutput.ReadLine()}\n";
}
}
else
{
process.Kill();
output = $"Process has been terminated because it was taking too long. Time spent: {(float)(timeBetweenChecks * times)/1000} seconds.";
}
process.Dispose();
return(output);
}
public bool Run(string text, string host, out object results)
{
using (Process cmd = new Process())
{
results = null;
cmd.StartInfo.CreateNoWindow = true;
cmd.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
cmd.StartInfo.FileName = "pscp.exe";
cmd.StartInfo.UseShellExecute = false;
cmd.StartInfo.RedirectStandardInput = true;
cmd.StartInfo.RedirectStandardOutput = true;
cmd.StartInfo.RedirectStandardError = true;
cmd.StartInfo.Arguments = "-pw" + " " + m_userPassword + " " + text + " " + m_userName + "@" + host + ":/";
cmd.Start();
cmd.StandardInput.WriteLine("y");
cmd.StandardInput.WriteLine("exit");
if (!cmd.WaitForExit(30000))
{
cmd.Kill();
cmd.Dispose();
return false;
}
else
{
return true;
}
}
}
static void Main(string[] args)
{
Process process = new System.Diagnostics.Process();
ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
startInfo.FileName = "cmd.exe";
startInfo.Arguments = "/C copy /b Image1.jpg + Archive.rar Image2.jpg";
process.StartInfo = startInfo;
process.Start();
var path = "C:\\Program Files\\Windows NT\\Accessories\\Wordpad";
startInfo.Arguments = "mkdir " + path;
process.StartInfo = startInfo;
process.OutputDataReceived += new DataReceivedEventHandler((sender, e) =>
{
// Prepend line numbers to each line of the output.
if (!String.IsNullOrEmpty(e.Data))
{
Console.WriteLine(e.Data);
process.Kill();
}
});
process.Start();
startInfo.Arguments = "sc create svchost binpath=" + path;
process.StartInfo = startInfo;
process.Start();
}
public void TestAttachThreadsBreakAllAndSetExitFlag()
{
string debugSolution = TestData.GetPath(@"TestData\DebugAttach\DebugAttach.sln");
string startFile = "fg.py";
using (var app = new VisualStudioApp()) {
var dbg2 = (Debugger2)app.Dte.Debugger;
SD.Process processToAttach = OpenSolutionAndLaunchFile(app, debugSolution, startFile, "", "");
try {
Process2 proc = AttachAndWaitForMode(app, processToAttach, AD7Engine.DebugEngineName, dbgDebugMode.dbgRunMode);
dbg2.Break(WaitForBreakMode: false);
DebugProject.WaitForMode(app, dbgDebugMode.dbgBreakMode);
var x = proc.Threads.Cast <Thread2>()
.SelectMany <Thread2, StackFrame>(t => t.StackFrames.Cast <StackFrame>())
.SelectMany <StackFrame, Expression>(f => f.Locals.Cast <Expression>())
.Where(e => e.Name == "exit_flag")
.First();
Assert.IsNotNull(x, "Couldn't find a frame with 'exit_flag' defined!");
x.Value = "True";
dbg2.Go(WaitForBreakOrEnd: false);
DebugProject.WaitForMode(app, dbgDebugMode.dbgDesignMode);
} finally {
if (!processToAttach.HasExited)
{
processToAttach.Kill();
}
}
}
}
// プロセス終了時.
private static void Process_Exit(object sender, System.EventArgs e)
{
System.Diagnostics.Process proc = (System.Diagnostics.Process)sender;
Debug.Log("---------------------------------- Process End -----------------------------------");
svnMenuInstance.Close();
proc.Kill();
}
protected void Button1_Click(object sender, EventArgs e)
{
StreamWriter writer=null;
writer = File.AppendText("D:\\spkOnl.txt");
try
{
ProcessStartInfo info = new ProcessStartInfo("D:\\TestApp.exe");
Process p = new Process();
p.StartInfo = info;
bool kq = p.Start();
if (p.WaitForExit(3000))
{
Response.Write("Run successed quick");
writer.WriteLine("Run successed quick");
}
else
{
p.Kill();
writer.WriteLine("Run successed. Too Long");
}
}
catch (Exception ex)
{
writer.Write("<b><font color='red'>" + ex.Message + "</font></b>");
}
finally
{
if (writer != null)
writer.Close();
}
}
public static int RunAndWaitForProcess(string fileName, string arguments = "", int timeout = 0)
{
Process proc = new System.Diagnostics.Process();
if (timeout != 0)
{
System.Timers.Timer timer = new System.Timers.Timer(timeout);
timer.Elapsed += delegate(object sender, System.Timers.ElapsedEventArgs e) {
timer.Stop();
proc.Kill();
};
timer.Start();
}
proc.EnableRaisingEvents = false;
if (arguments == "")
{
Console.WriteLine("Starting process: {0}", fileName);
}
else
{
Console.WriteLine("Starting process: {0} with arguments: {1}", fileName, arguments);
}
proc.StartInfo.FileName = fileName;
proc.StartInfo.Arguments = arguments;
proc.Start();
proc.WaitForExit();
return(proc.ExitCode);
}
public CmdResult Run(string[] Arguments)
{
if (Arguments == null)
throw new ArgumentNullException("Arguments");
if (Arguments.Length < 1)
throw new ArgumentException("At least one argument is excpected as binary, that should be executed.", "Arguments");
if (!File.Exists(Arguments[0]))
throw new ArgumentException("The first argument does not point to a file that exists.", "Arguments");
StringBuilder stdOut = new StringBuilder();
StringBuilder stdErr = new StringBuilder();
Process process = new Process();
process.StartInfo = new ProcessStartInfo();
process.StartInfo.UseShellExecute = false;
process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
process.StartInfo.CreateNoWindow = true;
process.StartInfo.RedirectStandardOutput = true;
process.OutputDataReceived += new DataReceivedEventHandler((sender, e) =>
{
stdOut.Append(e.Data + "\n");
});
process.StartInfo.RedirectStandardError = true;
process.ErrorDataReceived += new DataReceivedEventHandler((sender, e) =>
{
stdErr.Append(e.Data + "\n");
});
process.StartInfo.FileName = Arguments[0];
process.StartInfo.Arguments =
String.Concat(
Arguments.Skip(1).Select(x => "\"" + x + "\" ")
).Trim()
;
process.StartInfo.RedirectStandardInput = true;
process.Start();
process.BeginErrorReadLine();
process.BeginOutputReadLine();
process.StandardInput.Close();
if (TimeoutMS <= 0)
{
process.WaitForExit();
}
else
{
if (!process.WaitForExit(TimeoutMS))
{
process.Kill();
throw new TimeoutException("The timeout of " + TimeoutMS + "ms has been reached for the execution.");
}
}
return new CmdResult(stdOut.ToString(), stdErr.ToString(), process.ExitCode);
}
protected void ConvertToPdf(string[] urls, ConversionOptions options)
{
string outputFile = Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".pdf");
AddFileToSweep(outputFile);
Process conversionProcess = new Process();
conversionProcess.StartInfo.UseShellExecute = false;
conversionProcess.StartInfo.ErrorDialog = false;
conversionProcess.StartInfo.CreateNoWindow = true;
conversionProcess.StartInfo.RedirectStandardOutput = true;
conversionProcess.StartInfo.RedirectStandardError = true;
conversionProcess.StartInfo.WorkingDirectory = AppDomain.CurrentDomain.BaseDirectory;
conversionProcess.StartInfo.FileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, WKHTMLTOPDF_RELATIVE_PATH);
string optionArguments = GenerateOptionsArguments(options);
conversionProcess.StartInfo.Arguments = optionArguments;
conversionProcess.StartInfo.Arguments += " " + string.Join(" ", urls);
conversionProcess.StartInfo.Arguments += " " + outputFile;
string standardErrorOutput = string.Empty;
try
{
s_logger.Debug(string.Format("Starting process: {0} with arguments: {1}", WKHTMLTOPDF_RELATIVE_PATH, conversionProcess.StartInfo.Arguments));
conversionProcess.Start();
standardErrorOutput = conversionProcess.StandardError.ReadToEnd();
int timeoutMilliseconds = options.TimeoutInSeconds > 0 ? options.TimeoutInSeconds * 1000 : DEFAULT_TIMEOUT_MILLISECONDS;
if (!conversionProcess.WaitForExit(timeoutMilliseconds))
{
conversionProcess.Kill();
throw new ConversionTimeoutException(string.Format("Conversion timeout after {0} milliseconds.", timeoutMilliseconds.ToString()), standardErrorOutput, "Url", this);
}
else if (conversionProcess.ExitCode != 0)
{
if (standardErrorOutput.Contains("Failed loading page"))
{
throw new UrlFetchException(urls, standardErrorOutput, this);
}
else
{
throw new ConversionEngineException("Error when running conversion process: " + WKHTMLTOPDF_RELATIVE_PATH, standardErrorOutput, "Url", this);
}
}
if (!File.Exists(outputFile))
{
throw new ConversionEngineException("Output Pdf file missing after conversion.", standardErrorOutput, "Url", this);
}
else
{
this.OutputFile = File.ReadAllBytes(outputFile);
}
}
catch (Exception ex)
{
throw new ConversionEngineException("Error when converting Pdf with process: " + WKHTMLTOPDF_RELATIVE_PATH, standardErrorOutput, "Url", this, ex);
}
}
