public bool HandleUnmonitoredProcesses()
{
try
{
var processes = Process.GetProcessesByName(ApplicationName);
foreach (var process in processes)
{
if (ProcessHandlers.All(procHandle => procHandle.Process == null || procHandle.Process.Id != process.Id))
{
// This process o
var processHandler = new ProcessHandler
{
WaitForExit = false,
NonResponsiveInterval = NonResponsiveInterval,
};
processHandler.MonitorProcess(process);
ProcessHandlers.Add(processHandler);
}
// Perform
}
}
catch (Exception ex)
{
Logger.Warn("Error while starting to monitor application {0}: {1}", ApplicationName, ex.Message);
//Debug.WriteLine(ex.Message);
}
return(true);
}
private static void checkprogress()
{
try
{
IntPtr hFocusPearlCommandPrompt = ProcessHandlers.FindWindow(null, PearlModelCommandPrompt);
while (!(hFocusPearlCommandPrompt.Equals(IntPtr.Zero)))
{
Thread.Sleep(25000);
hFocusPearlCommandPrompt = ProcessHandlers.FindWindow(null, PearlModelCommandPrompt);
Thread.Sleep(25000);
}
Thread.Sleep(25000);
IntPtr hFocusPearlCommandPromptCheck = ProcessHandlers.FindWindow(null, PearlModelCommandPrompt);
while (!(hFocusPearlCommandPromptCheck.Equals(IntPtr.Zero)))
{
Thread.Sleep(25000);
hFocusPearlCommandPromptCheck = ProcessHandlers.FindWindow(null, PearlModelCommandPrompt);
Thread.Sleep(25000);
}
}
catch (Exception)
{
throw;
}
}
private void HandleExitedProcesses()
{
for (int index = 0; index < ProcessHandlers.Count; index++)
{
var processHandler = ProcessHandlers[index];
if (processHandler.HasExited)
{
Logger.Warn("Process {0} has exited", processHandler.Name);
//Debug.WriteLine("{0} has exited", processHandler.Name);
processHandler.Close();
var notEnoughProcesses = (ProcessNo(processHandler.Name) < MinProcesses);
var lessProcessesThanBefore = (ProcessNo(processHandler.Name) < MaxProcesses) && KeepExistingNoProcesses;
if (notEnoughProcesses || lessProcessesThanBefore)
{
if (notEnoughProcesses)
{
Logger.Info("Process {0} has exited and no others are running, so start new", processHandler.Name);
}
if (lessProcessesThanBefore)
{
Logger.Info("Process {0} has exited, and number of processed needs to maintained , so start new", processHandler.Name);
}
processHandler.CallExecutable();
}
else
{
Logger.Info("Process {0} has exited, but no requirement to start new one", processHandler.Name);
ProcessHandlers.Remove(processHandler);
}
}
}
}
public virtual void ProcessRequest(HttpContext context)
{
SetHeaders();
ProcessHandlers.ForEach(x => x(this));
InvokeMethod();
DisposeHandlers.ForEach(x => x(this));
Dispose();
context.Response.End();
}
private void HandleProcessNotRunning()
{
var processes = Process.GetProcessesByName(ApplicationName);
if (processes.Length == 0)
{
// Start new process
var processHandler = new ProcessHandler
{
WaitForExit = false,
NonResponsiveInterval = NonResponsiveInterval,
StartingInterval = StartupMonitorDelay
};
Logger.Info("No process of application {0} is running, so one will be started", ApplicationName);
processHandler.CallExecutable(ApplicationPath, "");
ProcessHandlers.Add(processHandler);
}
}
public static void RunOCRonBluebeamtool(string folderpath)
{
try
{
ProcessHandlers.killapp("Revu");
var psi = new ProcessStartInfo(ExeSourceFile);
psi.UseShellExecute = true;
_application = TestStack.White.Application.AttachOrLaunch(psi);
Process p = Process.GetProcessesByName("Revu").FirstOrDefault();
while (p.MainWindowHandle == IntPtr.Zero)
{
p.Refresh();
}
p.WaitForInputIdle();
if (p != null)
{
IntPtr h = p.MainWindowHandle;
ProcessHandlers.SetForegroundWindow(h);
p.WaitForInputIdle();
IntPtr hPRAZChem = ProcessHandlers.FindWindow(null, "Bluebeam Revu x64");
if (!hPRAZChem.Equals(IntPtr.Zero))
{
ProcessHandlers.SetForegroundWindow(hPRAZChem);
}
p.WaitForInputIdle();
Thread.Sleep(3000);
sendkeyevent(1, "%");
// sendkeyevent(1, "{RIGHT}");
sendkeyevent(1, "{DOWN}");
sendkeyevent(7, "{RIGHT}");
sendkeyevent(1, "{ENTER}");
sendkeyevent(1, "{DOWN}");
sendkeyevent(1, "{ENTER}");
IntPtr hPRAZChem1 = ProcessHandlers.FindWindow(null, "Add Files for Batch Processing");
p.WaitForInputIdle();
if (!hPRAZChem1.Equals(IntPtr.Zero))
{
ProcessHandlers.SetForegroundWindow(hPRAZChem1);
}
p.WaitForInputIdle();
SendKeys.SendWait(folderpath);
Thread.Sleep(10000);
if (folderpath.Contains(".pdf"))
{
sendkeyevent(4, "{ENTER}");
}
else
{
sendkeyevent(1, "{ENTER}");
Thread.Sleep(3000);
sendkeyevent(8, "{TAB}");
sendkeyevent(1, "^(a)");
// SendKeys.SendWait("{A}");
sendkeyevent(4, "{ENTER}");
}
checkprogress();
checkprogress();
p.WaitForInputIdle();
ProcessHandlers.killapp("Revu");
}
}
catch (Exception ex)
{
throw;
}
}
private ProcessHandler FindProcessHandler(Process process)
{
return(ProcessHandlers.Find((processHander) => processHander.Process.Id == process.Id));
}
public void HandleDuplicateProcesses()
{
//if (ProcessNo(ApplicationName) < MaxProcesses))
{
var processes = Process.GetProcessesByName(ApplicationName);
if (processes.Length <= MaxProcesses)
{
return;
}
//if (processes.Length <= 1) return ;
Logger.Error("multiple processes of application {0} are running, all but one will be killed ", ApplicationName);
var remainingProcesses = new List <Process>();
var result = true;
var nummProcesses = processes.Length;
//Wield out the bad applications first
foreach (var process in processes)
{
var processHandler = FindProcessHandler(process);
// Make sure we leave at least one process running
if (nummProcesses <= MaxProcesses)
{
break;
}
if (!process.Responding)
{
Logger.Warn("unresponsive duplicate process {0} will now be killed ", ApplicationName);
var currResult = (processHandler != null)?processHandler.Kill():ProcessUtils.KillProcess(process);
if (currResult && processHandler != null)
{
ProcessHandlers.Remove(processHandler);
processHandler.Close();
Logger.Info("Unresponsive duplicate process {0} has been killed ", ApplicationName);
}
else
{
Logger.Error("Unresponsive duplicate process {0} could not be killed ", ApplicationName);
}
result = result && currResult;
nummProcesses--;
}
else
{
remainingProcesses.Add(process);
}
//Return the other process instance.
}
//Loop through the running processes in with the same name
for (var index = MaxProcesses; index < remainingProcesses.Count; index++)
{
var process = remainingProcesses[index];
var processHandler = FindProcessHandler(process);
Logger.Warn("unresponsive duplicate process {0} will now be killed ", ApplicationName);
var currResult = ProcessUtils.KillProcess(process);
if (currResult && processHandler != null)
{
ProcessHandlers.Remove(processHandler);
processHandler.Close();
Logger.Info("Duplicate process {0} has been killed ", ApplicationName);
}
else
{
Logger.Error("Unresponsive duplicate process {0} could not be killed ", ApplicationName);
}
result = result && currResult;
}
}
}
private void HandleNonResponsiveProcesses()
{
for (var index = 0; index < ProcessHandlers.Count; index++)
{
var processHandler = ProcessHandlers[index];
if (processHandler.HasExited)
{
continue; // We will deal with this later
}
if (processHandler.IsStarting)
{
//Logger.Info("Process {0} is still in startup phase, no checking is being performed", processHandler.Name);
Debug.WriteLine("Process {0} is still in startup phase, no checking is being performed", processHandler.Name);
continue; // Is still starting up, so ignore
}
if (_heartbeatServer.HeartbeatTimedOut(processHandler.Name, HeartbeatInterval / 2) && UseHeartbeat)
{
//todo: add throttling
Logger.Warn("No heartbeat received from process {0} within the soft limit", processHandler.Name);
//Debug.WriteLine("Process {0} has no heartbeat within soft limit", processHandler.Name);
}
//if (processHandler.Responding && !_heartbeatServer.HeartbeatHardTimeout(processHandler.Name)) continue;
//Debug.WriteLine("Process {0} not responding", processHandler.Name);
var notRespondingAfterInterval = processHandler.NotRespondingAfterInterval;
var noHeartbeat = _heartbeatServer.HeartbeatTimedOut(processHandler.Name, HeartbeatInterval) && UseHeartbeat;
var requestedKill = _heartbeatServer.KillRequested(processHandler.Name);
var performKill = notRespondingAfterInterval || noHeartbeat || requestedKill;
var reason = notRespondingAfterInterval ? "not responding" : noHeartbeat ? "not sending a heartbeat signal within hard limit" : "requesting to be killed";
if (performKill)
{
Logger.Error("process {0} is {1}, and will be killed ", processHandler.Name, reason);
//Debug.WriteLine("Process {0} is not responsive, or no heartbeat within hard limit",processHandler.Name);
if (processHandler.Kill())
{
Logger.Error("Process {0} was {1} and has been successfully killed ", processHandler.Name, reason);
//Debug.WriteLine("Process {0} has been killed due to non-responsiveness not responding",processHandler.Name);
processHandler.Close();
var notEnoughProcesses = (ProcessNo(processHandler.Name) < MinProcesses);
var lessProcessesThanBefore = (ProcessNo(processHandler.Name) < MaxProcesses) && KeepExistingNoProcesses;
//if ((ProcessNo(processHandler.Name) == 0) || (ProcessNo(processHandler.Name) > 0) && (KeepExistingNoProcesses && !EnsureSingleProcess))
if (notEnoughProcesses || lessProcessesThanBefore)
{
processHandler.CallExecutable();
}
else
{
ProcessHandlers.Remove(processHandler);
}
}
else
{
// todo smarter handling of this case (try again in next loop, put to sleep, etc)
Logger.Error("Process {0} was {1} but could not be successfully killed ", processHandler.Name, reason);
//Debug.WriteLine("Process {0} could not be killed after getting non responsive",processHandler.Name);
}
}
}
}
