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);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="QueueStatusProviderError{TTransportInit}" /> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="connection">The connection.</param>
/// <param name="statusCreator">The status creator.</param>
/// <param name="error">The error.</param>
public QueueStatusProviderError(string name, string connection, QueueContainer <TTransportInit> statusCreator, Exception error)
{
_name = name;
_connection = connection;
_status = statusCreator;
Error = error;
}
private void RunRpcSend(ILogProvider logProvider, int messageCount, bool async, TTConnectionSettings rpcConnection)
{
using (
var creatorRpc =
new QueueContainer <TTransportInit>(
serviceRegister => serviceRegister.Register(() => logProvider, LifeStyles.Singleton)))
{
//create the queue
using (var
queue =
creatorRpc
.CreateRpc
<TTResponse, TTMessage, TTConnectionSettings>(rpcConnection))
{
queue.Configuration.TransportConfigurationReceive.QueueDelayBehavior.Clear();
queue.Configuration.TransportConfigurationReceive.QueueDelayBehavior.Add(
TimeSpan.FromMilliseconds(500));
queue.Configuration.MessageExpiration.MonitorTime = TimeSpan.FromSeconds(10);
queue.Start();
if (async)
{
SendMultipleMessagesAsync(queue, messageCount);
}
else
{
SendMultipleMessages(queue, messageCount);
}
}
}
}
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 producer
using (var queueContainer = new QueueContainer <RedisQueueInit>(serviceRegister =>
Injectors.AddInjectors(new SerilogAdapter(log), SharedConfiguration.EnableTrace, SharedConfiguration.EnableMetrics, SharedConfiguration.EnableCompression, SharedConfiguration.EnableEncryption, "RedisProducer", 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();
}
}
}
}
}
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 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 Create_CreateProducer(string queue, string connection)
{
using (var test = new QueueContainer <CreateContainerTest.NoOpDuplexTransport>())
{
test.CreateProducer <FakeMessage>(new QueueConnection(queue, connection));
}
}
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));
}
finally
{
using (var queueCreator =
new QueueCreationContainer<SqlServerMessageQueueInit>())
{
using (
var oCreation =
queueCreator.GetQueueCreation<SqlServerMessageQueueCreation>(queueName,
ConnectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
}
private void CreateScheduler()
{
lock (_startup)
{
if (_consumer != null)
{
return;
}
_container = new JobSchedulerContainer(container =>
container.Register(() => _timeFactory, LifeStyles.Singleton));
_scheduler = _container.CreateJobScheduler();
_scheduler.Start();
_consumerContainer = new SchedulerContainer();
_consumerScheduler = _consumerContainer.CreateTaskScheduler();
_taskFactory = _consumerContainer.CreateTaskFactory(_consumerScheduler);
_taskFactory = _consumerContainer.CreateTaskFactory(_consumerScheduler);
_taskFactory.Scheduler.Configuration.MaximumThreads = _configuration.ThreadsMax;
_taskFactory.Scheduler.Configuration.MaxQueueSize = _configuration.QueueMax;
_taskFactory.Scheduler.Configuration.WaitForThreadPoolToFinish =
_configuration.WaitForThreadPoolToFinish;
_taskFactory.Scheduler.Start();
_queueContainer = new QueueContainer <MemoryMessageQueueInit>();
_consumer = _queueContainer.CreateConsumerMethodQueueScheduler(QueueName, Connection,
_taskFactory);
_consumer.Start();
}
}
public void Create_CreateConsumerQueueScheduler(string queue, string connection)
{
using (var test = new QueueContainer<CreateContainerTest.NoOpDuplexTransport>())
{
test.CreateConsumerQueueScheduler(queue, connection);
}
}
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 void Run(string queueNameReceive, string queueNameSend, string connectionStringReceive, string connectionStringSend, ILogProvider logProviderReceive, ILogProvider logProviderSend,
int runtime, int messageCount, int workerCount, int timeOut, bool async, TTConnectionSettings rpcConnection,
TimeSpan heartBeatTime, TimeSpan heartBeatMonitorTime, string updateTime)
{
using (_creator = new QueueContainer <TTransportInit>())
{
_queues = new ConcurrentDictionary <IConnectionInformation, IProducerQueueRpc <TTResponse> >();
var processedCount = new IncrementWrapper();
var waitForFinish = new ManualResetEventSlim(false);
var task1 = Task.Factory.StartNew(() =>
RunRpcReceive(queueNameSend, connectionStringSend, logProviderSend,
runtime, processedCount, messageCount,
waitForFinish, workerCount, timeOut, heartBeatTime, heartBeatMonitorTime, updateTime));
RunRpcSend(logProviderSend, messageCount, async, rpcConnection);
Task.WaitAll(task1);
LoggerShared.CheckForErrors(queueNameSend);
LoggerShared.CheckForErrors(queueNameReceive);
foreach (var queue in _queues)
{
queue.Value.Dispose();
}
_queues.Clear();
}
}
public void Create_CreateConsumerAsync(string queue, string connection)
{
using (var test = new QueueContainer <CreateContainerTest.NoOpDuplexTransport>())
{
test.CreateConsumerAsync(new QueueConnection(queue, connection));
}
}
public void Create_CreateProducer(string queue, string connection)
{
using (var test = new QueueContainer<CreateContainerTest.NoOpDuplexTransport>())
{
test.CreateProducer<FakeMessage>(
queue, connection);
}
}
void Dispose()
{
if (container)
{
container.RemoveFromQueue();
container = null;
}
Destroy(this.gameObject);
}
/// <summary>
/// Gets the specified queue.
/// </summary>
/// <typeparam name="TTransportInit">The type of the transport initialize.</typeparam>
/// <typeparam name="TQueue">The type of the queue.</typeparam>
/// <param name="queueConnection">Queue and connection information.</param>
/// <param name="producerConfiguration">The producer configuration.</param>
/// <returns></returns>
/// <exception cref="DotNetWorkQueueException">Failed to create the queue. The error message is {createResult.ErrorMessage}</exception>
public IProducerMethodJobQueue Get <TTransportInit, TQueue>(QueueConnection queueConnection, Action <QueueProducerConfiguration> producerConfiguration = null)
where TTransportInit : ITransportInit, new()
where TQueue : class, IJobQueueCreation
{
var connectionInfo = new BaseConnectionInformation(queueConnection);
if (_queues.ContainsKey(connectionInfo))
{
return(_queues[connectionInfo]);
}
var transportName = typeof(TTransportInit).ToString();
if (!_containers.ContainsKey(transportName))
{
var container = new QueueContainer <TTransportInit>(_registrations.QueueRegistrations, _registrations.QueueOptions);
if (!_containers.TryAdd(transportName, container))
{
container.Dispose();
}
}
if (!_queues.ContainsKey(connectionInfo))
{
using (var jobQueueCreation =
new JobQueueCreationContainer <TTransportInit>(_registrations.QueueCreationRegistrations, _registrations.QueueCreationOptions))
{
using (var createQueue = jobQueueCreation.GetQueueCreation <TQueue>(queueConnection))
{
var createResult = createQueue.CreateJobSchedulerQueue(_registrations.QueueCreationRegistrations, queueConnection, _registrations.QueueCreationOptions);
if (createResult.Success)
{
var scope = createQueue.Scope;
var queue = _containers[transportName].CreateMethodJobProducer(queueConnection);
producerConfiguration?.Invoke(queue.Configuration);
if (!_queues.TryAdd(connectionInfo, queue))
{
queue.Dispose();
scope.Dispose();
}
else
{
queue.Start();
_creationScopes.TryAdd(connectionInfo, scope);
}
}
else
{
throw new DotNetWorkQueueException($"Failed to create the queue. The error message is {createResult.ErrorMessage}");
}
}
}
}
return(_queues[connectionInfo]);
}
private IConsumerMethodQueue CreateConsumerInternalThread(ICreationScope scope)
{
_badQueueContainer = SharedSetup.CreateCreator <TTransportInit>(_badQueueAdditions);
var queue =
_badQueueContainer.CreateMethodConsumer(_queueConnection, x => x.RegisterNonScopedSingleton(scope));
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, _workerCount, _heartBeatTime, _heartBeatMonitorTime, _updatetime, null);
return(queue);
}
private IConsumerQueue CreateConsumerInternalThread(string updateTime, string route)
{
_badQueueContainer = SharedSetup.CreateCreator <TTransportInit>(_badQueueAdditions);
var queue =
_badQueueContainer.CreateConsumer(_queueConnection);
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, _workerCount, _heartBeatTime,
_heartBeatMonitorTime, updateTime, route);
return(queue);
}
private IConsumerMethodQueue CreateConsumerInternalThread()
{
_badQueueContainer = SharedSetup.CreateCreator <TTransportInit>(_badQueueAdditions);
var queue =
_badQueueContainer.CreateMethodConsumer(_queueName,
_connectionString);
SharedSetup.SetupDefaultConsumerQueue(queue.Configuration, _workerCount, _heartBeatTime, _heartBeatMonitorTime, _updatetime, null);
return(queue);
}
public void Create_CreateConsumerQueueSchedulerWithFactory(string queue, string connection)
{
var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
var factory = fixture.Create<ITaskFactory>();
factory.Scheduler.Returns(fixture.Create<ATaskScheduler>());
var workGroup = fixture.Create<IWorkGroup>();
using (var test = new QueueContainer<CreateContainerTest.NoOpDuplexTransport>())
{
test.CreateConsumerQueueScheduler(queue, connection, factory, workGroup);
}
}
public void Create_Null_Services_Fails(string queue, string connection)
{
using (var test = new QueueContainer <CreateContainerTest.NoOpDuplexTransport>(null))
{
Assert.Throws <NullReferenceException>(
delegate
{
// ReSharper disable once AccessToDisposedClosure
test.CreateProducer <FakeMessage>(new QueueConnection(queue, connection));
});
}
}
public void Create_Null_Services_Fails(string queue, string connection)
{
using (var test = new QueueContainer<CreateContainerTest.NoOpDuplexTransport>(null))
{
Assert.Throws<NullReferenceException>(
delegate
{
// ReSharper disable once AccessToDisposedClosure
test.CreateProducer<FakeMessage>(
queue, connection);
});
}
}
public void Create_CreateConsumerQueueSchedulerWithFactory(string queue, string connection)
{
var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
var factory = fixture.Create <ITaskFactory>();
factory.Scheduler.Returns(fixture.Create <ATaskScheduler>());
var workGroup = fixture.Create <IWorkGroup>();
using (var test = new QueueContainer <CreateContainerTest.NoOpDuplexTransport>())
{
test.CreateConsumerQueueScheduler(new QueueConnection(queue, connection), factory, workGroup);
}
}
public void Run <TTransportInit, TJobQueueCreator, TTransportCreate>(
QueueConnection queueConnection,
bool interceptors,
bool dynamic,
Action <QueueConnection, long, ICreationScope> verify,
Action <QueueConnection, ICreationScope> setErrorFlag)
where TTransportInit : ITransportInit, new()
where TJobQueueCreator : class, IJobQueueCreation
where TTransportCreate : class, IQueueCreation
{
using (var trace = SharedSetup.CreateTrace("jobscheduler"))
{
using (var queueCreator =
new QueueCreationContainer <TTransportInit>((x) => x.RegisterNonScopedSingleton(trace.Source)))
{
var oCreation = queueCreator.GetQueueCreation <TTransportCreate>(queueConnection);
ICreationScope scope = oCreation.Scope;
using (var queueContainer =
new QueueContainer <TTransportInit>(x => x.RegisterNonScopedSingleton(scope).RegisterNonScopedSingleton(trace.Source)))
{
try
{
var tests = new JobSchedulerTestsShared();
if (!dynamic)
{
tests.RunEnqueueTestCompiled <TTransportInit, TJobQueueCreator>(
queueConnection, interceptors,
verify, setErrorFlag,
queueContainer.CreateTimeSync(queueConnection.Connection),
oCreation.Scope, LoggerShared.Create(queueConnection.Queue, GetType().Name));
}
else
{
tests.RunEnqueueTestDynamic <TTransportInit, TJobQueueCreator>(
queueConnection, interceptors,
verify, setErrorFlag,
queueContainer.CreateTimeSync(queueConnection.Connection),
oCreation.Scope, LoggerShared.Create(queueConnection.Queue, GetType().Name));
}
}
finally
{
oCreation.RemoveQueue();
oCreation.Dispose();
scope?.Dispose();
}
}
}
}
}
public void Run(
bool dynamic)
{
using (var connectionInfo = new IntegrationConnectionInfo())
{
var queueName = GenerateQueueName.Create();
using (var queueCreator =
new QueueCreationContainer <MemoryMessageQueueInit>())
{
using (
var oCreation =
queueCreator.GetQueueCreation <MessageQueueCreation>(queueName,
connectionInfo.ConnectionString)
)
{
using (var queueContainer = new QueueContainer <MemoryMessageQueueInit>(x => { }))
{
try
{
var tests = new JobSchedulerTestsShared();
if (!dynamic)
{
tests.RunEnqueueTestCompiled <MemoryMessageQueueInit, JobQueueCreation>(
queueName,
connectionInfo.ConnectionString, true,
Helpers.Verify, Helpers.SetError,
queueContainer.CreateTimeSync(connectionInfo.ConnectionString),
oCreation.Scope, LoggerShared.Create(queueName, GetType().Name));
}
#if NETFULL
else
{
tests.RunEnqueueTestDynamic <MemoryMessageQueueInit, JobQueueCreation>(
queueName,
connectionInfo.ConnectionString, true,
Helpers.Verify, Helpers.SetError,
queueContainer.CreateTimeSync(connectionInfo.ConnectionString),
oCreation.Scope, LoggerShared.Create(queueName, GetType().Name));
}
#endif
}
finally
{
oCreation.RemoveQueue();
}
}
}
}
}
}
private void RunConsumer <TTransportInit>(QueueConnection queueConnection, ICreationScope scope)
where TTransportInit : ITransportInit, new()
{
{
using (var queueContainer = new QueueContainer <TTransportInit>((x) => QueueContainer(x, scope)))
{
using (var queue = queueContainer.CreateMethodConsumer(queueConnection, x => x.RegisterNonScopedSingleton(scope)))
{
queue.Configuration.Worker.WorkerCount = 1;
queue.Start();
Thread.Sleep(9500);
}
}
}
}
private void RunConsumer <TTransportInit>(string queueName,
string connectionString)
where TTransportInit : ITransportInit, new()
{
{
using (var queueContainer = new QueueContainer <TTransportInit>(QueueContainer))
{
using (var queue = queueContainer.CreateMethodConsumer(queueName, connectionString))
{
queue.Configuration.Worker.WorkerCount = 1;
queue.Start();
Thread.Sleep(7500);
}
}
}
}
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);
using (var queueContainer = new QueueContainer <RedisQueueInit>(serviceRegister =>
Injectors.AddInjectors(new SerilogAdapter(log), SharedConfiguration.EnableTrace, SharedConfiguration.EnableMetrics, SharedConfiguration.EnableCompression, SharedConfiguration.EnableEncryption, "RedisConsumer", serviceRegister)
, options => Injectors.SetOptions(options, SharedConfiguration.EnableChaos)))
{
using (var queue = queueContainer.CreateConsumer(queueConnection))
{
//set some processing options and start looking for work
queue.Configuration.Worker.WorkerCount = 4; //lets run 4 worker threads
queue.Configuration.HeartBeat.UpdateTime = "sec(*%10)"; //set a heartbeat every 10 seconds
queue.Configuration.HeartBeat.MonitorTime = TimeSpan.FromSeconds(15); //check for dead records every 15 seconds
queue.Configuration.HeartBeat.Time = TimeSpan.FromSeconds(35); //records with no heartbeat after 35 seconds are considered dead
//an invalid data exception will be re-tried 3 times, with delays of 3, 6 and then finally 9 seconds
queue.Configuration.TransportConfiguration.RetryDelayBehavior.Add(typeof(InvalidDataException), new List <TimeSpan> {
TimeSpan.FromSeconds(3), TimeSpan.FromSeconds(6), TimeSpan.FromSeconds(9)
});
queue.Configuration.MessageExpiration.Enabled = true;
queue.Configuration.MessageExpiration.MonitorTime = TimeSpan.FromSeconds(20); //check for expired messages every 20 seconds
queue.Start <SimpleMessage>(MessageProcessing.HandleMessages);
Console.WriteLine("Processing messages - press any key to stop");
Console.ReadKey((true));
}
}
//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);
}
}
internal void Add(string connectionId, Unpacked <IPackage> unpacked)
{
ThrowIfDisposed();
QueueContainer queueContainer;
using (new TryLock(_syncObject, Timeout))
{
_requests.TryGetValue(connectionId, out queueContainer);
if (queueContainer == null)
{
_requests.Add(connectionId, queueContainer = new QueueContainer(this));
}
}
queueContainer.Enqueue(new CommandArgs(connectionId, unpacked));
}
internal void Add(string connectionId, ICommand <TArgs> command, TArgs args)
{
ThrowIfDisposed();
QueueContainer queueContainer;
using (new TryLock(syncObject, Timeout))
{
requests.TryGetValue(connectionId, out queueContainer);
if (queueContainer == null)
{
requests.Add(connectionId, queueContainer = new QueueContainer(this));
}
}
queueContainer.Enqueue(command, args);
}
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 RemoveFromQueue(QueueContainer obj, bool destroy = true)
{
for (int i = 0; i < mQueue.Length; ++i)
{
if (mQueue[i] && mQueue[i].GetComponent <QueueContainer>() == obj)
{
Destroy(mQueue[i]); //TODO: keep an eye on this
mQueue[i] = null;
mNumInQueue--;
break;
}
}
if (destroy)
{
Destroy(obj.gameObject);
}
}
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(
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, true,
Helpers.Verify, Helpers.SetError, queueContainer.CreateTimeSync(connectionString), null, LoggerShared.Create(queueName, GetType().Name));
}
#if NETFULL
else
{
tests.RunEnqueueTestDynamic <RedisQueueInit, RedisJobQueueCreation>(queueName,
connectionString, true,
Helpers.Verify, Helpers.SetError, queueContainer.CreateTimeSync(connectionString), null, LoggerShared.Create(queueName, GetType().Name));
}
#endif
}
finally
{
using (var queueCreator =
new QueueCreationContainer <RedisQueueInit>())
{
using (
var oCreation =
queueCreator.GetQueueCreation <RedisQueueCreation>(queueName,
connectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
}
public void Run(
bool interceptors,
bool dynamic)
{
var queueName = GenerateQueueName.Create();
using (var queueContainer = new QueueContainer <SqlServerMessageQueueInit>(x => {
}))
{
try
{
var tests = new JobSchedulerTestsShared();
if (!dynamic)
{
tests.RunEnqueueTestCompiled <SqlServerMessageQueueInit, SqlServerJobQueueCreation>(queueName,
ConnectionInfo.ConnectionString, interceptors,
Helpers.Verify, Helpers.SetError, queueContainer.CreateTimeSync(ConnectionInfo.ConnectionString), null, LoggerShared.Create(queueName, GetType().Name));
}
#if NETFULL
else
{
tests.RunEnqueueTestDynamic <SqlServerMessageQueueInit, SqlServerJobQueueCreation>(queueName,
ConnectionInfo.ConnectionString, interceptors,
Helpers.Verify, Helpers.SetError, queueContainer.CreateTimeSync(ConnectionInfo.ConnectionString), null, LoggerShared.Create(queueName, GetType().Name));
}
#endif
}
finally
{
using (var queueCreator =
new QueueCreationContainer <SqlServerMessageQueueInit>())
{
using (
var oCreation =
queueCreator.GetQueueCreation <SqlServerMessageQueueCreation>(queueName,
ConnectionInfo.ConnectionString)
)
{
oCreation.RemoveQueue();
}
}
}
}
}
