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 DontHangConsumerThread() { var mockConnectionFactory = new Mock <RC.IConnectionFactory>(); var mockConnection = new Mock <RC.IConnection>(); var mockChannel = new Mock <RC.IModel>(); mockConnectionFactory.Setup((f) => f.CreateConnection(It.IsAny <string>())).Returns(mockConnection.Object); mockConnection.Setup((c) => c.IsOpen).Returns(true); mockConnection.Setup((c) => c.CreateModel()).Returns(mockChannel.Object); mockChannel.Setup((c) => c.IsOpen).Returns(true); mockChannel.Setup((c) => c.CreateBasicProperties()).Returns(new MockRabbitBasicProperties()); var consumer = new AtomicReference <RC.IBasicConsumer>(); mockChannel.Setup((c) => c.QueueDeclare(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >())) .Returns(new RC.QueueDeclareOk("foo", 0, 0)); mockChannel.Setup((c) => c.BasicConsume(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >(), It.IsAny <RC.IBasicConsumer>())) .Callback <string, bool, string, bool, bool, IDictionary <string, object>, RC.IBasicConsumer>((arg1, arg2, arg3, arg4, arg5, arg6, arg7) => consumer.Value = arg7); var connectionFactory = new SingleConnectionFactory(mockConnectionFactory.Object); var template = new RabbitTemplate(connectionFactory) { ReplyTimeout = 1 }; var payload = EncodingUtils.GetDefaultEncoding().GetBytes("Hello, world!"); var input = Message.Create(payload, new MessageHeaders()); template.DoSendAndReceiveWithTemporary("foo", "bar", input, null, default); // used to hang here because of the SynchronousQueue and doSendAndReceive() already exited consumer.Value.HandleBasicDeliver("foo", 1ul, false, "foo", "bar", new MockRabbitBasicProperties(), new byte[0]); }
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 void WithMessageBatch(List <IMessage <byte[]> > messageBatch) { BatchPayloads = new List <object>(); foreach (var m in messageBatch) { BatchPayloads.Add(EncodingUtils.GetDefaultEncoding().GetString((byte[])m.Payload)); } }
public void TestConvertBytes() { var template = new RabbitTemplate(); var payload = EncodingUtils.GetDefaultEncoding().GetBytes("Hello, world!"); var message = template.ConvertMessageIfNecessary(payload); Assert.Same(payload, message.Payload); }
public void TestConvertMessage() { var template = new RabbitTemplate(); var payload = EncodingUtils.GetDefaultEncoding().GetBytes("Hello, world!"); var input = Message.Create(payload, new MessageHeaders()); var message = template.ConvertMessageIfNecessary(input); Assert.Same(message, input); }
public void TestConvertString() { var template = new RabbitTemplate(); var payload = "Hello, world!"; var message = template.ConvertMessageIfNecessary(payload); var messageString = EncodingUtils.GetDefaultEncoding().GetString((byte[])message.Payload); Assert.Equal(payload, messageString); }
public void TestExplicitListenerMethod() { adapter.DefaultListenerMethod = "Handle"; adapter.Instance = simpleService; var bytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo"); adapter.OnMessage(Message.Create(bytes, messageProperties), null); Assert.Equal("Handle", simpleService.Called); }
public void TestShutdownWhileWaitingForReply() { var mockConnectionFactory = new Mock <RC.IConnectionFactory>(); var mockConnection = new Mock <RC.IConnection>(); var mockChannel1 = new Mock <RC.IModel>(); mockChannel1.Setup((c) => c.IsOpen).Returns(true); mockConnection.Setup((c) => c.IsOpen).Returns(true); mockConnectionFactory.Setup((f) => f.CreateConnection(It.IsAny <string>())).Returns(mockConnection.Object); mockConnection.SetupSequence((c) => c.CreateModel()).Returns(mockChannel1.Object); mockChannel1.Setup((c) => c.CreateBasicProperties()).Returns(new MockRabbitBasicProperties()); mockChannel1.Setup((c) => c.QueueDeclare(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >())) .Returns(() => new RC.QueueDeclareOk("foo", 0, 0)); var listener = new AtomicReference <EventHandler <RC.ShutdownEventArgs> >(); var shutdownLatch = new CountdownEvent(1); mockChannel1.SetupAdd((m) => m.ModelShutdown += It.IsAny <EventHandler <RC.ShutdownEventArgs> >()) .Callback <EventHandler <RC.ShutdownEventArgs> >((handler) => { listener.Value = handler; shutdownLatch.Signal(); }); var connectionFactory = new SingleConnectionFactory(mockConnectionFactory.Object); var template = new RabbitTemplate(connectionFactory) { ReplyTimeout = 60_000 }; var input = Message.Create(EncodingUtils.GetDefaultEncoding().GetBytes("Hello, world!"), new MessageHeaders()); Task.Run(() => { try { shutdownLatch.Wait(TimeSpan.FromSeconds(10)); } catch (Exception) { // Ignore } listener.Value.Invoke(null, new RC.ShutdownEventArgs(RC.ShutdownInitiator.Peer, (ushort)RabbitUtils.NotFound, string.Empty)); }); try { template.DoSendAndReceiveWithTemporary("foo", "bar", input, null, default); throw new Exception("Expected exception"); } catch (RabbitException e) { var cause = e.InnerException; Assert.IsType <ShutdownSignalException>(cause); } }
protected override Encoding DetectStreamEncoding(Stream stream) { Encoding ret = EncodingUtils.GetEncodingFromConfigXMLName(fmtInfo.Encoding); if (ret == null) { ret = EncodingUtils.DetectEncodingFromBOM(stream, EncodingUtils.GetDefaultEncoding()); } return(ret); }
public void TestUninterruptibleListenerDMLC() { var cf = new CachingConnectionFactory("localhost"); var admin = new RabbitAdmin(cf); admin.DeclareQueue(new Config.Queue("test.shutdown")); var container = new DirectMessageListenerContainer(null, cf) { ShutdownTimeout = 500 }; container.SetQueueNames("test.shutdown"); var latch = new CountdownEvent(1); var testEnded = new CountdownEvent(1); var listener = new TestListener(latch, testEnded); container.MessageListener = listener; var connection = cf.CreateConnection() as ChannelCachingConnectionProxy; // var channels = TestUtils.getPropertyValue(connection, "target.delegate._channelManager._channelMap"); var field = typeof(RC.Framing.Impl.Connection) .GetField("m_sessionManager", BindingFlags.Instance | BindingFlags.NonPublic); Assert.NotNull(field); var channels = (SessionManager)field.GetValue(connection.Target.Connection); Assert.NotNull(channels); container.Start(); Assert.True(container._startedLatch.Wait(TimeSpan.FromSeconds(10))); try { var template = new RabbitTemplate(cf); template.Execute(c => { var properties = c.CreateBasicProperties(); var bytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo"); c.BasicPublish(string.Empty, "test.shutdown", false, properties, bytes); RabbitUtils.SetPhysicalCloseRequired(c, false); }); Assert.True(latch.Wait(TimeSpan.FromSeconds(30))); Assert.Equal(2, channels.Count); } finally { container.Stop(); Assert.Equal(1, channels.Count); cf.Destroy(); testEnded.Signal(); admin.DeleteQueue("test.shutdown"); } }
public void TestAlternateConstructor() { var called = new AtomicBoolean(false); var dele = new TestDelegate2(called); adapter = new MessageListenerAdapter(null, dele, "MyPojoMessageMethod"); var bytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo"); adapter.OnMessage(Message.Create(bytes, messageProperties), null); Assert.True(called.Value); }
public void TestDefaultListenerMethod() { var called = new AtomicBoolean(false); var dele = new TestDelegate1(called); adapter.Instance = dele; var bytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo"); adapter.OnMessage(Message.Create(bytes, messageProperties), null); Assert.True(called.Value); }
public async Task TestReleaseConsumerRace() { var connectionFactory = new CachingConnectionFactory("localhost"); var container = new DirectReplyToMessageListenerContainer(null, connectionFactory); var latch = new CountdownEvent(1); container.MessageListener = new EmptyListener(); var mockMessageListener = new MockChannelAwareMessageListener(container.MessageListener, latch); container.SetChannelAwareMessageListener(mockMessageListener); var foobytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo"); var barbytes = EncodingUtils.GetDefaultEncoding().GetBytes("bar"); await container.Start(); Assert.True(container._startedLatch.Wait(TimeSpan.FromSeconds(10))); var channel1 = container.GetChannelHolder(); var props = channel1.Channel.CreateBasicProperties(); props.ReplyTo = Address.AMQ_RABBITMQ_REPLY_TO; RC.IModelExensions.BasicPublish(channel1.Channel, string.Empty, TEST_RELEASE_CONSUMER_Q, props, foobytes); var replyChannel = connectionFactory.CreateConnection().CreateChannel(false); var request = replyChannel.BasicGet(TEST_RELEASE_CONSUMER_Q, true); var n = 0; while (n++ < 100 && request == null) { Thread.Sleep(100); request = replyChannel.BasicGet(TEST_RELEASE_CONSUMER_Q, true); } Assert.NotNull(request); props = channel1.Channel.CreateBasicProperties(); RC.IModelExensions.BasicPublish(replyChannel, string.Empty, request.BasicProperties.ReplyTo, props, barbytes); replyChannel.Close(); Assert.True(latch.Wait(TimeSpan.FromSeconds(10))); var channel2 = container.GetChannelHolder(); Assert.Same(channel1.Channel, channel2.Channel); container.ReleaseConsumerFor(channel1, false, null); // simulate race for future timeout/cancel and onMessage() var inUse = container._inUseConsumerChannels; Assert.Single(inUse); container.ReleaseConsumerFor(channel2, false, null); Assert.Empty(inUse); await container.Stop(); connectionFactory.Destroy(); }
public void TestExtendedListenerAdapter() { var extendedAdapter = new ExtendedListenerAdapter(null); var called = new AtomicBoolean(false); var channelMock = new Mock <IModel>(); var delgate = new TestDelegate(called); extendedAdapter.Instance = delgate; extendedAdapter.ContainerAckMode = Core.AcknowledgeMode.MANUAL; var bytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo"); extendedAdapter.OnMessage(Message.Create <byte[]>(bytes, messageProperties), channelMock.Object); Assert.True(called.Value); }
public void BuildMessageWithStandardMessage() { var result = RabbitMessageBuilder.WithPayload("Response") .SetHeader("foo", "bar") .SetHeader(RabbitMessageHeaders.TYPE, "msg_type") .SetHeader(RabbitMessageHeaders.REPLY_TO, "reply") .Build(); var session = new Mock <IModel>(); var listener = GetSimpleInstance("Echo", typeof(IMessage <string>)); var replyMessage = listener.BuildMessage(session.Object, result, null); Assert.NotNull(replyMessage); Assert.Equal("Response", EncodingUtils.GetDefaultEncoding().GetString(replyMessage.Payload)); Assert.Equal("msg_type", replyMessage.Headers.Type()); Assert.Equal("reply", replyMessage.Headers.ReplyTo()); Assert.Equal("bar", replyMessage.Headers.Get <string>("foo")); }
public void TestTaskReturn() { var called = new CountdownEvent(1); var dele = new TestAsyncDelegate(); adapter = new MessageListenerAdapter(null, dele, "MyPojoMessageMethod") { ContainerAckMode = AcknowledgeMode.MANUAL, ResponseExchange = "default" }; var mockChannel = new Mock <IModel>(); mockChannel.Setup(c => c.CreateBasicProperties()).Returns(new MockRabbitBasicProperties()); mockChannel.Setup(c => c.BasicAck(It.IsAny <ulong>(), false)) .Callback(() => called.Signal()); var bytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo"); var message = Message.Create(bytes, messageProperties); adapter.OnMessage(message, mockChannel.Object); Assert.True(called.Wait(TimeSpan.FromSeconds(10))); }
public static byte[] ToBytes(string content) { return(EncodingUtils.GetDefaultEncoding().GetBytes(content)); }
public static string ExtractText(IMessage message) { return(EncodingUtils.GetDefaultEncoding().GetString((byte[])message.Payload)); }