public void while_queue_is_busy_should_crash_with_timeout()
{
var consumer = new WaitingConsumer(1);
var busyQueue = new QueuedHandler(consumer, "busy_test_queue", watchSlowMsg: false, threadStopWaitTimeout: TimeSpan.FromMilliseconds(100));
var waitHandle = new ManualResetEvent(false);
var handledEvent = new ManualResetEvent(false);
try
{
busyQueue.Start();
busyQueue.Publish(new DeferredExecutionTestMessage(() =>
{
handledEvent.Set();
waitHandle.WaitOne();
}));
handledEvent.WaitOne();
Assert.Throws <TimeoutException>(() => busyQueue.Stop());
}
finally
{
waitHandle.Set();
consumer.Wait();
busyQueue.Stop();
waitHandle.Dispose();
handledEvent.Dispose();
consumer.Dispose();
}
}
public virtual void TearDown()
{
Queue.Stop();
Queue = null;
Consumer.Dispose();
Consumer = null;
}
public void stoped_not_starting_server()
{
//GIVEN
var controller = new SleepTestController1();
var mainQueue = new QueuedHandler(controller, "Main Queue", 1000);
//WHEN
mainQueue.Stop();
}
public void multiple_stoped()
{
//GIVEN
var controller = new SleepTestController1();
var mainQueue = new QueuedHandler(controller, "Main Queue", 1000);
mainQueue.Start();
mainQueue.Enqueue(new QueuedTestMessage1());
controller.MessageHandled();
try
{
mainQueue.Stop();
}
catch (InvalidOperationException) { }
//WHEN
mainQueue.Stop();
}
public void Stop()
{
if (_masterInputQueue != null)
{
_masterInputQueue.Stop();
}
foreach (var queue in _coreQueues)
{
queue.Value.Stop();
}
}
protected override void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
SyncQueue?.Stop();
}
_disposed = true;
}
base.Dispose(disposing);
}
public void starting_stoped_server()
{
//GIVEN
var mainQueue = new QueuedHandler(null, "Main Queue");
mainQueue.Start();
Thread.Sleep(1000);
mainQueue.Stop();
//WHEN
mainQueue.Start();
}
public void throw_exception_on_timeout()
{
//GIVEN
var controller = new SleepTestController1();
var mainQueue = new QueuedHandler(controller, "Main Queue", 1000);
mainQueue.Start();
mainQueue.Enqueue(new QueuedTestMessage1());
//WHEN
Assert.AreEqual(false, controller.MessageHandled());
mainQueue.Stop();
}
protected override void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
_isLive.Set();
_running.Reset();
SyncQueue?.Stop();
_running.Dispose();
}
_disposed = true;
}
base.Dispose(disposing);
}
public void Stop()
{
if (_subsystemStarted)
{
if (_masterInputQueue != null)
{
_masterInputQueue.Stop();
}
foreach (var queue in _coreQueues)
{
queue.Value.Stop();
}
}
_subsystemStarted = false;
}
private void EnqueueMessage(Message message)
{
if (message is StorageMessage.IFlushableMessage)
{
Interlocked.Increment(ref FlushMessagesInQueue);
}
StorageWriterQueue.Publish(message);
if (message is SystemMessage.BecomeShuttingDown) // we need to handle this message on main thread to stop StorageWriterQueue
{
StorageWriterQueue.Stop();
BlockWriter = true;
Bus.Publish(new SystemMessage.ServiceShutdown("StorageWriter"));
}
}