public async Task DeclareAsync()
{
bool exists = await _bunny.ExchangeExistsAsync(Name);
if (exists)
{
return;
}
IModel channel = null;
try
{
channel = _bunny.Channel(newOne: true);
await Task.Run(() =>
{
channel.ExchangeDeclare(Name, ExchangeType, Durable, AutoDelete, _args);
});
}
catch (System.Exception exc)
{
throw DeclarationException.DeclareFailed(exc, "exchange-declare failed!");
}
finally
{
channel.Close();
}
}
private void SetupAndPublish(IBunny bunny, string queueName = queue)
{
var msg = new ConsumeMessage();
var bytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(msg));
var channel = bunny.Channel(newOne: true);
var prop = channel.CreateBasicProperties();
prop.Persistent = true;
channel.BasicPublish("", queueName, false, prop, bytes);
}
public async Task GetSucceedsIfMessageIsAvailable()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
var msg = new ConsumeMessage();
var bytes = Config.Serialize(msg);
bunny.Channel(newOne: true).BasicPublish("", get, false, null, bytes);
var opResult = await bunny.Consumer <ConsumeMessage>(get).AsAutoAck().GetAsync(carrot => Task.CompletedTask);
Assert.NotNull(opResult);
Assert.Equal(OperationState.Get, opResult.State);
Assert.NotNull(opResult.Message.MyText);
}
public void NackRequeues()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
var consumer = bunny.Consumer <ConsumeMessage>(queue).Callback(async carrot =>
{
var result = await carrot.SendNackAsync(withRequeue: true);
Assert.Equal(OperationState.Nacked, result.State);
uint count = bunny.Channel().MessageCount(nackReQueue);
Assert.Equal((uint)1, count);
});
SetupAndPublish(bunny, nackReQueue);
}
public async Task OverWriteRoutingKeySendsToDifferentQueuesEachTime()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
var publisher = bunny.Publisher <TestMessage>("amq.direct");
string queueName = "polymorph-queue-other";
string queueNameYetOther = "polymorph-queue-yet-another";
await publisher.WithQueueDeclare(queueName, "poly")
.SendAsync(new OtherMessage());
await publisher.WithQueueDeclare(queueNameYetOther, "poly-2")
.WithRoutingKey("poly-2")
.SendAsync(new YetAnotherMessage());
uint otherCount = bunny.Channel().MessageCount(queueName);
uint yetOtherCount = bunny.Channel().MessageCount(queueNameYetOther);
Assert.Equal(1, (int)otherCount);
Assert.Equal(1, (int)yetOtherCount);
await bunny.Setup().DeleteQueueAsync(queueName, force: true);
await bunny.Setup().DeleteQueueAsync(queueNameYetOther, force: true);
}
public async Task MultiplePublishOnSinglePublisher()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
var publisher = bunny.Publisher <TestMessage>("amq.direct");
string queueName = "polymorph-queue";
await publisher.WithQueueDeclare(queueName, "poly")
.SendAsync(new OtherMessage());
await publisher.SendAsync(new YetAnotherMessage());
await Task.Delay(150);
uint count = bunny.Channel().MessageCount(queueName);
Assert.Equal(2, (int)count);
await bunny.Setup().DeleteQueueAsync(queueName, force: true);
}
internal static async Task <bool> ExchangeExistsAsync(this IBunny bunny, string name)
{
try
{
var channel = bunny.Channel(newOne: true);
await Task.Run(() => channel.ExchangeDeclarePassive(name));
return(true);
}
catch (RabbitMQ.Client.Exceptions.OperationInterruptedException)
{
return(false);
}
catch (Exception ex)
{
throw DeclarationException.DeclareFailed(ex);
}
}
internal static async Task <bool> QueueExistsAsync(this IBunny bunny, string name)
{
try
{
var channel = bunny.Channel(newOne: true);
var result = await new TaskFactory().StartNew <QueueDeclareOk>(() => channel.QueueDeclarePassive(name));
return(true);
}
catch (RabbitMQ.Client.Exceptions.OperationInterruptedException)
{
return(false);
}
catch (Exception ex)
{
throw DeclarationException.DeclareFailed(ex);
}
}
private static async Task <bool> ExecuteOnChannelAsync(IBunny bunny, Action <IModel> execute)
{
IModel channel = null;
try
{
channel = bunny.Channel(newOne: true);
await Task.Run(() => execute(channel));
return(true);
}
catch
{
return(false);
}
finally
{
channel.Close();
}
}
