protected void prepare() { if (this.options.jmsProvider == null || this.options.msgProducer == null) { throw new IllegalStateException("JMS Provider and MessageProducer not set."); } LOG.debug("Connecting JMS.."); try { ConnectionFactory cf = this.options.jmsProvider.connectionFactory(); Destination dest = this.options.jmsProvider.destination(); this.connection = cf.createConnection(); this.session = connection.createSession(this.options.jmsTransactional, this.options.jmsAcknowledgeMode); this.messageProducer = session.createProducer(dest); connection.start(); } catch (Exception e) { LOG.warn("Error creating JMS connection.", e); } }
Destination dest = jmsProvider.destination(); this.connection = cf.createConnection(); this.session = connection.createSession(false, jmsAcknowledgeMode); MessageConsumer consumer = session.createConsumer(dest); consumer.setMessageListener(this); this.connection.start();
/** * A variant of {@link #execute(SessionCallback, boolean)} that explicitly * creates a non-transactional {@link Session}. The given {@link SessionCallback} * does not participate in an existing transaction. */ @Nullable private <T> T executeLocal(SessionCallback<T> action, boolean startConnection) throws JmsException { Assert.notNull(action, "Callback object must not be null"); Connection con = null; Session session = null; try { con = createConnection(); session = con.createSession(false, Session.AUTO_ACKNOWLEDGE); if (startConnection) { con.start(); } if (logger.isDebugEnabled()) { logger.debug("Executing callback on JMS Session: " + session); } return action.doInJms(session); } catch (JMSException ex) { throw convertJmsAccessException(ex); } finally { JmsUtils.closeSession(session); ConnectionFactoryUtils.releaseConnection(con, getConnectionFactory(), startConnection); } }
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);
given(con.createSession(true, Session.AUTO_ACKNOWLEDGE)).willReturn(txSession); given(txSession.getTransacted()).willReturn(true); given(con.createSession(false, Session.CLIENT_ACKNOWLEDGE)).willReturn(nonTxSession); Session session1 = con1.createSession(true, Session.AUTO_ACKNOWLEDGE); session1.getTransacted(); session1 = con1.createSession(false, Session.CLIENT_ACKNOWLEDGE); session1.close(); con1.start(); Connection con2 = scf.createConnection(); Session session2 = con2.createSession(false, Session.CLIENT_ACKNOWLEDGE); session2.close(); session2 = con2.createSession(true, Session.AUTO_ACKNOWLEDGE); session2.commit(); session2.close(); con2.start(); con1.close(); con2.close(); verify(txSession).close(); verify(nonTxSession).close(); verify(con).start(); verify(con).stop(); verify(con).close();
private void unsubscribe(final String url, final String username, final String password, final String subscriptionId, final String jmsProvider, final int timeoutMillis) throws JMSException { final Connection connection; if (username == null && password == null) { connection = JmsFactory.createConnectionFactory(url, timeoutMillis, jmsProvider).createConnection(); } else { connection = JmsFactory.createConnectionFactory(url, timeoutMillis, jmsProvider).createConnection(username, password); } Session session = null; try { connection.setClientID(subscriptionId); session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); session.unsubscribe(subscriptionId); getLogger().info("Successfully unsubscribed from {}, Subscription Identifier {}", new Object[]{url, subscriptionId}); } finally { if (session != null) { try { session.close(); } catch (final Exception e1) { getLogger().warn("Unable to close session with JMS Server due to {}; resources may not be cleaned up appropriately", new Object[]{e1}); } } try { connection.close(); } catch (final Exception e1) { getLogger().warn("Unable to close connection to JMS Server due to {}; resources may not be cleaned up appropriately", new Object[]{e1}); } } }
public JmsAppenderTest() throws Exception { // this needs to set up before LoggerContextRule given(connectionFactory.createConnection()).willReturn(connection); given(connectionFactory.createConnection(anyString(), anyString())).willThrow(IllegalArgumentException.class); given(connection.createSession(eq(false), eq(Session.AUTO_ACKNOWLEDGE))).willReturn(session); given(session.createProducer(eq(destination))).willReturn(messageProducer); given(session.createTextMessage(anyString())).willReturn(textMessage); given(session.createObjectMessage(isA(Serializable.class))).willReturn(objectMessage); }
sess = conn.createSession(useTransaction, ackMode); producer = sess.createProducer(destination); producer.send(msg); } catch (final Exception e) { throw new JobExecutionException(e);
Mockito.when(session.createBytesMessage()).thenReturn(Mockito.mock(BytesMessage.class)); MessageProducer producer = Mockito.mock(MessageProducer.class); Mockito.when(session.createProducer(queue)).thenReturn(producer); Mockito.when(connection.createSession(Mockito.anyBoolean(), Mockito.anyInt())).thenReturn(session); Mockito.when(this.jmsConnectionFactory.createConnection()).thenReturn(connection);
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);
connection.setClientID(clientId.get()); connection.start(); } catch (JMSException e) { throw new FlumeException("Could not create connection to broker", e); session = connection.createSession(true, Session.SESSION_TRANSACTED); } catch (JMSException e) { throw new FlumeException("Could not create session", e); messageSelector.isEmpty() ? null : messageSelector, true); } else { messageConsumer = session.createConsumer(destination, messageSelector.isEmpty() ? null : messageSelector);
scf.setReconnectOnException(false); Connection con1 = scf.createTopicConnection(); Session session1 = con1.createSession(true, Session.AUTO_ACKNOWLEDGE); session1.getTransacted(); session1 = con1.createSession(false, Session.CLIENT_ACKNOWLEDGE); session1.close(); con1.start(); TopicConnection con2 = scf.createTopicConnection(); Session session2 = con2.createTopicSession(false, Session.CLIENT_ACKNOWLEDGE); session2.close(); con2.start(); con1.close(); con2.close();
given(con.createSession(true, Session.AUTO_ACKNOWLEDGE)).willReturn(session); verify(con).close();
/** * Initializes JMS resources. */ @Override public void prepare(Map<String, Object> topoConf, TopologyContext context, OutputCollector collector) { if (this.jmsProvider == null || this.producer == null) { throw new IllegalStateException("JMS Provider and MessageProducer not set."); } this.collector = collector; LOG.debug("Connecting JMS.."); try { ConnectionFactory cf = this.jmsProvider.connectionFactory(); Destination dest = this.jmsProvider.destination(); this.connection = cf.createConnection(); this.session = connection.createSession(this.jmsTransactional, this.jmsAcknowledgeMode); this.messageProducer = session.createProducer(dest); connection.start(); } catch (Exception e) { LOG.warn("Error creating JMS connection.", e); } } }
when(connection.createSession(true, Session.AUTO_ACKNOWLEDGE)).thenReturn(session); when(session.createProducer(any())).thenReturn(producer); when(session.createTextMessage(any())).thenReturn(message);
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();
given(session.createConsumer(QUEUE_DESTINATION, null)).willReturn(messageConsumer); // no MessageSelector... given(connection.createSession(this.container.isSessionTransacted(), this.container.getSessionAcknowledgeMode())).willReturn(session); verify(connection).start();
Session tas = tac.createSession(false, Session.AUTO_ACKNOWLEDGE); tas.getTransacted(); tas.close(); tac.close(); verify(this.connection).start(); if (useTransactedTemplate()) { verify(this.session).commit(); verify(this.connection).close();
given(con.createSession(true, Session.AUTO_ACKNOWLEDGE)).willReturn(session); given(con.createSession(false, Session.AUTO_ACKNOWLEDGE)).willReturn(session2); verify(session).close(); verify(session2).close(); verify(con, times(2)).close();
@Before public void setUp() throws Exception { brokerService = new BrokerService(); brokerService.setPersistent(false); brokerService.start(); factory = new ActiveMQConnectionFactory(BrokerRegistry.getInstance().findFirst().getVmConnectorURI()); producerConnection = factory.createConnection(); producerConnection.start(); producerSession = producerConnection.createSession(false,Session.AUTO_ACKNOWLEDGE); queue = producerSession.createQueue(getClass().getName()); producer = producerSession.createProducer(queue); }