public void TestListenerRecoversFromClosedChannelAndStop() { var template = new RabbitTemplate(this.CreateConnectionFactory()); var latch = new CountdownEvent(this.messageCount); this.container = this.CreateContainer(queue.Name, new AbortChannelListener(latch), this.CreateConnectionFactory()); var n = 0; while (n++ < 100 && this.container.ActiveConsumerCount != this.concurrentConsumers) { Thread.Sleep(50); } Assert.AreEqual(this.concurrentConsumers, this.container.ActiveConsumerCount); for (var i = 0; i < this.messageCount; i++) { template.ConvertAndSend(queue.Name, i + "foo"); } var timeout = this.GetTimeout(); Logger.Debug("Waiting for messages with timeout = " + timeout + " (s)"); var waited = latch.Wait(new TimeSpan(0, 0, timeout)); Assert.True(waited, "Timed out waiting for message"); Assert.Null(template.ReceiveAndConvert(queue.Name)); Assert.AreEqual(this.concurrentConsumers, this.container.ActiveConsumerCount); this.container.Stop(); Assert.AreEqual(0, this.container.ActiveConsumerCount); }
static void Main(string[] args) { Tracer.Trace = new NLogAdapter(); var brokerUri = "failover:(amqp://127.0.0.1:5672,amqp://127.0.0.1:5673)" + "?failover.initialReconnectDelay=1000" + "&failover.reconnectDelay=1000" + "&failover.maxReconnectAttempts=10"; var connectionFactory = new NmsConnectionFactory(brokerUri); var simpleMessageListenerContainer = new SimpleMessageListenerContainer { ConnectionFactory = connectionFactory, DestinationName = DestinationName, MessageListener = new MessageListener() }; // start listener simpleMessageListenerContainer.AfterPropertiesSet(); var cachingConnectionFactory = new CachingConnectionFactory(connectionFactory); var nmsTemplate = new NmsTemplate(cachingConnectionFactory) { DefaultDestinationName = DestinationName, }; while (true) { Logger.Info("Enter your message."); var text = Console.ReadLine(); nmsTemplate.SendWithDelegate(session => session.CreateTextMessage(text)); } }
public void GatewayWithConnectionFactoryAndDestinationName() { XmlApplicationContext ctx = (XmlApplicationContext) NmsTestUtils.GetContext(@"Nms\Config\NmsGatewayWithConnectionFactoryAndDestinationName.xml"); IPollableChannel channel = (IPollableChannel)ctx.GetObject("requestChannel"); NmsMessageDrivenEndpoint gateway = (NmsMessageDrivenEndpoint)ctx.GetObject("nmsGateway"); Assert.That(gateway.GetType(), Is.EqualTo(typeof(NmsMessageDrivenEndpoint))); ctx.Start(); ThreadPerTaskExecutor executor = new ThreadPerTaskExecutor(); executor.Execute(delegate { SimpleMessageListenerContainer listenerContainer = (SimpleMessageListenerContainer) ctx.GetObject("Spring.Messaging.Nms.Listener.SimpleMessageListenerContainer#0"); ISessionAwareMessageListener messageListener = (ISessionAwareMessageListener)listenerContainer.MessageListener; messageListener.OnMessage(new StubTextMessage("message-driven-test"), new StubSession("message-driven-test")); }); IMessage message = channel.Receive(TimeSpan.FromMilliseconds(3000)); Assert.That(message, Is.Not.Null); Assert.That(message.Payload, Is.EqualTo("message-driven-test")); ctx.Stop(); }
private IMessageListener GetListener(string containerObjectName) { SimpleMessageListenerContainer container = (SimpleMessageListenerContainer)ctx.GetObject(containerObjectName); return((IMessageListener)container.MessageListener); }
public void ContainerConfiguration() { var containers = ctx.GetObjects <SimpleMessageListenerContainer>(); IConnectionFactory defaultConnectionFactory = (IConnectionFactory)ctx.GetObject(DEFAULT_CONNECTION_FACTORY); IConnectionFactory explicitConnectionFactory = (IConnectionFactory)ctx.GetObject(EXPLICIT_CONNECTION_FACTORY); int defaultConnectionFactoryCount = 0; int explicitConnectionFactoryCount = 0; foreach (KeyValuePair <string, SimpleMessageListenerContainer> dictionaryEntry in containers) { SimpleMessageListenerContainer container = dictionaryEntry.Value; if (container.ConnectionFactory.Equals(defaultConnectionFactory)) { defaultConnectionFactoryCount++; } else if (container.ConnectionFactory.Equals(explicitConnectionFactory)) { explicitConnectionFactoryCount++; } } Assert.AreEqual(1, defaultConnectionFactoryCount, "1 container should have the default connectionFactory"); Assert.AreEqual(2, explicitConnectionFactoryCount, "2 containers should have the explicit connectionFactory"); }
static void Main(string[] args) { try { ConnectionFactory connectionFactory = new ConnectionFactory(URI); connectionFactory.UserName = USER; connectionFactory.Password = PASS; using (SimpleMessageListenerContainer listenerContainer = new SimpleMessageListenerContainer()) { listenerContainer.ConnectionFactory = connectionFactory; listenerContainer.DestinationName = DESTINATION; listenerContainer.MessageListener = new Listener(); listenerContainer.AfterPropertiesSet(); Console.WriteLine("Listener started."); Console.WriteLine("Press <ENTER> to exit."); Console.ReadLine(); } } catch (Exception ex) { Console.WriteLine(ex); Console.WriteLine("Press <ENTER> to exit."); Console.Read(); } // comment when testing Console.ReadLine(); }
public void ContainerConfiguration() { IDictionary <string, object> containers = ctx.GetObjectsOfType(typeof(SimpleMessageListenerContainer)); EmsConnectionFactory defaultConnectionFactory = (EmsConnectionFactory)ctx.GetObject(DEFAULT_CONNECTION_FACTORY); defaultConnectionFactory = (EmsConnectionFactory)ctx.GetObject(DEFAULT_CONNECTION_FACTORY); EmsConnectionFactory explicitConnectionFactory = (EmsConnectionFactory)ctx.GetObject(EXPLICIT_CONNECTION_FACTORY); int defaultConnectionFactoryCount = 0; int explicitConnectionFactoryCount = 0; foreach (KeyValuePair <string, object> dictionaryEntry in containers) { SimpleMessageListenerContainer container = (SimpleMessageListenerContainer)dictionaryEntry.Value; if (container.ConnectionFactory.Equals(defaultConnectionFactory)) { defaultConnectionFactoryCount++; } else if (container.ConnectionFactory.Equals(explicitConnectionFactory)) { explicitConnectionFactoryCount++; Assert.AreEqual(4, container.ConcurrentConsumers); } } Assert.AreEqual(1, defaultConnectionFactoryCount, "1 container should have the default connectionFactory"); Assert.AreEqual(2, explicitConnectionFactoryCount, "2 containers should have the explicit connectionFactory"); }
public void TestListenerSendsMessageAndThenRollback() { var connectionFactory = this.CreateConnectionFactory(); var template = new RabbitTemplate(connectionFactory); new RabbitAdmin(connectionFactory).DeclareQueue(sendQueue); this.acknowledgeMode = AcknowledgeModeUtils.AcknowledgeMode.Auto; this.transactional = true; var latch = new CountdownEvent(1); this.container = this.CreateContainer(queue.Name, new ChannelSenderListener(sendQueue.Name, latch, true), connectionFactory); template.ConvertAndSend(queue.Name, "foo"); var timeout = this.GetTimeout(); Logger.Debug("Waiting for messages with timeout = " + timeout + " (s)"); var waited = latch.Wait(timeout * 1000); Assert.True(waited, "Timed out waiting for message"); this.container.Stop(); Thread.Sleep(200); // Foo message is redelivered Assert.AreEqual("foo", template.ReceiveAndConvert(queue.Name)); // Sending of bar message is also rolled back Assert.Null(template.ReceiveAndConvert(sendQueue.Name)); }
public void TestListenerSendsMessageAndThenContainerCommits() { var connectionFactory = this.CreateConnectionFactory(); var template = new RabbitTemplate(connectionFactory); new RabbitAdmin(connectionFactory).DeclareQueue(sendQueue); this.acknowledgeMode = AcknowledgeModeUtils.AcknowledgeMode.Auto; this.transactional = true; var latch = new CountdownEvent(1); this.container = this.CreateContainer(queue.Name, new ChannelSenderListener(sendQueue.Name, latch, false), connectionFactory); template.ConvertAndSend(queue.Name, "foo"); var timeout = this.GetTimeout(); Logger.Debug("Waiting for messages with timeout = " + timeout + " (s)"); var waited = latch.Wait(new TimeSpan(0, 0, timeout)); Assert.True(waited, "Timed out waiting for message"); Thread.Sleep(500); // All messages committed var bytes = (byte[])template.ReceiveAndConvert(sendQueue.Name); Assert.NotNull(bytes); Assert.AreEqual("bar", Encoding.UTF8.GetString(bytes)); Assert.AreEqual(null, template.ReceiveAndConvert(queue.Name)); }
public void TestDefaultConsumerCount() { var container = new SimpleMessageListenerContainer(new SingleConnectionFactory()); container.MessageListener = new MessageListenerAdapter(this); container.QueueNames = new[] { "foo" }; container.AutoStartup = false; container.AfterPropertiesSet(); Assert.AreEqual(1, ReflectionUtils.GetInstanceFieldValue(container, "concurrentConsumers")); }
private ReservationWorker() { ConnectionFactory factory = new ConnectionFactory(Config.Url); listenerContainer = new SimpleMessageListenerContainer { ConnectionFactory = factory, DestinationName = Config.ReturnMessageQueue, MessageListener = new GenericMessageListener <MessageDto>(new MessageHandler()) }; listenerContainer.AfterPropertiesSet(); }
/// <summary>Does the test.</summary> /// <param name="concurrentConsumers">The concurrent consumers.</param> /// <param name="configurer">The configurer.</param> private void DoTest(int concurrentConsumers, IContainerConfigurer configurer) { var messageCount = 10; var template = new RabbitTemplate(); var connectionFactory = new CachingConnectionFactory(); connectionFactory.ChannelCacheSize = concurrentConsumers; connectionFactory.Port = BrokerTestUtils.GetPort(); template.ConnectionFactory = connectionFactory; var messageConverter = new SimpleMessageConverter(); messageConverter.CreateMessageIds = true; template.MessageConverter = messageConverter; for (var i = 0; i < messageCount; i++) { template.ConvertAndSend(queue1.Name, i); template.ConvertAndSend(queue2.Name, i); } var container = new SimpleMessageListenerContainer(connectionFactory); var latch = new CountdownEvent(messageCount * 2); var listener = new MultiplePocoListener(latch); container.MessageListener = new MessageListenerAdapter(listener); container.AcknowledgeMode = AcknowledgeModeUtils.AcknowledgeMode.Auto; container.ChannelTransacted = true; container.ConcurrentConsumers = concurrentConsumers; configurer.Configure(container); container.AfterPropertiesSet(); container.Start(); try { var timeout = Math.Min((1 + messageCount) / concurrentConsumers, 50); Logger.Info("Timeout: " + timeout); var waited = latch.Wait(timeout * 1000); Logger.Info("All messages recovered: " + waited); Assert.AreEqual(concurrentConsumers, container.ActiveConsumerCount); Assert.True(waited, "Timed out waiting for messages"); } catch (ThreadInterruptedException e) { Thread.CurrentThread.Interrupt(); throw new ThreadStateException("unexpected interruption"); } finally { container.Shutdown(); Assert.AreEqual(0, container.ActiveConsumerCount); } Assert.Null(template.ReceiveAndConvert(queue1.Name)); Assert.Null(template.ReceiveAndConvert(queue2.Name)); }
/// <summary>Creates the container.</summary> /// <param name="queueName">Name of the queue.</param> /// <param name="listener">The listener.</param> /// <param name="connectionFactory">The connection factory.</param> /// <returns>The container.</returns> private SimpleMessageListenerContainer CreateContainer(string queueName, object listener, IConnectionFactory connectionFactory) { var container = new SimpleMessageListenerContainer(connectionFactory); container.MessageListener = new MessageListenerAdapter(listener); container.QueueNames = new[] { queueName }; container.ConcurrentConsumers = this.concurrentConsumers; container.ChannelTransacted = this.transactional; container.AcknowledgeMode = this.acknowledgeMode; container.AfterPropertiesSet(); container.Start(); return(container); }
/// <summary>Does the sunny day test.</summary> /// <param name="latch">The latch.</param> /// <param name="listener">The listener.</param> private void DoSunnyDayTest(CountdownEvent latch, object listener) { this.container = this.CreateContainer(listener); for (var i = 0; i < this.messageCount; i++) { this.template.ConvertAndSend(this.queue.Name, i + "foo"); } Logger.Debug(m => m("Waiting {0} seconds for messages to be received.", Math.Max(2, this.messageCount / 20))); var waited = latch.Wait(new TimeSpan(0, 0, 0, Math.Max(2, this.messageCount / 20))); Assert.True(waited, "Timed out waiting for message"); Assert.Null(this.template.ReceiveAndConvert(this.queue.Name)); }
public void TestListenerDoesNotRecoverFromMissingQueue() { try { this.concurrentConsumers = 3; var latch = new CountdownEvent(this.messageCount); this.container = this.CreateContainer("nonexistent", new VanillaListener(latch), this.CreateConnectionFactory()); } catch (Exception e) { Assert.True(e is AmqpIllegalStateException); this.concurrentConsumers = 1; } }
private SimpleMessageListenerContainer CreateContainer(object listener) { var container = new SimpleMessageListenerContainer(this.template.ConnectionFactory); container.MessageListener = new MessageListenerAdapter(listener); container.QueueNames = new[] { this.queue.Name }; container.TxSize = this.txSize; container.PrefetchCount = this.txSize; container.ConcurrentConsumers = this.concurrentConsumers; container.ChannelTransacted = this.transactional; container.AcknowledgeMode = AcknowledgeModeUtils.AcknowledgeMode.Auto; container.AfterPropertiesSet(); container.Start(); return(container); }
public void TestListenerRecoversFromDeadBroker() { var queues = this.brokerAdmin.GetQueues(); Logger.Info("Queues: " + queues); Assert.AreEqual(1, queues.Count); Assert.True(queues[0].Durable); var template = new RabbitTemplate(this.connectionFactory); var latch = new CountdownEvent(this.messageCount); Assert.AreEqual(this.messageCount, latch.CurrentCount, "No more messages to receive before even sent!"); this.container = this.CreateContainer(this.queue.Name, new VanillaListener(latch), this.connectionFactory); for (var i = 0; i < this.messageCount; i++) { template.ConvertAndSend(this.queue.Name, i + "foo"); } Assert.True(latch.CurrentCount > 0, "No more messages to receive before broker stopped"); Logger.Info(string.Format("Latch.CurrentCount Before Shutdown: {0}", latch.CurrentCount)); this.brokerAdmin.StopBrokerApplication(); Assert.True(latch.CurrentCount > 0, "No more messages to receive after broker stopped"); Logger.Info(string.Format("Latch.CurrentCount After Shutdown: {0}", latch.CurrentCount)); var waited = latch.Wait(500); Assert.False(waited, "Did not time out waiting for message"); this.container.Stop(); Assert.AreEqual(0, this.container.ActiveConsumerCount); Logger.Info(string.Format("Latch.CurrentCount After Container Stop: {0}", latch.CurrentCount)); this.brokerAdmin.StartBrokerApplication(); queues = this.brokerAdmin.GetQueues(); Logger.Info("Queues: " + queues); this.container.Start(); Logger.Info(string.Format("Concurrent Consumers After Container Start: {0}", this.container.ActiveConsumerCount)); Assert.AreEqual(this.concurrentConsumers, this.container.ActiveConsumerCount); Logger.Info(string.Format("Latch.CurrentCount After Container Start: {0}", latch.CurrentCount)); var timeout = Math.Min((4 + this.messageCount) / (4 * this.concurrentConsumers), 30); Logger.Debug("Waiting for messages with timeout = " + timeout + " (s)"); waited = latch.Wait(timeout * 1000); Assert.True(waited, "Timed out waiting for message"); Assert.IsNull(template.ReceiveAndConvert(this.queue.Name)); }
public void TestSingleListenerDoesNotRecoverFromMissingQueue() { try { /* * A single listener sometimes doesn't have time to attempt to start before we ask it if it has failed, so this * is a good test of that potential bug. */ this.concurrentConsumers = 1; var latch = new CountdownEvent(this.messageCount); this.container = this.CreateContainer("nonexistent", new VanillaListener(latch), this.CreateConnectionFactory()); } catch (Exception e) { Assert.True(e is AmqpIllegalStateException); } }
public void Clear() { // Wait for broker communication to finish before trying to stop container Thread.Sleep(300); Logger.Debug("Shutting down at end of test"); if (this.container != null) { this.container.Shutdown(); } if (this.container != null) { this.container.Dispose(); } this.container = null; }
public void TestInconsistentAcknowledgeConfiguration() { var container = new SimpleMessageListenerContainer(new SingleConnectionFactory()); container.MessageListener = new MessageListenerAdapter(this); container.QueueNames = new[] { "foo" }; container.ChannelTransacted = true; container.AcknowledgeMode = AcknowledgeModeUtils.AcknowledgeMode.None; try { container.AfterPropertiesSet(); } catch (Exception e) { Assert.True(e is InvalidOperationException); } }
public void TestListenerWithManualAckNonTransactional() { var latch = new CountdownEvent(this.messageCount); this.container = this.CreateContainer(new TestListener(latch)); for (var i = 0; i < this.messageCount; i++) { this.template.ConvertAndSend(queue.Name, i + "foo"); } var timeout = Math.Min(1 + this.messageCount / (4 * this.concurrentConsumers), 30); Logger.Debug("Waiting for messages with timeout = " + timeout + " (s)"); var waited = latch.Wait(timeout * 1000); Assert.True(waited, "Timed out waiting for message"); Assert.Null(this.template.ReceiveAndConvert(queue.Name)); }
public void TestListenerTransactionalFails() { this.transactional = true; var latch = new CountdownEvent(this.messageCount); this.container = this.CreateContainer(new TxTestListener(latch, true, this)); for (var i = 0; i < this.txSize; i++) { this.template.ConvertAndSend(this.queue.Name, i + "foo"); } var timeout = Math.Min(1 + (this.messageCount / (4 * this.concurrentConsumers)), 30); Logger.Debug("Waiting for messages with timeout = " + timeout + " (s)"); var waited = latch.Wait(new TimeSpan(0, 0, 0, timeout)); Assert.True(waited, "Timed out waiting for message"); Assert.Null(this.template.ReceiveAndConvert(this.queue.Name)); }
/// <summary>Does the listener with exception test.</summary> /// <param name="latch">The latch.</param> /// <param name="listener">The listener.</param> private void DoListenerWithExceptionTest(CountdownEvent latch, object listener) { this.container = this.CreateContainer(listener); if (this.acknowledgeMode.TransactionAllowed()) { // Should only need one message if it is going to fail for (var i = 0; i < this.concurrentConsumers; i++) { this.template.ConvertAndSend(this.queue.Name, i + "foo"); } } else { for (var i = 0; i < this.messageCount; i++) { this.template.ConvertAndSend(this.queue.Name, i + "foo"); } } try { Logger.Debug(m => m("Waiting {0} seconds for messages to be received.", 5 + Math.Max(1, this.messageCount / 10))); var waited = latch.Wait(new TimeSpan(0, 0, 0, 5 + Math.Max(1, this.messageCount / 10))); Assert.True(waited, "Timed out waiting for message"); } finally { // Wait for broker communication to finish before trying to stop // container Thread.Sleep(300); this.container.Shutdown(); Thread.Sleep(300); } if (this.acknowledgeMode.TransactionAllowed()) { Assert.NotNull(this.template.ReceiveAndConvert(this.queue.Name)); } else { Assert.Null(this.template.ReceiveAndConvert(this.queue.Name)); } }
/// <summary>Creates the container.</summary> /// <param name="listener">The listener.</param> /// <returns>The container.</returns> private SimpleMessageListenerContainer CreateContainer(object listener) { var container = new SimpleMessageListenerContainer(this.template.ConnectionFactory); container.MessageListener = listener; container.QueueNames = new[] { this.queue.Name }; container.TxSize = this.txSize; container.PrefetchCount = this.txSize; container.ConcurrentConsumers = this.concurrentConsumers; container.ChannelTransacted = this.transactional; container.AcknowledgeMode = this.acknowledgeMode; if (this.externalTransaction) { container.TransactionManager = new IntegrationTestTransactionManager(); } container.AfterPropertiesSet(); container.Start(); return(container); }
/// <summary>Does the test.</summary> /// <param name="messageCount">The message count.</param> /// <param name="errorHandler">The error handler.</param> /// <param name="latch">The latch.</param> /// <param name="listener">The listener.</param> public void DoTest(int messageCount, IErrorHandler errorHandler, CountdownEvent latch, object listener) { var concurrentConsumers = 1; var template = this.CreateTemplate(concurrentConsumers); // Send messages to the queue for (var i = 0; i < messageCount; i++) { template.ConvertAndSend(queue.Name, i + "foo"); } var container = new SimpleMessageListenerContainer(template.ConnectionFactory); container.MessageListener = listener; container.AcknowledgeMode = AcknowledgeModeUtils.AcknowledgeMode.None; container.ChannelTransacted = false; container.ConcurrentConsumers = concurrentConsumers; container.PrefetchCount = messageCount; container.TxSize = messageCount; container.QueueNames = new[] { queue.Name }; container.ErrorHandler = errorHandler; container.AfterPropertiesSet(); container.Start(); var waited = latch.Wait(1000); if (messageCount > 1) { Assert.True(waited, "Expected to receive all messages before stop"); } try { Assert.Null(template.ReceiveAndConvert(queue.Name)); } finally { container.Shutdown(); } }
public void SendAndAsyncReceive() { SimpleMessageListenerContainer container = (SimpleMessageListenerContainer)applicationContext["SimpleMessageListenerContainer"]; SimpleMessageListener listener = applicationContext["SimpleMessageListener"] as SimpleMessageListener; Assert.IsNotNull(container); Assert.IsNotNull(listener); Admin admin = new Admin("tcp://localhost:7222", "admin", null); admin.PurgeQueue("test.queue"); EmsTemplate emsTemplate = (EmsTemplate)applicationContext["MessageTemplate"] as EmsTemplate; Assert.IsNotNull(emsTemplate); Assert.AreEqual(0, listener.MessageCount); emsTemplate.ConvertAndSend("Hello World 1"); int waitInMillis = 2000; Thread.Sleep(waitInMillis); Assert.AreEqual(1, listener.MessageCount); container.Stop(); Console.WriteLine("container stopped."); emsTemplate.ConvertAndSend("Hello World 2"); Thread.Sleep(waitInMillis); Assert.AreEqual(1, listener.MessageCount); container.Start(); Console.WriteLine("container started."); Thread.Sleep(waitInMillis); Assert.AreEqual(2, listener.MessageCount); container.Shutdown(); Thread.Sleep(waitInMillis); }
public void TestListenerRecoversFromClosedConnection() { var template = new RabbitTemplate(this.CreateConnectionFactory()); var latch = new CountdownEvent(this.messageCount); var connectionFactory = this.CreateConnectionFactory(); this.container = this.CreateContainer(queue.Name, new CloseConnectionListener((IConnectionProxy)connectionFactory.CreateConnection(), latch), connectionFactory); for (var i = 0; i < this.messageCount; i++) { template.ConvertAndSend(queue.Name, i + "foo"); } var timeout = Math.Min(4 + (this.messageCount / (4 * this.concurrentConsumers)), 30); Logger.Debug("Waiting for messages with timeout = " + timeout + " (s)"); var waited = latch.Wait(new TimeSpan(0, 0, timeout)); Assert.True(waited, "Timed out waiting for message"); Assert.Null(template.ReceiveAndConvert(queue.Name)); }
public void TestListenerRecoversFromBogusDoubleAck() { var template = new RabbitTemplate(this.CreateConnectionFactory()); this.acknowledgeMode = AcknowledgeModeUtils.AcknowledgeMode.Manual; var latch = new CountdownEvent(this.messageCount); this.container = this.CreateContainer(queue.Name, new ManualAckListener(latch), this.CreateConnectionFactory()); for (var i = 0; i < this.messageCount; i++) { template.ConvertAndSend(queue.Name, i + "foo"); } var timeout = this.GetTimeout(); Logger.Debug("Waiting for messages with timeout = " + timeout + " (s)"); var waited = latch.Wait(new TimeSpan(0, 0, timeout)); Assert.True(waited, "Timed out waiting for message"); Assert.Null(template.ReceiveAndConvert(queue.Name)); }
protected void listen(IMessageEventHandler <T> handler, string url, string queueName) { try { ConnectionFactory factory = new ConnectionFactory(url); SimpleMessageListenerContainer listenerContainer = new SimpleMessageListenerContainer(); listenerContainer.ConnectionFactory = factory; listenerContainer.DestinationName = queueName; listenerContainer.MessageListener = new GenericMessageListener <T>(handler); listenerContainer.AfterPropertiesSet(); string info = String.Format("Service started!"); writeToLog(info, LogMessage.LogType.INFO); Console.WriteLine(info); Console.WriteLine("Press ENTER to exit."); Console.ReadLine(); } catch (System.Exception e) { Console.WriteLine(e.Message); } }
public void SendAndAsyncReceive() { SimpleMessageListenerContainer container = (SimpleMessageListenerContainer)applicationContext["SimpleMessageListenerContainer"]; SimpleMessageListener listener = applicationContext["SimpleMessageListener"] as SimpleMessageListener; Assert.IsNotNull(container); Assert.IsNotNull(listener); NmsTemplate nmsTemplate = (NmsTemplate)applicationContext["MessageTemplate"] as NmsTemplate; Assert.IsNotNull(nmsTemplate); Assert.AreEqual(0, listener.MessageCount); nmsTemplate.ConvertAndSend("Hello World 1"); int waitInMillis = 2000; Thread.Sleep(waitInMillis); Assert.AreEqual(1, listener.MessageCount); container.Stop(); Console.WriteLine("container stopped."); nmsTemplate.ConvertAndSend("Hello World 2"); Thread.Sleep(waitInMillis); Assert.AreEqual(1, listener.MessageCount); container.Start(); Console.WriteLine("container started."); Thread.Sleep(waitInMillis); Assert.AreEqual(2, listener.MessageCount); container.Shutdown(); Thread.Sleep(waitInMillis); }