public void RunConsumer <TTransportInit>(string queueName, string connectionString, bool addInterceptors,
ILogProvider logProvider,
int workerCount, int timeOut, int messageCount,
TimeSpan heartBeatTime, TimeSpan heartBeatMonitorTime, string updateTime, string route, bool enableChaos)
where TTransportInit : ITransportInit, new()
{
if (enableChaos)
{
timeOut *= 2;
}
using (var metrics = new Metrics.Metrics(queueName))
{
var addInterceptorConsumer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorConsumer = InterceptorAdding.ConfigurationOnly;
}
var processedCount = new IncrementWrapper();
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorConsumer, logProvider,
metrics, false, enableChaos)
)
{
bool rollBacks;
using (
var queue =
creator.CreateConsumer(queueName,
connectionString))
{
rollBacks = queue.Configuration.TransportConfiguration.MessageRollbackSupported;
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, workerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, route);
SharedSetup.SetupDefaultErrorRetry(queue.Configuration);
var waitForFinish = new ManualResetEventSlim(false);
waitForFinish.Reset();
//start looking for work
queue.Start <TMessage>((message, notifications) =>
{
MessageHandlingShared.HandleFakeMessagesError(processedCount, waitForFinish,
messageCount, message);
});
waitForFinish.Wait(timeOut * 1000);
//wait 3 more seconds before starting to shutdown
Thread.Sleep(3000);
}
if (rollBacks)
{
VerifyMetrics.VerifyRollBackCount(queueName, metrics.GetCurrentMetrics(), messageCount, 2, 2);
}
}
}
}
public void RunConsumer <TTransportInit>(string queueName, string connectionString, bool addInterceptors,
ILogProvider logProvider,
int runTime, int messageCount,
int workerCount, int timeOut,
TimeSpan heartBeatTime, TimeSpan heartBeatMonitorTime, string updateTime,
string route, bool enableChaos)
where TTransportInit : ITransportInit, new()
{
if (enableChaos)
{
timeOut *= 2;
}
using (var metrics = new Metrics.Metrics(queueName))
{
var addInterceptorConsumer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorConsumer = InterceptorAdding.ConfigurationOnly;
}
var processedCount = new IncrementWrapper();
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorConsumer, logProvider, metrics, false, enableChaos)
)
{
using (
var queue =
creator.CreateConsumer(queueName,
connectionString))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, workerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, route);
queue.Configuration.MessageExpiration.Enabled = true;
queue.Configuration.MessageExpiration.MonitorTime = TimeSpan.FromSeconds(8);
var waitForFinish = new ManualResetEventSlim(false);
waitForFinish.Reset();
//start looking for work
queue.Start <TMessage>((message, notifications) =>
{
MessageHandlingShared.HandleFakeMessages <TMessage>(null, runTime, processedCount, messageCount,
waitForFinish);
});
for (var i = 0; i < timeOut; i++)
{
if (VerifyMetrics.GetExpiredMessageCount(metrics.GetCurrentMetrics()) == messageCount)
{
break;
}
Thread.Sleep(1000);
}
}
Assert.Equal(0, processedCount.ProcessedCount);
VerifyMetrics.VerifyProcessedCount(queueName, metrics.GetCurrentMetrics(), 0);
VerifyMetrics.VerifyExpiredMessageCount(queueName, metrics.GetCurrentMetrics(), messageCount);
LoggerShared.CheckForErrors(queueName);
}
}
}
public void RunConsumer <TTransportInit>(QueueConnection queueConnection,
bool addInterceptors,
int workerCount,
ILogger logProvider,
int timeOut,
int runTime,
long messageCount,
TimeSpan heartBeatTime,
TimeSpan heartBeatMonitorTime,
string updateTime,
string route, bool enableChaos, ICreationScope scope)
where TTransportInit : ITransportInit, new()
{
if (enableChaos)
{
timeOut *= 2;
}
using (var metrics = new Metrics.Metrics(queueConnection.Queue))
{
var addInterceptorConsumer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorConsumer = InterceptorAdding.ConfigurationOnly;
}
var processedCount = new IncrementWrapper();
var haveIProcessedYouBefore = new ConcurrentDictionary <string, int>();
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorConsumer, logProvider, metrics, false, enableChaos, scope)
)
{
using (
var queue =
creator.CreateConsumer(queueConnection))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, workerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, route);
var waitForFinish = new ManualResetEventSlim(false);
waitForFinish.Reset();
//start looking for work
queue.Start <TMessage>((message, notifications) =>
{
MessageHandlingShared.HandleFakeMessagesRollback(message, runTime, processedCount,
messageCount,
waitForFinish, haveIProcessedYouBefore);
});
waitForFinish.Wait(timeOut * 1000);
}
Assert.Equal(messageCount, processedCount.ProcessedCount);
VerifyMetrics.VerifyProcessedCount(queueConnection.Queue, metrics.GetCurrentMetrics(), messageCount);
VerifyMetrics.VerifyRollBackCount(queueConnection.Queue, metrics.GetCurrentMetrics(), messageCount, 1, 0);
LoggerShared.CheckForErrors(queueConnection.Queue);
haveIProcessedYouBefore.Clear();
}
}
}
public void RunConsumer <TTransportInit>(QueueConnection queueConnection,
bool addInterceptors,
int workerCount,
ILogger logProvider,
int timeOut,
long messageCount,
TimeSpan heartBeatTime,
TimeSpan heartBeatMonitorTime,
string updateTime,
string route,
bool enableChaos, ICreationScope scope)
where TTransportInit : ITransportInit, new()
{
if (enableChaos)
{
timeOut *= 2;
}
using (var metrics = new Metrics.Metrics(queueConnection.Queue))
{
var addInterceptorConsumer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorConsumer = InterceptorAdding.ConfigurationOnly;
}
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorConsumer, logProvider, metrics,
true, enableChaos, scope))
{
using (
var queue =
creator.CreateConsumer(queueConnection))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, workerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, route);
var waitForFinish = new ManualResetEventSlim(false);
waitForFinish.Reset();
//start looking for work
queue.Start <TMessage>((message, notifications) =>
{
MessageHandlingShared.HandleFakeMessageNoOp();
});
for (var i = 0; i < timeOut; i++)
{
if (VerifyMetrics.GetPoisonMessageCount(metrics.GetCurrentMetrics()) == messageCount)
{
break;
}
Thread.Sleep(1000);
}
}
VerifyMetrics.VerifyPoisonMessageCount(queueConnection.Queue, metrics.GetCurrentMetrics(), messageCount);
}
}
}
private void RunConsumerInternal(QueueConnection queueConnection, bool addInterceptors,
ILogger logProvider,
int runTime, int messageCount,
int workerCount, int timeOut, IDisposable queueBad,
TimeSpan heartBeatTime, TimeSpan heartBeatMonitorTime, string updateTime, string route, bool enableChaos, ICreationScope scope)
{
using (var trace = SharedSetup.CreateTrace("consumer-cancel"))
{
using (var metrics = new Metrics.Metrics(queueConnection.Queue))
{
var processedCount = new IncrementWrapper();
var addInterceptorConsumer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorConsumer = InterceptorAdding.ConfigurationOnly;
}
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorConsumer, logProvider,
metrics, false, enableChaos, scope, trace.Source)
)
{
using (
var queue =
creator.CreateConsumer(queueConnection))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, workerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, route);
var waitForFinish = new ManualResetEventSlim(false);
waitForFinish.Reset();
//start looking for work
queue.Start <TMessage>((message, notifications) =>
{
MessageHandlingShared.HandleFakeMessages <TMessage>(null, runTime, processedCount,
messageCount,
waitForFinish);
});
var time = runTime * 1000 / 2;
waitForFinish.Wait(time);
queueBad.Dispose();
_badQueueContainer.Dispose();
waitForFinish.Wait(timeOut * 1000 - time);
}
Assert.Equal(messageCount, processedCount.ProcessedCount);
VerifyMetrics.VerifyProcessedCount(queueConnection.Queue, metrics.GetCurrentMetrics(),
messageCount);
LoggerShared.CheckForErrors(queueConnection.Queue);
}
}
}
}
private void RunBadQueue()
{
//start looking for work
try
{
_queue.Start <TMessage>((message, notifications) =>
{
MessageHandlingShared.HandleFakeMessagesThreadAbort(_runTime * 1000 / 2);
});
}
catch
{
//bad queue failing is weird, but doesn't really need to be handled right here
}
}
public void RunConsumer <TTransportInit>(string queueName, string connectionString, bool addInterceptors,
ILogProvider logProvider,
int runTime, int messageCount,
int workerCount, int timeOut,
TimeSpan heartBeatTime, TimeSpan heartBeatMonitorTime, string updateTime)
where TTransportInit : ITransportInit, new()
{
using (var metrics = new Metrics.Metrics(queueName))
{
var addInterceptorConsumer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorConsumer = InterceptorAdding.ConfigurationOnly;
}
var processedCount = new IncrementWrapper();
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorConsumer, logProvider, metrics)
)
{
using (
var queue =
creator.CreateConsumer(queueName,
connectionString))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, workerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, null);
var waitForFinish = new ManualResetEventSlim(false);
waitForFinish.Reset();
//start looking for work
queue.Start <TMessage>((message, notifications) =>
{
MessageHandlingShared.HandleFakeMessages(message, runTime, processedCount, messageCount,
waitForFinish);
});
waitForFinish.Wait(timeOut * 1000);
}
Assert.Null(processedCount.IdError);
Assert.Equal(messageCount, processedCount.ProcessedCount);
VerifyMetrics.VerifyProcessedCount(queueName, metrics.GetCurrentMetrics(), messageCount);
LoggerShared.CheckForErrors(queueName);
}
}
}
public void RunConsumer <TTransportInit>(QueueConnection queueConnection,
bool addInterceptors,
int workerCount,
ILogger logProvider,
int timeOut,
int readerCount,
int queueSize,
long messageCount,
TimeSpan heartBeatTime,
TimeSpan heartBeatMonitorTime,
string updateTime,
string route,
bool enableChaos, ICreationScope scope)
where TTransportInit : ITransportInit, new()
{
if (enableChaos)
{
timeOut *= 2;
}
using (var metrics = new Metrics.Metrics(queueConnection.Queue))
{
var addInterceptorConsumer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorConsumer = InterceptorAdding.ConfigurationOnly;
}
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorConsumer, logProvider, metrics,
true, enableChaos, scope))
{
using (var schedulerCreator = new SchedulerContainer())
{
using (var taskScheduler = schedulerCreator.CreateTaskScheduler())
{
taskScheduler.Configuration.MaximumThreads = workerCount;
taskScheduler.Configuration.MaxQueueSize = queueSize;
taskScheduler.Start();
var taskFactory = schedulerCreator.CreateTaskFactory(taskScheduler);
using (
var queue =
creator
.CreateConsumerQueueScheduler(
queueConnection, taskFactory))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, readerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, route);
//start looking for work
queue.Start <TMessage>((message, notifications) =>
{
MessageHandlingShared.HandleFakeMessageNoOp();
});
for (var i = 0; i < timeOut; i++)
{
if (VerifyMetrics.GetPoisonMessageCount(metrics.GetCurrentMetrics()) == messageCount)
{
break;
}
Thread.Sleep(1000);
}
//wait for last error to be saved if needed.
Thread.Sleep(3000);
}
}
VerifyMetrics.VerifyPoisonMessageCount(queueConnection.Queue, metrics.GetCurrentMetrics(), messageCount);
}
}
}
}
public void RunConsumer <TTransportInit>(QueueConnection queueConnection,
bool addInterceptors,
int workerCount,
ILogger logProvider,
int timeOut,
int readerCount,
int queueSize,
int runTime,
int messageCount,
TimeSpan heartBeatTime,
TimeSpan heartBeatMonitorTime,
string updateTime,
string route, bool enableChaos, ICreationScope scope)
where TTransportInit : ITransportInit, new()
{
var processedCount = new IncrementWrapper();
var haveIProcessedYouBefore = new ConcurrentDictionary <string, int>();
if (enableChaos)
{
timeOut *= 2;
}
using (var trace = SharedSetup.CreateTrace("consumer-rollback"))
{
using (var metrics = new Metrics.Metrics(queueConnection.Queue))
{
var addInterceptorConsumer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorConsumer = InterceptorAdding.ConfigurationOnly;
}
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorConsumer, logProvider,
metrics, false, enableChaos, scope, trace.Source)
)
{
using (var schedulerCreator = new SchedulerContainer((x) => x.RegisterNonScopedSingleton(trace.Source)))
{
using (var taskScheduler = schedulerCreator.CreateTaskScheduler())
{
taskScheduler.Configuration.MaximumThreads = workerCount;
taskScheduler.Start();
var taskFactory = schedulerCreator.CreateTaskFactory(taskScheduler);
using (
var queue =
creator
.CreateConsumerQueueScheduler(
queueConnection, taskFactory))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, readerCount,
heartBeatTime,
heartBeatMonitorTime, updateTime, route);
var waitForFinish = new ManualResetEventSlim(false);
waitForFinish.Reset();
//start looking for work
queue.Start <TMessage>((message, notifications) =>
{
MessageHandlingShared.HandleFakeMessagesRollback(message, runTime,
processedCount,
messageCount, waitForFinish, haveIProcessedYouBefore);
});
waitForFinish.Wait(timeOut * 1000);
}
}
Assert.Equal(messageCount, processedCount.ProcessedCount);
VerifyMetrics.VerifyProcessedCount(queueConnection.Queue, metrics.GetCurrentMetrics(),
messageCount);
VerifyMetrics.VerifyRollBackCount(queueConnection.Queue, metrics.GetCurrentMetrics(),
messageCount, 1, 0);
}
}
haveIProcessedYouBefore.Clear();
}
}
}
void RunConsumer <TTransportInit>(string queueName,
string connectionString,
bool addInterceptors,
ILogProvider logProvider,
int runTime,
int messageCount,
int timeOut,
int readerCount,
TimeSpan heartBeatTime,
TimeSpan heartBeatMonitorTime,
string updateTime,
List <string> routes = null)
where TTransportInit : ITransportInit, new()
{
var metricName = queueName;
if (routes != null)
{
metricName = routes.Aggregate(metricName, (current, route) => current + route + "|-|");
}
using (var metrics = new Metrics.Metrics(metricName))
{
var processedCount = new IncrementWrapper();
var addInterceptorConsumer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorConsumer = InterceptorAdding.ConfigurationOnly;
}
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorConsumer, logProvider, metrics)
)
{
using (
var queue =
creator
.CreateConsumerQueueScheduler(
queueName, connectionString, Factory))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, readerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, null);
if (routes != null)
{
queue.Configuration.Routes.AddRange(routes);
}
var waitForFinish = new ManualResetEventSlim(false);
waitForFinish.Reset();
//start looking for work
queue.Start <TMessage>((message, notifications) =>
{
if (routes != null && routes.Count > 0)
{
MessageHandlingShared.HandleFakeMessages(message, runTime, processedCount, messageCount * routes.Count,
waitForFinish);
}
else
{
MessageHandlingShared.HandleFakeMessages(message, runTime, processedCount, messageCount,
waitForFinish);
}
});
waitForFinish.Wait(timeOut * 1000);
}
Assert.Null(processedCount.IdError);
if (routes != null && routes.Count > 0)
{
Assert.Equal(messageCount * routes.Count, processedCount.ProcessedCount);
VerifyMetrics.VerifyProcessedCount(queueName, metrics.GetCurrentMetrics(), messageCount * routes.Count);
}
else
{
Assert.Equal(messageCount, processedCount.ProcessedCount);
VerifyMetrics.VerifyProcessedCount(queueName, metrics.GetCurrentMetrics(), messageCount);
}
LoggerShared.CheckForErrors(queueName);
}
}
}
public void RunConsumer <TTransportInit>(string queueName, string connectionString, bool addInterceptors,
ILogProvider logProvider,
int messageCount, int workerCount, int timeOut,
int queueSize, int readerCount,
TimeSpan heartBeatTime, TimeSpan heartBeatMonitorTime,
string updateTime,
string route,
bool enableChaos)
where TTransportInit : ITransportInit, new()
{
if (enableChaos)
{
timeOut *= 2;
}
using (var metrics = new Metrics.Metrics(queueName))
{
var addInterceptorConsumer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorConsumer = InterceptorAdding.ConfigurationOnly;
}
var processedCount = new IncrementWrapper();
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorConsumer, logProvider, metrics, false, enableChaos)
)
{
using (var schedulerCreator =
new SchedulerContainer(
// ReSharper disable once AccessToDisposedClosure
serviceRegister => serviceRegister.Register(() => metrics, LifeStyles.Singleton), options => SharedSetup.SetOptions(options, enableChaos)))
{
bool rollBacks;
using (var taskScheduler = schedulerCreator.CreateTaskScheduler())
{
taskScheduler.Configuration.MaximumThreads = workerCount;
taskScheduler.Configuration.MaxQueueSize = queueSize;
taskScheduler.Start();
var taskFactory = schedulerCreator.CreateTaskFactory(taskScheduler);
using (
var queue =
creator
.CreateConsumerQueueScheduler(
queueName, connectionString, taskFactory))
{
rollBacks = queue.Configuration.TransportConfiguration.MessageRollbackSupported;
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, readerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, route);
SharedSetup.SetupDefaultErrorRetry(queue.Configuration);
var waitForFinish = new ManualResetEventSlim(false);
waitForFinish.Reset();
//start looking for work
queue.Start <TMessage>((message, notifications) =>
{
MessageHandlingShared.HandleFakeMessagesError(processedCount, waitForFinish,
messageCount, message);
});
waitForFinish.Wait(timeOut * 1000);
//wait for last error to be saved if needed.
Thread.Sleep(3000);
}
}
if (rollBacks)
{
VerifyMetrics.VerifyRollBackCount(queueName, metrics.GetCurrentMetrics(), messageCount, 2, 2);
}
}
}
}
}
void RunConsumer <TTransportInit>(QueueConnection queueConnection,
bool addInterceptors,
ILogger logProvider,
int runTime,
int messageCount,
int timeOut,
int readerCount,
TimeSpan heartBeatTime,
TimeSpan heartBeatMonitorTime,
string updateTime,
bool enableChaos,
ICreationScope scope,
string route,
Action <QueueConsumerConfiguration> setQueueOptions = null)
where TTransportInit : ITransportInit, new()
{
if (enableChaos)
{
timeOut *= 2;
}
var metricName = queueConnection.Queue;
if (!string.IsNullOrEmpty(route))
{
metricName = queueConnection.Queue + "|-|" + route;
}
using (var trace = SharedSetup.CreateTrace("consumer"))
{
using (var metrics = new Metrics.Metrics(metricName))
{
var processedCount = new IncrementWrapper();
var addInterceptorConsumer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorConsumer = InterceptorAdding.ConfigurationOnly;
}
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorConsumer, logProvider,
metrics, false, enableChaos, scope, trace.Source)
)
{
using (
var queue =
creator
.CreateConsumerQueueScheduler(
queueConnection, Factory))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, readerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, route);
if (!string.IsNullOrWhiteSpace(route))
{
queue.Configuration.Routes.Add(route);
}
setQueueOptions?.Invoke(queue.Configuration);
var waitForFinish = new ManualResetEventSlim(false);
waitForFinish.Reset();
//start looking for work
queue.Start <TMessage>((message, notifications) =>
{
MessageHandlingShared.HandleFakeMessages(message, runTime, processedCount, messageCount,
waitForFinish);
});
waitForFinish.Wait(timeOut * 1000);
}
Assert.Null(processedCount.IdError);
Assert.Equal(messageCount, processedCount.ProcessedCount);
VerifyMetrics.VerifyProcessedCount(queueConnection.Queue, metrics.GetCurrentMetrics(),
messageCount);
LoggerShared.CheckForErrors(queueConnection.Queue);
}
}
}
}