public static Connection createConnection(final ProcessContext context, final String clientId) throws JMSException { Objects.requireNonNull(context); Objects.requireNonNull(clientId); final ConnectionFactory connectionFactory = createConnectionFactory(context); final String username = context.getProperty(USERNAME).getValue(); final String password = context.getProperty(PASSWORD).getValue(); final Connection connection = (username == null && password == null) ? connectionFactory.createConnection() : connectionFactory.createConnection(username, password); connection.setClientID(clientId); connection.start(); return connection; }
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); messageConsumer = session.createDurableSubscriber( (Topic) destination, durableSubscriptionName, messageSelector.isEmpty() ? null : messageSelector, true);
@Test(timeout = 60000) public void testStealLinkFails() throws Exception { final String clientID = "ThisIsAClientId"; ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory(unstealableConnectionURI); Connection connection1 = factory.createConnection(); connection1.setClientID(clientID); connection1.start(); try { Connection connection2 = factory.createConnection(); connection2.setClientID(clientID); connection2.start(); fail("Should not have been able to steal the link."); } catch (InvalidClientIDException e) { LOG.info("Caught expected error on trying to steal link: {}", e.getMessage()); LOG.trace("Error: ", e); } }
@Override public void init() { try { connection = connectionFactory.createConnection(); connection.setClientID(getId()); connection.start(); senderSession = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); publisherSession = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); } catch (JMSException e) { e.printStackTrace(); } }
@Test public void testWithConnectionFactoryAndClientId() throws JMSException { ConnectionFactory cf = mock(ConnectionFactory.class); Connection con = mock(Connection.class); given(cf.createConnection()).willReturn(con); SingleConnectionFactory scf = new SingleConnectionFactory(cf); scf.setClientId("myId"); Connection con1 = scf.createConnection(); Connection con2 = scf.createConnection(); con1.start(); con2.start(); con1.close(); con2.close(); scf.destroy(); // should trigger actual close verify(con).setClientID("myId"); verify(con).start(); verify(con).stop(); verify(con).close(); verifyNoMoreInteractions(con); }
static TopicSubscriber createDurableSubscriber(final Connection connection, final Topic topic, final String clientID, final String subscriptionName, final int ackMode) throws JMSException { connection.setClientID(clientID); Session s = connection.createSession(false, ackMode); return s.createDurableSubscriber(topic, subscriptionName); }
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}); } } }
@Test(timeout = 5000, expected = JMSException.class) public void testInvalidClientIdSetConnection() throws Exception { Connection con = cf.createConnection(); try { con.setClientID("invalid"); } finally { try { con.close(); } catch (Exception ignored) { } } }
protected Session createSession(Connection connection) throws Exception { if (durable) { connection.setClientID(clientID); } Session session = connection.createSession(transacted, ackMode); if (topic) { destination = session.createTopic(subject); } else { destination = session.createQueue(subject); } return session; }
/** * Manually start the Client. */ public void start() { try { try { connection = connectionFactory.createConnection(); String clientId = getClientId(); if (clientId != null) { connection.setClientID(clientId); } session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); createClient(); } catch (JMSException jmsEx) { throw new RuntimeException("Producer initialization failed" + this.getClass().getSimpleName(), jmsEx); } connection.start(); } catch (JMSException jmsEx) { throw new IllegalStateException("Producer failed to start", jmsEx); } log.info("Ready to produce messages to {}", connectionFactory.getBrokerURL()); }
/** * Connection specific setup for JMS. * * @throws JMSException */ public void createConnection() throws JMSException { connection = getConnectionFactory().createConnection(); if (durable && clientId != null) { connection.setClientID(clientId); } logger.debug("Before starting connection."); connection.start(); logger.debug("After starting connection."); // Create session session = connection.createSession(transacted, getSessionAckMode(ackMode)); // Create destination destination = topic ? session.createTopic(subject) : session.createQueue(subject); }
@Test(timeout = 5000) public void testValidIdSetConnection() throws Exception { Connection con = cf.createConnection(); try { con.setClientID("valid"); con.start(); } finally { con.close(); } }
connection.setClientID(clientId.trim()); connection.start();
@Test public void testInvalidSelectorException() throws Exception { Connection c = createConnection(); c.setClientID("sofiavergara"); Session s = c.createSession(false, Session.AUTO_ACKNOWLEDGE); try { s.createDurableSubscriber(ActiveMQServerTestCase.topic1, "mysubscribption", "=TEST 'test'", true); ProxyAssertSupport.fail("this should fail"); } catch (InvalidSelectorException e) { // OK } }
@Test public void testDurableSubscriptionInvalidUnsubscribe() throws Exception { final String CLIENT_ID1 = "test-client-id1"; Connection conn1 = null; try { conn1 = createConnection(); conn1.setClientID(CLIENT_ID1); Session sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE); try { sess1.unsubscribe("non-existent subscription"); ProxyAssertSupport.fail(); } catch (JMSException e) { } } finally { if (conn1 != null) { conn1.close(); } } }
@Test public void testSetClientID() throws Exception { Connection connection = createConnection(); final String clientID = "my-test-client-id"; connection.setClientID(clientID); ProxyAssertSupport.assertEquals(clientID, connection.getClientID()); Connection connection2 = createConnection(); try { connection2.setClientID(clientID); Assert.fail("setClientID was expected to throw an exception"); } catch (JMSException e) { // expected } connection.close(); connection2.setClientID(clientID); }
final String clientID = "ThisIsAClientId"; ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory(stealableConnectionURI); Connection connection1 = factory.createConnection(); connection1.setClientID(clientID); connection1.start(); Connection connection2 = factory.createConnection(); connection2.setClientID(clientID); connection2.start(); } catch (InvalidClientIDException e) { LOG.info("Should not have failed while stealing the link: {}", e.getMessage());
@Test public void testSetSameIdToDifferentConnections() throws Exception { String id = "somethingElse" + name.getMethodName(); conn = cf.createConnection(); conn2 = cf.createConnection(); conn.getClientID(); conn.setClientID(id); try { conn2.setClientID(id); Assert.fail("should not happen."); } catch (InvalidClientIDException expected) { // expected } Session session1 = conn.createSession(); Session session2 = conn.createSession(); session1.close(); session2.close(); }
private void reconnect() throws Exception { connection = cf.createConnection(); connection.setClientID("cid"); session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); subscriber1 = session.createDurableSubscriber(topic1, "subscriber-1"); subscriber2 = session.createDurableSubscriber(topic1, "subscriber-2"); connection.start(); }
@Override @Before public void setUp() throws Exception { super.setUp(); serverConnection = createConnection(); serverConnection.setClientID("serverConnection:" + name.getMethodName()); serverSession = serverConnection.createSession(false, Session.AUTO_ACKNOWLEDGE); replyProducer = serverSession.createProducer(null); requestDestination = createDestination(serverSession); /* build queues */ System.out.println("Creating consumer on: " + requestDestination); final MessageConsumer requestConsumer = serverSession.createConsumer(requestDestination); if (useAsyncConsume) { requestConsumer.setMessageListener(this); } else { Thread thread = new Thread(new Runnable() { @Override public void run() { syncConsumeLoop(requestConsumer); } }); thread.start(); } serverConnection.start(); }