static async Task SimplePoolTestAsync()
{
var configManager = CreateConfigurationManager();
var consumerFactory = new RMQConsumerFactory(new RMQConnectionFactory());
var producerFactory = new RMQProducerFactory(new RMQConnectionFactory());
var subscriberFactory = new RMQSubscriberFactory(new RMQConnectionFactory());
var publisherFactory = new RMQPublisherFactory(new RMQConnectionFactory());
var factory = new RMQSenderReceiverFactory(consumerFactory, producerFactory, subscriberFactory, publisherFactory);
using (var amqPool = new RMQPoolAsync(configManager, factory, 5))
{
using (var producer = await amqPool.GetAsync <IRMQProducerText>("connection", "MY_RMQ_TEST"))
{
await producer.Instance.SendAsync("Simple test");
}
}
}
static void SimplePoolTest()
{
var configManager = CreateConfigurationManager();
var consumerFactory = new RMQConsumerFactory(new RMQConnectionFactory());
var producerFactory = new RMQProducerFactory(new RMQConnectionFactory());
var subscriberFactory = new RMQSubscriberFactory(new RMQConnectionFactory());
var publisherFactory = new RMQPublisherFactory(new RMQConnectionFactory());
var factory = new RMQSenderReceiverFactory(consumerFactory, producerFactory, subscriberFactory, publisherFactory);
using (var rmqPool = new RMQPool(configManager, factory, 5))
{
using (var producer = rmqPool.Get <IRMQProducerText>("connection", "MY_RMQ_TEST"))
{
producer.Instance.Send("Simple test");
}
}
}
static Task PoolTestAsync()
{
var configManager = CreateConfigurationManager();
var consumerFactory = new RMQConsumerFactory(new RMQConnectionFactory());
var producerFactory = new RMQProducerFactory(new RMQConnectionFactory());
var subscriberFactory = new RMQSubscriberFactory(new RMQConnectionFactory());
var publisherFactory = new RMQPublisherFactory(new RMQConnectionFactory());
var factory = new RMQSenderReceiverFactory(consumerFactory, producerFactory, subscriberFactory, publisherFactory);
using (var amqPool = new RMQPoolAsync(configManager, factory, 5))
{
var tasks = new List <Task>();
for (var i = 0; i < 10; i++)
{
var task = Task.Run(async() =>
{
try
{
for (var j = 0; j < 10; j++)
{
using (var producer = await amqPool.GetAsync <IRMQProducerText>("connection", "MY_RMQ_TEST"))
{
var message = $"message: {i * j}";
await producer.Instance.SendAsync(message);
Console.WriteLine($"Thread: {Thread.CurrentThread.ManagedThreadId} - {producer.PoolId} - {producer.Instance.Id} - {message}");
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
});
tasks.Add(task);
}
Console.WriteLine("Waiting for Tasks to complete...");
Task.WaitAll(tasks.ToArray());
Console.WriteLine("Tasks completed.");
return(Task.CompletedTask);
}
}
static void PoolThreadTest()
{
var configManager = CreateConfigurationManager();
var consumerFactory = new RMQConsumerFactory(new RMQConnectionFactory());
var producerFactory = new RMQProducerFactory(new RMQConnectionFactory());
var subscriberFactory = new RMQSubscriberFactory(new RMQConnectionFactory());
var publisherFactory = new RMQPublisherFactory(new RMQConnectionFactory());
var factory = new RMQSenderReceiverFactory(consumerFactory, producerFactory, subscriberFactory, publisherFactory);
using (var rmqPool = new RMQPool(configManager, factory, 2))
{
for (var i = 0; i < 10; i++)
{
var t = new Thread(PoolThreadTestThread);
t.Start(new Tuple <RMQPool, int>(rmqPool, i));
}
Console.WriteLine("Waiting for Tasks to complete...");
Console.ReadKey();
Console.WriteLine("Show have terminated.");
}
}
/// <summary>
/// Uses the RMQ bound consumers.
/// </summary>
/// <param name="serviceProvider">The service provider.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="onException">The on exception.</param>
public static void UseRMQBoundConsumers(this IServiceProvider serviceProvider, CancellationToken cancellationToken, Action <Exception> onException = null)
{
var consumerFactory = new RMQConsumerFactory(new RMQConnectionFactory());
var subcriberFactory = new RMQSubscriberFactory(new RMQConnectionFactory());
var logFactory = serviceProvider.GetService <ILoggerFactory>();
foreach (var type in _Consumers.Keys)
{
Task.Run(async() =>
{
var logger = logFactory.CreateLogger(type);
var options = _Consumers[type];
var consumer = (IRMQConsumer)null;
var isTextConsumer = typeof(IRMQBoundConsumerText).IsAssignableFrom(type);
if (options is RMQBuilderSubscriptionOptions)
{
var subOptions = (options as RMQBuilderSubscriptionOptions);
if (isTextConsumer)
{
consumer = subcriberFactory.CreateText(subOptions.ConnectionSettings, subOptions.ExchangeSettings, subOptions.QueueSettings);
}
else
{
consumer = subcriberFactory.CreateBytes(subOptions.ConnectionSettings, subOptions.ExchangeSettings, subOptions.QueueSettings);
}
}
else // standard consumer
{
if (isTextConsumer)
{
consumer = consumerFactory.CreateText(options.ConnectionSettings, options.QueueSettings);
}
else
{
consumer = consumerFactory.CreateBytes(options.ConnectionSettings, options.QueueSettings);
}
}
using (consumer)
{
consumer.Mode = ConsumerMode.OnNoMessage_ReturnNull;
while (cancellationToken.IsCancellationRequested == false)
{
try
{
try
{
if (consumer is IRMQConsumerText)
{
var message = (consumer as IRMQConsumerText).Receive(1000);
if (message != null)
{
using (var scope = serviceProvider.CreateScope())
{
var loopConsumer = scope.ServiceProvider.GetService(type) as IRMQBoundConsumerText;
await loopConsumer.OnMessageAsync(message, cancellationToken);
message.Acknowledge();
}
}
}
else // bytes
{
var message = (consumer as IRMQConsumerBytes).Receive(1000);
if (message != null)
{
using (var scope = serviceProvider.CreateScope())
{
var loopConsumer = scope.ServiceProvider.GetService(type) as IRMQBoundConsumerBytes;
await loopConsumer.OnMessageAsync(message);
message.Acknowledge();
}
}
}
}
catch (TimeoutException)
{
}
catch (MessageException ex)
{
switch (ex.ExceptionCode)
{
case MessageExceptionCode.ExclusiveLock:
await Task.Delay(1000);
break;
default:
throw;
}
}
}
catch (Exception ex)
{
consumer.ClearCacheBuffer();
try
{
onException?.Invoke(ex);
}
catch (Exception ex2)
{
var aggregateException = new AggregateException("RMQ Consumer Error (OnException Handler fault).", new[] { ex, ex2 });
logger.LogError(aggregateException, aggregateException.Message);
}
}
}
}
});
}
}
static private Task ConsumerAsync()
{
var args = new Dictionary <string, object>
{
{ "x-dead-letter-exchange", "" },
{ "x-dead-letter-routing-key", "My.DLQ" }
};
var consumerFactory = new RMQConsumerFactory(new RMQConnectionFactory());
var connectionSettings = GetRMQConnectionSettings();
var queueSettings = new RMQQueueSettings("My.Queue", "My.Queue", true, false, false, true, arguments: args);
using (var consumer = consumerFactory.CreateText(connectionSettings, queueSettings))
{
consumer.Mode = ConsumerMode.OnNoMessage_ReturnNull;
while (true)
{
try
{
try
{
var message = consumer.Receive(1000);
if (message != null)
{
//message.Reject(true);
//message.Reject();
message.Acknowledge();
}
}
catch (TimeoutException)
{
}
catch (MessageException ex)
{
switch (ex.ExceptionCode)
{
case MessageExceptionCode.ExclusiveLock:
//await Task.Delay(5000);
break;
case MessageExceptionCode.LostConnection:
//await Task.Delay(5000);
throw;
default:
throw;
}
}
catch (SqlException ex)
{
if (SQLErrors.IsSevereErrorCode(ex.Number))
{
// issue connecting with SQL server
//await Task.Delay(5000);
}
throw;
}
}
catch (Exception ex)
{
consumer.ClearCacheBuffer();
Console.WriteLine(ex);
}
}
}
}
static public async Task RunAsync()
{
var configuration = new RMQConfigurationManager($"{AppDomain.CurrentDomain.BaseDirectory}RMQSettings.Issue.json");
var connectionFactory = new RMQConnectionFactory();
var consumerFactory = new RMQConsumerFactory(connectionFactory);
var producerFactory = new RMQProducerFactory(connectionFactory);
var subscriberFactory = new RMQSubscriberFactory(connectionFactory);
var publisherFactory = new RMQPublisherFactory(connectionFactory);
var factory = new RMQSenderReceiverFactory(consumerFactory, producerFactory, subscriberFactory, publisherFactory);
var pool = new RMQPoolAsync(configuration, factory, 10);
var result = (RMQReceiverResultText)null;
var queueDetails = configuration.GetQueueSettings("Engine.Inbound");
using (var container = await pool.GetAsync <IRMQConsumerText>("connection", queueDetails.Name))
{
var reader = container.Instance;
reader.Mode = ConsumerMode.OnNoMessage_ReturnNull;
try
{
result = reader.Receive(1000);
if (result != null)
{
}
}
catch (TimeoutException)
{
// no data, just return null as an indicator
}
catch (MessageException ex)
{
switch (ex.ExceptionCode)
{
case MessageExceptionCode.ExclusiveLock:
await Task.Delay(1000);
break;
case MessageExceptionCode.LostConnection:
await Task.Delay(1000);
reader.ClearCacheBuffer();
throw;
default:
reader.ClearCacheBuffer();
throw;
}
}
catch (Exception)
{
result?.Reject();
throw;
}
}
//var qs = configManager.GetQueueSettings("Ross");
// await PublisherAsync("Ross", "Red");
// await ProducerPerformanceTestAsync();
// await ProducerAsync();
// await ConsumerAsync();
// await PoolTestAsync();
// await SimplePoolTestAsync();
// await PoolAsyncManagerReadTestAsync();
//var rmqConnectionSetting = new RMQConnectionSettings
//{
// Name = "connection",
// Username = "******",
// Password = "******",
// VirtualHost = "/",
// DelayOnReconnect = 1500,
// Uri = "amqp://some-host:5672"
//};
//var queues = new List<RMQQueueSettings>();
//foreach (var queue in new[] { "Engine.Inbound","Engine.Outbound","ERROR.SparkEvents" })
//{
// queues.Add(new RMQQueueSettings(queue, queue, true, false, false, true));
//}
//var config = new RMQConfigurationManager(new[] { rmqConnectionSetting }, queueSettings: queues);
//var con = config.GetConnectionSettings("connection");
//var queuesetting = config.GetQueueSettings("lms.activity.items");
await Task.Delay(0);
}
static private Task ConsumerAsync()
{
var configManager = CreateConfigurationManager();
var consumerFactory = new RMQConsumerFactory(new RMQConnectionFactory());
var connectionSettings = configManager.GetConnectionSettings("connection");
var queueSettings = configManager.GetQueueSettings("MY_RMQ_TEST");
using (var consumer = consumerFactory.CreateText(connectionSettings, queueSettings))
{
consumer.Mode = ConsumerMode.OnNoMessage_ReturnNull;
while (true)
{
try
{
try
{
var message = consumer.Receive(1000);
if (message != null)
{
//message.Reject(true);
//message.Reject();
Console.WriteLine(message.Data);
message.Acknowledge();
}
}
catch (TimeoutException)
{
}
catch (MessageException ex)
{
switch (ex.ExceptionCode)
{
case MessageExceptionCode.ExclusiveLock:
//await Task.Delay(5000);
break;
case MessageExceptionCode.LostConnection:
//await Task.Delay(5000);
break;
default:
throw;
}
}
catch (SqlException ex)
{
if (SQLErrors.IsSevereErrorCode(ex.Number))
{
// issue connecting with SQL server
//await Task.Delay(5000);
}
throw;
}
}
catch (Exception ex)
{
consumer.ClearCacheBuffer();
Console.WriteLine(ex);
}
}
}
}
