private async Task RunProducerInternalAsync(
IProducerMethodQueue
queue, long messageCount, Func <QueueProducerConfiguration, AdditionalMessageData> generateData,
bool sendViaBatch, int runTime, Guid id, LinqMethodTypes methodType)
{
var numberOfJobs = Convert.ToInt32(messageCount);
switch (methodType)
{
case LinqMethodTypes.Compiled:
{
var jobs = Enumerable.Range(0, numberOfJobs)
.Select(i => GenerateMethod.CreateCompiled(id, runTime));
await RunProducerInternalAsync(queue, generateData, sendViaBatch, jobs, numberOfJobs)
.ConfigureAwait(false);
}
break;
#if NETFULL
case LinqMethodTypes.Dynamic:
{
var jobs = Enumerable.Range(0, numberOfJobs)
.Select(i => GenerateMethod.CreateDynamic(id, runTime));
await RunProducerInternalAsync(queue, generateData, sendViaBatch, jobs, numberOfJobs)
.ConfigureAwait(false);
}
break;
#endif
}
}
private void GenerateRooms(int x, int y)
{
List <GenerateMethod> directionList = new List <GenerateMethod>();
directionList.Add(GenerateEast);
directionList.Add(GenerateWest);
directionList.Add(GenerateNorth);
directionList.Add(GenerateSouth);
while (directionList.Count > 0)
{
int index = Random.Range(0, directionList.Count);
if (Random.Range(0, 100) < stopDirectionChance)
{
GenerateMethod generateMethod = directionList[index];
extraDirectionQueue.Enqueue(() => generateMethod.Invoke(x, y));
}
else
{
directionList[index].Invoke(x, y);
}
directionList.RemoveAt(index);
}
}
private static double Randomize(this int number, GenerateMethod method = GenerateMethod.Sin)
{
var a = 0.0;
var b = 0.0;
var c = 0.0;
if (number % 100 == 0)
{
a = 2 * Random.NextDouble();
}
if (number % 1000 == 0)
{
b = 2 * Random.NextDouble();
}
if (number % 10000 == 0)
{
c = 2 * Random.NextDouble();
}
var spike = number % 1000 == 0 ? 10 : 0;
if (method == GenerateMethod.Sin)
{
return(2 * Math.Sin(number / 100.0) + a + b + c + spike + Random.NextDouble());
}
return(2 * Math.Cos(number / 100.0) + a + b + c + spike + Random.NextDouble());
}
private static void SendMultipleMessages(IRpcMethodQueue queue, int number, Guid id, int runTime, LinqMethodTypes linqMethodTypes)
{
switch (linqMethodTypes)
{
case LinqMethodTypes.Compiled:
{
var numberOfJobs = number;
var jobs = Enumerable.Range(0, numberOfJobs)
.Select(i => GenerateMethod.CreateRpcCompiled(id, runTime));
SendMultipleMessages(queue, jobs);
}
break;
#if NETFULL
case LinqMethodTypes.Dynamic:
{
var numberOfJobs = number;
var jobs = Enumerable.Range(0, numberOfJobs)
.Select(i => GenerateMethod.CreateRpcDynamic(id, runTime));
SendMultipleMessages(queue, jobs);
}
break;
#endif
}
}
public BlockType(Adress id)
{
this.Id = id;
this.Checker = null;
this.Generator = null;
this.generatorExternal = null;
this.checkerExternal = null;
}
public bool SetGenerator(GenerateMethod generator)
{
if (this.Generator != null)
{
return(false);
}
this.Generator = generator;
return(true);
}
public void Run(int messageCount, int runtime, int timeOut, int workerCount, int readerCount, int queueSize, ConnectionInfoTypes type, LinqMethodTypes linqMethodTypes)
{
var queueName = GenerateQueueName.Create();
var logProvider = LoggerShared.Create(queueName, GetType().Name);
var connectionString = new ConnectionInfo(type).ConnectionString;
using (
var queueCreator =
new QueueCreationContainer <RedisQueueInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
try
{
//create data
var id = Guid.NewGuid();
var producer = new ProducerMethodShared();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <RedisQueueInit>(queueName,
connectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateRollBackCompiled, runtime, null);
}
#if NETFULL
else
{
producer.RunTestDynamic <RedisQueueInit>(queueName,
connectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateRollBackDynamic, runtime, null);
}
#endif
//process data
var consumer = new ConsumerMethodAsyncRollBackShared();
consumer.RunConsumer <RedisQueueInit>(queueName, connectionString, false,
workerCount, logProvider,
timeOut, readerCount, queueSize, runtime, messageCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), id, "second(*%3)");
LoggerShared.CheckForErrors(queueName);
using (var count = new VerifyQueueRecordCount(queueName, connectionString))
{
count.Verify(0, false, -1);
}
GenerateMethod.ClearRollback(id);
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation <RedisQueueCreation>(queueName,
connectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
public bool SetGenerator(IExternalMethod external)
{
if (this.Generator != null)
{
return(false);
}
this.generatorExternal = external;
this.Generator = this.ExternalGenerate;
return(true);
}
public void Run(int messageCount, int runtime,
int timeOut, int workerCount, ConnectionInfoTypes type, LinqMethodTypes linqMethodTypes)
{
var queueName = GenerateQueueName.Create();
var logProvider = LoggerShared.Create(queueName, GetType().Name);
var connectionString = new ConnectionInfo(type).ConnectionString;
using (var queueCreator =
new QueueCreationContainer <RedisQueueInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
try
{
var id = Guid.NewGuid();
var producer = new ProducerMethodShared();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <RedisQueueInit>(queueName,
connectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateCancelCompiled, runtime, null);
}
#if NETFULL
else
{
producer.RunTestDynamic <RedisQueueInit>(queueName,
connectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateCancelDynamic, runtime, null);
}
#endif
var consumer = new ConsumerMethodCancelWorkShared <RedisQueueInit>();
consumer.RunConsumer(queueName, connectionString, false, logProvider,
runtime, messageCount,
workerCount, timeOut, serviceRegister => serviceRegister.Register <IMessageMethodHandling>(() => new MethodMessageProcessingCancel(id), LifeStyles.Singleton), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), "second(*%3)", id);
using (var count = new VerifyQueueRecordCount(queueName, connectionString))
{
count.Verify(0, false, -1);
}
GenerateMethod.ClearCancel(id);
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation <RedisQueueCreation>(queueName,
connectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
/// <summary>
/// Generates the data.
/// </summary>
/// <param name="startIndex">The start index.</param>
/// <param name="stopIndex">Index of the stop.</param>
/// <param name="method">The method.</param>
/// <returns>
/// System.ValueTuple<List<System.Nullable<System.Double>>, List<System.Nullable<
/// System.Double>>>.
/// </returns>
public static (List <object> X, List <object> Y) GenerateData(int startIndex, int stopIndex,
GenerateMethod method = GenerateMethod.Sin)
{
var x = new List <object>();
var y = new List <object>();
var start = Math.Min(startIndex, stopIndex);
var stop = Math.Max(startIndex, stopIndex);
for (var i = start; i < stop; i++)
{
x.Add(i);
y.Add(i.Randomize(method));
}
return(x, y);
}
public void Run(int messageCount, int runtime, int timeOut, int workerCount, bool useTransactions, LinqMethodTypes linqMethodTypes)
{
var queueName = GenerateQueueName.Create();
var logProvider = LoggerShared.Create(queueName, GetType().Name);
using (
var queueCreator =
new QueueCreationContainer <PostgreSqlMessageQueueInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
try
{
using (
var oCreation =
queueCreator.GetQueueCreation <PostgreSqlMessageQueueCreation>(queueName,
ConnectionInfo.ConnectionString)
)
{
oCreation.Options.EnableDelayedProcessing = true;
oCreation.Options.EnableHeartBeat = !useTransactions;
oCreation.Options.EnableHoldTransactionUntilMessageCommitted = useTransactions;
oCreation.Options.EnableStatus = !useTransactions;
oCreation.Options.EnableStatusTable = true;
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
var id = Guid.NewGuid();
//create data
var producer = new ProducerMethodShared();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <PostgreSqlMessageQueueInit>(queueName,
ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateRollBackCompiled, runtime, oCreation.Scope);
}
#if NETFULL
else
{
producer.RunTestDynamic <PostgreSqlMessageQueueInit>(queueName,
ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateRollBackDynamic, runtime, oCreation.Scope);
}
#endif
//process data
var consumer = new ConsumerMethodRollBackShared();
consumer.RunConsumer <PostgreSqlMessageQueueInit>(queueName, ConnectionInfo.ConnectionString,
false,
workerCount, logProvider, timeOut, runtime, messageCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), "second(*%3)", id);
new VerifyQueueRecordCount(queueName, oCreation.Options).Verify(0, false, false);
GenerateMethod.ClearRollback(id);
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation <PostgreSqlMessageQueueCreation>(queueName,
ConnectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
public void Run(int messageCount, int runtime,
int timeOut, int workerCount, bool inMemoryDb, LinqMethodTypes linqMethodTypes)
{
using (var connectionInfo = new IntegrationConnectionInfo(inMemoryDb))
{
var queueName = GenerateQueueName.Create();
var logProvider = LoggerShared.Create(queueName, GetType().Name);
using (
var queueCreator =
new QueueCreationContainer <SqLiteMessageQueueInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
try
{
using (
var oCreation =
queueCreator.GetQueueCreation <SqLiteMessageQueueCreation>(queueName,
connectionInfo.ConnectionString)
)
{
oCreation.Options.EnableDelayedProcessing = true;
oCreation.Options.EnableHeartBeat = true;
oCreation.Options.EnableStatus = true;
oCreation.Options.EnableStatusTable = true;
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
var producer = new ProducerMethodShared();
var id = Guid.NewGuid();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <SqLiteMessageQueueInit>(queueName,
connectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateCancelCompiled, runtime, oCreation.Scope);
}
else
{
producer.RunTestDynamic <SqLiteMessageQueueInit>(queueName,
connectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateCancelDynamic, runtime, oCreation.Scope);
}
var consumer = new ConsumerMethodHeartBeatShared();
consumer.RunConsumer <SqLiteMessageQueueInit>(queueName, connectionInfo.ConnectionString,
false,
logProvider,
runtime, messageCount,
workerCount, timeOut, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), id, "second(*%3)");
new VerifyQueueRecordCount(queueName, connectionInfo.ConnectionString, oCreation.Options).Verify(0, false, false);
GenerateMethod.ClearCancel(id);
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation <SqLiteMessageQueueCreation>(queueName,
connectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
}
public void Run <TTransportInit, TTransportCreate>(
QueueConnection queueConnection,
int messageCount, int runtime, int timeOut, int workerCount, int readerCount, int queueSize,
LinqMethodTypes linqMethodTypes,
bool enableChaos,
Action <TTransportCreate> setOptions,
Func <QueueProducerConfiguration, AdditionalMessageData> generateData,
Action <QueueConnection, QueueProducerConfiguration, long, ICreationScope> verify,
Action <QueueConnection, IBaseTransportOptions, ICreationScope, int, bool, bool> verifyQueueCount)
where TTransportInit : ITransportInit, new()
where TTransportCreate : class, IQueueCreation
{
var logProvider = LoggerShared.Create(queueConnection.Queue, GetType().Name);
using (var queueCreator =
new QueueCreationContainer <TTransportInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
ICreationScope scope = null;
var oCreation = queueCreator.GetQueueCreation <TTransportCreate>(queueConnection);
try
{
setOptions(oCreation);
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
scope = oCreation.Scope;
//create data
var producer = new ProducerMethodShared();
var id = Guid.NewGuid();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <TTransportInit>(queueConnection, false, messageCount,
logProvider, generateData,
verify, false, id, GenerateMethod.CreateRollBackCompiled, runtime, scope,
false);
}
else
{
producer.RunTestDynamic <TTransportInit>(queueConnection, false, messageCount,
logProvider, generateData,
verify, false, id, GenerateMethod.CreateRollBackDynamic, runtime, scope, false);
}
//process data
var consumer = new ConsumerMethodAsyncRollBackShared();
consumer.RunConsumer <TTransportInit>(queueConnection,
false,
workerCount, logProvider,
timeOut, readerCount, queueSize, runtime, messageCount, TimeSpan.FromSeconds(30),
TimeSpan.FromSeconds(35), id, "second(*%10)", enableChaos, scope);
LoggerShared.CheckForErrors(queueConnection.Queue);
verifyQueueCount(queueConnection, oCreation.BaseTransportOptions, scope, 0, false, false);
GenerateMethod.ClearRollback(id);
}
finally
{
oCreation.RemoveQueue();
oCreation.Dispose();
scope?.Dispose();
}
}
}
public void SumOperatorTest()
{
var d = GenerateMethod.Sum(1, 3);
Assert.Equal(1 + 3, d);
}
public static Scatter GenerateData(this Scatter reference, int startIndex, int stopIndex,
GenerateMethod method = GenerateMethod.Sin)
{
(reference.X, reference.Y) = GenerateData(startIndex, stopIndex);
return(reference);
}
public void Run(int messageCount, int runtime, int timeOut,
int workerCount, int readerCount, int queueSize, bool inMemoryDb, LinqMethodTypes linqMethodTypes, bool enableChaos)
{
using (var connectionInfo = new IntegrationConnectionInfo(inMemoryDb))
{
var queueName = GenerateQueueName.Create();
var logProvider = LoggerShared.Create(queueName, GetType().Name);
using (var queueCreator =
new QueueCreationContainer <SqLiteMessageQueueInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
try
{
using (
var oCreation =
queueCreator.GetQueueCreation <SqLiteMessageQueueCreation>(queueName,
connectionInfo.ConnectionString)
)
{
oCreation.Options.EnableDelayedProcessing = true;
oCreation.Options.EnableHeartBeat = true;
oCreation.Options.EnableStatus = true;
oCreation.Options.EnableStatusTable = true;
var result = oCreation.CreateQueue();
Assert.True(result.Success, result.ErrorMessage);
//create data
var producer = new ProducerMethodShared();
var id = Guid.NewGuid();
if (linqMethodTypes == LinqMethodTypes.Compiled)
{
producer.RunTestCompiled <SqLiteMessageQueueInit>(queueName,
connectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData,
Helpers.Verify, false, id, GenerateMethod.CreateRollBackCompiled, runtime, null, false);
}
//process data
var consumer = new ConsumerMethodAsyncRollBackShared();
consumer.RunConsumer <SqLiteMessageQueueInit>(queueName, connectionInfo.ConnectionString,
false,
workerCount, logProvider,
timeOut, readerCount, queueSize, runtime, messageCount, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(35), id, "second(*%10)", enableChaos);
LoggerShared.CheckForErrors(queueName);
new VerifyQueueRecordCount(queueName, connectionInfo.ConnectionString, oCreation.Options).Verify(0, false, false);
GenerateMethod.ClearRollback(id);
}
}
finally
{
using (
var oCreation =
queueCreator.GetQueueCreation <SqLiteMessageQueueCreation>(queueName,
connectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
}
