public void TestDebatchByContainerPerformance()
        {
            var provider = new ServiceCollection().BuildServiceProvider();
            var config   = new ConfigurationBuilder().Build();
            var received = new List <IMessage>();
            var count    = 100000;
            var latch    = new CountdownEvent(count);
            var context  = new GenericApplicationContext(provider, config);

            context.ServiceExpressionResolver = new StandardServiceExpressionResolver();
            var container = new DirectMessageListenerContainer(context, connectionFactory);

            container.SetQueueNames(ROUTE);
            var lastInBatch = new List <bool>();
            var batchSize   = new AtomicInteger();

            container.MessageListener  = new TestDebatchListener(received, null, null, latch);
            container.PrefetchCount    = 1000;
            container.BatchingStrategy = new SimpleBatchingStrategy(1000, int.MaxValue, 30000);
            container.Initialize();
            container.Start();
            try
            {
                var batchingStrategy = new SimpleBatchingStrategy(1000, int.MaxValue, 30000);
                var template         = new BatchingRabbitTemplate(batchingStrategy)
                {
                    ConnectionFactory = connectionFactory
                };
                var accessor = RabbitHeaderAccessor.GetMutableAccessor(new MessageHeaders());
                accessor.DeliveryMode = MessageDeliveryMode.NON_PERSISTENT;
                var message = Message.Create(new byte[256], accessor.MessageHeaders);
                var watch   = new Stopwatch();
                watch.Start();
                for (var i = 0; i < count; i++)
                {
                    template.Send(string.Empty, ROUTE, message);
                }

                Assert.True(latch.Wait(TimeSpan.FromSeconds(60)));
                watch.Stop();
                testOutputHelper.WriteLine(watch.ElapsedMilliseconds.ToString());
                Assert.Equal(count, received.Count);
            }
            finally
            {
                container.Stop();
            }
        }
        public void TestDebatchByContainer()
        {
            var provider = new ServiceCollection().BuildServiceProvider();
            var config   = new ConfigurationBuilder().Build();
            var received = new List <IMessage>();
            var latch    = new CountdownEvent(2);
            var context  = new GenericApplicationContext(provider, config);

            context.ServiceExpressionResolver = new StandardServiceExpressionResolver();
            var container = new DirectMessageListenerContainer(context, connectionFactory);

            container.SetQueueNames(ROUTE);
            var lastInBatch = new List <bool>();
            var batchSize   = new AtomicInteger();

            container.MessageListener = new TestDebatchListener(received, lastInBatch, batchSize, latch);
            container.Initialize();
            container.Start();
            try
            {
                var batchingStrategy = new SimpleBatchingStrategy(2, int.MaxValue, 30000);
                var template         = new BatchingRabbitTemplate(batchingStrategy)
                {
                    ConnectionFactory = connectionFactory
                };
                var message = Message.Create(Encoding.UTF8.GetBytes("foo"));
                template.Send(string.Empty, ROUTE, message);
                message = Message.Create(Encoding.UTF8.GetBytes("bar"));
                template.Send(string.Empty, ROUTE, message);
                Assert.True(latch.Wait(TimeSpan.FromSeconds(10)));
                Assert.Equal(2, received.Count);
                Assert.Equal("foo", Encoding.UTF8.GetString((byte[])received[0].Payload));
                Assert.Equal(3, received[0].Headers.ContentLength());
                Assert.False(lastInBatch[0]);

                Assert.Equal("bar", Encoding.UTF8.GetString((byte[])received[1].Payload));
                Assert.Equal(3, received[1].Headers.ContentLength());
                Assert.True(lastInBatch[1]);
                Assert.Equal(2, batchSize.Value);
            }
            finally
            {
                container.Stop();
            }
        }
        public void TestDebatchByContainerBadMessageRejected()
        {
            var provider = new ServiceCollection().BuildServiceProvider();
            var config   = new ConfigurationBuilder().Build();
            var context  = new GenericApplicationContext(provider, config);

            context.ServiceExpressionResolver = new StandardServiceExpressionResolver();
            var container = new DirectMessageListenerContainer(context, connectionFactory);

            container.SetQueueNames(ROUTE);
            var listener = new EmptyListener();

            container.MessageListener = listener;
            var errorHandler = new TestConditionalRejectingErrorHandler();

            container.ErrorHandler = errorHandler;
            container.Initialize();
            container.Start();
            try
            {
                var template = new RabbitTemplate
                {
                    ConnectionFactory = connectionFactory
                };
                var headers = new MessageHeaders(new Dictionary <string, object>()
                {
                    { RabbitMessageHeaders.SPRING_BATCH_FORMAT, RabbitMessageHeaders.BATCH_FORMAT_LENGTH_HEADER4 }
                });
                var message = Message.Create(Encoding.UTF8.GetBytes("\u0000\u0000\u0000\u0004foo"), headers);
                template.Send(string.Empty, ROUTE, message);
                Thread.Sleep(1000);
                Assert.Equal(0, listener.Count);
                Assert.True(errorHandler.HandleErrorCalled);
            }
            finally
            {
                container.Stop();
            }
        }
예제 #4
0
        public async Task TestAbstractRoutingConnectionFactoryWithListenerContainer()
        {
            var connectionFactory1       = new Mock <IConnectionFactory>();
            var connectionFactory2       = new Mock <IConnectionFactory>();
            var defaultConnectionFactory = new Mock <IConnectionFactory>();
            var connection1      = new Mock <IConnection>();
            var connection2      = new Mock <IConnection>();
            var defautConnection = new Mock <IConnection>();
            var channel1         = new Mock <RC.IModel>();
            var channel2         = new Mock <RC.IModel>();
            var defaultChannel   = new Mock <RC.IModel>();

            connectionFactory1.SetupSequence((f) => f.CreateConnection())
            .Returns(connection1.Object);

            connectionFactory2.SetupSequence((f) => f.CreateConnection())
            .Returns(connection1.Object)
            .Returns(connection2.Object);

            defaultConnectionFactory.SetupSequence((f) => f.CreateConnection())
            .Returns(defautConnection.Object);

            connection1.Setup((c) => c.IsOpen).Returns(true);
            connection1.Setup(c => c.CreateChannel(It.IsAny <bool>())).Returns(channel1.Object);

            connection2.Setup((c) => c.IsOpen).Returns(true);
            connection2.Setup(c => c.CreateChannel(It.IsAny <bool>())).Returns(channel2.Object);

            defautConnection.Setup((c) => c.IsOpen).Returns(true);
            defautConnection.Setup(c => c.CreateChannel(It.IsAny <bool>())).Returns(defaultChannel.Object);

            channel1.Setup(c => c.IsOpen).Returns(true);
            channel2.Setup(c => c.IsOpen).Returns(true);
            defaultChannel.Setup(c => c.IsOpen).Returns(true);

            var factories = new Dictionary <object, IConnectionFactory>
            {
                { "[baz]", connectionFactory1.Object },
                { "[foo,bar]", connectionFactory2.Object }
            };

            var connectionFactory = new SimpleRoutingConnectionFactory
            {
                LenientFallback = true,
                DefaultTargetConnectionFactory = defaultConnectionFactory.Object
            };

            connectionFactory.SetTargetConnectionFactories(factories);

            var container = new DirectMessageListenerContainer(null, connectionFactory);

            container.SetQueueNames("foo", "bar");
            container.Initialize();
            await container.Start();

            Assert.True(container._startedLatch.Wait(TimeSpan.FromSeconds(10)));

            connectionFactory1.Verify((f) => f.CreateConnection(), Times.Never);
            connectionFactory2.Verify((f) => f.CreateConnection(), Times.Exactly(2));
            defaultConnectionFactory.Verify((f) => f.CreateConnection(), Times.Once); // Checks connection

            connectionFactory1.Invocations.Clear();
            connectionFactory2.Invocations.Clear();
            defaultConnectionFactory.Invocations.Clear();

            container.SetQueueNames("baz");
            connectionFactory1.Verify((f) => f.CreateConnection());
            connectionFactory2.Verify((f) => f.CreateConnection(), Times.Never);
            defaultConnectionFactory.Verify((f) => f.CreateConnection(), Times.Never);

            connectionFactory1.Invocations.Clear();
            connectionFactory2.Invocations.Clear();
            defaultConnectionFactory.Invocations.Clear();

            container.SetQueueNames("qux");
            connectionFactory1.Verify((f) => f.CreateConnection(), Times.Never);
            connectionFactory2.Verify((f) => f.CreateConnection(), Times.Never);
            defaultConnectionFactory.Verify((f) => f.CreateConnection());

            await container.Stop();
        }