public void sendText(String message) { try { producer.send(session.createTextMessage(message)); } catch (JMSException e) { throw bomb(e); } } }
/** * Send the given RemoteInvocationResult as a JMS message to the originator. * @param requestMessage current request message * @param session the JMS Session to use * @param result the RemoteInvocationResult object * @throws javax.jms.JMSException if thrown by trying to send the message */ protected void writeRemoteInvocationResult( Message requestMessage, Session session, RemoteInvocationResult result) throws JMSException { Message response = createResponseMessage(requestMessage, session, result); MessageProducer producer = session.createProducer(requestMessage.getJMSReplyTo()); try { producer.send(response); } finally { JmsUtils.closeMessageProducer(producer); } }
try { responseQueue = session.createTemporaryQueue(); producer = session.createProducer(queue); consumer = session.createConsumer(responseQueue); requestMessage.setJMSReplyTo(responseQueue); producer.send(requestMessage); long timeout = getReceiveTimeout(); return (timeout > 0 ? consumer.receive(timeout) : consumer.receive());
try { queueConnection = connectionFactory.createConnection(); queueSession = queueConnection.createSession(transacted, Session.AUTO_ACKNOWLEDGE); TextMessage message = queueSession.createTextMessage(eventXml); message.setStringProperty("LogType", "Task"); producer = queueSession.createProducer(queue); producer.setPriority(priority); producer.send(message); } catch (Exception e) { throw new RuntimeException("Error when sending JMS message with working memory event", e); queueConnection.close(); } catch (JMSException e) { logger.warn("Error when closing queue connection", e);
@Test public void testBeforeTaskReleasedEvent() throws JMSException { logProducer.beforeTaskReleasedEvent(event); ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class); verify(session).createTextMessage(argument.capture()); String messageContent = argument.getValue(); assertThat(messageContent) .isNotNull() .doesNotContain("<auditTask>") .contains("<org.jbpm.services.task.audit.impl.model.TaskEventImpl>") .contains("<type>RELEASED</type>"); verify(message, times(1)).setStringProperty(eq("LogType"), eq("Task")); verify(producer, times(1)).setPriority(eq(7)); verify(producer, times(1)).send(eq(message)); }
private void checkDestination(String name) throws Exception { ConnectionFactory cf = (ConnectionFactory) namingContext.lookup("/someCF"); Connection conn = cf.createConnection(); Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE); Destination dest = (Destination) namingContext.lookup(name); conn.start(); MessageConsumer cons = sess.createConsumer(dest); MessageProducer prod = sess.createProducer(dest); prod.send(sess.createMessage()); assertNotNull(cons.receiveNoWait()); conn.close(); }
/** * Sends a batch of messages and validates that the rollbacked message was * not consumed. * * @throws Exception */ public void testSendReceiveWithPrefetchOne() throws Exception { setPrefetchToOne(); Message[] outbound = new Message[] {session.createTextMessage("First Message"), session.createTextMessage("Second Message"), session.createTextMessage("Third Message"), session.createTextMessage("Fourth Message")}; beginTx(); for (int i = 0; i < outbound.length; i++) { // sends a message producer.send(outbound[i]); } commitTx(); // receives the first message beginTx(); for (int i = 0; i < outbound.length; i++) { LOG.info("About to consume message 1"); Message message = consumer.receive(1000); assertNotNull(message); LOG.info("Received: " + message); } // validates that the rollbacked was not consumed commitTx(); }
sess = conn.createSession(useTransaction, ackMode); producer = sess.createProducer(destination); producer.send(msg); } catch (final Exception e) { throw new JobExecutionException(e);
public TextMessage testReplyWithJackson(String methodName, String replyContent) throws JMSException { Queue replyDestination = mock(Queue.class); Session session = mock(Session.class); MessageProducer messageProducer = mock(MessageProducer.class); TextMessage responseMessage = mock(TextMessage.class); given(session.createTextMessage(replyContent)).willReturn(responseMessage); given(session.createProducer(replyDestination)).willReturn(messageProducer); MessagingMessageListenerAdapter listener = getPayloadInstance("Response", methodName, Message.class); MappingJackson2MessageConverter messageConverter = new MappingJackson2MessageConverter(); messageConverter.setTargetType(MessageType.TEXT); listener.setMessageConverter(messageConverter); listener.setDefaultResponseDestination(replyDestination); listener.onMessage(mock(javax.jms.Message.class), session); verify(session, times(0)).createQueue(anyString()); verify(session).createTextMessage(replyContent); verify(messageProducer).send(responseMessage); verify(messageProducer).close(); return responseMessage; }
final ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url); final javax.jms.Connection connection = connectionFactory.createConnection(); connection.setClientID("12345"); connection.start(); final Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); final Topic temporaryTopic = session.createTemporaryTopic(); final MessageConsumer consumer1 = session.createConsumer(temporaryTopic); final MessageProducer producer = session.createProducer(temporaryTopic); producer.send(session.createTextMessage("Testmessage")); final TextMessage message = (TextMessage)consumer1.receiveNoWait(); Assert.assertNotNull(message); Assert.assertEquals("testing", message.getText());
public void testReRouteAllWithNullProducerExchange() throws Exception { final ActiveMQQueue queue = new ActiveMQQueue("Reroute.From."+topic.getTopicName()); final MessageInterceptorRegistry registry = MessageInterceptorRegistry.getInstance().get(BrokerRegistry.getInstance().findFirst()); registry.addMessageInterceptorForTopic(topic.getTopicName(), new MessageInterceptor() { @Override public void intercept(ProducerBrokerExchange producerExchange, Message message) { message.setDestination(queue); try { registry.injectMessage(producerExchange, message); } catch (Exception e) { e.printStackTrace(); } } }); final CountDownLatch latch = new CountDownLatch(messageCount); consumer = consumerSession.createConsumer(queue); consumer.setMessageListener(new MessageListener() { @Override public void onMessage(javax.jms.Message message) { latch.countDown(); } }); for (int i = 0; i < messageCount; i++){ javax.jms.Message message = producerSession.createTextMessage("test: " + i); producer.send(message); } latch.await(timeOutInSeconds, TimeUnit.SECONDS); assertEquals(0,latch.getCount()); }
try { queueConnection = connectionFactory.createConnection(); queueSession = queueConnection.createSession(transacted, Session.AUTO_ACKNOWLEDGE); TextMessage message = queueSession.createTextMessage(eventXml); message.setIntProperty("EventType", eventType); message.setStringProperty("LogType", "Process"); producer = queueSession.createProducer(queue); producer.setPriority(priority); producer.send(message); } catch (Exception e) { throw new RuntimeException("Error when sending JMS message with working memory event", e); queueConnection.close(); } catch (JMSException e) { logger.warn("Error when closing queue connection", e);
public void testCloseConsumer() throws Exception { Destination dest = session.createQueue(getSubject() + "?consumer.prefetchSize=0"); producer = session.createProducer(dest); beginTx(); producer.send(session.createTextMessage("message 1")); producer.send(session.createTextMessage("message 2")); commitTx(); beginTx(); consumer = session.createConsumer(dest); Message message1 = consumer.receive(1000); String text1 = ((TextMessage)message1).getText(); assertNotNull(message1); assertEquals("message 1", text1); consumer.close(); consumer = session.createConsumer(dest); Message message2 = consumer.receive(1000); String text2 = ((TextMessage)message2).getText(); assertNotNull(message2); assertEquals("message 2", text2); commitTx(); }
@Test public void testAfterTaskInputVariableChanged() throws JMSException { Map<String, Object> vars = new HashMap<>(); vars.put("test", "value"); logProducer.afterTaskInputVariableChangedEvent(event, vars); ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class); verify(session).createTextMessage(argument.capture()); String messageContent = argument.getValue(); assertThat(messageContent) .isNotNull() .doesNotContain("<auditTask>") .doesNotContain("<org.jbpm.services.task.audit.impl.model.TaskEventImpl>") .contains("<taskInputs>"); verify(message, times(1)).setStringProperty(eq("LogType"), eq("Task")); verify(producer, times(1)).setPriority(eq(2)); verify(producer, times(1)).send(eq(message)); }
/** * spec section 3.6 acking a message with automation acks has no effect. * @throws Exception */ public void testAckMessageInTx() throws Exception { Message[] outbound = new Message[] {session.createTextMessage("First Message")}; // sends a message beginTx(); producer.send(outbound[0]); outbound[0].acknowledge(); commitTx(); outbound[0].acknowledge(); // receives the first message beginTx(); ArrayList<Message> messages = new ArrayList<Message>(); LOG.info("About to consume message 1"); Message message = consumer.receive(1000); messages.add(message); LOG.info("Received: " + message); // validates that the rollbacked was not consumed commitTx(); Message inbound[] = new Message[messages.size()]; messages.toArray(inbound); assertTextMessagesEqual("Message not delivered.", outbound, inbound); }
/** * Send a dummy message to probe if the JMS connection is healthy * @return true if connection is healthy, false otherwise */ protected boolean isConnectionHealthy() { try { Topic topic = createTopic(getTopicPrefix(getConf()) + "." + HEALTH_CHECK_TOPIC_SUFFIX); MessageProducer producer = createProducer(topic); Message msg = session.get().createTextMessage(HEALTH_CHECK_MSG); producer.send(msg, DeliveryMode.NON_PERSISTENT, 4, 0); } catch (Exception e) { return false; } return true; }
public void onMessage(javax.jms.Message request, Session session) throws JMSException { String text = "priority=" + request.getJMSPriority(); TextMessage reply = session.createTextMessage(text); MessageProducer producer = session.createProducer(request.getJMSReplyTo()); reply.setJMSCorrelationID(request.getJMSMessageID()); producer.send(reply); } }
public void testReRouteAll() throws Exception { final ActiveMQQueue queue = new ActiveMQQueue("Reroute.From."+topic.getTopicName()); final MessageInterceptorRegistry registry = MessageInterceptorRegistry.getInstance().get(BrokerRegistry.getInstance().findFirst()); registry.addMessageInterceptorForTopic(topic.getTopicName(), new MessageInterceptor() { @Override public void intercept(ProducerBrokerExchange producerExchange, Message message) { message.setDestination(queue); try { registry.injectMessage(producerExchange, message); } catch (Exception e) { e.printStackTrace(); } } }); final CountDownLatch latch = new CountDownLatch(messageCount); consumer = consumerSession.createConsumer(queue); consumer.setMessageListener(new MessageListener() { @Override public void onMessage(javax.jms.Message message) { latch.countDown(); } }); for (int i = 0; i < messageCount; i++){ javax.jms.Message message = producerSession.createTextMessage("test: " + i); producer.send(message); } latch.await(timeOutInSeconds, TimeUnit.SECONDS); assertEquals(0,latch.getCount()); }
/** * Send the given response message to the given destination. * @param response the JMS message to send * @param destination the JMS destination to send to * @param session the JMS session to operate on * @throws JMSException if thrown by JMS API methods * @see #postProcessProducer * @see javax.jms.Session#createProducer * @see javax.jms.MessageProducer#send */ protected void sendResponse(Session session, Destination destination, Message response) throws JMSException { MessageProducer producer = session.createProducer(destination); try { postProcessProducer(producer, response); QosSettings settings = getResponseQosSettings(); if (settings != null) { producer.send(response, settings.getDeliveryMode(), settings.getPriority(), settings.getTimeToLive()); } else { producer.send(response); } } finally { JmsUtils.closeMessageProducer(producer); } }
try { connection = cf.createConnection(userName, password); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); MessageProducer producer = session.createProducer(dest); ActiveMQTextMessage msg = (ActiveMQTextMessage) session.createTextMessage(body); producer.send(msg); connection.close();