public RabbitAckInfo(IConnection connection, RC.IModel channel, bool transacted, RC.BasicGetResult getResponse) { Connection = connection; Channel = channel; Transacted = transacted; Response = getResponse; }
/// <summary>Converts from BasicProperties to MessageProperties.</summary> /// <param name="source">The source.</param> /// <param name="envelope">The envelope.</param> /// <param name="charset">The charset.</param> /// <returns>The message properties.</returns> public MessageProperties ToMessageProperties(IBasicProperties source, BasicGetResult envelope, string charset) { var target = new MessageProperties(); var headers = source.Headers; if (headers != null && headers.Count > 0) { foreach (DictionaryEntry entry in headers) { var value = entry.Value; /* if (value is LongString) { value = this.convertLongString((LongString) value, charset); } */ target.Headers[(string)entry.Key] = value; } } target.Timestamp = source.Timestamp.ToDateTime(); target.MessageId = source.MessageId; target.UserId = source.UserId; target.AppId = source.AppId; target.ClusterId = source.ClusterId; target.Type = source.Type; target.DeliveryMode = (MessageDeliveryMode)source.DeliveryMode; target.Expiration = source.Expiration; target.Priority = source.Priority; target.ContentType = source.ContentType; target.ContentEncoding = source.ContentEncoding; var correlationId = source.CorrelationId; if (correlationId != null) { try { target.CorrelationId = source.CorrelationId.ToByteArrayWithEncoding(charset); } catch (Exception ex) { throw new AmqpUnsupportedEncodingException(ex); } } var replyTo = source.ReplyTo; if (replyTo != null) { target.ReplyTo = replyTo; } if (envelope != null) { target.ReceivedExchange = envelope.Exchange; target.ReceivedRoutingKey = envelope.RoutingKey; target.Redelivered = envelope.Redelivered; target.DeliveryTag = (long)envelope.DeliveryTag; } return target; }
// Summary: // Sets the new instance's properties from the arguments passed in. public BasicGetResult(RabbitMQ.Client.BasicGetResult result) { BasicProperties = result.BasicProperties; Body = result.Body; DeliveryTag = result.DeliveryTag; Exchange = result.Exchange; MessageCount = result.MessageCount; Redelivered = result.Redelivered; RoutingKey = result.RoutingKey; }
public void TestAck() { var config = new ConfigurationBuilder().Build(); var services = new ServiceCollection().BuildServiceProvider(); var context = new GenericApplicationContext(services, config); var channel = new Mock <R.IModel>(); channel.Setup(c => c.IsOpen).Returns(true); var props = new MockRabbitBasicProperties(); var getResponse = new R.BasicGetResult(123Ul, false, "ex", "rk", 0, props, Encoding.UTF8.GetBytes("foo")); channel.Setup(c => c.BasicGet("foo", false)).Returns(getResponse); var connection = new Mock <R.IConnection>(); connection.Setup(c => c.IsOpen).Returns(true); connection.Setup(c => c.CreateModel()).Returns(channel.Object); var connectionFactory = new Mock <R.IConnectionFactory>(); connectionFactory.Setup(f => f.CreateConnection(It.IsAny <string>())).Returns(connection.Object); var ccf = new CachingConnectionFactory(connectionFactory.Object); var source = new RabbitMessageSource(context, ccf, "foo"); source.RawMessageHeader = true; var received = source.Receive(); var rawMessage = received.Headers.Get <IMessage>(RabbitMessageHeaderErrorMessageStrategy.AMQP_RAW_MESSAGE); var sourceData = received.Headers.Get <IMessage>(IntegrationMessageHeaderAccessor.SOURCE_DATA); Assert.NotNull(rawMessage); Assert.Same(rawMessage, sourceData); Assert.Equal("foo", received.Headers.Get <string>(RabbitMessageHeaders.CONSUMER_QUEUE)); // make sure channel is not cached var conn = ccf.CreateConnection(); var notCached = conn.CreateChannel(false); connection.Verify(c => c.CreateModel(), Times.Exactly(2)); var callback = received.Headers.Get <IAcknowledgmentCallback>(IntegrationMessageHeaderAccessor.ACKNOWLEDGMENT_CALLBACK); callback.Acknowledge(Status.ACCEPT); channel.Verify(c => c.BasicAck(123ul, false)); var cached = conn.CreateChannel(false); // should have been "closed" connection.Verify(c => c.CreateModel(), Times.Exactly(2)); notCached.Close(); cached.Close(); ccf.Destroy(); channel.Verify(c => c.Close(), Times.Exactly(2)); connection.Verify(c => c.Close(30000)); }
public void TestBatch() { var bs = new SimpleBatchingStrategy(2, 10_000, 10_000L); var headers = new RabbitHeaderAccessor(); headers.ContentType = "test/plain"; var message = Message.Create(Encoding.UTF8.GetBytes("test1"), headers.MessageHeaders); bs.AddToBatch("foo", "bar", message); message = Message.Create(Encoding.UTF8.GetBytes("test2"), headers.MessageHeaders); var batched = bs.AddToBatch("foo", "bar", message); Assert.True(batched.HasValue); var batchMessage = batched.Value.Message; var batchHeaders = batchMessage.Headers; var headerConverter = new DefaultMessageHeadersConverter(); var props = new MockRabbitBasicProperties(); headerConverter.FromMessageHeaders(batchHeaders, props, Encoding.UTF8); props.ContentType = "text/plain"; var config = new ConfigurationBuilder().Build(); var services = new ServiceCollection().BuildServiceProvider(); var context = new GenericApplicationContext(services, config); var channel = new Mock <R.IModel>(); channel.Setup(c => c.IsOpen).Returns(true); var getResponse = new R.BasicGetResult(123Ul, false, "ex", "rk", 0, props, (byte[])batchMessage.Payload); channel.Setup(c => c.BasicGet("foo", false)).Returns(getResponse); var connection = new Mock <R.IConnection>(); connection.Setup(c => c.IsOpen).Returns(true); connection.Setup(c => c.CreateModel()).Returns(channel.Object); var connectionFactory = new Mock <R.IConnectionFactory>(); connectionFactory.Setup(f => f.CreateConnection(It.IsAny <string>())).Returns(connection.Object); var ccf = new CachingConnectionFactory(connectionFactory.Object); var source = new RabbitMessageSource(context, ccf, "foo"); var received = source.Receive(); Assert.NotNull(received); var asList = received.Payload as List <object>; Assert.NotNull(asList); Assert.Contains("test1", asList); Assert.Contains("test2", asList); }
public override void HandleBasicDeliver( string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IBasicProperties properties, byte[] body) { var msgResult = new BasicGetResult( deliveryTag: deliveryTag, redelivered: redelivered, exchange: exchange, routingKey: routingKey, messageCount: 0, //Not available, received by RabbitMQ when declaring queue basicProperties: properties, body: body); queue.Enqueue(msgResult); }
private void TestNackOrRequeue(bool requeue) { var config = new ConfigurationBuilder().Build(); var services = new ServiceCollection().BuildServiceProvider(); var context = new GenericApplicationContext(services, config); var channel = new Mock <R.IModel>(); channel.Setup(c => c.IsOpen).Returns(true); var props = new MockRabbitBasicProperties(); var getResponse = new R.BasicGetResult(123Ul, false, "ex", "rk", 0, props, Encoding.UTF8.GetBytes("bar")); channel.Setup(c => c.BasicGet("foo", false)).Returns(getResponse); var connection = new Mock <R.IConnection>(); connection.Setup(c => c.IsOpen).Returns(true); connection.Setup(c => c.CreateModel()).Returns(channel.Object); var connectionFactory = new Mock <R.IConnectionFactory>(); connectionFactory.Setup(f => f.CreateConnection(It.IsAny <string>())).Returns(connection.Object); var ccf = new CachingConnectionFactory(connectionFactory.Object); var source = new RabbitMessageSource(context, ccf, "foo"); var received = source.Receive(); connection.Verify(c => c.CreateModel()); var callback = received.Headers.Get <IAcknowledgmentCallback>(IntegrationMessageHeaderAccessor.ACKNOWLEDGMENT_CALLBACK); if (requeue) { callback.Acknowledge(Status.REQUEUE); } else { callback.Acknowledge(Status.REJECT); } channel.Verify(c => c.BasicReject(123ul, requeue)); connection.Verify(c => c.CreateModel()); ccf.Destroy(); channel.Verify(c => c.Close()); connection.Verify(c => c.Close(30000)); }
protected void HandleReceivedMessage(IModel channel, SubscriptionConfiguration subscription, BasicGetResult result) { var messageProperties = BuildMessageProperties(channel, subscription, result.BasicProperties); ReceivedMessage message = null; try { OnMessageReceived(result.Body, result.Exchange, result.RoutingKey, messageProperties, out message); } catch (Exception e) { Logger.Log("Exception occureed while receiving message"); Logger.Log("Message: " + e.Message); Logger.Log("Stacktrace: " + e.StackTrace); ErrorHandler.HandleError(message, EndpointName); if (ErrorHandler.ShouldRethrowExceptions(EndpointName)) throw; } finally { AckMessage(channel, result.DeliveryTag, subscription.NoAck, message); } }
public void ReadFromQueue(string queueName, Func <BasicGetResult, bool> action) { TryCreateConnectionFactory(null); if (factory == null) { //Retry? return; } try { using (var connection = factory.CreateConnection()) using (var channel = connection.CreateModel()) { channel.QueueDeclare(queueName, true, false, false, null); RabbitMQ.Client.BasicGetResult data = channel.BasicGet(queueName, false); if (data == null) { return; // queue is empty hence no message } // execute an action with the message from the queue. // If the action succeeds, acknowledge receipt // Otherwise non-acknowledge and resubmit message to queue if (action.Invoke(data)) { Log.Information("RabbitMq: ReadFromQueue - Message Acknowledged from queue {0}", queueName); channel.BasicAck(data.DeliveryTag, false); } else { Log.Information("RabbitMq: ReadFromQueue - Message not Acknowledged from queue {0} and requeued", queueName); channel.BasicNack(data.DeliveryTag, false, true); } } } catch (Exception ex) { Log.Error(ex, "RabbitMq: ReadFromQueue(queueName = {0}, action) has thrown an exception", queueName); } }
/// <summary> /// Handle basic deliver. /// </summary> /// <param name="consumerTag"> /// The consumer tag. /// </param> /// <param name="deliveryTag"> /// The delivery tag. /// </param> /// <param name="redelivered"> /// The redelivered. /// </param> /// <param name="exchange"> /// The exchange. /// </param> /// <param name="routingKey"> /// The routing key. /// </param> /// <param name="properties"> /// The properties. /// </param> /// <param name="body"> /// The body. /// </param> public override void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IBasicProperties properties, byte[] body) { // TODO: Validate that 1 is the right message count. var envelope = new BasicGetResult(deliveryTag, redelivered, exchange, routingKey, 1, properties, body); this.HandleBasicDeliver(consumerTag, envelope, properties, body); }
/// <summary> /// Handle basic deliver. /// </summary> /// <param name="consumerTag"> /// The consumer tag. /// </param> /// <param name="envelope"> /// The envelope. /// </param> /// <param name="properties"> /// The properties. /// </param> /// <param name="body"> /// The body. /// </param> public void HandleBasicDeliver(string consumerTag, BasicGetResult envelope, IBasicProperties properties, byte[] body) { if (this.outer.cancelled) { if (this.outer.acknowledgeMode.TransactionAllowed()) { return; } } if (this.logger.IsDebugEnabled) { this.logger.Debug("Storing delivery for " + this.outer.ToString()); } try { // N.B. we can't use a bounded queue and offer() here with a timeout // in case the connection thread gets blocked this.outer.queue.Add(new Delivery(envelope, properties, body)); } catch (ThreadInterruptedException e) { Thread.CurrentThread.Interrupt(); } }
/// <summary> /// Initializes a new instance of the <see cref="Delivery"/> class. /// </summary> /// <param name="envelope"> /// The envelope. /// </param> /// <param name="properties"> /// The properties. /// </param> /// <param name="body"> /// The body. /// </param> public Delivery(BasicGetResult envelope, IBasicProperties properties, byte[] body) { this.envelope = envelope; this.properties = properties; this.body = body; }
/// <summary> /// Initializes a new instance of the <see cref="RabbitWorkMessage" /> class. /// </summary> /// <param name="queue">The queue.</param> /// <param name="evt">The evt.</param> public RabbitWorkMessage(RabbitWorkQueue queue, RabbitMQ.Client.BasicGetResult evt) { _queue = queue; _msg2 = evt; }
/// <summary> /// Create MessageProperties. /// </summary> /// <param name="source"> /// The source. /// </param> /// <param name="envelope"> /// The envelope. /// </param> /// <param name="charset"> /// The charset. /// </param> /// <returns> /// The MessageProperties. /// </returns> /// <exception cref="AmqpUnsupportedEncodingException"> /// </exception> public static MessageProperties CreateMessageProperties(IBasicProperties source, BasicGetResult envelope, string charset) { var target = new MessageProperties(); var headers = source.Headers; if (!CollectionUtils.IsEmpty(headers)) { foreach (DictionaryEntry entry in headers) { target.Headers[entry.Key] = entry.Value; } } target.Timestamp = source.Timestamp.ToDateTime(); target.MessageId = source.MessageId; target.UserId = source.UserId; target.AppId = source.AppId; target.ClusterId = source.ClusterId; target.Type = source.Type; target.DeliveryMode = (MessageDeliveryMode)source.DeliveryMode; target.Expiration = source.Expiration; target.Priority = source.Priority; target.ContentType = source.ContentType; target.ContentEncoding = source.ContentEncoding; var correlationId = source.CorrelationId; if (correlationId != null) { try { // TODO: Get the encoding from the ContentEncoding string. target.CorrelationId = Encoding.UTF8.GetBytes(source.CorrelationId); } catch (Exception ex) { throw new AmqpUnsupportedEncodingException(ex); } } var replyTo = source.ReplyTo; if (replyTo != null) { target.ReplyTo = new Address(replyTo); } if (envelope != null) { target.ReceivedExchange = envelope.Exchange; target.ReceivedRoutingKey = envelope.RoutingKey; target.Redelivered = envelope.Redelivered; target.DeliveryTag = (long)envelope.DeliveryTag; } return target; }
[Test] // AMQP-249 public void DontHangConsumerThread() { var mockConnectionFactory = new Mock<ConnectionFactory>(); var mockConnection = new Mock<IConnection>(); var mockChannel = new Mock<IModel>(); mockConnectionFactory.Setup(m => m.CreateConnection()).Returns(mockConnection.Object); mockConnection.Setup(m => m.IsOpen).Returns(true); mockConnection.Setup(m => m.CreateModel()).Returns(mockChannel.Object); mockChannel.Setup(m => m.QueueDeclare()).Returns(new QueueDeclareOk("foo", 0, 0)); mockChannel.Setup(m => m.CreateBasicProperties()).Returns(() => new BasicProperties()); var consumer = new AtomicReference<DefaultBasicConsumer>(); mockChannel.Setup(m => m.BasicConsume(It.IsAny<string>(), It.IsAny<bool>(), It.IsAny<string>(), It.IsAny<bool>(), It.IsAny<bool>(), It.IsAny<IDictionary>(), It.IsAny<IBasicConsumer>())).Callback <string, bool, string, bool, bool, IDictionary, IBasicConsumer>( (a1, a2, a3, a4, a5, a6, a7) => consumer.LazySet((DefaultBasicConsumer)a7)); var template = new RabbitTemplate(new SingleConnectionFactory(mockConnectionFactory.Object)); template.ReplyTimeout = 1; var input = new Message(Encoding.UTF8.GetBytes("Hello, world!"), new MessageProperties()); var doSendAndReceiveWithTemporaryMethod = typeof(RabbitTemplate).GetMethod("DoSendAndReceiveWithTemporary", BindingFlags.NonPublic | BindingFlags.Instance); doSendAndReceiveWithTemporaryMethod.Invoke(template, new object[] { "foo", "bar", input }); var envelope = new BasicGetResult(1, false, "foo", "bar", 0, new BasicProperties(), null); // used to hang here because of the SynchronousQueue and DoSendAndReceive() already exited consumer.Value.HandleBasicDeliver("foo", envelope.DeliveryTag, envelope.Redelivered, envelope.Exchange, envelope.RoutingKey, new BasicProperties(), new byte[0]); }
public void DequeueReturnsMessageTest() { var connFactory = Substitute.For<IConnectionFactory>(); var conn = Substitute.For<IConnection>(); var model = Substitute.For<IModel>(); var queueName = Guid.NewGuid().ToString(); connFactory.CreateConnection().Returns(conn); connFactory.CreateConnection(string.Empty).ReturnsForAnyArgs(conn); conn.CreateModel().Returns(model); conn.IsOpen.Returns(true); model.IsClosed.Returns(false); model.QueueDeclare(null, false, false, false, null).ReturnsForAnyArgs(new QueueDeclareOk(queueName, 1, 0)); model.QueueDeclarePassive(null).ReturnsForAnyArgs(new QueueDeclareOk(string.Empty, 1, 0)); model.MessageCount(null).ReturnsForAnyArgs(x => 1u); var payload = Guid.NewGuid().ToByteArray(); var result = new BasicGetResult(0, false, null, null, 0, null, payload); model.BasicGet(queueName, false).Returns(result); var setup = new RabbitMQReaderSetup { ConnectionFactory = connFactory, Exchange = Constants.DefaultExchange, QueueName = queueName, IsDurable = false, DeleteQueueOnClose = true, QueueTimeToLive = TimeSpan.FromMinutes(20), Options = new RabbitMQReaderOptions(), }; using (var rdr = new RabbitMQReader(setup, false)) { var msg = rdr.Dequeue(TimeSpan.FromSeconds(30), CancellationToken.None); Assert.Equal(payload, msg.Body.CopyToByteArray()); } }
/// <summary>Handle basic deliver.</summary> /// <param name="consumerTag">The consumer tag.</param> /// <param name="deliveryTag">The delivery tag.</param> /// <param name="redelivered">The redelivered.</param> /// <param name="exchange">The exchange.</param> /// <param name="routingKey">The routing key.</param> /// <param name="properties">The properties.</param> /// <param name="body">The body.</param> public override void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IBasicProperties properties, byte[] body) { var envelope = new BasicGetResult(deliveryTag, redelivered, exchange, routingKey, 1, properties, body); this.HandleBasicDeliver(consumerTag, envelope, properties, body); }
public void Setup() { TaskUtil.Await(async () => { var connectionFactory = _host.Settings.GetConnectionFactory(); using (var connection = connectionFactory.CreateConnection()) using (var model = connection.CreateModel()) { byte[] bytes = Encoding.UTF8.GetBytes("[]"); model.BasicPublish("input_queue", "", model.CreateBasicProperties(), bytes); await Task.Delay(3000).ConfigureAwait(false); _basicGetResult = model.BasicGet("input_queue_error", true); _body = Encoding.UTF8.GetString(_basicGetResult.Body); model.Close(200, "Cleanup complete"); connection.Close(200, "Cleanup complete"); } }); }
protected void SetupModelBasicGet(QueueEndpoint endPoint, BasicGetResult result) { Model.Stub(x => x.BasicGet(endPoint.RoutingKey, false)).Return(result); }