public void Run(int messageCount, 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); //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.CreateErrorCompiled, 0, oCreation.Scope); } //process data var consumer = new ConsumerMethodErrorShared(); consumer.RunConsumer <SqLiteMessageQueueInit>(queueName, connectionInfo.ConnectionString, false, logProvider, workerCount, timeOut, messageCount, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(35), id, "second(*%10)"); ValidateErrorCounts(queueName, connectionInfo.ConnectionString, messageCount); new VerifyQueueRecordCount(queueName, connectionInfo.ConnectionString, oCreation.Options).Verify(messageCount, true, false); } } finally { using ( var oCreation = queueCreator.GetQueueCreation <SqLiteMessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
public void Run(int messageCount, int timeOut, int workerCount, bool useTransactions) { 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.EnableHoldTransactionUntilMessageCommited = useTransactions; oCreation.Options.EnableStatus = !useTransactions; oCreation.Options.EnableStatusTable = true; var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); //create data var producer = new ProducerShared(); producer.RunTest<PostgreSqlMessageQueueInit, FakeMessage>(queueName, ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false); //process data var consumer = new ConsumerPoisonMessageShared<FakeMessage>(); consumer.RunConsumer<PostgreSqlMessageQueueInit>(queueName, ConnectionInfo.ConnectionString, false, workerCount, logProvider, timeOut, messageCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12)); ValidateErrorCounts(queueName, messageCount); new VerifyQueueRecordCount(queueName, oCreation.Options).Verify(messageCount, true, true); } } finally { using ( var oCreation = queueCreator.GetQueueCreation<PostgreSqlMessageQueueCreation>(queueName, ConnectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } }
public void Run(int messageCount, int timeOut, int workerCount, int readerCount, int queueSize, bool useTransactions) { var queueName = GenerateQueueName.Create(); var logProvider = LoggerShared.Create(queueName, GetType().Name); using (var queueCreator = new QueueCreationContainer <SqlServerMessageQueueInit>( serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton))) { try { using ( var oCreation = queueCreator.GetQueueCreation <SqlServerMessageQueueCreation>(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); //create data var producer = new ProducerShared(); producer.RunTest <SqlServerMessageQueueInit, FakeMessage>(queueName, ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, oCreation.Scope); //process data var consumer = new ConsumerAsyncPoisonMessageShared <FakeMessage>(); consumer.RunConsumer <SqlServerMessageQueueInit>(queueName, ConnectionInfo.ConnectionString, false, workerCount, logProvider, timeOut, readerCount, queueSize, messageCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), "second(*%3)", null); ValidateErrorCounts(queueName, messageCount); new VerifyQueueRecordCount(queueName, oCreation.Options).Verify(messageCount, true, true); } } finally { using ( var oCreation = queueCreator.GetQueueCreation <SqlServerMessageQueueCreation>(queueName, ConnectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } }
public void Run(int messageCount, int timeOut, int workerCount, int readerCount, int queueSize, bool inMemoryDb) { 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 ProducerShared(); producer.RunTest<SqLiteMessageQueueInit, FakeMessage>(queueName, connectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false); //process data var consumer = new ConsumerAsyncErrorShared<FakeMessage>(); consumer.RunConsumer<SqLiteMessageQueueInit>(queueName,connectionInfo.ConnectionString, false, logProvider, messageCount, workerCount, timeOut, queueSize, readerCount, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(35)); ValidateErrorCounts(queueName, connectionInfo.ConnectionString, messageCount); new VerifyQueueRecordCount(queueName, connectionInfo.ConnectionString, oCreation.Options).Verify(messageCount, true, false); } } finally { using ( var oCreation = queueCreator.GetQueueCreation<SqLiteMessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
public void Run(int messageCount, int runtime, int timeOut, int workerCount, bool inMemoryDb, 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.EnableMessageExpiration = true; 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 ProducerShared(); producer.RunTest <SqLiteMessageQueueInit, FakeMessage>(queueName, connectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, oCreation.Scope, false); var consumer = new ConsumerExpiredMessageShared <FakeMessage>(); consumer.RunConsumer <SqLiteMessageQueueInit>(queueName, connectionInfo.ConnectionString, false, logProvider, runtime, messageCount, workerCount, timeOut, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(35), "second(*%10)", null, enableChaos); new VerifyQueueRecordCount(queueName, connectionInfo.ConnectionString, oCreation.Options).Verify(0, false, false); } } finally { using ( var oCreation = queueCreator.GetQueueCreation <SqLiteMessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
public void Run(int messageCount, int runtime, int timeOut, int workerCount, bool useTransactions, bool enableChaos) { 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(); var producer = new ProducerMethodMultipleDynamicShared(); producer.RunTestDynamic <PostgreSqlMessageQueueInit>(queueName, ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, id, GenerateMethod.CreateMultipleDynamic, runtime, oCreation.Scope, false); var consumer = new ConsumerMethodShared(); consumer.RunConsumer <PostgreSqlMessageQueueInit>(queueName, ConnectionInfo.ConnectionString, false, logProvider, runtime, messageCount, workerCount, timeOut, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), id, "second(*%3)", enableChaos); new VerifyQueueRecordCount(queueName, oCreation.Options).Verify(0, false, false); } } finally { using ( var oCreation = queueCreator.GetQueueCreation <PostgreSqlMessageQueueCreation>(queueName, ConnectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } }
public void Run( int messageCount, LinqMethodTypes linqMethodTypes) { using (var connectionInfo = new IntegrationConnectionInfo()) { var queueName = GenerateQueueName.Create(); var logProvider = LoggerShared.Create(queueName, GetType().Name); using (var queueCreator = new QueueCreationContainer <MemoryMessageQueueInit>( serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton))) { try { using ( var oCreation = queueCreator.GetQueueCreation <MessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); var id = Guid.NewGuid(); var producer = new ProducerMethodShared(); if (linqMethodTypes == LinqMethodTypes.Compiled) { producer.RunTestCompiled <MemoryMessageQueueInit>(queueName, connectionInfo.ConnectionString, true, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, id, GenerateMethod.CreateCompiled, 0, oCreation.Scope, false); } #if NETFULL else { producer.RunTestDynamic <MemoryMessageQueueInit>(queueName, connectionInfo.ConnectionString, true, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, id, GenerateMethod.CreateDynamic, 0, oCreation.Scope, false); } #endif } } finally { using ( var oCreation = queueCreator.GetQueueCreation <MessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
public void Run(int messageCount, int timeOut, int workerCount) { using (var connectionInfo = new IntegrationConnectionInfo()) { var queueName = GenerateQueueName.Create(); var logProvider = LoggerShared.Create(queueName, GetType().Name); using (var queueCreator = new QueueCreationContainer <MemoryMessageQueueInit>( serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton))) { try { using ( var oCreation = queueCreator.GetQueueCreation <MessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); //create data var producer = new ProducerShared(); producer.RunTest <MemoryMessageQueueInit, FakeMessage>(queueName, connectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, oCreation.Scope, false); //process data var consumer = new ConsumerErrorShared <FakeMessage>(); consumer.RunConsumer <MemoryMessageQueueInit>(queueName, connectionInfo.ConnectionString, false, logProvider, workerCount, timeOut, messageCount, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(35), "second(*%10)", null, false); ValidateErrorCounts(oCreation.Scope, messageCount); new VerifyQueueRecordCount().Verify(oCreation.Scope, messageCount, false); //purge error records consumer.PurgeErrorMessages <MemoryMessageQueueInit>(queueName, connectionInfo.ConnectionString, false, logProvider, true); //memory queue doesn't actually keep errors, so nothing to check for... } } finally { using ( var oCreation = queueCreator.GetQueueCreation <MessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
public void Run(int messageCount, int runtime, int timeOut, int workerCount) { using (var connectionInfo = new IntegrationConnectionInfo()) { var queueName = GenerateQueueName.Create(); var logProvider = LoggerShared.Create(queueName, GetType().Name); using ( var queueCreator = new QueueCreationContainer <MemoryMessageQueueInit>( serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton))) { try { using ( var oCreation = queueCreator.GetQueueCreation <MessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); var producer = new ProducerMethodMultipleDynamicShared(); var id = Guid.NewGuid(); producer.RunTestDynamic <MemoryMessageQueueInit>(queueName, connectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, id, GenerateMethod.CreateMultipleDynamic, runtime, oCreation.Scope); var consumer = new ConsumerMethodShared(); consumer.RunConsumer <MemoryMessageQueueInit>(queueName, connectionInfo.ConnectionString, false, logProvider, runtime, messageCount, workerCount, timeOut, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(35), id, "second(*%10)"); new VerifyQueueRecordCount() .Verify(oCreation.Scope, 0, true); } } finally { using ( var oCreation = queueCreator.GetQueueCreation <MessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
public void Run(int messageCount, int runtime, int timeOut, int workerCount, bool useTransactions) { var queueName = GenerateQueueName.Create(); var logProvider = LoggerShared.Create(queueName, GetType().Name); using ( var queueCreator = new QueueCreationContainer<SqlServerMessageQueueInit>( serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton))) { try { using ( var oCreation = queueCreator.GetQueueCreation<SqlServerMessageQueueCreation>(queueName, ConnectionInfo.ConnectionString) ) { oCreation.Options.EnableDelayedProcessing = true; oCreation.Options.EnableHeartBeat = !useTransactions; oCreation.Options.EnableHoldTransactionUntilMessageCommited = useTransactions; oCreation.Options.EnableStatus = !useTransactions; oCreation.Options.EnableStatusTable = true; var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); var id = Guid.NewGuid(); var producer = new ProducerMethodMultipleDynamicShared(); producer.RunTestDynamic<SqlServerMessageQueueInit>(queueName, ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, id, GenerateMethod.CreateMultipleDynamic, runtime); var consumer = new ConsumerMethodShared(); consumer.RunConsumer<SqlServerMessageQueueInit>(queueName, ConnectionInfo.ConnectionString, false, logProvider, runtime, messageCount, workerCount, timeOut, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), id); new VerifyQueueRecordCount(queueName, oCreation.Options).Verify(0, false, false); } } finally { using ( var oCreation = queueCreator.GetQueueCreation<SqlServerMessageQueueCreation>(queueName, ConnectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } }
public void Run(int messageCount, int runtime, int timeOut, int readerCount, bool inMemoryDb, int routeCount) { 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; oCreation.Options.EnableRoute = true; var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); var routeTest = new RouteTestsShared(); routeTest.RunTest<SqLiteMessageQueueInit, FakeMessageA>(queueName, connectionInfo.ConnectionString, true, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, GenerateRoutes(routeCount), runtime, timeOut, readerCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12)); new VerifyQueueRecordCount(queueName, connectionInfo.ConnectionString, oCreation.Options).Verify(0, false, false); } } finally { using ( var oCreation = queueCreator.GetQueueCreation<SqLiteMessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
public void Run(int messageCount, int runtime, int timeOut, int readerCount, bool inMemoryDb, int routeCount) { 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; oCreation.Options.EnableRoute = true; var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); var routeTest = new RouteTestsShared(); routeTest.RunTest <SqLiteMessageQueueInit, FakeMessageA>(queueName, connectionInfo.ConnectionString, true, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, GenerateRoutes(routeCount), runtime, timeOut, readerCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), oCreation.Scope, "second(*%3)"); new VerifyQueueRecordCount(queueName, connectionInfo.ConnectionString, oCreation.Options).Verify(0, false, false); } } finally { using ( var oCreation = queueCreator.GetQueueCreation <SqLiteMessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
public void RunMultiple( bool interceptors, int producerCount, ConnectionInfoTypes type) { var queueName = GenerateQueueName.Create(); var connectionString = new ConnectionInfo(type).ConnectionString; using (var queueContainer = new QueueContainer<RedisQueueInit>(x => { })) { try { var tests = new JobSchedulerTestsShared(); tests.RunTestMultipleProducers<RedisQueueInit, RedisJobQueueCreation>(queueName, connectionString, interceptors, producerCount, queueContainer.CreateTimeSync(connectionString)); } finally { using (var queueCreator = new QueueCreationContainer<RedisQueueInit>()) { using ( var oCreation = queueCreator.GetQueueCreation<RedisQueueCreation>(queueName, connectionString) ) { oCreation.RemoveQueue(); } } } } }
static void Main(string[] args) { //we are using serilog for sample purposes var log = new LoggerConfiguration() .WriteTo.Console() .MinimumLevel.Debug() .CreateLogger(); Log.Logger = log; log.Information("Startup"); log.Information(SharedConfiguration.AllSettings); var queueName = ConfigurationManager.AppSettings.ReadSetting("QueueName"); var connectionString = ConfigurationManager.AppSettings.ReadSetting("Database"); var queueConnection = new QueueConnection(queueName, connectionString); //create the container for creating a new queue using (var createQueueContainer = new QueueCreationContainer <PostgreSqlMessageQueueInit>(serviceRegister => Injectors.AddInjectors(new SerilogAdapter(log), SharedConfiguration.EnableTrace, SharedConfiguration.EnableMetrics, SharedConfiguration.EnableCompression, SharedConfiguration.EnableEncryption, "PostgreSqlProducer", serviceRegister) , options => Injectors.SetOptions(options, SharedConfiguration.EnableChaos))) { using (var createQueue = createQueueContainer.GetQueueCreation <PostgreSqlMessageQueueCreation>(queueConnection)) { //Create the queue if it doesn't exist if (!createQueue.QueueExists) { //queue options createQueue.Options.EnableDelayedProcessing = true; createQueue.Options.EnableHeartBeat = true; createQueue.Options.EnableMessageExpiration = true; createQueue.Options.EnableStatus = true; createQueue.Options.EnableStatusTable = true; var result = createQueue.CreateQueue(); log.Information(result.Status.ToString()); } else { log.Information("Queue already exists; not creating"); } } } //create the producer using (var queueContainer = new QueueContainer <PostgreSqlMessageQueueInit>(serviceRegister => Injectors.AddInjectors(new SerilogAdapter(log), SharedConfiguration.EnableTrace, SharedConfiguration.EnableMetrics, SharedConfiguration.EnableCompression, SharedConfiguration.EnableEncryption, "PostgreSqlProducer", serviceRegister) , options => Injectors.SetOptions(options, SharedConfiguration.EnableChaos))) { using (var queue = queueContainer.CreateMethodProducer(queueConnection)) { RunProducer.RunLoop(queue, ExpiredData, ExpiredDataFuture); } } //if jaeger is using udp, sometimes the messages get lost; there doesn't seem to be a flush() call ? if (SharedConfiguration.EnableTrace) { System.Threading.Thread.Sleep(2000); } }
static void Main(string[] args) { //we are using serilog for sample purposes var log = new LoggerConfiguration() .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] [{SourceContext}] {Message:lj}{NewLine}{Exception}") .MinimumLevel.Debug() .CreateLogger(); Log.Logger = log; log.Information("Startup"); log.Information(SharedConfiguration.AllSettings); //determine our file path var fileLocation = Path.Combine(Environment.ExpandEnvironmentVariables("%userprofile%"), "Documents"); var queueName = ConfigurationManager.AppSettings.ReadSetting("QueueName"); var connectionString = $"Filename={fileLocation}{ConfigurationManager.AppSettings.ReadSetting("Database")};Connection=shared;"; var queueConnection = new QueueConnection(queueName, connectionString); //create the container for creating a new queue using (var createQueueContainer = new QueueCreationContainer <LiteDbMessageQueueInit>(serviceRegister => Injectors.AddInjectors(Helpers.CreateForSerilog(), SharedConfiguration.EnableTrace, SharedConfiguration.EnableMetrics, SharedConfiguration.EnableCompression, SharedConfiguration.EnableEncryption, "LiteDbProducer", serviceRegister) , options => Injectors.SetOptions(options, SharedConfiguration.EnableChaos))) { using (var createQueue = createQueueContainer.GetQueueCreation <LiteDbMessageQueueCreation>(queueConnection)) { //Create the queue if it doesn't exist if (!createQueue.QueueExists) { //queue options createQueue.Options.EnableDelayedProcessing = true; createQueue.Options.EnableMessageExpiration = true; createQueue.Options.EnableStatusTable = true; var result = createQueue.CreateQueue(); log.Information(result.Status.ToString()); } else { log.Information("Queue already exists; not creating"); } } } //create the producer using (var queueContainer = new QueueContainer <LiteDbMessageQueueInit>(serviceRegister => Injectors.AddInjectors(Helpers.CreateForSerilog(), SharedConfiguration.EnableTrace, SharedConfiguration.EnableMetrics, SharedConfiguration.EnableCompression, SharedConfiguration.EnableEncryption, "LiteDbProducer", serviceRegister), options => Injectors.SetOptions(options, SharedConfiguration.EnableChaos))) { using (var queue = queueContainer.CreateProducer <SimpleMessage>(queueConnection)) { RunProducer.RunLoop(queue, ExpiredData, ExpiredDataFuture, DelayedProcessing); } } //if jaeger is using udp, sometimes the messages get lost; there doesn't seem to be a flush() call ? if (SharedConfiguration.EnableTrace) { System.Threading.Thread.Sleep(2000); } }
public void RunMultiple( int producerCount, ConnectionInfoTypes type) { var queueName = GenerateQueueName.Create(); var connectionString = new ConnectionInfo(type).ConnectionString; using (var queueContainer = new QueueContainer <RedisQueueInit>(x => { })) { try { var tests = new JobSchedulerTestsShared(); tests.RunTestMultipleProducers <RedisQueueInit, RedisJobQueueCreation>(queueName, connectionString, true, producerCount, queueContainer.CreateTimeSync(connectionString), LoggerShared.Create(queueName, GetType().Name)); } finally { using (var queueCreator = new QueueCreationContainer <RedisQueueInit>()) { using ( var oCreation = queueCreator.GetQueueCreation <RedisQueueCreation>(queueName, connectionString) ) { oCreation.RemoveQueue(); } } } } }
public async void Run( int messageCount, bool interceptors, bool batchSending, ConnectionInfoTypes type) { var queueName = GenerateQueueName.Create(); var logProvider = LoggerShared.Create(queueName, GetType().Name); var producer = new ProducerAsyncShared(); var connectionString = new ConnectionInfo(type).ConnectionString; using ( var queueCreator = new QueueCreationContainer <RedisQueueInit>( serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton))) { try { await producer.RunTestAsync <RedisQueueInit, FakeMessage>(queueName, connectionString, interceptors, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, batchSending, null).ConfigureAwait(false); } finally { using ( var oCreation = queueCreator.GetQueueCreation <RedisQueueCreation>(queueName, connectionString) ) { oCreation.RemoveQueue(); } } } }
public void Run( int producerCount, bool inMemoryDb) { using (var connectionInfo = new IntegrationConnectionInfo(inMemoryDb)) { var queueName = GenerateQueueName.Create(); using (var queueContainer = new QueueContainer <SqLiteMessageQueueInit>(x => { })) { try { var tests = new JobSchedulerTestsShared(); tests.RunTestMultipleProducers <SqLiteMessageQueueInit, SqliteJobQueueCreation>(queueName, connectionInfo.ConnectionString, true, producerCount, queueContainer.CreateTimeSync(connectionInfo.ConnectionString), LoggerShared.Create(queueName, GetType().Name)); } finally { using (var queueCreator = new QueueCreationContainer <SqLiteMessageQueueInit>()) { using ( var oCreation = queueCreator.GetQueueCreation <SqLiteMessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } } }
public void Run( bool interceptors, int producerCount) { var queueName = GenerateQueueName.Create(); using (var queueContainer = new QueueContainer <SqlServerMessageQueueInit>(x => { })) { try { var tests = new JobSchedulerTestsShared(); tests.RunTestMultipleProducers <SqlServerMessageQueueInit, SqlServerJobQueueCreation>(queueName, ConnectionInfo.ConnectionString, interceptors, producerCount, queueContainer.CreateTimeSync(ConnectionInfo.ConnectionString), LoggerShared.Create(queueName, GetType().Name)); } finally { using (var queueCreator = new QueueCreationContainer <SqlServerMessageQueueInit>()) { using ( var oCreation = queueCreator.GetQueueCreation <SqlServerMessageQueueCreation>(queueName, ConnectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
public void Run( bool interceptors, int producerCount) { var queueName = GenerateQueueName.Create(); using (var queueContainer = new QueueContainer<SqlServerMessageQueueInit>(x => { })) { try { var tests = new JobSchedulerTestsShared(); tests.RunTestMultipleProducers<SqlServerMessageQueueInit, SqlServerJobQueueCreation>(queueName, ConnectionInfo.ConnectionString, interceptors, producerCount, queueContainer.CreateTimeSync(ConnectionInfo.ConnectionString)); } finally { using (var queueCreator = new QueueCreationContainer<SqlServerMessageQueueInit>()) { using ( var oCreation = queueCreator.GetQueueCreation<SqlServerMessageQueueCreation>(queueName, ConnectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
public void Run <TTransportInit, TTransportCreate>( QueueConnection queueConnection, int messageCount, int queueCount, LinqMethodTypes linqMethodTypes, bool enableChaos, Func <QueueProducerConfiguration, AdditionalMessageData> generateData, Action <QueueConnection, IBaseTransportOptions, ICreationScope, int, string> 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 { var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); scope = oCreation.Scope; RunTest <TTransportInit>(queueConnection, messageCount, queueCount, logProvider, linqMethodTypes, oCreation.Scope, enableChaos, generateData); LoggerShared.CheckForErrors(queueConnection.Queue); verifyQueueCount(queueConnection, oCreation.BaseTransportOptions, scope, messageCount * queueCount, null); } finally { oCreation.RemoveQueue(); oCreation.Dispose(); scope?.Dispose(); } } }
public void Run <TTransportInit, TJobQueueCreator, TTransportCreate>( QueueConnection queueConnection, int producerCount) where TTransportInit : ITransportInit, new() where TJobQueueCreator : class, IJobQueueCreation where TTransportCreate : class, IQueueCreation { using (var queueCreator = new QueueCreationContainer <TTransportInit>()) { var oCreation = queueCreator.GetQueueCreation <TTransportCreate>(queueConnection); var scope = oCreation.Scope; using (var queueContainer = new QueueContainer <TTransportInit>(x => x.RegisterNonScopedSingleton(scope))) { 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 async void Run( int messageCount, bool interceptors, bool batchSending, ConnectionInfoTypes type) { var queueName = GenerateQueueName.Create(); var logProvider = LoggerShared.Create(queueName, GetType().Name); var producer = new ProducerAsyncShared(); var connectionString = new ConnectionInfo(type).ConnectionString; using ( var queueCreator = new QueueCreationContainer<RedisQueueInit>( serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton))) { try { await producer.RunTest<RedisQueueInit, FakeMessage>(queueName, connectionString, interceptors, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, batchSending); } finally { using ( var oCreation = queueCreator.GetQueueCreation<RedisQueueCreation>(queueName, connectionString) ) { oCreation.RemoveQueue(); } } } }
public async void Run( int messageCount, LinqMethodTypes linqMethodTypes) { using (var connectionInfo = new IntegrationConnectionInfo()) { var queueName = GenerateQueueName.Create(); var logProvider = LoggerShared.Create(queueName, GetType().Name); using ( var queueCreator = new QueueCreationContainer <MemoryMessageQueueInit>( serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton))) { try { using ( var oCreation = queueCreator.GetQueueCreation <MessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); var producer = new ProducerMethodAsyncShared(); var id = Guid.NewGuid(); await producer.RunTestAsync <MemoryMessageQueueInit>(queueName, connectionInfo.ConnectionString, true, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, 0, id, linqMethodTypes, oCreation.Scope, false).ConfigureAwait(false); } } finally { using ( var oCreation = queueCreator.GetQueueCreation <MessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
public void Run(int messageCount, int runtime, int timeOut, int readerCount, int routeCount, ConnectionInfoTypes type) { 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 { using ( var oCreation = queueCreator.GetQueueCreation<RedisQueueCreation>(queueName, connectionString) ) { var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); var routeTest = new RouteTestsShared(); routeTest.RunTest<RedisQueueInit, FakeMessageA>(queueName, connectionString, true, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, GenerateRoutes(routeCount), runtime, timeOut, readerCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12)); using (var count = new VerifyQueueRecordCount(queueName, connectionString)) { count.Verify(0, false, -1); } } } finally { using ( var oCreation = queueCreator.GetQueueCreation<RedisQueueCreation>(queueName, connectionString) ) { oCreation.RemoveQueue(); } } } }
public void Run(int messageCount, int runtime, int timeOut, int readerCount, int routeCount, ConnectionInfoTypes type, bool batch) { 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 { using ( var oCreation = queueCreator.GetQueueCreation <RedisQueueCreation>(queueName, connectionString) ) { var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); var routeTest = new RouteTestsShared(); routeTest.RunTest <RedisQueueInit, FakeMessageA>(queueName, connectionString, true, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, batch, GenerateRoutes(routeCount), runtime, timeOut, readerCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), oCreation.Scope, "second(*%3)", false); using (var count = new VerifyQueueRecordCount(queueName, connectionString)) { count.Verify(0, false, -1); } } } finally { using ( var oCreation = queueCreator.GetQueueCreation <RedisQueueCreation>(queueName, connectionString) ) { oCreation.RemoveQueue(); } } } }
public void Run( int messageCount, bool interceptors, bool batchSending, bool enableDelay, bool enableExpiration, ConnectionInfoTypes type) { var queueName = GenerateQueueName.Create(); var logProvider = LoggerShared.Create(queueName, GetType().Name); var producer = new ProducerShared(); var connectionString = new ConnectionInfo(type).ConnectionString; using ( var queueCreator = new QueueCreationContainer <RedisQueueInit>( serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton))) { try { if (enableExpiration && enableDelay) { producer.RunTest <RedisQueueInit, FakeMessage>(queueName, connectionString, interceptors, messageCount, logProvider, Helpers.GenerateDelayExpiredData, Helpers.Verify, batchSending, null); } else if (enableDelay) { producer.RunTest <RedisQueueInit, FakeMessage>(queueName, connectionString, interceptors, messageCount, logProvider, Helpers.GenerateDelayData, Helpers.Verify, batchSending, null); } else if (enableExpiration) { producer.RunTest <RedisQueueInit, FakeMessage>(queueName, connectionString, interceptors, messageCount, logProvider, Helpers.GenerateExpiredData, Helpers.Verify, batchSending, null); } else { producer.RunTest <RedisQueueInit, FakeMessage>(queueName, connectionString, interceptors, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, batchSending, null); } } finally { using ( var oCreation = queueCreator.GetQueueCreation <RedisQueueCreation>(queueName, connectionString) ) { oCreation.RemoveQueue(); } } } }
public void Run(int messageCount, 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 { //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.CreateNoOpCompiled, 0, null, false); } #if NETFULL else { producer.RunTestDynamic <RedisQueueInit>(queueName, connectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, id, GenerateMethod.CreateNoOpDynamic, 0, null, false); } #endif //process data var consumer = new ConsumerMethodPoisonMessageShared(); consumer.RunConsumer <RedisQueueInit>(queueName, connectionString, false, workerCount, logProvider, timeOut, messageCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), "second(*%3)", false); ValidateErrorCounts(queueName, connectionString, messageCount); using ( var count = new VerifyQueueRecordCount(queueName, connectionString)) { count.Verify(messageCount, true, 2); } } finally { using ( var oCreation = queueCreator.GetQueueCreation <RedisQueueCreation>(queueName, connectionString) ) { oCreation.RemoveQueue(); } } } }
public void Run(int messageCount, int timeOut, int workerCount, ConnectionInfoTypes type, bool route) { 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 if (route) { var producer = new ProducerShared(); producer.RunTest <RedisQueueInit, FakeMessage>(queueName, connectionString, false, messageCount, logProvider, Helpers.GenerateRouteData, Helpers.Verify, false, null, false); } else { var producer = new ProducerShared(); producer.RunTest <RedisQueueInit, FakeMessage>(queueName, connectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, null, false); } //process data var defaultRoute = route ? Helpers.DefaultRoute : null; var consumer = new ConsumerPoisonMessageShared <FakeMessage>(); consumer.RunConsumer <RedisQueueInit>(queueName, connectionString, false, workerCount, logProvider, timeOut, messageCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), "second(*%3)", defaultRoute, false); ValidateErrorCounts(queueName, connectionString, messageCount); using ( var count = new VerifyQueueRecordCount(queueName, connectionString)) { count.Verify(messageCount, true, 2); } } finally { using ( var oCreation = queueCreator.GetQueueCreation <RedisQueueCreation>(queueName, connectionString) ) { oCreation.RemoveQueue(); } } } }
public void Run( int messageCount, bool interceptors) { using (var connectionInfo = new IntegrationConnectionInfo()) { var queueName = GenerateQueueName.Create(); var logProvider = LoggerShared.Create(queueName, GetType().Name); using (var queueCreator = new QueueCreationContainer <MemoryMessageQueueInit>( serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton))) { try { using ( var oCreation = queueCreator.GetQueueCreation <MessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); var producer = new ProducerShared(); producer.RunTest <MemoryMessageQueueInit, FakeMessage>(queueName, connectionInfo.ConnectionString, interceptors, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, true, oCreation.Scope, false); } } finally { using ( var oCreation = queueCreator.GetQueueCreation <MessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
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.GenerateExpiredData, Helpers.Verify, false, id, GenerateMethod.CreateCompiled, runtime, null); } #if NETFULL else { producer.RunTestDynamic <RedisQueueInit>(queueName, connectionString, false, messageCount, logProvider, Helpers.GenerateExpiredData, Helpers.Verify, false, id, GenerateMethod.CreateDynamic, runtime, null); } #endif Thread.Sleep(2000); var consumer = new ConsumerMethodExpiredMessageShared(); consumer.RunConsumer <RedisQueueInit>(queueName, connectionString, false, logProvider, runtime, messageCount, workerCount, timeOut, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), "second(*%10)", id); using (var count = new VerifyQueueRecordCount(queueName, connectionString)) { count.Verify(0, false, -1); } } finally { using ( var oCreation = queueCreator.GetQueueCreation <RedisQueueCreation>(queueName, connectionString) ) { oCreation.RemoveQueue(); } } } }
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 void Run <TTransportInit, TMessage, TTransportCreate>( QueueConnection queueConnection, int messageCount, int runtime, int timeOut, int workerCount, 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 TMessage : class 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; var producer = new ProducerShared(); producer.RunTest <TTransportInit, TMessage>(queueConnection, false, messageCount, logProvider, generateData, verify, false, scope, false); var consumer = new ConsumerShared <TMessage>(); consumer.RunConsumer <TTransportInit>(queueConnection, false, logProvider, runtime, messageCount, workerCount, timeOut, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(35), "second(*%10)", enableChaos, scope); verifyQueueCount(queueConnection, oCreation.BaseTransportOptions, scope, 0, false, false); } finally { oCreation?.RemoveQueue(); oCreation?.Dispose(); scope?.Dispose(); } } }
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); } else { producer.RunTestDynamic<RedisQueueInit>(queueName, connectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, id, GenerateMethod.CreateCancelDynamic, runtime); } var consumer = new ConsumerMethodHeartBeatShared(); consumer.RunConsumer<RedisQueueInit>(queueName, connectionString, false, logProvider, runtime, messageCount, workerCount, timeOut, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), 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(); } } } }
public void Run <TTransportInit, TTransportCreate>( QueueConnection queueConnection, int messageCount, LinqMethodTypes linqMethodTypes, bool interceptors, bool enableChaos, bool sendViaBatch, Action <TTransportCreate> setOptions, Func <QueueProducerConfiguration, AdditionalMessageData> generateData, Action <QueueConnection, QueueProducerConfiguration, long, ICreationScope> verify) 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; var id = Guid.NewGuid(); var producer = new ProducerMethodShared(); if (linqMethodTypes == LinqMethodTypes.Compiled) { producer.RunTestCompiled <TTransportInit>(queueConnection, interceptors, messageCount, logProvider, generateData, verify, sendViaBatch, id, GenerateMethod.CreateCompiled, 0, oCreation.Scope, enableChaos); } else { producer.RunTestDynamic <TTransportInit>(queueConnection, interceptors, messageCount, logProvider, generateData, verify, sendViaBatch, id, GenerateMethod.CreateDynamic, 0, oCreation.Scope, enableChaos); } } finally { oCreation.RemoveQueue(); oCreation.Dispose(); scope?.Dispose(); } } }
public void Run(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) ) { var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); RunTest(queueName, 100, 10, logProvider, connectionInfo.ConnectionString, linqMethodTypes); LoggerShared.CheckForErrors(queueName); new VerifyQueueData(queueName, connectionInfo.ConnectionString, oCreation.Options).Verify(100 * 10, null); } } finally { using ( var oCreation = queueCreator.GetQueueCreation<SqLiteMessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
public void Run(int messageCount, 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) ) { var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); RunTest(queueName, messageCount, 10, logProvider, connectionInfo.ConnectionString, linqMethodTypes, oCreation.Scope, enableChaos); LoggerShared.CheckForErrors(queueName); new VerifyQueueData(queueName, connectionInfo.ConnectionString, oCreation.Options).Verify(messageCount * 10, null); } } finally { using ( var oCreation = queueCreator.GetQueueCreation <SqLiteMessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
public void Run(int messageCount, int runtime, int timeOut, int readerCount, int routeCount, bool enableChaos, IntegrationConnectionInfo.ConnectionTypes connectionType) { using (var connectionInfo = new IntegrationConnectionInfo(connectionType)) { var queueName = GenerateQueueName.Create(); var consumer = new DotNetWorkQueue.IntegrationTests.Shared.Route.Implementation.RouteMultiTests(); consumer.Run <LiteDbMessageQueueInit, LiteDbMessageQueueCreation>(new QueueConnection(queueName, connectionInfo.ConnectionString), messageCount, runtime, timeOut, readerCount, routeCount, enableChaos, x => { Helpers.SetOptions(x, false, false, true, true); }, Helpers.GenerateData, Helpers.Verify, Helpers.VerifyQueueCount); } using (var connectionInfo = new IntegrationConnectionInfo(connectionType)) { var queueName = GenerateQueueName.Create(); var logProvider = LoggerShared.Create(queueName, GetType().Name); using (var queueCreator = new QueueCreationContainer <LiteDbMessageQueueInit>( serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton))) { var queueConnection = new DotNetWorkQueue.Configuration.QueueConnection(queueName, connectionInfo.ConnectionString); ICreationScope scope = null; var oCreation = queueCreator.GetQueueCreation <LiteDbMessageQueueCreation>(queueConnection); try { oCreation.Options.EnableStatusTable = true; oCreation.Options.EnableRoute = true; var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); scope = oCreation.Scope; var routeTest = new RouteMultiTestsShared(); routeTest.RunTest <LiteDbMessageQueueInit, FakeMessageA>(queueConnection, true, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, GenerateRoutes(routeCount, 1), GenerateRoutes(routeCount, routeCount + 1), runtime, timeOut, readerCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), oCreation.Scope, "second(*%3)", enableChaos); new VerifyQueueRecordCount(queueName, connectionInfo.ConnectionString, oCreation.Options, scope) .Verify(0, false, false); } finally { oCreation?.RemoveQueue(); oCreation?.Dispose(); scope?.Dispose(); } } } }
public void Run() { using (var connectionInfo = new IntegrationConnectionInfo()) { var queueName = GenerateQueueName.Create(); var logProvider = LoggerShared.Create(queueName, GetType().Name); using (var queueCreator = new QueueCreationContainer <MemoryMessageQueueInit>( serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton))) { try { using ( var oCreation = queueCreator.GetQueueCreation <MessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); RunTest(queueName, 100, 10, logProvider, connectionInfo.ConnectionString, oCreation.Scope); LoggerShared.CheckForErrors(queueName); } } finally { using ( var oCreation = queueCreator.GetQueueCreation <MessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
public void Run() { 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) ) { var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); RunTest(queueName, 1000, 10, logProvider, oCreation.Scope); LoggerShared.CheckForErrors(queueName); new VerifyQueueData(queueName, oCreation.Options).Verify(1000 * 10, null); } } finally { using ( var oCreation = queueCreator.GetQueueCreation <PostgreSqlMessageQueueCreation>(queueName, ConnectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } }
public void Run(int messageCount, int timeOut, int workerCount, ConnectionInfoTypes type) { 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 producer = new ProducerShared(); producer.RunTest<RedisQueueInit, FakeMessage>(queueName, connectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false); //process data var consumer = new ConsumerPoisonMessageShared<FakeMessage>(); consumer.RunConsumer<RedisQueueInit>(queueName, connectionString, false, workerCount, logProvider, timeOut, messageCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12)); ValidateErrorCounts(queueName, connectionString, messageCount); using ( var count = new VerifyQueueRecordCount(queueName, connectionString)) { count.Verify(messageCount, true, 2); } } finally { using ( var oCreation = queueCreator.GetQueueCreation<RedisQueueCreation>(queueName, connectionString) ) { oCreation.RemoveQueue(); } } } }
public void Run( bool interceptors, bool dynamic, bool inMemoryDb) { using (var queueContainer = new QueueContainer<SqLiteMessageQueueInit>(x => {})) { using (var connectionInfo = new IntegrationConnectionInfo(inMemoryDb)) { var queueName = GenerateQueueName.Create(); try { var tests = new JobSchedulerTestsShared(); if (!dynamic) { tests.RunEnqueueTestCompiled<SqLiteMessageQueueInit, SqliteJobQueueCreation>(queueName, connectionInfo.ConnectionString, interceptors, Helpers.Verify, Helpers.SetError, queueContainer.CreateTimeSync(connectionInfo.ConnectionString)); } else { tests.RunEnqueueTestDynamic<SqLiteMessageQueueInit, SqliteJobQueueCreation>(queueName, connectionInfo.ConnectionString, interceptors, Helpers.Verify, Helpers.SetError, queueContainer.CreateTimeSync(connectionInfo.ConnectionString)); } } finally { using (var queueCreator = new QueueCreationContainer<SqLiteMessageQueueInit>()) { using ( var oCreation = queueCreator.GetQueueCreation<SqLiteMessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } } }
public void Run( bool interceptors, bool dynamic, ConnectionInfoTypes type) { var queueName = GenerateQueueName.Create(); var connectionString = new ConnectionInfo(type).ConnectionString; using (var queueContainer = new QueueContainer<RedisQueueInit>(x => { })) { try { var tests = new JobSchedulerTestsShared(); if (!dynamic) { tests.RunEnqueueTestCompiled<RedisQueueInit, RedisJobQueueCreation>(queueName, connectionString, interceptors, Helpers.Verify, Helpers.SetError, queueContainer.CreateTimeSync(connectionString)); } else { tests.RunEnqueueTestDynamic<RedisQueueInit, RedisJobQueueCreation>(queueName, connectionString, interceptors, Helpers.Verify, Helpers.SetError, queueContainer.CreateTimeSync(connectionString)); } } finally { using (var queueCreator = new QueueCreationContainer<RedisQueueInit>()) { using ( var oCreation = queueCreator.GetQueueCreation<RedisQueueCreation>(queueName, connectionString) ) { oCreation.RemoveQueue(); } } } } }
public void Run(int messageCount, int runtime, int timeOut, int workerCount, bool async, ConnectionInfoTypes type, LinqMethodTypes linqMethodTypes) { var queueNameSend = GenerateQueueName.Create(); var logProviderSend = LoggerShared.Create(queueNameSend, GetType().Name); var connectionString = new ConnectionInfo(type).ConnectionString; using (var queueCreatorSend = new QueueCreationContainer<RedisQueueInit>( serviceRegister => serviceRegister.Register(() => logProviderSend, LifeStyles.Singleton))) { try { var id = Guid.NewGuid(); var rpc = new RpcMethodShared <RedisQueueInit, FakeResponse, RedisQueueRpcConnection>(); rpc.Run(queueNameSend, queueNameSend, connectionString, connectionString, logProviderSend, logProviderSend, runtime, messageCount, workerCount, timeOut, async, new RedisQueueRpcConnection(connectionString, queueNameSend), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), id, linqMethodTypes); using (var count = new VerifyQueueRecordCount(queueNameSend, connectionString)) { count.Verify(0, false, -1); } } finally { using ( var oCreation = queueCreatorSend.GetQueueCreation<RedisQueueCreation>(queueNameSend, connectionString) ) { oCreation.RemoveQueue(); } } } }
public void Run(int messageCount, int runtime, int timeOut, int workerCount, int readerCount, int queueSize, int messageType, ConnectionInfoTypes type) { SchedulerContainer schedulerContainer = null; if (Factory == null) { Factory = CreateFactory(workerCount, queueSize, out schedulerContainer); } 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 { if (messageType == 1) { var producer = new ProducerAsyncShared(); producer.RunTest<RedisQueueInit, FakeMessage>(queueName, connectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false).Wait(timeOut * 1000 / 2); var consumer = new ConsumerAsyncShared<FakeMessage> {Factory = Factory}; consumer.RunConsumer<RedisQueueInit>(queueName, connectionString, false, logProvider, runtime, messageCount, timeOut, readerCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12)); } else if (messageType == 2) { var producer = new ProducerAsyncShared(); producer.RunTest<RedisQueueInit, FakeMessageA>(queueName, connectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false).Wait(timeOut * 1000 / 2); var consumer = new ConsumerAsyncShared<FakeMessageA> {Factory = Factory}; consumer.RunConsumer<RedisQueueInit>(queueName, connectionString, false, logProvider, runtime, messageCount, timeOut, readerCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12)); } else if (messageType == 3) { var producer = new ProducerAsyncShared(); producer.RunTest<RedisQueueInit, FakeMessageB>(queueName, connectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false).Wait(timeOut * 1000 / 2); var consumer = new ConsumerAsyncShared<FakeMessageB> {Factory = Factory}; consumer.RunConsumer<RedisQueueInit>(queueName, connectionString, false, logProvider, runtime, messageCount, timeOut, readerCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12)); } using (var count = new VerifyQueueRecordCount(queueName, connectionString)) { count.Verify(0, false, -1); } } finally { schedulerContainer?.Dispose(); using ( var oCreation = queueCreator.GetQueueCreation<RedisQueueCreation>(queueName, connectionString) ) { oCreation.RemoveQueue(); } } } }
public void Run( int messageCount, bool interceptors, bool enableDelayedProcessing, bool enableHeartBeat, bool enableMessageExpiration, bool enablePriority, bool enableStatus, bool enableStatusTable, bool additionalColumn, 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 = enableDelayedProcessing; oCreation.Options.EnableHeartBeat = enableHeartBeat; oCreation.Options.EnableMessageExpiration = enableMessageExpiration; oCreation.Options.EnablePriority = enablePriority; oCreation.Options.EnableStatus = enableStatus; oCreation.Options.EnableStatusTable = enableStatusTable; if (additionalColumn) { oCreation.Options.AdditionalColumns.Add(new Column("OrderID", ColumnTypes.Integer, false, null)); } 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, interceptors, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, true, id, GenerateMethod.CreateCompiled, 0); } else { producer.RunTestDynamic<SqLiteMessageQueueInit>(queueName, connectionInfo.ConnectionString, interceptors, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, true, id, GenerateMethod.CreateDynamic, 0); } } } finally { using ( var oCreation = queueCreator.GetQueueCreation<SqLiteMessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
public void Run(int messageCount, int runtime, int timeOut, int workerCount, bool async, bool inMemoryDb) { var queueNameSend = GenerateQueueName.Create(); var queueNameReceive = GenerateQueueName.Create(); var logProviderSend = LoggerShared.Create(queueNameSend, GetType().Name); var logProviderReceive = LoggerShared.Create(queueNameReceive, GetType().Name); using (var connectionInfo = new IntegrationConnectionInfo(inMemoryDb)) { using (var queueCreatorReceive = new QueueCreationContainer<SqLiteMessageQueueInit>( serviceRegister => serviceRegister.Register(() => logProviderReceive, LifeStyles.Singleton))) { using (var queueCreatorSend = new QueueCreationContainer<SqLiteMessageQueueInit>( serviceRegister => serviceRegister.Register(() => logProviderSend, LifeStyles.Singleton))) { try { using ( var oCreationReceive = queueCreatorReceive.GetQueueCreation<SqLiteMessageQueueCreation>(queueNameReceive, connectionInfo.ConnectionString) ) { oCreationReceive.Options.EnableDelayedProcessing = true; oCreationReceive.Options.EnableHeartBeat = true; oCreationReceive.Options.EnableStatus = true; oCreationReceive.Options.EnableStatusTable = true; oCreationReceive.Options.QueueType = QueueTypes.RpcReceive; var resultReceive = oCreationReceive.CreateQueue(); Assert.True(resultReceive.Success, resultReceive.ErrorMessage); using ( var oCreation = queueCreatorSend.GetQueueCreation<SqLiteMessageQueueCreation>(queueNameSend, connectionInfo.ConnectionString) ) { oCreation.Options.EnableDelayedProcessing = true; oCreation.Options.EnableHeartBeat = true; oCreation.Options.EnableStatus = true; oCreation.Options.EnableStatusTable = true; oCreation.Options.QueueType = QueueTypes.RpcSend; var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); var rpc = new RpcShared <SqLiteMessageQueueInit, FakeResponse, FakeMessage, SqLiteRpcConnection>(); rpc.Run(queueNameReceive, queueNameSend, connectionInfo.ConnectionString, connectionInfo.ConnectionString, logProviderReceive, logProviderSend, runtime, messageCount, workerCount, timeOut, async, new SqLiteRpcConnection(connectionInfo.ConnectionString, queueNameSend, connectionInfo.ConnectionString, queueNameReceive), TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(35)); new VerifyQueueRecordCount(queueNameSend, connectionInfo.ConnectionString, oCreation.Options).Verify(0, false, false); new VerifyQueueRecordCount(queueNameReceive, connectionInfo.ConnectionString, oCreationReceive.Options).Verify(0, false, false); } } } finally { using ( var oCreation = queueCreatorSend.GetQueueCreation<SqLiteMessageQueueCreation>(queueNameSend, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } using ( var oCreation = queueCreatorReceive.GetQueueCreation<SqLiteMessageQueueCreation>(queueNameReceive, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } } }
public void Run(int messageCount, int timeOut, int workerCount, int readerCount, int queueSize, bool useTransactions, LinqMethodTypes linqMethodTypes) { var queueName = GenerateQueueName.Create(); var logProvider = LoggerShared.Create(queueName, GetType().Name); using (var queueCreator = new QueueCreationContainer<SqlServerMessageQueueInit>( serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton))) { try { using ( var oCreation = queueCreator.GetQueueCreation<SqlServerMessageQueueCreation>(queueName, ConnectionInfo.ConnectionString) ) { oCreation.Options.EnableDelayedProcessing = true; oCreation.Options.EnableHeartBeat = !useTransactions; oCreation.Options.EnableHoldTransactionUntilMessageCommited = useTransactions; oCreation.Options.EnableStatus = !useTransactions; oCreation.Options.EnableStatusTable = true; var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); //create data var id = Guid.NewGuid(); var producer = new ProducerMethodShared(); if (linqMethodTypes == LinqMethodTypes.Compiled) { producer.RunTestCompiled<SqlServerMessageQueueInit>(queueName, ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, id, GenerateMethod.CreateNoOpCompiled, 0); } else { producer.RunTestDynamic<SqlServerMessageQueueInit>(queueName, ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, id, GenerateMethod.CreateNoOpDynamic, 0); } //process data var consumer = new ConsumerMethodAsyncPoisonMessageShared(); consumer.RunConsumer<SqlServerMessageQueueInit>(queueName, ConnectionInfo.ConnectionString, false, workerCount, logProvider, timeOut, readerCount, queueSize, messageCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12)); ValidateErrorCounts(queueName, messageCount); new VerifyQueueRecordCount(queueName, oCreation.Options).Verify(messageCount, true, true); } } finally { using ( var oCreation = queueCreator.GetQueueCreation<SqlServerMessageQueueCreation>(queueName, ConnectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } }
public void Run(int messageCount, int runtime, int timeOut, int workerCount, 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 = true; oCreation.Options.EnableHoldTransactionUntilMessageCommited = false; oCreation.Options.EnableStatus = true; oCreation.Options.EnableStatusTable = true; var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); var id = Guid.NewGuid(); var producer = new ProducerMethodShared(); if (linqMethodTypes == LinqMethodTypes.Compiled) { producer.RunTestCompiled<PostgreSqlMessageQueueInit>(queueName, ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, id, GenerateMethod.CreateCancelCompiled, runtime); } else { producer.RunTestDynamic<PostgreSqlMessageQueueInit>(queueName, ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, id, GenerateMethod.CreateCancelDynamic, runtime); } var consumer = new ConsumerMethodCancelWorkShared<PostgreSqlMessageQueueInit>(); consumer.RunConsumer(queueName, ConnectionInfo.ConnectionString, false, logProvider, runtime, messageCount, workerCount, timeOut, serviceRegister => serviceRegister.Register<IMessageMethodHandling>(() => new MethodMessageProcessingCancel(id), LifeStyles.Singleton), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), id); new VerifyQueueRecordCount(queueName, oCreation.Options).Verify(0, false, false); GenerateMethod.ClearCancel(id); } } finally { using ( var oCreation = queueCreator.GetQueueCreation<PostgreSqlMessageQueueCreation>(queueName, ConnectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } }
public void Run(int messageCount, int runtime, int timeOut, int workerCount, int readerCount, int queueSize, bool useTransactions, int messageType) { SchedulerContainer schedulerContainer = null; if (Factory == null) { Factory = CreateFactory(workerCount, queueSize, out schedulerContainer); } 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.EnableHoldTransactionUntilMessageCommited = useTransactions; oCreation.Options.EnableStatus = !useTransactions; oCreation.Options.EnableStatusTable = true; var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); if (messageType == 1) { var producer = new ProducerAsyncShared(); producer.RunTest<PostgreSqlMessageQueueInit, FakeMessage>(queueName, ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false).Wait(timeOut / 2 * 1000); var consumer = new ConsumerAsyncShared<FakeMessage> {Factory = Factory}; consumer.RunConsumer<PostgreSqlMessageQueueInit>(queueName, ConnectionInfo.ConnectionString, false, logProvider, runtime, messageCount, timeOut, readerCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12)); } else if (messageType == 2) { var producer = new ProducerAsyncShared(); producer.RunTest<PostgreSqlMessageQueueInit, FakeMessageA>(queueName, ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false).Wait(timeOut / 2 * 1000); var consumer = new ConsumerAsyncShared<FakeMessageA> {Factory = Factory}; consumer.RunConsumer<PostgreSqlMessageQueueInit>(queueName, ConnectionInfo.ConnectionString, false, logProvider, runtime, messageCount, timeOut, readerCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12)); } else if (messageType == 3) { var producer = new ProducerAsyncShared(); producer.RunTest<PostgreSqlMessageQueueInit, FakeMessageB>(queueName, ConnectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false).Wait(timeOut / 2 * 1000); var consumer = new ConsumerAsyncShared<FakeMessageB> {Factory = Factory}; consumer.RunConsumer<PostgreSqlMessageQueueInit>(queueName, ConnectionInfo.ConnectionString, false, logProvider, runtime, messageCount, timeOut, readerCount, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12)); } new VerifyQueueRecordCount(queueName, oCreation.Options).Verify(0, false, false); } } finally { schedulerContainer?.Dispose(); 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.CreateCompiled, runtime); } else { producer.RunTestDynamic<SqLiteMessageQueueInit>(queueName, connectionInfo.ConnectionString, false, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false, id, GenerateMethod.CreateDynamic, runtime); } var consumer = new ConsumerMethodShared(); consumer.RunConsumer<SqLiteMessageQueueInit>(queueName, connectionInfo.ConnectionString, false, logProvider, runtime, messageCount, workerCount, timeOut, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(35), id); new VerifyQueueRecordCount(queueName, connectionInfo.ConnectionString, oCreation.Options).Verify(0, false, false); } } finally { using ( var oCreation = queueCreator.GetQueueCreation<SqLiteMessageQueueCreation>(queueName, connectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
public void Run(int messageCount, int runtime, int timeOut, int workerCount, bool useTransactions, bool async, LinqMethodTypes linqMethodTypes) { var queueNameSend = GenerateQueueName.Create(); var queueNameReceive = GenerateQueueName.Create(); var logProviderSend = LoggerShared.Create(queueNameSend, GetType().Name); var logProviderReceive = LoggerShared.Create(queueNameReceive, GetType().Name); using (var queueCreatorReceive = new QueueCreationContainer<PostgreSqlMessageQueueInit>( serviceRegister => serviceRegister.Register(() => logProviderReceive, LifeStyles.Singleton))) { using (var queueCreatorSend = new QueueCreationContainer<PostgreSqlMessageQueueInit>( serviceRegister => serviceRegister.Register(() => logProviderSend, LifeStyles.Singleton))) { try { using ( var oCreationReceive = queueCreatorReceive.GetQueueCreation<PostgreSqlMessageQueueCreation>(queueNameReceive, ConnectionInfo.ConnectionString) ) { oCreationReceive.Options.EnableDelayedProcessing = true; oCreationReceive.Options.EnableHeartBeat = !useTransactions; oCreationReceive.Options.EnableHoldTransactionUntilMessageCommited = useTransactions; oCreationReceive.Options.EnableStatus = !useTransactions; oCreationReceive.Options.EnableStatusTable = true; oCreationReceive.Options.QueueType = QueueTypes.RpcReceive; var resultReceive = oCreationReceive.CreateQueue(); Assert.True(resultReceive.Success, resultReceive.ErrorMessage); using ( var oCreation = queueCreatorSend.GetQueueCreation<PostgreSqlMessageQueueCreation>(queueNameSend, ConnectionInfo.ConnectionString) ) { oCreation.Options.EnableDelayedProcessing = true; oCreation.Options.EnableHeartBeat = !useTransactions; oCreation.Options.EnableHoldTransactionUntilMessageCommited = useTransactions; oCreation.Options.EnableStatus = !useTransactions; oCreation.Options.EnableStatusTable = true; oCreation.Options.QueueType = QueueTypes.RpcSend; var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); var id = Guid.NewGuid(); var rpc = new RpcMethodShared <PostgreSqlMessageQueueInit, FakeResponse, PostgreSqlRpcConnection>(); rpc.Run(queueNameReceive, queueNameSend, ConnectionInfo.ConnectionString, ConnectionInfo.ConnectionString, logProviderReceive, logProviderSend, runtime, messageCount, workerCount, timeOut, async, new PostgreSqlRpcConnection(ConnectionInfo.ConnectionString, queueNameSend, ConnectionInfo.ConnectionString, queueNameReceive), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(12), id, linqMethodTypes); new VerifyQueueRecordCount(queueNameSend, oCreation.Options).Verify(0, false, false); new VerifyQueueRecordCount(queueNameReceive, oCreationReceive.Options).Verify(0, false, false); } } } finally { using ( var oCreation = queueCreatorSend.GetQueueCreation<PostgreSqlMessageQueueCreation>(queueNameSend, ConnectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } using ( var oCreation = queueCreatorReceive.GetQueueCreation<PostgreSqlMessageQueueCreation>(queueNameReceive, ConnectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } } }
public async void Run( int messageCount, bool interceptors, bool enableDelayedProcessing, bool enableHeartBeat, bool enableHoldTransactionUntilMessageCommited, bool enableMessageExpiration, bool enablePriority, bool enableStatus, bool enableStatusTable, bool additionalColumn) { var queueName = GenerateQueueName.Create(); var logProvider = LoggerShared.Create(queueName, GetType().Name); using ( var queueCreator = new QueueCreationContainer<SqlServerMessageQueueInit>( serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton))) { try { using ( var oCreation = queueCreator.GetQueueCreation<SqlServerMessageQueueCreation>(queueName, ConnectionInfo.ConnectionString) ) { oCreation.Options.EnableDelayedProcessing = enableDelayedProcessing; oCreation.Options.EnableHeartBeat = enableHeartBeat; oCreation.Options.EnableMessageExpiration = enableMessageExpiration; oCreation.Options.EnableHoldTransactionUntilMessageCommited = enableHoldTransactionUntilMessageCommited; oCreation.Options.EnablePriority = enablePriority; oCreation.Options.EnableStatus = enableStatus; oCreation.Options.EnableStatusTable = enableStatusTable; if (additionalColumn) { oCreation.Options.AdditionalColumns.Add(new Column("OrderID", ColumnTypes.Int, false, null)); } var result = oCreation.CreateQueue(); Assert.True(result.Success, result.ErrorMessage); var producer = new ProducerAsyncShared(); await producer.RunTest<SqlServerMessageQueueInit, FakeMessage>(queueName, ConnectionInfo.ConnectionString, interceptors, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, false); } } finally { using ( var oCreation = queueCreator.GetQueueCreation<SqlServerMessageQueueCreation>(queueName, ConnectionInfo.ConnectionString) ) { oCreation.RemoveQueue(); } } } }
public void Run( int messageCount, bool interceptors, bool batchSending, bool enableDelay, bool enableExpiration, ConnectionInfoTypes type, LinqMethodTypes linqMethodTypes) { var queueName = GenerateQueueName.Create(); var logProvider = LoggerShared.Create(queueName, GetType().Name); var producer = new ProducerMethodShared(); var connectionString = new ConnectionInfo(type).ConnectionString; using ( var queueCreator = new QueueCreationContainer<RedisQueueInit>( serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton))) { try { var id = Guid.NewGuid(); if (enableExpiration && enableDelay) { if (linqMethodTypes == LinqMethodTypes.Compiled) { producer.RunTestCompiled<RedisQueueInit>(queueName, connectionString, interceptors, messageCount, logProvider, Helpers.GenerateDelayExpiredData, Helpers.Verify, batchSending, id, GenerateMethod.CreateCompiled, 0); } else { producer.RunTestDynamic<RedisQueueInit>(queueName, connectionString, interceptors, messageCount, logProvider, Helpers.GenerateDelayExpiredData, Helpers.Verify, batchSending, id, GenerateMethod.CreateDynamic, 0); } } else if (enableDelay) { if (linqMethodTypes == LinqMethodTypes.Compiled) { producer.RunTestCompiled<RedisQueueInit>(queueName, connectionString, interceptors, messageCount, logProvider, Helpers.GenerateDelayData, Helpers.Verify, batchSending, id, GenerateMethod.CreateCompiled, 0); } else { producer.RunTestDynamic<RedisQueueInit>(queueName, connectionString, interceptors, messageCount, logProvider, Helpers.GenerateDelayData, Helpers.Verify, batchSending, id, GenerateMethod.CreateDynamic, 0); } } else if (enableExpiration) { if (linqMethodTypes == LinqMethodTypes.Compiled) { producer.RunTestCompiled<RedisQueueInit>(queueName, connectionString, interceptors, messageCount, logProvider, Helpers.GenerateExpiredData, Helpers.Verify, batchSending, id, GenerateMethod.CreateCompiled, 0); } else { producer.RunTestDynamic<RedisQueueInit>(queueName, connectionString, interceptors, messageCount, logProvider, Helpers.GenerateExpiredData, Helpers.Verify, batchSending, id, GenerateMethod.CreateDynamic, 0); } } else { if (linqMethodTypes == LinqMethodTypes.Compiled) { producer.RunTestCompiled<RedisQueueInit>(queueName, connectionString, interceptors, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, batchSending, id, GenerateMethod.CreateCompiled, 0); } else { producer.RunTestDynamic<RedisQueueInit>(queueName, connectionString, interceptors, messageCount, logProvider, Helpers.GenerateData, Helpers.Verify, batchSending, id, GenerateMethod.CreateDynamic, 0); } } } finally { using ( var oCreation = queueCreator.GetQueueCreation<RedisQueueCreation>(queueName, connectionString) ) { oCreation.RemoveQueue(); } } } }