public void Stop()
{
if (messageQueue.Running)
{
messageQueue.Stop();
TaskRunner taskRunner = this.taskRunner;
if (taskRunner != null)
{
this.taskRunner = null;
taskRunner.Shutdown();
}
}
}
public void Stop()
{
if (!_messageQueue.Started)
{
return;
}
_messageQueue.Stop();
var taskRunner = _taskRunner;
if (taskRunner == null)
{
return;
}
_taskRunner = null;
taskRunner.Shutdown();
}
internal void Rollback()
{
lock (_syncRoot)
lock ( _dispatchedMessages )
{
if (_dispatchedMessages.Count == 0)
{
return;
}
// Only increase the redelivery delay after the first redelivery..
var lastMd = _dispatchedMessages.First();
var currentRedeliveryCount = lastMd.Message.RedeliveryCounter;
_redeliveryDelay = RedeliveryPolicy.RedeliveryDelay(currentRedeliveryCount);
foreach (var dispatch in _dispatchedMessages)
{
dispatch.Message.OnMessageRollback();
}
if (RedeliveryPolicy.MaximumRedeliveries >= 0 &&
lastMd.Message.RedeliveryCounter > RedeliveryPolicy.MaximumRedeliveries)
{
_redeliveryDelay = 0;
}
else
{
// stop the delivery of messages.
_unconsumedMessages.Stop();
foreach (var dispatch in _dispatchedMessages)
{
_unconsumedMessages.Enqueue(dispatch, true);
}
if (_redeliveryDelay > 0 && !_unconsumedMessages.Stopped)
{
var deadline = DateTime.Now.AddMilliseconds(_redeliveryDelay);
ThreadPool.QueueUserWorkItem(RollbackHelper, deadline);
}
else
{
Start();
}
}
_deliveredCounter -= _dispatchedMessages.Count;
_dispatchedMessages.Clear();
}
// Only redispatch if there's an async _listener otherwise a synchronous
// consumer will pull them from the local queue.
if (_listener != null)
{
_session.Redispatch(_unconsumedMessages);
}
}
public void TestStop()
{
MessageDispatchChannel channel = new MessageDispatchChannel();
channel.Start();
Assert.IsTrue(channel.Running == true);
channel.Stop();
Assert.IsTrue(channel.Running == false);
}