Transport transport = createTransport(); connection = createActiveMQConnection(transport, factoryStats); connection.setUserName(userName); connection.setPassword(password); configureConnection(connection); connection.setDefaultClientID(clientID); connection.close(); } catch (Throwable ignore) { connection.close(); } catch (Throwable ignore) {
public MessageSender createSender(String topic) { try { Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); MessageProducer producer = session.createProducer(session.createTopic(topic)); producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT); return new ActiveMqMessageSender(session, producer); } catch (Exception e) { throw bomb(e); } }
@Autowired public ActiveMqMessagingService(DaemonThreadStatsCollector daemonThreadStatsCollector) throws Exception { this.daemonThreadStatsCollector = daemonThreadStatsCollector; SystemEnvironment systemEnvironment = new SystemEnvironment(); broker = new BrokerService(); broker.setBrokerName(BROKER_NAME); broker.setPersistent(false); broker.setUseJmx(systemEnvironment.getActivemqUseJmx()); broker.getManagementContext().setConnectorPort(systemEnvironment.getActivemqConnectorPort()); broker.start(); factory = new ActiveMQConnectionFactory(BROKER_URL); factory.getPrefetchPolicy().setQueuePrefetch(systemEnvironment.getActivemqQueuePrefetch()); factory.setCopyMessageOnSend(false); connection = (ActiveMQConnection) factory.createConnection(); connection.start(); }
protected void configureConnection(ActiveMQConnection connection) throws JMSException { connection.setPrefetchPolicy(getPrefetchPolicy()); connection.setDisableTimeStampsByDefault(isDisableTimeStampsByDefault()); connection.setOptimizedMessageDispatch(isOptimizedMessageDispatch()); connection.setCopyMessageOnSend(isCopyMessageOnSend()); connection.setUseCompression(isUseCompression()); connection.setObjectMessageSerializationDefered(isObjectMessageSerializationDefered()); connection.setDispatchAsync(isDispatchAsync()); connection.setUseAsyncSend(isUseAsyncSend()); connection.setAlwaysSyncSend(isAlwaysSyncSend()); connection.setAlwaysSessionAsync(isAlwaysSessionAsync()); connection.setOptimizeAcknowledge(isOptimizeAcknowledge()); connection.setOptimizeAcknowledgeTimeOut(getOptimizeAcknowledgeTimeOut()); connection.setOptimizedAckScheduledAckInterval(getOptimizedAckScheduledAckInterval()); connection.setUseRetroactiveConsumer(isUseRetroactiveConsumer()); connection.setExclusiveConsumer(isExclusiveConsumer()); connection.setRedeliveryPolicyMap(getRedeliveryPolicyMap()); connection.setTransformer(getTransformer()); connection.setBlobTransferPolicy(getBlobTransferPolicy().copy()); connection.setWatchTopicAdvisories(isWatchTopicAdvisories()); connection.setProducerWindowSize(getProducerWindowSize()); connection.setWarnAboutUnstartedConnectionTimeout(getWarnAboutUnstartedConnectionTimeout()); connection.setSendTimeout(getSendTimeout()); connection.setCloseTimeout(getCloseTimeout()); connection.setSendAcksAsync(isSendAcksAsync()); connection.setAuditDepth(getAuditDepth()); connection.setAuditMaximumProducerNumber(getAuditMaximumProducerNumber()); connection.setUseDedicatedTaskRunner(isUseDedicatedTaskRunner()); connection.setConsumerFailoverRedeliveryWaitPeriod(getConsumerFailoverRedeliveryWaitPeriod()); connection.setCheckForDuplicates(isCheckForDuplicates());
/** * Construct the Session * * @param connection * @param sessionId * @param acknowledgeMode n.b if transacted - the acknowledgeMode == * Session.SESSION_TRANSACTED * @param asyncDispatch * @param sessionAsyncDispatch * @throws JMSException on internal error */ protected ActiveMQSession(ActiveMQConnection connection, SessionId sessionId, int acknowledgeMode, boolean asyncDispatch, boolean sessionAsyncDispatch) throws JMSException { this.debug = LOG.isDebugEnabled(); this.connection = connection; this.acknowledgementMode = acknowledgeMode; this.asyncDispatch = asyncDispatch; this.sessionAsyncDispatch = sessionAsyncDispatch; this.info = new SessionInfo(connection.getConnectionInfo(), sessionId.getValue()); setTransactionContext(new TransactionContext(connection)); stats = new JMSSessionStatsImpl(producers, consumers); this.connection.asyncSendPacket(info); setTransformer(connection.getTransformer()); setBlobTransferPolicy(connection.getBlobTransferPolicy()); this.connectionExecutor=connection.getExecutor(); this.executor = new ActiveMQSessionExecutor(this); connection.addSession(this); if (connection.isStarted()) { start(); } }
@Test public void testAutoSend() throws Exception { connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createQueue(queueName); MessageConsumer consumer = session.createConsumer(queue); MessageProducer producer = session.createProducer(queue); for (int i = 0; i < 10; i++) { producer.send(session.createTextMessage("testXX" + i)); } connection.start(); for (int i = 0; i < 10; i++) { TextMessage txt = (TextMessage) consumer.receive(5000); Assert.assertEquals("testXX" + i, txt.getText()); } }
@Test public void testInitialRedeliveryDelayZero() throws Exception { RedeliveryPolicy policy = connection.getRedeliveryPolicy(); policy.setInitialRedeliveryDelay(0); policy.setUseExponentialBackOff(false); policy.setMaximumRedeliveries(1); connection.start(); Session session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE); ActiveMQQueue destination = new ActiveMQQueue("TEST"); this.makeSureCoreQueueExist("TEST"); MessageProducer producer = session.createProducer(destination); MessageConsumer consumer = session.createConsumer(destination); producer.send(session.createTextMessage("1st")); producer.send(session.createTextMessage("2nd")); session.commit(); m = (TextMessage) consumer.receive(100); assertNotNull(m); assertEquals("1st", m.getText()); session.rollback(); m = (TextMessage) consumer.receive(100); assertNotNull(m); assertEquals("1st", m.getText());
@Test public void testRollbackWithAcked() throws Exception { connection.start(); Session session = connection.createSession(true, Session.SESSION_TRANSACTED); Queue queue = session.createQueue(queueName); MessageConsumer consumer = session.createConsumer(queue); MessageProducer producer = session.createProducer(queue); for (int i = 0; i < 10; i++) { TextMessage msg = session.createTextMessage("testXX" + i); msg.setStringProperty("count", "str " + i); producer.send(msg); session.commit(); connection.start(); TextMessage txt = (TextMessage) consumer.receive(5000); Assert.assertEquals("testXX" + i, txt.getText()); session.rollback(); consumer.close(); consumer = session.createConsumer(queue); TextMessage txt = (TextMessage) consumer.receive(5000); System.out.println("TXT " + txt.getText());
@Test public void testAckedMessageAreConsumed() throws Exception { connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createQueue(queueName); MessageProducer producer = session.createProducer(queue); producer.send(session.createTextMessage("Hello")); // Consume the message... MessageConsumer consumer = session.createConsumer(queue); consumer.setMessageListener(this); latch.await(10, TimeUnit.SECONDS); session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); // Attempt to Consume the message...check if message was acknowledge consumer = session.createConsumer(queue); Message msg = consumer.receive(1000); assertNull(msg); session.close(); }
factory.setUseAsyncSend(true); this.flowControlConnection = (ActiveMQConnection) factory.createConnection(); this.flowControlConnection.start(); final Session session = this.flowControlConnection.createSession(true, Session.SESSION_TRANSACTED); final MessageProducer producer = session.createProducer(queueA); try { for (int i = 0; i < 5000; i++) { producer.send(session.createTextMessage("Test message")); session.commit(); successSent++; TextMessage msg; for (int idx = 0; idx < successSent; ++idx) { msg = (TextMessage) consumer.receive(1000); Assert.assertNotNull(msg); System.out.println("Received " + msg); if (msg != null) { msg.acknowledge(); session.commit(); consumer.close();
@Test public void testSimpleSendReceive() throws Exception { factory.setAlwaysSyncSend(true); flowControlConnection = (ActiveMQConnection) factory.createConnection(); flowControlConnection.start(); Session session = flowControlConnection.createSession(false, Session.CLIENT_ACKNOWLEDGE); MessageConsumer consumer = session.createConsumer(queueA); // Test sending to Queue B it should not block. CountDownLatch pubishDoneToQeueuA = asyncSendTo(queueA, "Message 1"); assertTrue(pubishDoneToQeueuA.await(2, TimeUnit.SECONDS)); TextMessage msg = (TextMessage) consumer.receive(); assertEquals("Message 1", msg.getText()); msg.acknowledge(); pubishDoneToQeueuA = asyncSendTo(queueA, "Message 2"); assertTrue(pubishDoneToQeueuA.await(2, TimeUnit.SECONDS)); msg = (TextMessage) consumer.receive(); assertEquals("Message 2", msg.getText()); msg.acknowledge(); consumer.close(); }
@Test public void testClientRedlivery() throws Exception { try { Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); this.makeSureCoreQueueExist("TEST"); Queue queue = session.createQueue("TEST"); MessageProducer producer = session.createProducer(queue); producer.send(session.createTextMessage("test")); } finally { connection.close(); } for (int i = 0; i < 10; ++i) { connection = (ActiveMQConnection) factory.createConnection(); connection.start(); try { Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); Queue queue = session.createQueue("TEST"); MessageConsumer consumer = session.createConsumer(queue); Message message = consumer.receive(1000); assertNotNull("Message null on iteration " + i, message); System.out.println("received message: " + i); System.out.println("is redelivered: " + message.getJMSRedelivered()); if (i > 0) { assertTrue(message.getJMSRedelivered()); } } finally { connection.close(); } } }
@Test public void testReceiveWildcardTopicMatchSinglePastTheEndWildcard() throws Exception { connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); ActiveMQDestination destination1 = (ActiveMQDestination) session.createTopic("a.>"); ActiveMQDestination destination2 = (ActiveMQDestination) session.createTopic("a"); Message m = null; MessageConsumer consumer = null; String text = null; consumer = session.createConsumer(destination1); sendMessage(session, destination2, destination3String); m = consumer.receive(1000); assertNotNull(m); text = ((TextMessage) m).getText(); if (!(text.equals(destination1String) || text.equals(destination3String))) { fail("unexpected message:" + text); } assertNull(consumer.receiveNoWait()); }
@Test public void testTopicNoLocalDurable() throws Exception { connection.setClientID("forNoLocal-1"); connection.start(); TopicSession session = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE); final String body2 = "MfromAMQ-2"; TextMessage msg = session.createTextMessage(body1); producer.send(msg); msg.setStringProperty("TESTKEY", "test"); producer.send(msg); TextMessage receivedMsg = (TextMessage) nolocalConsumer.receive(1000); assertNull("nolocal consumer got: " + receivedMsg, receivedMsg); receivedMsg = (TextMessage) consumer.receive(1000); assertNotNull(receivedMsg); assertEquals(body1, receivedMsg.getText()); receivedMsg = (TextMessage) consumer.receive(1000); assertNotNull(receivedMsg); assertEquals(body2, receivedMsg.getText()); assertNull(consumer.receiveNoWait()); assertNotNull(consumer.receive(1000));
@Test public void testSendReceiveBytesMessage() throws Exception { // Receive a message with the JMS API connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); ActiveMQDestination destination = createDestination(session, destinationType); MessageConsumer consumer = session.createConsumer(destination); MessageProducer producer = session.createProducer(destination); BytesMessage message = session.createBytesMessage(); message.writeBoolean(true); message.writeBoolean(false); producer.send(message); // Make sure only 1 message was delivered. BytesMessage m = (BytesMessage) consumer.receive(1000); assertNotNull(m); assertTrue(m.readBoolean()); assertFalse(m.readBoolean()); assertNull(consumer.receiveNoWait()); }
@Test public void testSendReceive() throws Exception { // Send a message to the broker. connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); ActiveMQDestination destination = createDestination(session, destinationType); System.out.println("destionation: " + destination); MessageProducer producer = session.createProducer(destination); producer.setDeliveryMode(this.deliveryMode); MessageConsumer consumer = session.createConsumer(destination); ActiveMQMessage message = new ActiveMQMessage(); producer.send(message); // Make sure only 1 message was delivered. assertNotNull(consumer.receive(1000)); assertNull(consumer.receiveNoWait()); }
@Test public void testMapMessage() throws Exception { // Receive a message with the JMS API connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); destination = createDestination(session, destinationType); MessageConsumer consumer = session.createConsumer(destination); MessageProducer producer = session.createProducer(destination); // send the message. { MapMessage message = session.createMapMessage(); message.setBoolean("boolKey", true); producer.send(message); } // get the message. { MapMessage message = (MapMessage) consumer.receive(1000); assertNotNull(message); assertTrue(message.getBoolean("boolKey")); } assertNull(consumer.receiveNoWait()); }
@Test public void testPublisherRecoverAfterBlock() throws Exception { flowControlConnection = (ActiveMQConnection) factory.createConnection(); flowControlConnection.start(); final Session session = flowControlConnection.createSession(false, Session.CLIENT_ACKNOWLEDGE); final MessageProducer producer = session.createProducer(queueA); MessageConsumer consumer = session.createConsumer(queueA); TextMessage msg; for (int idx = 0; idx < 5; ++idx) { msg = (TextMessage) consumer.receive(1000); System.out.println("received: " + idx + ", msg: " + msg.getJMSMessageID()); msg.acknowledge(); consumer.close(); assertFalse("producer has resumed", done.get());
@Override public void run() { Session session = null; try { session = flowControlConnection.createSession(false, Session.AUTO_ACKNOWLEDGE); MessageProducer producer = session.createProducer(queue); producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT); producer.send(session.createTextMessage(message)); done.countDown(); } catch (JMSException e) { e.printStackTrace(); } finally { safeClose(session); } } }.start();
@Test public void testQueueBrowser() throws Exception { // Send a message to the broker. connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); ActiveMQDestination destination = createDestination(session, destinationType); MessageProducer producer = session.createProducer(destination); producer.setDeliveryMode(this.deliveryMode); sendMessages(session, producer, 5); producer.close(); QueueBrowser browser = session.createBrowser((Queue) destination); Enumeration<?> enumeration = browser.getEnumeration(); for (int i = 0; i < 5; i++) { Thread.sleep(100); assertTrue(enumeration.hasMoreElements()); Message m = (Message) enumeration.nextElement(); assertNotNull(m); assertEquals("" + i, ((TextMessage) m).getText()); } assertFalse(enumeration.hasMoreElements()); }