public static async Task Main()
{
var rabbitMqConnectionManager = new RabbitMqConnectionManager(new Uri("amqp://localhost"), "test", TimeSpan.FromSeconds(30));
const string queueName = "some-queue-name";
var options = new RabbitMqServiceOptionsBuilder()
.WithRetry(TimeSpan.FromSeconds(15), null, TimeSpan.FromSeconds(1))
.WithDeliveryMode(DeliveryMode.Persistent)
.WithConnectionManager(rabbitMqConnectionManager)
.WithDefaultSerializer(message => Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)), "application/json")
.Build();
var serviceClient = new RabbitMqServiceClient(options);
// Create a queue
await serviceClient.CreateQueueAsync(queueName + "-Error", true);
// Create a queue with options builder
var createQueueOption = new CreateQueueOptionsBuilder(QueueType.Classic)
.Durable()
.WithDeadLetterExchange(RabbitMqConstants.DefaultExchangeName)
.WithDeadLetterRoutingKey(queueName + "-Error")
.Build();
await serviceClient.CreateQueueAsync(queueName, createQueueOption);
// Listen to queue (Auto reconnect is enabled)
var consumerOptions = new ConsumerOptionsBuilder <string>()
.WithDefaultDeSerializer(message => JsonConvert.DeserializeObject <string>(Encoding.UTF8.GetString(message.Span)))
.WithSimpleMessageAck()
.WithCustomPipe(async(context, next) =>
{
Console.WriteLine("Some logging message before processing");
await next();
Console.WriteLine("Some logging message after processing");
})
.Build();
var activeConsumer = await serviceClient.StartListeningQueueAsync(queueName, consumerOptions, (message, items, ct) =>
{
Console.WriteLine(message);
return(Task.CompletedTask);
});
// Enqueue a message
await serviceClient.EnqueueMessageAsync(queueName, "some-message");
await Task.Delay(100);
// Enqueue using EnqueueQueueClient
var queueClient = serviceClient.CreateQueueClient(queueName);
await queueClient.EnqueueMessageAsync("some-other-message");
// Cancel listening
activeConsumer.Cancel();
// Purge the queue
await serviceClient.PurgeQueueAsync(queueName);
// Delete a queue
await serviceClient.DeleteQueueAsync(queueName, false, false);
await serviceClient.DeleteQueueAsync(queueName + "-Error", false, false);
}
public async Task CanCancelAndInterruptCurrentProcessing()
{
var consumerOptions = new ConsumerOptionsBuilder <string>()
.WithDefaultDeSerializer(message => JsonConvert.DeserializeObject <string>(Encoding.UTF8.GetString(message.Span)))
.WithSimpleMessageAck()
.Build();
var completed = false;
var messageCount = 0;
var activeConsumer = await _serviceClient.StartListeningQueueAsync(_queueName, consumerOptions, async (message, _, ct) =>
{
messageCount++;
await Task.Delay(TimeSpan.FromSeconds(1), ct);
completed = true;
});
await _serviceClient.EnqueueMessageAsync(_queueName, "some-message");
await _serviceClient.EnqueueMessageAsync(_queueName, "some-message");
await Task.Delay(TimeSpan.FromMilliseconds(200));
await activeConsumer.CancelAsync();
messageCount.Should().Be(1);
completed.Should().Be(false);
}
public async Task CanUseDelayedConsumer()
{
var thrownException = new Exception();
var semaphore = new SemaphoreSlim(1);
var receivedExceptions = new List <(Exception exception, bool lastAttempt)>();
var consumerOptions = new ConsumerOptionsBuilder <string>()
.WithDefaultDeSerializer(message => JsonConvert.DeserializeObject <string>(Encoding.UTF8.GetString(message.Span)))
.WithFastRetryMessageAck(3)
.WithErrorLogging((exception, lastAttempt) => receivedExceptions.Add((exception, lastAttempt)))
.Build();
await _serviceClient.StartListeningQueueAsync(_queueName, consumerOptions, (message, _, ct) =>
{
semaphore.Release();
return(Task.FromException(thrownException));
});
await semaphore.WaitAsync();
await _serviceClient.EnqueueMessageAsync(_queueName, "some-message");
await semaphore.WaitAsync();
await Task.Delay(TimeSpan.FromSeconds(1));
receivedExceptions.Should().BeEquivalentTo(
(thrownException, false),
(thrownException, false),
(thrownException, false),
(thrownException, true)
);
}
public async Task CanListenToMessageAndCancelIt()
{
var randomMessage = Guid.NewGuid();
var semaphore = new SemaphoreSlim(1);
await _serviceClient.CreateQueueAsync(_queueName);
var actualMessages = new List <string>();
var consumerOptions = new ConsumerOptionsBuilder <string>()
.WithDefaultDeSerializer(message => JsonConvert.DeserializeObject <string>(Encoding.UTF8.GetString(message.Span)))
.WithSimpleMessageAck()
.Build();
var activeConsumer = await _serviceClient.StartListeningQueueAsync(_queueName, consumerOptions, (message, _, ct) =>
{
actualMessages.Add(message);
semaphore.Release();
return(Task.CompletedTask);
});
await semaphore.WaitAsync();
await _serviceClient.EnqueueMessageAsync(_queueName, randomMessage);
await semaphore.WaitAsync(TimeSpan.FromSeconds(20));
activeConsumer.Cancel();
await _serviceClient.EnqueueMessageAsync(_queueName, randomMessage);
await semaphore.WaitAsync(TimeSpan.FromSeconds(1));
actualMessages.Should().HaveCount(1);
}
public async Task CanListenToMessageAndSurviveRestart()
{
var randomMessage1 = "first-" + Guid.NewGuid();
var randomMessage2 = "second-" + Guid.NewGuid();
var semaphore = new SemaphoreSlim(1);
await _serviceClient.CreateQueueAsync(_queueName);
var actualMessages = new List <string>();
var consumerOptions = new ConsumerOptionsBuilder <string>()
.WithDefaultDeSerializer(message => JsonConvert.DeserializeObject <string>(Encoding.UTF8.GetString(message.Span)))
.WithSimpleMessageAck()
.Build();
await _serviceClient.StartListeningQueueAsync(_queueName, consumerOptions, (message, _, ct) =>
{
actualMessages.Add(message);
semaphore.Release();
return(Task.CompletedTask);
});
await semaphore.WaitAsync();
await _serviceClient.EnqueueMessageAsync(_queueName, randomMessage1);
await semaphore.WaitAsync(TimeSpan.FromSeconds(20));
InitRabbitMqDocker.RestartRabbitMq();
await _serviceClient.EnqueueMessageAsync(_queueName, randomMessage2);
await semaphore.WaitAsync(TimeSpan.FromSeconds(20));
actualMessages.Should().BeEquivalentTo(randomMessage1, randomMessage2);
}
public async Task CanUseDelayedConsumer()
{
var actualMessages = new List <string>();
var semaphore = new SemaphoreSlim(1);
var delayQueueName = await DelayedRetryMessageAcknowledgementPipe <string> .CreateDelayQueueAsync(_serviceClient, _queueName);
var consumerOptions = new ConsumerOptionsBuilder <string>()
.WithDefaultDeSerializer(message => JsonConvert.DeserializeObject <string>(Encoding.UTF8.GetString(message.Span)))
.WithDelayedRetryMessageAck(new[] { TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2) })
.Build();
await _serviceClient.StartListeningQueueAsync(_queueName, consumerOptions, (message, _, ct) =>
{
actualMessages.Add(message);
semaphore.Release();
return(Task.FromException(new Exception("test")));
});
var sw = Stopwatch.StartNew();
await semaphore.WaitAsync();
(await _serviceClient.GetMessageCountInQueueAsync(delayQueueName)).Should().Be(0);
await _serviceClient.EnqueueMessageAsync(_queueName, "some-message");
await semaphore.WaitAsync(TimeSpan.FromSeconds(2));
await Task.Delay(TimeSpan.FromMilliseconds(100));
(await _serviceClient.GetMessageCountInQueueAsync(_queueName)).Should().Be(0);
(await _serviceClient.GetMessageCountInQueueAsync(delayQueueName)).Should().Be(1);
await semaphore.WaitAsync(TimeSpan.FromSeconds(2));
await Task.Delay(TimeSpan.FromMilliseconds(100));
(await _serviceClient.GetMessageCountInQueueAsync(_queueName)).Should().Be(0);
(await _serviceClient.GetMessageCountInQueueAsync(delayQueueName)).Should().Be(1);
await semaphore.WaitAsync(TimeSpan.FromSeconds(2));
await Task.Delay(TimeSpan.FromMilliseconds(100));
(await _serviceClient.GetMessageCountInQueueAsync(_queueName)).Should().Be(0);
(await _serviceClient.GetMessageCountInQueueAsync(delayQueueName)).Should().Be(0);
sw.ElapsedMilliseconds.Should().BeGreaterThan(3000);
actualMessages.Should().HaveCount(3);
(await _serviceClient.GetMessageCountInQueueAsync(_queueName)).Should().Be(0);
}
