public async Task RunTestAsync <TTransportInit, TMessage>(string queueName,
string connectionString,
bool addInterceptors,
long messageCount,
ILogProvider logProvider,
Func <QueueProducerConfiguration, AdditionalMessageData> generateData,
Action <string, string, QueueProducerConfiguration, long, ICreationScope> verify, bool sendViaBatch,
ICreationScope scope, bool enableChaos)
where TTransportInit : ITransportInit, new()
where TMessage : class
{
using (var metrics = new Metrics.Metrics(queueName))
{
var addInterceptorProducer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorProducer = InterceptorAdding.Yes;
}
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorProducer, logProvider, metrics, false, enableChaos)
)
{
//create the queue
using (var queue =
creator
.CreateProducer
<TMessage>(queueName, connectionString))
{
await RunProducerAsync(queue, queueName, messageCount, generateData, verify, sendViaBatch, scope).ConfigureAwait(false);
}
VerifyMetrics.VerifyProducedAsyncCount(queueName, metrics.GetCurrentMetrics(), messageCount);
}
}
}
public void Run <TTransportInit, TJobQueueCreator, TTransportCreate>(
QueueConnection queueConnection,
int producerCount)
where TTransportInit : ITransportInit, new()
where TJobQueueCreator : class, IJobQueueCreation
where TTransportCreate : class, IQueueCreation
{
using (var trace = SharedSetup.CreateTrace("jobscheduler"))
{
using (var queueCreator =
new QueueCreationContainer <TTransportInit>(x => x.RegisterNonScopedSingleton(trace.Source)))
{
var oCreation = queueCreator.GetQueueCreation <TTransportCreate>(queueConnection);
var scope = oCreation.Scope;
using (var queueContainer =
new QueueContainer <TTransportInit>(x => x.RegisterNonScopedSingleton(scope).RegisterNonScopedSingleton(trace.Source)))
{
try
{
var tests = new JobSchedulerTestsShared();
tests.RunTestMultipleProducers <TTransportInit, TJobQueueCreator>(
queueConnection, true, producerCount,
queueContainer.CreateTimeSync(queueConnection.Connection),
LoggerShared.Create(queueConnection.Queue, GetType().Name), scope);
}
finally
{
oCreation.RemoveQueue();
oCreation.Dispose();
scope?.Dispose();
}
}
}
}
}
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,
int workerCount,
ILogProvider logProvider,
int timeOut,
int runTime,
long messageCount,
TimeSpan heartBeatTime,
TimeSpan heartBeatMonitorTime,
string updateTime,
Guid id, 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;
}
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorConsumer, logProvider, metrics, false, enableChaos)
)
{
using (
var queue =
creator.CreateMethodConsumer(queueName,
connectionString))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, workerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, null);
queue.Start();
var counter = 0;
while (counter < timeOut)
{
if (MethodIncrementWrapper.Count(id) >= messageCount)
{
break;
}
Thread.Sleep(1000);
counter++;
}
//wait for queues to commit records
Thread.Sleep(3000);
}
Assert.Equal(messageCount, MethodIncrementWrapper.Count(id));
VerifyMetrics.VerifyProcessedCount(queueName, metrics.GetCurrentMetrics(), messageCount);
VerifyMetrics.VerifyRollBackCount(queueName, metrics.GetCurrentMetrics(), messageCount, 1, 0);
LoggerShared.CheckForErrors(queueName);
}
}
}
private void RunConsumerInternal(QueueConnection queueConnection, bool addInterceptors,
ILogger logProvider,
int runTime, int messageCount,
int workerCount, int timeOut, IDisposable queueBad,
TimeSpan heartBeatTime, TimeSpan heartBeatMonitorTime, Guid id, string updateTime, bool enableChaos, ICreationScope scope)
{
using (var trace = SharedSetup.CreateTrace("consumer-cancel"))
{
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 queue =
creator.CreateMethodConsumer(queueConnection, x => x.RegisterNonScopedSingleton(scope).RegisterNonScopedSingleton(trace.Source)))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, workerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, null);
queue.Start();
var time = runTime * 1000 / 2;
Thread.Sleep(time);
queueBad.Dispose();
_badQueueContainer.Dispose();
var counter = 0;
var counterLess = timeOut / 2;
while (counter < counterLess)
{
if (MethodIncrementWrapper.Count(id) >= messageCount)
{
break;
}
Thread.Sleep(1000);
counter++;
}
//wait for commits in transport...
Thread.Sleep(3000);
}
var count = MethodIncrementWrapper.Count(id);
Assert.Equal(messageCount, count);
VerifyMetrics.VerifyProcessedCount(queueConnection.Queue, metrics.GetCurrentMetrics(),
messageCount);
LoggerShared.CheckForErrors(queueConnection.Queue);
}
}
}
}
public void PurgeErrorMessages <TTransportInit>(QueueConnection queueConnection,
bool addInterceptors, ILogger logProvider, bool actuallyPurge, ICreationScope scope)
where TTransportInit : ITransportInit, new()
{
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, false, scope)
)
{
using (
var queue =
creator.CreateMethodConsumer(queueConnection, x => x.RegisterNonScopedSingleton(scope)))
{
SharedSetup.SetupDefaultConsumerQueueErrorPurge(queue.Configuration, actuallyPurge);
SharedSetup.SetupDefaultErrorRetry(queue.Configuration);
queue.Start();
Thread.Sleep(15000);
}
}
}
}
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);
}
}
}
public void RunConsumer <TTransportInit>(QueueConnection queueConnection,
bool addInterceptors,
int workerCount,
ILogger logProvider,
int timeOut,
long messageCount,
TimeSpan heartBeatTime,
TimeSpan heartBeatMonitorTime,
string updateTime,
bool enableChaos, ICreationScope scope)
where TTransportInit : ITransportInit, new()
{
if (enableChaos)
{
timeOut *= 2;
}
using (var trace = SharedSetup.CreateTrace("consumer-poison"))
{
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, trace.Source))
{
using (
var queue =
creator.CreateMethodConsumer(queueConnection, x => x.RegisterNonScopedSingleton(scope).RegisterNonScopedSingleton(trace.Source)))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, workerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, null);
var waitForFinish = new ManualResetEventSlim(false);
waitForFinish.Reset();
queue.Start();
for (var i = 0; i < timeOut; i++)
{
if (VerifyMetrics.GetPoisonMessageCount(metrics.GetCurrentMetrics()) == messageCount)
{
break;
}
Thread.Sleep(1000);
}
}
VerifyMetrics.VerifyPoisonMessageCount(queueConnection.Queue, metrics.GetCurrentMetrics(),
messageCount);
}
}
}
}
public void RunConsumer <TTransportInit>(QueueConnection queueConnection, bool addInterceptors,
ILogger logProvider,
int runTime, int messageCount,
int workerCount, int timeOut,
TimeSpan heartBeatTime, TimeSpan heartBeatMonitorTime,
string updateTime,
Guid id, bool enableChaos, ICreationScope scope)
where TTransportInit : ITransportInit, new()
{
using (var trace = SharedSetup.CreateTrace("consumer-expired"))
{
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, false, enableChaos, scope, trace.Source)
)
{
using (
var queue =
creator.CreateMethodConsumer(queueConnection, x => x.RegisterNonScopedSingleton(scope).RegisterNonScopedSingleton(trace.Source)))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, workerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, null);
queue.Configuration.MessageExpiration.Enabled = true;
queue.Configuration.MessageExpiration.MonitorTime = TimeSpan.FromSeconds(8);
queue.Start();
for (var i = 0; i < timeOut; i++)
{
if (VerifyMetrics.GetExpiredMessageCount(metrics.GetCurrentMetrics()) == messageCount)
{
break;
}
Thread.Sleep(1000);
}
}
Assert.Equal(0, MethodIncrementWrapper.Count(id));
VerifyMetrics.VerifyProcessedCount(queueConnection.Queue, metrics.GetCurrentMetrics(), 0);
VerifyMetrics.VerifyExpiredMessageCount(queueConnection.Queue, metrics.GetCurrentMetrics(),
messageCount);
LoggerShared.CheckForErrors(queueConnection.Queue);
}
}
}
}
void RunConsumer <TTransportInit>(QueueConnection queueConnection,
bool addInterceptors,
ILogger logProvider,
int runTime,
int messageCount,
int timeOut,
int readerCount,
TimeSpan heartBeatTime,
TimeSpan heartBeatMonitorTime,
Guid id,
string updateTime,
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, false, enableChaos, scope)
)
{
using (
var queue =
creator
.CreateConsumerMethodQueueScheduler(
queueConnection, Factory))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, readerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, null);
queue.Start();
var counter = 0;
while (counter < timeOut)
{
if (MethodIncrementWrapper.Count(id) >= messageCount)
{
break;
}
Thread.Sleep(1000);
counter++;
}
}
Assert.Equal(messageCount, MethodIncrementWrapper.Count(id));
VerifyMetrics.VerifyProcessedCount(queueConnection.Queue, metrics.GetCurrentMetrics(), messageCount);
LoggerShared.CheckForErrors(queueConnection.Queue);
}
}
}
public void RunConsumer <TTransportInit>(string queueName, string connectionString, bool addInterceptors,
ILogProvider logProvider,
int workerCount, int timeOut, int messageCount,
TimeSpan heartBeatTime, TimeSpan heartBeatMonitorTime, Guid id, string updateTime, 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;
}
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorConsumer, logProvider, metrics, false, enableChaos)
)
{
bool rollbacks;
using (
var queue =
creator.CreateMethodConsumer(queueName,
connectionString))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, workerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, null);
SharedSetup.SetupDefaultErrorRetry(queue.Configuration);
rollbacks = queue.Configuration.TransportConfiguration.MessageRollbackSupported;
queue.Start();
var counter = 0;
while (counter < timeOut)
{
if (MethodIncrementWrapper.Count(id) >= messageCount * 3)
{
break;
}
Thread.Sleep(1000);
counter++;
}
//wait 3 more seconds before starting to shutdown
Thread.Sleep(3000);
}
if (rollbacks)
{
VerifyMetrics.VerifyRollBackCount(queueName, metrics.GetCurrentMetrics(), messageCount, 2, 2);
}
}
}
}
public void PurgeErrorMessages <TTransportInit>(QueueConnection queueConnection,
bool addInterceptors, ILogger logProvider, bool actuallyPurge, ICreationScope scope)
where TTransportInit : ITransportInit, new()
{
using (var trace = SharedSetup.CreateTrace("consumer-error"))
{
using (var metrics = new Metrics.Metrics(queueConnection.Queue))
{
var addInterceptorConsumer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorConsumer = InterceptorAdding.ConfigurationOnly;
}
var processedCount = new IncrementWrapper();
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorConsumer, logProvider,
metrics, false, false, scope, trace.Source)
)
{
using (var schedulerCreator =
new SchedulerContainer(
// ReSharper disable once AccessToDisposedClosure
serviceRegister => serviceRegister.Register(() => metrics, LifeStyles.Singleton).RegisterNonScopedSingleton(trace.Source),
options => SharedSetup.SetOptions(options, false)))
{
using (var taskScheduler = schedulerCreator.CreateTaskScheduler())
{
taskScheduler.Start();
var taskFactory = schedulerCreator.CreateTaskFactory(taskScheduler);
using (
var queue =
creator
.CreateConsumerQueueScheduler(
queueConnection, taskFactory))
{
SharedSetup.SetupDefaultConsumerQueueErrorPurge(queue.Configuration, actuallyPurge);
SharedSetup.SetupDefaultErrorRetry(queue.Configuration);
var waitForFinish = new ManualResetEventSlim(false);
waitForFinish.Reset();
//start looking for work
queue.Start <TMessage>((message, notifications) =>
throw new Exception("There should have been no data to process"));
//wait for 30 seconds
waitForFinish.Wait(15000);
}
}
}
}
}
}
}
private IConsumerMethodQueue CreateConsumerInternalThread(ICreationScope scope)
{
_badQueueContainer = SharedSetup.CreateCreator <TTransportInit>(_badQueueAdditions);
var queue =
_badQueueContainer.CreateMethodConsumer(_queueConnection, x => x.RegisterNonScopedSingleton(scope));
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, _workerCount, _heartBeatTime, _heartBeatMonitorTime, _updatetime, null);
return(queue);
}
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 IConsumerQueue CreateConsumerInternalThread(string updateTime, string route)
{
_badQueueContainer = SharedSetup.CreateCreator <TTransportInit>(_badQueueAdditions);
var queue =
_badQueueContainer.CreateConsumer(_queueConnection);
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, _workerCount, _heartBeatTime,
_heartBeatMonitorTime, updateTime, route);
return(queue);
}
private IConsumerMethodQueue CreateConsumerInternalThread()
{
_badQueueContainer = SharedSetup.CreateCreator <TTransportInit>(_badQueueAdditions);
var queue =
_badQueueContainer.CreateMethodConsumer(_queueName,
_connectionString);
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, _workerCount, _heartBeatTime, _heartBeatMonitorTime, _updatetime, null);
return(queue);
}
public void Run <TTransportInit, TJobQueueCreator, TTransportCreate>(
QueueConnection queueConnection,
bool interceptors,
bool dynamic,
Action <QueueConnection, long, ICreationScope> verify,
Action <QueueConnection, ICreationScope> setErrorFlag)
where TTransportInit : ITransportInit, new()
where TJobQueueCreator : class, IJobQueueCreation
where TTransportCreate : class, IQueueCreation
{
using (var trace = SharedSetup.CreateTrace("jobscheduler"))
{
using (var queueCreator =
new QueueCreationContainer <TTransportInit>((x) => x.RegisterNonScopedSingleton(trace.Source)))
{
var oCreation = queueCreator.GetQueueCreation <TTransportCreate>(queueConnection);
ICreationScope scope = oCreation.Scope;
using (var queueContainer =
new QueueContainer <TTransportInit>(x => x.RegisterNonScopedSingleton(scope).RegisterNonScopedSingleton(trace.Source)))
{
try
{
var tests = new JobSchedulerTestsShared();
if (!dynamic)
{
tests.RunEnqueueTestCompiled <TTransportInit, TJobQueueCreator>(
queueConnection, interceptors,
verify, setErrorFlag,
queueContainer.CreateTimeSync(queueConnection.Connection),
oCreation.Scope, LoggerShared.Create(queueConnection.Queue, GetType().Name));
}
else
{
tests.RunEnqueueTestDynamic <TTransportInit, TJobQueueCreator>(
queueConnection, interceptors,
verify, setErrorFlag,
queueContainer.CreateTimeSync(queueConnection.Connection),
oCreation.Scope, LoggerShared.Create(queueConnection.Queue, GetType().Name));
}
}
finally
{
oCreation.RemoveQueue();
oCreation.Dispose();
scope?.Dispose();
}
}
}
}
}
public void RunConsumer <TTransportInit>(string queueName,
string connectionString,
bool addInterceptors,
int workerCount,
ILogProvider logProvider,
int timeOut,
long messageCount,
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;
}
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorConsumer, logProvider, metrics,
true))
{
using (
var queue =
creator.CreateMethodConsumer(queueName,
connectionString))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, workerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, null);
var waitForFinish = new ManualResetEventSlim(false);
waitForFinish.Reset();
queue.Start();
for (var i = 0; i < timeOut; i++)
{
if (VerifyMetrics.GetPoisonMessageCount(metrics.GetCurrentMetrics()) == messageCount)
{
break;
}
Thread.Sleep(1000);
}
}
VerifyMetrics.VerifyPoisonMessageCount(queueName, metrics.GetCurrentMetrics(), messageCount);
}
}
}
public void PurgeErrorMessages <TTransportInit>(QueueConnection queueConnection,
bool addInterceptors, ILogger logProvider, bool actuallyPurge, ICreationScope scope)
where TTransportInit : ITransportInit, new()
{
using (var trace = SharedSetup.CreateTrace("consumer-error"))
{
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, false, scope, trace.Source)
)
{
using (var schedulerCreator =
new SchedulerContainer(
// ReSharper disable once AccessToDisposedClosure
serviceRegister => serviceRegister.Register(() => metrics, LifeStyles.Singleton).RegisterNonScopedSingleton(trace.Source)))
{
using (var taskScheduler = schedulerCreator.CreateTaskScheduler())
{
taskScheduler.Start();
var taskFactory = schedulerCreator.CreateTaskFactory(taskScheduler);
using (
var queue =
creator
.CreateConsumerMethodQueueScheduler(
queueConnection, taskFactory))
{
SharedSetup.SetupDefaultConsumerQueueErrorPurge(queue.Configuration, actuallyPurge);
SharedSetup.SetupDefaultErrorRetry(queue.Configuration);
queue.Start();
Thread.Sleep(15000);
}
}
}
}
}
}
}
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 RunTest <TTransportInit, TMessage>(QueueConnection queueConnection,
bool addInterceptors,
long messageCount,
ILogger logProvider,
Func <QueueProducerConfiguration, AdditionalMessageData> generateData,
Action <QueueConnection, QueueProducerConfiguration, long, ICreationScope> verify,
bool sendViaBatch, bool validateMetricCounts,
ICreationScope scope, bool enableChaos)
where TTransportInit : ITransportInit, new()
where TMessage : class
{
using (var trace = SharedSetup.CreateTrace("producer"))
{
using (var metrics = new Metrics.Metrics(queueConnection.Queue))
{
var addInterceptorProducer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorProducer = InterceptorAdding.Yes;
}
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorProducer, logProvider,
metrics, false, enableChaos, scope, trace.Source)
)
{
//create the queue
using (var queue =
creator
.CreateProducer
<TMessage>(queueConnection))
{
RunProducer(queue, queueConnection, messageCount, generateData, verify, sendViaBatch,
scope);
}
if (validateMetricCounts)
{
VerifyMetrics.VerifyProducedCount(queueConnection.Queue, metrics.GetCurrentMetrics(),
messageCount);
}
}
}
}
}
public void RunTestCompiled <TTransportInit>(QueueConnection queueConnection,
bool addInterceptors,
long messageCount,
ILogger logProvider,
Func <QueueProducerConfiguration, AdditionalMessageData> generateData,
Action <QueueConnection, QueueProducerConfiguration, long, ICreationScope> verify,
bool sendViaBatch, bool validateMetricCounts, Guid id,
Func <Guid, int, Expression <Action <IReceivedMessage <MessageExpression>, IWorkerNotification> > >
generateTestMethod, int runTime, ICreationScope scope, bool enableChaos)
where TTransportInit : ITransportInit, new()
{
using (var trace = SharedSetup.CreateTrace("producer-method"))
{
using (var metrics = new Metrics.Metrics(queueConnection.Queue))
{
var addInterceptorProducer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorProducer = InterceptorAdding.Yes;
}
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorProducer, logProvider,
metrics, false, enableChaos, scope, trace.Source)
)
{
//create the queue
using (var queue =
creator
.CreateMethodProducer(queueConnection))
{
RunProducerCompiled(queue, queueConnection, messageCount, generateData, verify,
sendViaBatch, id,
generateTestMethod, runTime, scope);
}
if (validateMetricCounts)
{
VerifyMetrics.VerifyProducedCount(queueConnection.Queue, metrics.GetCurrentMetrics(),
messageCount);
}
}
}
}
}
public async Task RunTestAsync <TTransportInit>(QueueConnection queueConnection,
bool addInterceptors,
long messageCount,
ILogger logProvider,
Func <QueueProducerConfiguration, AdditionalMessageData> generateData,
Action <QueueConnection, QueueProducerConfiguration, long, ICreationScope> verify, bool sendViaBatch,
int runTime, Guid id, LinqMethodTypes linqMethodTypes,
ICreationScope scope, bool enableChaos)
where TTransportInit : ITransportInit, new()
{
using (var trace = SharedSetup.CreateTrace("producer"))
{
using (var metrics = new Metrics.Metrics(queueConnection.Queue))
{
var addInterceptorProducer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorProducer = InterceptorAdding.Yes;
}
using (
var creator =
SharedSetup.CreateCreator <TTransportInit>(addInterceptorProducer, logProvider, metrics, false,
enableChaos, scope, trace.Source)
)
{
//create the queue
using (var queue =
creator
.CreateMethodProducer(queueConnection))
{
await
RunProducerAsync(queue, queueConnection, messageCount, generateData, verify,
sendViaBatch,
runTime, id,
linqMethodTypes, scope).ConfigureAwait(false);
}
VerifyMetrics.VerifyProducedAsyncCount(queueConnection.Queue, metrics.GetCurrentMetrics(),
messageCount);
}
}
}
}
private void RunRpcReceive(string queueName, string connectionString,
ILogProvider logProvider,
// ReSharper disable once UnusedParameter.Local
int runTime, int messageCount,
int workerCount, int timeOut,
TimeSpan heartBeatTime, TimeSpan heartBeatMonitorTime, string updateTime, Guid id)
{
using (var metrics = new Metrics.Metrics(queueName))
{
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(InterceptorAdding.Yes, logProvider, metrics)
)
{
using (
var queue =
creator.CreateMethodConsumer(queueName, connectionString))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, workerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, null);
queue.Configuration.TransportConfiguration.QueueDelayBehavior.Clear();
queue.Configuration.TransportConfiguration.QueueDelayBehavior.Add(TimeSpan.FromMilliseconds(100));
queue.Configuration.Worker.SingleWorkerWhenNoWorkFound = false;
queue.Start();
var counter = 0;
while (counter < timeOut)
{
if (MethodIncrementWrapper.Count(id) >= messageCount)
{
break;
}
Thread.Sleep(1000);
counter++;
}
}
Assert.Equal(messageCount, MethodIncrementWrapper.Count(id));
VerifyMetrics.VerifyProcessedCount(queueName, metrics.GetCurrentMetrics(), messageCount);
}
}
}
public void PurgeErrorMessages <TTransportInit>(QueueConnection queueConnection,
bool addInterceptors, ILogger logProvider, bool actuallyPurge, ICreationScope scope)
where TTransportInit : ITransportInit, new()
{
using (var trace = SharedSetup.CreateTrace("consumer-error"))
{
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, false, scope, trace.Source)
)
{
using (
var queue =
creator.CreateConsumer(queueConnection))
{
SharedSetup.SetupDefaultConsumerQueueErrorPurge(queue.Configuration, actuallyPurge);
SharedSetup.SetupDefaultErrorRetry(queue.Configuration);
var waitForFinish = new ManualResetEventSlim(false);
waitForFinish.Reset();
//start looking for work
queue.Start <TMessage>((message, notifications) =>
throw new Exception("There should have been no data to process"));
//wait for 30 seconds
waitForFinish.Wait(15000);
}
}
}
}
}
private void RunRpcReceive(string queueName, string connectionString,
ILogProvider logProvider,
int runTime, IncrementWrapper processedCount, int messageCount, ManualResetEventSlim waitForFinish,
int workerCount, int timeOut,
TimeSpan heartBeatTime, TimeSpan heartBeatMonitorTime, string updateTime)
{
using (var metrics = new Metrics.Metrics(queueName))
{
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(InterceptorAdding.Yes, logProvider, metrics)
)
{
using (
var queue =
creator.CreateConsumer(queueName, connectionString))
{
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, workerCount, heartBeatTime,
heartBeatMonitorTime, updateTime, null);
queue.Configuration.TransportConfiguration.QueueDelayBehavior.Clear();
queue.Configuration.TransportConfiguration.QueueDelayBehavior.Add(TimeSpan.FromMilliseconds(100));
queue.Configuration.Worker.SingleWorkerWhenNoWorkFound = false;
waitForFinish.Reset();
//start looking for work
queue.Start <TTMessage>((message, notifications) =>
{
HandleFakeMessages(message, notifications, runTime, processedCount, messageCount,
waitForFinish);
});
waitForFinish.Wait(timeOut * 1000);
}
Assert.Equal(messageCount, processedCount.ProcessedCount);
VerifyMetrics.VerifyProcessedCount(queueName, metrics.GetCurrentMetrics(), messageCount);
}
}
}
public void RunTest <TTransportInit, TMessage>(string queueName,
string connectionString,
bool addInterceptors,
long messageCount,
ILogProvider logProvider,
Func <QueueProducerConfiguration, AdditionalMessageData> generateData,
Action <string, string, QueueProducerConfiguration, long, ICreationScope> verify,
bool sendViaBatch, bool validateMetricCounts,
ICreationScope scope)
where TTransportInit : ITransportInit, new()
where TMessage : class
{
using (var metrics = new Metrics.Metrics(queueName))
{
var addInterceptorProducer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorProducer = InterceptorAdding.Yes;
}
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorProducer, logProvider, metrics)
)
{
//create the queue
using (var queue =
creator
.CreateProducer
<TMessage>(queueName, connectionString))
{
RunProducer(queue, queueName, messageCount, generateData, verify, sendViaBatch, scope);
}
if (validateMetricCounts)
{
VerifyMetrics.VerifyProducedCount(queueName, metrics.GetCurrentMetrics(), messageCount);
}
}
}
}
public void RunTestDynamic <TTransportInit>(string queueName,
string connectionString,
bool addInterceptors,
long messageCount,
ILogProvider logProvider,
Func <QueueProducerConfiguration, AdditionalMessageData> generateData,
Action <string, string, QueueProducerConfiguration, long, ICreationScope> verify,
bool sendViaBatch, bool validateMetricCounts, Guid id,
Func <Guid, int, int, LinqExpressionToRun> generateTestMethod,
int runTime, ICreationScope scope, bool enableChaos)
where TTransportInit : ITransportInit, new()
{
using (var metrics = new Metrics.Metrics(queueName))
{
var addInterceptorProducer = InterceptorAdding.No;
if (addInterceptors)
{
addInterceptorProducer = InterceptorAdding.Yes;
}
using (
var creator = SharedSetup.CreateCreator <TTransportInit>(addInterceptorProducer, logProvider, metrics, false, enableChaos)
)
{
//create the queue
using (var queue =
creator
.CreateMethodProducer(queueName, connectionString))
{
RunProducerDynamic(queue, queueName, messageCount, generateData, verify, sendViaBatch, id,
generateTestMethod, runTime, scope);
}
if (validateMetricCounts)
{
VerifyMetrics.VerifyProducedCount(queueName, metrics.GetCurrentMetrics(), messageCount);
}
}
}
}