public void TestMissingContentType() { var bytes = Encoding.UTF8.GetBytes("{\"name\" : \"foo\" }"); var messageProperties = new MessageHeaders(); var message = Message.Create(bytes, messageProperties); var j2Converter = new JsonMessageConverter(); var typeMapper = new DefaultTypeMapper { DefaultType = typeof(Foo) }; j2Converter.TypeMapper = typeMapper; var foo = j2Converter.FromMessage(message, null); Assert.IsType <Foo>(foo); var accessor = RabbitHeaderAccessor.GetMutableAccessor(messageProperties); accessor.ContentType = null; foo = j2Converter.FromMessage(message, null); Assert.IsType <Foo>(foo); j2Converter.AssumeSupportedContentType = false; foo = j2Converter.FromMessage(message, null); Assert.Same(foo, bytes); }
public void TestSimpleBatchGZippedWithEncodingInflated() { var batchingStrategy = new SimpleBatchingStrategy(2, int.MaxValue, 30000); var template = new BatchingRabbitTemplate(batchingStrategy) { ConnectionFactory = connectionFactory }; var gZipPostProcessor = new GZipPostProcessor(); template.SetBeforePublishPostProcessors(gZipPostProcessor); template.SetAfterReceivePostProcessors(new DelegatingDecompressingPostProcessor()); var accessor = new RabbitHeaderAccessor(new MessageHeaders()) { ContentEncoding = "foo" }; var props = accessor.ToMessageHeaders(); var message = Message.Create(Encoding.UTF8.GetBytes("foo"), props); template.Send(string.Empty, ROUTE, message); message = Message.Create(Encoding.UTF8.GetBytes("bar"), props); template.Send(string.Empty, ROUTE, message); Thread.Sleep(100); var output = template.ReceiveAndConvert <byte[]>(ROUTE); Assert.NotNull(output); Assert.Equal("\u0000\u0000\u0000\u0003foo\u0000\u0000\u0000\u0003bar", Encoding.UTF8.GetString(output)); }
public IMessage PostProcessMessage(IMessage message) { var accessor = RabbitHeaderAccessor.GetMutableAccessor(message); accessor.Delay = 1000; return(message); }
public void TestReplyRetry() { adapter.DefaultListenerMethod = "Handle"; adapter.Instance = simpleService; adapter.RetryTemplate = new PollyRetryTemplate(new Dictionary <Type, bool>(), 2, true, 1, 1, 1); var replyMessage = new AtomicReference <IMessage>(); var replyAddress = new AtomicReference <Address>(); var throwable = new AtomicReference <Exception>(); adapter.RecoveryCallback = new TestRecoveryCallback(replyMessage, replyAddress, throwable); var accessor = RabbitHeaderAccessor.GetMutableAccessor(messageProperties); accessor.ReplyTo = "foo/bar"; var ex = new Exception(); var mockChannel = new Mock <IModel>(); mockChannel.Setup(c => c.BasicPublish("foo", "bar", false, It.IsAny <IBasicProperties>(), It.IsAny <byte[]>())) .Throws(ex); mockChannel.Setup(c => c.CreateBasicProperties()).Returns(new MockRabbitBasicProperties()); var bytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo"); var message = Message.Create(bytes, messageProperties); adapter.OnMessage(message, mockChannel.Object); Assert.Equal("Handle", simpleService.Called); Assert.NotNull(replyMessage.Value); var reply = EncodingUtils.GetDefaultEncoding().GetString((byte[])replyMessage.Value.Payload); Assert.NotNull(replyAddress.Value); var addr = replyAddress.Value; Assert.Equal("foo", addr.ExchangeName); Assert.Equal("bar", addr.RoutingKey); Assert.Same(ex, throwable.Value); }
public void TestMappedListenerMethod() { var map = new Dictionary <string, string> { { "foo", "Handle" }, { "bar", "NotDefinedOnInterface" } }; adapter.DefaultListenerMethod = "AnotherHandle"; adapter.SetQueueOrTagToMethodName(map); adapter.Instance = simpleService; var bytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo"); var message = Message.Create(bytes, messageProperties); var accessor = RabbitHeaderAccessor.GetMutableAccessor(message); accessor.ConsumerQueue = "foo"; accessor.ConsumerTag = "bar"; adapter.OnMessage(message, null); Assert.Equal("Handle", simpleService.Called); message = Message.Create(bytes, messageProperties); accessor = RabbitHeaderAccessor.GetMutableAccessor(message); accessor.ConsumerQueue = "junk"; adapter.OnMessage(message, null); Assert.Equal("NotDefinedOnInterface", simpleService.Called); message = Message.Create(bytes, messageProperties); accessor = RabbitHeaderAccessor.GetMutableAccessor(message); accessor.ConsumerTag = "junk"; adapter.OnMessage(message, null); Assert.Equal("AnotherHandle", simpleService.Called); }
public static IMessage <byte[]> CreateTextMessage(string body, MessageHeaders properties) { var accessor = RabbitHeaderAccessor.GetMutableAccessor(properties); accessor.ContentType = MimeTypeUtils.TEXT_PLAIN_VALUE; return(Message.Create(ToBytes(body), properties)); }
private IMessage Handle(Delivery delivery) { if (delivery == null && Shutdown != null) { throw new ShutdownSignalException(Shutdown); } if (delivery == null) { return(null); } var body = delivery.Body; var messageProperties = MessageHeadersConverter.ToMessageHeaders(delivery.Properties, delivery.Envelope, EncodingUtils.Utf8); var accesor = RabbitHeaderAccessor.GetMutableAccessor(messageProperties); accesor.ConsumerTag = delivery.ConsumerTag; accesor.ConsumerQueue = delivery.Queue; var message = Message.Create(body, accesor.MessageHeaders); Logger?.LogDebug("Received message: {message}", message); if (messageProperties.DeliveryTag() != null) { DeliveryTags.Add(messageProperties.DeliveryTag().Value); } if (Transactional && !LocallyTransacted) { ConnectionFactoryUtils.RegisterDeliveryTag(ConnectionFactory, Channel, delivery.Envelope.DeliveryTag); } return(message); }
public IMessage PostProcessMessage(IMessage message, CorrelationData correlation) { var accessor = RabbitHeaderAccessor.GetMutableAccessor(message); accessor.Delay = 15000; return(message); }
private void TestFullConfiguration(IApplicationContext context) { var simpleFactory = context.GetService <IRabbitListenerContainerFactory>("simpleFactory") as RabbitListenerContainerTestFactory; Assert.Single(simpleFactory.ListenerContainers); var testContainer = simpleFactory.GetListenerContainers()[0]; var endpoint = testContainer.Endpoint as AbstractRabbitListenerEndpoint; Assert.Equal("listener1", endpoint.Id); AssertQueues(endpoint, "queue1", "queue2"); Assert.Empty(endpoint.Queues); Assert.True(endpoint.Exclusive); Assert.Equal(34, endpoint.Priority); var admin = context.GetRabbitAdmin(); Assert.Same(endpoint.Admin, admin); var container = new DirectMessageListenerContainer(context); endpoint.SetupListenerContainer(container); var listener = container.MessageListener as MessagingMessageListenerAdapter; var accessor = new RabbitHeaderAccessor { ContentType = MessageHeaders.CONTENT_TYPE_TEXT_PLAIN }; var message = Message.Create(Encoding.UTF8.GetBytes("Hello"), accessor.MessageHeaders); var mockChannel = new Mock <R.IModel>(); listener.OnMessage(message, mockChannel.Object); }
protected virtual IMessage CreateMessage(IMessage message, byte[] compressed) { var headers = RabbitHeaderAccessor.GetMutableAccessor(message.Headers); if (CopyHeaders) { headers = RabbitHeaderAccessor.GetMutableAccessor(new MessageHeaders(message.Headers, message.Headers.Id, message.Headers.Timestamp)); } if (AutoDecompress) { headers.SetHeader(RabbitMessageHeaders.SPRING_AUTO_DECOMPRESS, true); } if (message.Headers.ContentEncoding() == null) { headers.ContentEncoding = GetEncoding(); } else { headers.ContentEncoding = GetEncoding() + ":" + message.Headers.ContentEncoding(); } return(Message.Create(compressed, headers.ToMessageHeaders())); }
public void TestReplyToNullByDefault() { var properties = new RabbitHeaderAccessor(); Assert.Null(properties.ReplyTo); Assert.Null(properties.ReplyToAddress); }
public void TestSimpleBatchDeflaterWithEncoding() { var batchingStrategy = new SimpleBatchingStrategy(2, int.MaxValue, 30000); var template = new BatchingRabbitTemplate(batchingStrategy) { ConnectionFactory = connectionFactory }; var deflatorPostProcessor = new DeflaterPostProcessor { Level = CompressionLevel.Fastest }; template.SetBeforePublishPostProcessors(deflatorPostProcessor); var accessor = new RabbitHeaderAccessor(new MessageHeaders()) { ContentEncoding = "foo" }; var props = accessor.ToMessageHeaders(); var message = Message.Create(Encoding.UTF8.GetBytes("foo"), props); template.Send(string.Empty, ROUTE, message); message = Message.Create(Encoding.UTF8.GetBytes("bar"), props); template.Send(string.Empty, ROUTE, message); var result = Receive(template); Assert.Equal("deflate:foo", result.Headers.ContentEncoding()); var unzipper = new InflaterPostProcessor(); var unzip = unzipper.PostProcessMessage(result); Assert.Equal("\u0000\u0000\u0000\u0003foo\u0000\u0000\u0000\u0003bar", Encoding.UTF8.GetString((byte[])unzip.Payload)); }
private IMessage <byte[]> AssembleMessage() { if (_messages.Count == 1) { return(_messages[0]); } var accessor = RabbitHeaderAccessor.GetMutableAccessor(_messages[0]); var body = new byte[_currentSize]; var bytes = new Span <byte>(body); var index = 0; foreach (var message in _messages) { var slice = bytes.Slice(index); BinaryPrimitives.WriteInt32BigEndian(slice, message.Payload.Length); index += 4; slice = bytes.Slice(index); for (var i = 0; i < message.Payload.Length; i++) { slice[i] = message.Payload[i]; } index = index + message.Payload.Length; } accessor.SetHeader(RabbitMessageHeaders.SPRING_BATCH_FORMAT, RabbitMessageHeaders.BATCH_FORMAT_LENGTH_HEADER4); accessor.SetHeader(RabbitMessageHeaders.BATCH_SIZE, _messages.Count); return(Message.Create(body, accessor.MessageHeaders)); }
public IMessage PostProcessMessage(IMessage message) { var headers = RabbitHeaderAccessor.GetMutableAccessor(message); headers.SetHeader("someHeader", "someValue"); return(message); }
public virtual bool HandleError(Exception exception) { _logger?.LogWarning(exception, "Execution of Rabbit message listener failed."); if (!CauseChainContainsRRADRE(exception) && _exceptionStrategy.IsFatal(exception)) { if (DiscardFatalsWithXDeath && exception is ListenerExecutionFailedException listenerException) { var failed = listenerException.FailedMessage; if (failed != null) { var accessor = RabbitHeaderAccessor.GetMutableAccessor(failed); var xDeath = accessor.GetXDeathHeader(); if (xDeath != null && xDeath.Count > 0) { _logger?.LogError( "x-death header detected on a message with a fatal exception; " + "perhaps requeued from a DLQ? - discarding: {failedMessage} ", failed); throw new ImmediateAcknowledgeException("Fatal and x-death present"); } } } throw new RabbitRejectAndDontRequeueException("Error Handler converted exception to fatal", RejectManual, exception); } return(true); }
public IMessage PostProcessMessage(IMessage message) { var accessor = RabbitHeaderAccessor.GetMutableAccessor(message); accessor.RemoveHeaders("__TypeId__"); return(message); }
protected virtual void AddDelayProperty(IMessage message) { if (DelayGenerator != null) { var accessor = RabbitHeaderAccessor.GetMutableAccessor(message); accessor.Delay = DelayGenerator.ProcessMessage(message); } }
public void TestReplyTo() { var properties = new RabbitHeaderAccessor { ReplyTo = "foo/bar" }; Assert.Equal("bar", properties.ReplyToAddress.RoutingKey); }
public void ShouldThrowAnExceptionWhenContentClassIdIsNotPresentWhenClassIdIsContainerType() { var accessor = RabbitHeaderAccessor.GetMutableAccessor(headers); accessor.SetHeader(typeMapper.ClassIdFieldName, typeof(List <>).FullName); var excep = Assert.Throws <MessageConversionException>(() => typeMapper.ToType(accessor.MessageHeaders)); Assert.Contains("Could not resolve ", excep.Message); }
public void TestContentLengthSet() { var properties = new RabbitHeaderAccessor { ContentLength = 1L }; Assert.True(properties.IsContentLengthSet); }
public void ProperEncoding() { var message = Message.Create(EncodingUtils.Utf16.GetBytes("ÁRVÍZTŰRŐ TÜKÖRFÚRÓGÉP"), new MessageHeaders()); var acccessor = RabbitHeaderAccessor.GetMutableAccessor(message); acccessor.ContentType = MessageHeaders.CONTENT_TYPE_JSON; acccessor.ContentEncoding = "UTF-16"; Assert.Contains("ÁRVÍZTŰRŐ TÜKÖRFÚRÓGÉP", message.ToString()); }
public void TestAdapterConversionError() { var config = new ConfigurationBuilder().Build(); var services = new ServiceCollection().BuildServiceProvider(); var context = new GenericApplicationContext(services, config); var channel = new Mock <RC.IModel>(); channel.Setup(c => c.IsOpen).Returns(true); var connection = new Mock <Messaging.RabbitMQ.Connection.IConnection>(); connection.Setup(c => c.IsOpen).Returns(true); connection.Setup(c => c.CreateChannel(It.IsAny <bool>())).Returns(channel.Object); var connectionFactory = new Mock <Messaging.RabbitMQ.Connection.IConnectionFactory>(); connectionFactory.Setup(f => f.CreateConnection()).Returns(connection.Object); var container = new DirectMessageListenerContainer(); container.ConnectionFactory = connectionFactory.Object; var adapter = new RabbitInboundChannelAdapter(context, container); var outputChannel = new QueueChannel(context); adapter.OutputChannel = outputChannel; var errorChannel = new QueueChannel(context); adapter.ErrorChannel = errorChannel; adapter.MessageConverter = new ThrowingMessageConverter(); var accessor = new RabbitHeaderAccessor(); accessor.DeliveryTag = 123ul; var headers = accessor.MessageHeaders; var message = Message.Create(string.Empty, headers); var listener = container.MessageListener as IChannelAwareMessageListener; listener.OnMessage(message, null); Assert.Null(outputChannel.Receive(0)); var received = errorChannel.Receive(0); Assert.NotNull(received.Headers.Get <IMessage>(RabbitMessageHeaderErrorMessageStrategy.AMQP_RAW_MESSAGE)); Assert.IsType <ListenerExecutionFailedException>(received.Payload); container.AcknowledgeMode = Messaging.RabbitMQ.Core.AcknowledgeMode.MANUAL; var channel2 = new Mock <RC.IModel>(); listener.OnMessage(message, channel2.Object); Assert.Null(outputChannel.Receive(0)); received = errorChannel.Receive(0); Assert.NotNull(received.Headers.Get <IMessage>(RabbitMessageHeaderErrorMessageStrategy.AMQP_RAW_MESSAGE)); Assert.IsType <ManualAckListenerExecutionFailedException>(received.Payload); var ex = (ManualAckListenerExecutionFailedException)received.Payload; Assert.Same(channel2.Object, ex.Channel); Assert.Equal(123ul, ex.DeliveryTag); }
public IMessage PostProcessMessage(IMessage message) { var accessor = RabbitHeaderAccessor.GetMutableAccessor(message); accessor.ContentType = "text/other"; accessor.SetHeader("strings", new string[] { "1", "2" }); accessor.SetHeader("objects", new object[] { new Foo(), new Foo() }); accessor.SetHeader("bytes", EncodingUtils.Utf8.GetBytes("abc")); return(message); }
public IMessage PostProcessMessage(IMessage message) { var accessor = RabbitHeaderAccessor.GetMutableAccessor(message); accessor.ContentType = "application/json"; accessor.UserId = "guest"; accessor.SetHeader("stringHeader", "string"); accessor.SetHeader("intHeader", 42); return(message); }
public void ChannelReleasedOnTimeout() { var connectionFactory = new CachingConnectionFactory("localhost"); var rabbitTemplate = CreateSendAndReceiveRabbitTemplate(connectionFactory); rabbitTemplate.ReplyTimeout = 1; var exception = new AtomicReference <Exception>(); var latch = new CountdownEvent(1); rabbitTemplate.ReplyErrorHandler = new TestErrorHandler(exception, latch); var reply = rabbitTemplate.ConvertSendAndReceive <object>(ROUTE, "foo"); Assert.Null(reply); var directReplyToContainers = rabbitTemplate._directReplyToContainers; var container = rabbitTemplate.UsePublisherConnection ? directReplyToContainers[connectionFactory.PublisherConnectionFactory] : directReplyToContainers[connectionFactory]; Assert.Empty(container._inUseConsumerChannels); Assert.Same(rabbitTemplate.ReplyErrorHandler, container.ErrorHandler); var replyMessage = Message.Create(Encoding.UTF8.GetBytes("foo"), new MessageHeaders()); var ex = Assert.Throws <RabbitRejectAndDontRequeueException>(() => rabbitTemplate.OnMessage(replyMessage)); Assert.Contains("No correlation header in reply", ex.Message); var accessor = RabbitHeaderAccessor.GetMutableAccessor(replyMessage); accessor.CorrelationId = "foo"; ex = Assert.Throws <RabbitRejectAndDontRequeueException>(() => rabbitTemplate.OnMessage(replyMessage)); Assert.Contains("Reply received after timeout", ex.Message); _ = Task.Run(() => { var message = rabbitTemplate.Receive(ROUTE, 10000); Assert.NotNull(message); rabbitTemplate.Send(message.Headers.ReplyTo(), replyMessage); return(message); }); while (rabbitTemplate.Receive(ROUTE, 100) != null) { } reply = rabbitTemplate.ConvertSendAndReceive <object>(ROUTE, "foo"); Assert.Null(reply); Assert.True(latch.Wait(TimeSpan.FromSeconds(10))); Assert.IsType <ListenerExecutionFailedException>(exception.Value); var listException = exception.Value as ListenerExecutionFailedException; Assert.Contains("Reply received after timeout", exception.Value.InnerException.Message); Assert.Equal(replyMessage.Payload, listException.FailedMessage.Payload); Assert.Empty(container._inUseConsumerChannels); rabbitTemplate.Stop().Wait(); connectionFactory.Destroy(); }
public void ShouldLookInTheContentClassIdFieldNameToFindTheContainerClassIDWhenClassIdIsContainerType() { var accessor = RabbitHeaderAccessor.GetMutableAccessor(headers); accessor.SetHeader("contentType", typeof(string).ToString()); accessor.SetHeader(typeMapper.ClassIdFieldName, typeof(List <>).FullName); typeMapper.ContentClassIdFieldName = "contentType"; var type = typeMapper.ToType(accessor.MessageHeaders); Assert.Equal(typeof(List <string>), type); }
protected override IMessage CreateMessage(object payload, IMessageHeaders messageProperties, object conversionHint) { byte[] bytes = null; var accessor = RabbitHeaderAccessor.GetMutableAccessor(messageProperties); if (payload is byte[]) { bytes = (byte[])payload; accessor.ContentType = MessageHeaders.CONTENT_TYPE_BYTES; } else if (payload is string) { try { var enc = EncodingUtils.GetEncoding(DefaultCharset); bytes = enc.GetBytes((string)payload); } catch (Exception e) { throw new MessageConversionException("failed to convert to Message content", e); } accessor.ContentType = MessageHeaders.CONTENT_TYPE_TEXT_PLAIN; accessor.ContentEncoding = DefaultCharset; } else if (payload.GetType().IsSerializable) { try { var formatter = new BinaryFormatter(); var stream = new MemoryStream(512); // TODO: don't disable this warning! https://aka.ms/binaryformatter #pragma warning disable SYSLIB0011 // Type or member is obsolete formatter.Serialize(stream, payload); #pragma warning restore SYSLIB0011 // Type or member is obsolete bytes = stream.ToArray(); accessor.ContentType = MessageHeaders.CONTENT_TYPE_DOTNET_SERIALIZED_OBJECT; } catch (Exception e) { throw new MessageConversionException("failed to convert serialized Message content", e); } } if (bytes == null) { throw new ArgumentException("SimpleMessageConverter only supports string, byte[] and serializable payloads, received: " + payload?.GetType().Name); } var message = Message.Create(bytes, messageProperties); accessor.ContentLength = bytes.Length; return(message); }
public void ShouldLookInTheClassIdFieldNameToFindTheClassName() { var accessor = RabbitHeaderAccessor.GetMutableAccessor(headers); accessor.SetHeader("type", "System.String"); typeMapper.ClassIdFieldName = "type"; var type = typeMapper.ToType(accessor.MessageHeaders); Assert.Equal(typeof(string), type); }
public void MessageToString() { var converter = new SimpleMessageConverter(); var message = Message.Create(Encoding.UTF8.GetBytes("test"), new MessageHeaders()); var accessor = RabbitHeaderAccessor.GetMutableAccessor(message); accessor.ContentType = MessageHeaders.CONTENT_TYPE_TEXT_PLAIN; var result = converter.FromMessage <string>(message); Assert.Equal("test", result); }
protected override object DoReceive() { var connection = ConnectionFactory.CreateConnection(); var channel = connection.CreateChannel(Transacted); try { var resp = channel.BasicGet(QueueName, false); if (resp == null) { RabbitUtils.CloseChannel(channel); RabbitUtils.CloseConnection(connection); return(null); } var callback = AckCallbackFactory.CreateCallback(new RabbitAckInfo(connection, channel, Transacted, resp)); var envelope = new Envelope(resp.DeliveryTag, resp.Redelivered, resp.Exchange, resp.RoutingKey); var messageProperties = MessageHeaderConverter.ToMessageHeaders(resp.BasicProperties, envelope, EncodingUtils.Utf8); var accessor = RabbitHeaderAccessor.GetMutableAccessor(messageProperties); accessor.ConsumerQueue = this.QueueName; // Map<String, Object> headers = this.headerMapper.toHeadersFromRequest(messageProperties); var message = Message.Create <byte[]>(resp.Body, accessor.MessageHeaders); object payload; if (BatchingStrategy.CanDebatch(message.Headers)) { var payloads = new List <object>(); BatchingStrategy.DeBatch(message, fragment => payloads.Add(MessageConverter.FromMessage(fragment, null))); payload = payloads; } else { payload = MessageConverter.FromMessage(message, null); } var builder = MessageBuilderFactory.WithPayload(payload) .CopyHeaders(accessor.MessageHeaders) .SetHeader(IntegrationMessageHeaderAccessor.ACKNOWLEDGMENT_CALLBACK, callback); if (RawMessageHeader) { builder.SetHeader(RabbitMessageHeaderErrorMessageStrategy.AMQP_RAW_MESSAGE, message); builder.SetHeader(IntegrationMessageHeaderAccessor.SOURCE_DATA, message); } return(builder); } catch (Exception e) { RabbitUtils.CloseChannel(channel); RabbitUtils.CloseConnection(connection); throw RabbitExceptionTranslator.ConvertRabbitAccessException(e); } }