public virtual async Task <OperationResult <T> > SendAsync(T msg, bool force = false)
{
var operationResult = new OperationResult <T>();
operationResult.Message = msg;
IModel channel = null;
try
{
channel = _thisChannel.Channel;
var properties = ConstructProperties(channel.CreateBasicProperties(), Persistent, this.Expires);
Handlers(channel);
if (_queueDeclare != null)
{
await _queueDeclare.DeclareAsync();
}
if (force)
{
await _bunny.Setup()
.Exchange(_publishTo)
.AsDurable()
.DeclareAsync();
}
await Task.Run(() =>
{
if (_useConfirm)
{
channel.ConfirmSelect();
}
channel.BasicPublish(_publishTo, RoutingKey, mandatory: Mandatory, properties, _serialize(msg));
if (_useConfirm)
{
channel.WaitForConfirmsOrDie();
}
});
operationResult.IsSuccess = true;
operationResult.State = OperationState.Published;
}
catch (System.Exception ex)
{
operationResult.IsSuccess = false;
operationResult.Error = ex;
operationResult.State = OperationState.Failed;
}
finally
{
if (_uniqueChannel)
{
Handlers(channel, dismantle: true);
channel?.Close();
}
}
return(operationResult);
}
public async Task ConfirmsAndAcksWork()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
IQueue queue = bunny.Setup()
.Queue("constraint")
.MaxLength(1)
.QueueExpiry(1500)
.Bind("amq.direct", "constraint-key")
.OverflowReject();
bool isNacked = false;
bool isAcked = false;
var publisher = bunny.Publisher <TestMessage>("amq.direct");
Func <BasicNackEventArgs, Task> nacker = ea => { isNacked = true; return(Task.CompletedTask); };
Func <BasicAckEventArgs, Task> acker = ea => { isAcked = true; return(Task.CompletedTask); };
await publisher.WithQueueDeclare(queue)
.WithConfirm(acker, nacker)
.WithRoutingKey("constraint-key")
.SendAsync(new TestMessage()
{
Text = "Confirm-1st"
});
await publisher.WithQueueDeclare(queue)
.WithConfirm(acker, nacker)
.SendAsync(new TestMessage()
{
Text = "Confirm-2nd"
});
Assert.True(isAcked);
Assert.True(isNacked);
bunny.Dispose();
}
public IRequest <TRequest, TResponse> WithQueueDeclare(string queue = null, string exchange = null, string routingKey = null)
{
string name = queue ?? typeof(TRequest).FullName;
string rKey = routingKey ?? typeof(TRequest).FullName;
_queueDeclare = _bunny.Setup().Queue(name).Bind(_toExchange, rKey).AsDurable();
return(this);
}
public async Task StartConsumingAsyncWithForceDeclaresTheQueue()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
var before = await bunny.Setup().QueueExistsAsync("force-declared");
var queue = bunny.Setup().Queue("force-declared");
var consumer = await bunny.Consumer <ConsumeMessage>()
.StartConsumingAsync(queue);
var after = await bunny.Setup().QueueExistsAsync("force-declared");
Assert.False(before);
Assert.True(after);
var deleted = await bunny.Setup().DeleteQueueAsync("force-declared", force: true);
Assert.True(deleted);
}
public async Task ForceCreatesTheExchangeIfNotExists()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
IPublish <TestMessage> publisher = bunny.Publisher <TestMessage>("test-exchange");
OperationResult <TestMessage> result = await publisher.SendAsync(new TestMessage(), force : true);
Assert.True(result.IsSuccess);
bool removed_exchange = await bunny.Setup().DeleteExchangeAsync("test-exchange", force: true);
Assert.True(removed_exchange);
bunny.Dispose();
}
public async Task <OperationResult <TResponse> > StartRespondingAsync()
{
var result = new OperationResult <TResponse>();
var publisher = _bunny.Publisher <TResponse>(DEFAULT_EXCHANGE)
.WithSerialize(_serialize);
publisher.UseUniqueChannel(uniqueChannel: _useUniqueChannel);
Func <ICarrot <TRequest>, Task> _receiver = async carrot =>
{
var request = carrot.Message;
try
{
TResponse response = await _respond(request);
string reply_to = carrot.MessageProperties.ReplyTo;
publisher.WithRoutingKey(reply_to);
result = await publisher.SendAsync(response);
}
catch (System.Exception ex)
{
result.IsSuccess = false;
result.State = OperationState.RpcReplyFailed;
result.Error = ex;
}
};
// consume
IQueue forceDeclare = _bunny.Setup()
.Queue(_consumeFromQueue)
.AsDurable()
.Bind(_rpcExchange, _consumeFromQueue);
var consumeResult = await _bunny.Consumer <TRequest>(_consumeFromQueue)
.DeserializeMessage(_deserialize)
.Callback(_receiver)
.StartConsumingAsync(forceDeclare);
if (consumeResult.IsSuccess)
{
result.IsSuccess = true;
result.State = OperationState.Response;
}
else
{
result.IsSuccess = false;
result.Error = consumeResult.Error;
result.State = consumeResult.State;
}
return(result);
}
public async Task DeclareAndBindDefaultAmqDirectSucceeds()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
var declare = bunny.Setup()
.Queue("bind-test")
.Bind("amq.direct", "bind-test-key")
.AsDurable()
.QueueExpiry(1500)
.WithTTL(500)
.MaxLength(10);
await declare.DeclareAsync();
Assert.Equal(1, 1);
}
public async Task PublisherSimplySendsWitQueueReturnsSuccess()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
IPublish <TestMessage> publisher = bunny.Publisher <TestMessage>(Exchange);
OperationResult <TestMessage> result = await publisher
.WithQueueDeclare()
.SendAsync(new TestMessage());
bool success = await bunny.Setup().DeleteQueueAsync(typeof(TestMessage).FullName, force: true);
Assert.True(result.IsSuccess);
Assert.True(success);
bunny.Dispose();
}
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 DeclareAndDeleteExchangeNotExistsAfterWards()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
IExchange declare = bunny.Setup()
.Exchange("to-delete-ex", "fanout");
await declare.DeclareAsync();
bool exists = await declare.ExchangeExistsAsync(declare.Name);
Assert.True(exists);
await declare.DeleteExchangeAsync(declare.Name);
exists = await declare.ExchangeExistsAsync(declare.Name);
Assert.False(exists);
}
public async Task DeclareAndDeleteQueueNotExistsAfterWards()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
IQueue declare = bunny.Setup()
.Queue("to-delete");
await declare.DeclareAsync();
bool exists = await declare.QueueExistsAsync(declare.Name);
Assert.True(exists);
await declare.DeleteQueueAsync(declare.Name);
exists = await declare.QueueExistsAsync(declare.Name);
Assert.False(exists);
}
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);
}
public async Task MandatoryWorksWithQueue()
{
IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp);
bool isReturned = true;
var publisher = bunny.Publisher <TestMessage>("amq.direct");
Func <BasicReturnEventArgs, Task> nacker = ea => { isReturned = false; return(Task.CompletedTask); };
await publisher.AsMandatory(nacker)
.WithQueueDeclare()
.SendAsync(new TestMessage()
{
Text = "Mandatory-succeeds"
});
bool removed = await bunny.Setup().DeleteQueueAsync(typeof(TestMessage).FullName, force: true);
Assert.True(isReturned);
bunny.Dispose();
}
