/// <summary>
/// Run the callback in a new thread immediately. If the thread exits with an exception log it but do
/// not propogate it.
/// </summary>
/// <param name="callback">Code for the thread to execute.</param>
/// <param name="obj">Object to pass to the thread.</param>
/// <param name="name">Name of the thread</param>
public static void RunInThread(WaitCallback callback, object obj, string name, bool log = false)
{
if (Util.FireAndForgetMethod == FireAndForgetMethod.RegressionTest)
{
Culture.SetCurrentCulture();
callback(obj);
return;
}
ThreadStart ts = new ThreadStart(delegate()
{
try
{
Culture.SetCurrentCulture();
callback(obj);
}
catch (Exception e)
{
m_log.Error(string.Format("[WATCHDOG]: Exception in thread {0}.", name), e);
}
finally
{
try
{
Watchdog.RemoveThread(log: false);
}
catch { }
}
});
StartThread(ts, name, false, log: log);
}
private void ProcessRequests()
{
while (IsRunning || m_jobQueue.Count > 0)
{
try
{
CurrentJob = m_jobQueue.Take(m_cancelSource.Token);
}
catch (ObjectDisposedException e)
{
// If we see this whilst not running then it may be due to a race where this thread checks
// IsRunning after the stopping thread sets it to false and disposes of the cancellation source.
if (IsRunning)
{
throw e;
}
else
{
m_log.DebugFormat("[JobEngine] {0} stopping ignoring {1} jobs in queue",
Name, m_jobQueue.Count);
break;
}
}
catch (OperationCanceledException)
{
break;
}
if (LogLevel >= 1)
{
m_log.DebugFormat("[{0}]: Processing job {1}", LoggingName, CurrentJob.Name);
}
try
{
CurrentJob.Action();
}
catch (Exception e)
{
m_log.Error(
string.Format(
"[{0}]: Job {1} failed, continuing. Exception ", LoggingName, CurrentJob.Name), e);
}
if (LogLevel >= 1)
{
m_log.DebugFormat("[{0}]: Processed job {1}", LoggingName, CurrentJob.Name);
}
CurrentJob = null;
}
Watchdog.RemoveThread(false);
m_finishedProcessingAfterStop.Set();
}
public static Thread StartThread(
ThreadStart start, string name, ThreadPriority priority, int stackSize = -1, bool suspendflow = true)
{
Thread thread;
if (suspendflow)
{
using (ExecutionContext.SuppressFlow())
{
if (stackSize > 0)
{
thread = new Thread(start, stackSize);
}
else
{
thread = new Thread(start);
}
}
}
else
{
if (stackSize > 0)
{
thread = new Thread(start, stackSize);
}
else
{
thread = new Thread(start);
}
}
thread.Priority = priority;
thread.IsBackground = true;
thread.Name = name;
Watchdog.ThreadWatchdogInfo twi = new Watchdog.ThreadWatchdogInfo(thread, Watchdog.DEFAULT_WATCHDOG_TIMEOUT_MS, name)
{
AlarmIfTimeout = false,
AlarmMethod = null
};
Watchdog.AddThread(twi, name, false);
thread.Start();
return(thread);
}
/// <summary>
/// Start a new thread that is tracked by the watchdog
/// </summary>
/// <param name="start">The method that will be executed in a new thread</param>
/// <param name="name">A name to give to the new thread</param>
/// <param name="priority">Priority to run the thread at</param>
/// <param name="isBackground">True to run this thread as a background
/// thread, otherwise false</param>
/// <param name="alarmIfTimeout">Trigger an alarm function is we have timed out</param>
/// <param name="alarmMethod">
/// Alarm method to call if alarmIfTimeout is true and there is a timeout.
/// Normally, this will just return some useful debugging information.
/// </param>
/// <param name="timeout">Number of milliseconds to wait until we issue a warning about timeout.</param>
/// <param name="log">If true then creation of thread is logged.</param>
/// <returns>The newly created Thread object</returns>
public static Thread StartThread(
ThreadStart start, string name, ThreadPriority priority, bool isBackground,
bool alarmIfTimeout, Func <string> alarmMethod, int timeout, bool log = true)
{
Thread thread = new Thread(start);
thread.Priority = priority;
thread.IsBackground = isBackground;
thread.Name = name;
Watchdog.ThreadWatchdogInfo twi
= new Watchdog.ThreadWatchdogInfo(thread, timeout, name)
{
AlarmIfTimeout = alarmIfTimeout, AlarmMethod = alarmMethod
};
Watchdog.AddThread(twi, name, log: log);
thread.Start();
return(thread);
}
public static void Stop()
{
JobEngine.Stop();
Watchdog.Stop();
}
