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(); }