/// <summary>
/// Starts the specified poll function.
/// </summary>
/// <param name="pollFunction">The poll function.</param>
/// <param name="dueTime">The due time.</param>
/// <param name="period">The milliseconds between polls.</param>
/// <param name="maximumRetries">The maximum retries.</param>
public void Start(Func <bool> pollFunction, int dueTime = 0, int period = 3000, int maximumRetries = 5)
{
Guard.Will.ProtectAgainstNullArgument(() => pollFunction);
Debug.WriteLine(DateTime.Now.ToString().FormattedWith("POLL START: {0}"));
if (dueTime < 0)
{
return;
}
this.pollFunction = pollFunction;
this.maximumRetries = maximumRetries;
var timerCallback = new TimerCallback(this.TimerCallback);
var autoResetEvent = new AutoResetEvent(false);
timer = new Timer(timerCallback, autoResetEvent, dueTime, period);
this.State = PollerState.Polling;
autoResetEvent.WaitOne();
}
private void DoWork()
{
while (_pollerState == PollerState.Running)
{
try
{
_action();
}
catch (Exception ex)
{
_log.Error(Thread.CurrentThread.Name + "failed.", ex);
}
finally
{
if (_stopEvent.WaitOne(_pollingInterval))
{
if (_pollerState == PollerState.StopRequested)
{
_pollerState = PollerState.Stopped;
}
}
if (_pollerState == PollerState.PauseRequested)
{
_pollerState = PollerState.Paused;
_pauseEvent.Wait();
// Continue only if we are still in Pause mode and not StopRequested
if (_pollerState == PollerState.Paused)
{
_pollerState = PollerState.Running;
}
}
}
}
_log.Debug("Exiting: " + Thread.CurrentThread.Name);
}
public async Task <PollerState[]> LoadAsync(string pollerContractName, CancellationToken cancellationToken = default(CancellationToken))
{
List <PollerState> states = null;
using (var cnn = new SqlConnection(_connectionString))
using (var cmd = cnn.CreateCommand())
{
cmd.CommandText = SqlClientScripts.SelectStates;
cmd.AddInputParam(SqlClientScripts.ParamPollerContractName, DbType.String, pollerContractName);
await cmd.Connection.OpenAsync(cancellationToken).NotOnCapturedContext();
using (var reader = await cmd.ExecuteReaderAsync(CommandBehavior.SingleResult | CommandBehavior.SequentialAccess, cancellationToken).NotOnCapturedContext())
{
if (reader.HasRows)
{
states = new List <PollerState>(100);
while (await reader.ReadAsync(cancellationToken).NotOnCapturedContext())
{
var state = new PollerState(
await reader.GetFieldValueAsync <string>(colIndexForPollerContractName, cancellationToken).NotOnCapturedContext(),
await reader.GetFieldValueAsync <string>(colIndexForSourceContractName, cancellationToken).NotOnCapturedContext(),
await reader.GetFieldValueAsync <string>(colIndexForHandlerContractName, cancellationToken).NotOnCapturedContext())
{
EventSequenceId = await reader.GetFieldValueAsync <long>(colIndexForEventSequence, cancellationToken).NotOnCapturedContext()
};
states.Add(state);
}
}
}
}
return(states?.ToArray() ?? new PollerState[0]);
}
public PollerState[] Load(string pollerContractName)
{
List <PollerState> states = null;
using (var cnn = new SqlConnection(_connectionString))
using (var cmd = cnn.CreateCommand())
{
cmd.CommandText = SqlClientScripts.SelectStates;
cmd.AddInputParam(SqlClientScripts.ParamPollerContractName, DbType.String, pollerContractName);
cmd.Connection.Open();
using (var reader = cmd.ExecuteReader(CommandBehavior.SingleResult | CommandBehavior.SequentialAccess))
{
if (reader.HasRows)
{
states = new List <PollerState>(100);
while (reader.Read())
{
var state = new PollerState(
reader.GetFieldValue <string>(colIndexForPollerContractName),
reader.GetFieldValue <string>(colIndexForSourceContractName),
reader.GetFieldValue <string>(colIndexForHandlerContractName))
{
EventSequenceId = reader.GetFieldValue <long>(colIndexForEventSequence)
};
states.Add(state);
}
}
}
}
return(states?.ToArray() ?? new PollerState[0]);
}
public void Pause()
{
lock (_syncLock)
{
if (_pollerState != PollerState.Running)
{
_log.WarnFormat("Requested PAUSE on {0} poller state.", _pollerState);
}
_pauseEvent.Reset();
_pollerState = PollerState.PauseRequested;
}
}
public Poller(string pollerName, Action action, int pollingInterval, bool isBackground)
{
_action = action;
_pollingInterval = pollingInterval;
_stopEvent = new AutoResetEvent(false);
_pauseEvent = new ManualResetEventSlim(false);
_processingThread = new Thread(DoWork)
{
IsBackground = isBackground, Name = pollerName
};
_pollerState = PollerState.Unstarted;
}
public void Stop()
{
lock (_syncLock)
{
if (_pollerState != PollerState.Running && _pollerState != PollerState.PauseRequested)
{
_log.WarnFormat("Requested STOP on {0} poller state.", _pollerState);
}
_pollerState = PollerState.StopRequested;
_stopEvent.Set();
_pauseEvent.Set();
}
}
public void Continue()
{
lock (_syncLock)
{
if (_pollerState == PollerState.PauseRequested)
{
_pollerState = PollerState.Running; // applicable if job is long running or no new poll was needed since pause requested
}
else if (_pollerState != PollerState.Paused)
{
_log.WarnFormat("Requested CONTINUE on {0} poller state.", _pollerState);
}
_pauseEvent.Set();
}
}
/// <summary>
/// Stops the polling.
/// </summary>
/// <param name="state">The state.</param>
/// <param name="pollerState">The poll result.</param>
private void Stop(object state, PollerState pollerState)
{
Debug.WriteLine(pollerState.ToString().FormattedWith("POLL STOP: {0}"));
var autoResetEvent = (AutoResetEvent)state;
this.State = pollerState;
this.PollCount = 0;
autoResetEvent.Set();
if (timer != null)
{
timer.Dispose();
timer = null;
}
}
public async Task InsertOrUpdateAsync(PollerState state, CancellationToken cancellationToken = default(CancellationToken))
{
using (var cnn = new SqlConnection(_connectionString))
using (var cmd = cnn.CreateCommand())
{
await cnn.OpenAsync(cancellationToken).NotOnCapturedContext();
cmd.CommandText = SqlClientScripts.UpdateState;
cmd.AddInputParam(SqlClientScripts.ParamPollerContractName, DbType.String, state.PollerContractName);
cmd.AddInputParam(SqlClientScripts.ParamSourceContractName, DbType.String, state.SourceContractName);
cmd.AddInputParam(SqlClientScripts.ParamHandlerContractName, DbType.String, state.HandlerContractName);
cmd.AddInputParam(SqlClientScripts.ParamEventSequence, DbType.Int64, state.EventSequenceId);
if (await cmd.ExecuteNonQueryAsync(cancellationToken).NotOnCapturedContext() == 0)
{
cmd.CommandText = SqlClientScripts.InsertState;
await cmd.ExecuteNonQueryAsync(cancellationToken).NotOnCapturedContext();
}
}
}
/// <summary>
/// Starts the specified poll function.
/// </summary>
/// <param name="pollFunction">The poll function.</param>
/// <param name="dueTime">The due time.</param>
/// <param name="period">The milliseconds between polls.</param>
/// <param name="maximumRetries">The maximum retries.</param>
public void Start(Func<bool> pollFunction, int dueTime = 0, int period = 3000, int maximumRetries = 5)
{
Guard.Will.ProtectAgainstNullArgument(() => pollFunction);
Debug.WriteLine(DateTime.Now.ToString().FormattedWith("POLL START: {0}"));
if (dueTime < 0)
{
return;
}
this.pollFunction = pollFunction;
this.maximumRetries = maximumRetries;
var timerCallback = new TimerCallback(this.TimerCallback);
var autoResetEvent = new AutoResetEvent(false);
timer = new Timer(timerCallback, autoResetEvent, dueTime, period);
this.State = PollerState.Polling;
autoResetEvent.WaitOne();
}
/// <summary>
/// Stops the polling.
/// </summary>
/// <param name="state">The state.</param>
/// <param name="pollerState">The poll result.</param>
private void Stop(object state, PollerState pollerState)
{
Debug.WriteLine(pollerState.ToString().FormattedWith("POLL STOP: {0}"));
var autoResetEvent = (AutoResetEvent)state;
this.State = pollerState;
this.PollCount = 0;
autoResetEvent.Set();
if (timer != null)
{
timer.Dispose();
timer = null;
}
}
public void Start()
{
_pollerState = PollerState.Running;
_processingThread.Start();
}
