boolean isBlockOnAcknowledge = sessionFactory.getServerLocator().isBlockOnAcknowledge(); int ackBatchSize = sessionFactory.getServerLocator().getAckBatchSize(); if (acknowledgeMode == Session.SESSION_TRANSACTED) { session = sessionFactory.createSession(username, password, isXA, false, false, sessionFactory.getServerLocator().isPreAcknowledge(), transactionBatchSize); } else if (acknowledgeMode == Session.AUTO_ACKNOWLEDGE) { session = sessionFactory.createSession(username, password, isXA, true, true, sessionFactory.getServerLocator().isPreAcknowledge(), 0); } else if (acknowledgeMode == Session.DUPS_OK_ACKNOWLEDGE) { session = sessionFactory.createSession(username, password, isXA, true, true, sessionFactory.getServerLocator().isPreAcknowledge(), dupsOKBatchSize); } else if (acknowledgeMode == Session.CLIENT_ACKNOWLEDGE) { session = sessionFactory.createSession(username, password, isXA, true, false, sessionFactory.getServerLocator().isPreAcknowledge(), isBlockOnAcknowledge ? transactionBatchSize : ackBatchSize); } else if (acknowledgeMode == ActiveMQJMSConstants.INDIVIDUAL_ACKNOWLEDGE) { session = sessionFactory.createSession(username, password, isXA, true, false, false, isBlockOnAcknowledge ? transactionBatchSize : ackBatchSize);
@Override public synchronized void handleLargeMessage(final ClientLargeMessageInternal clientLargeMessage, long largeMessageSize) throws Exception { if (closing) { // This is ok - we just ignore the message return; } // Flow control for the first packet, we will have others File largeMessageCache = null; if (session.isCacheLargeMessageClient()) { largeMessageCache = File.createTempFile("tmp-large-message-" + clientLargeMessage.getMessageID() + "-", ".tmp"); largeMessageCache.deleteOnExit(); } ClientSessionFactory sf = session.getSessionFactory(); ServerLocator locator = sf.getServerLocator(); long callTimeout = locator.getCallTimeout(); currentLargeMessageController = new LargeMessageControllerImpl(this, largeMessageSize, callTimeout, largeMessageCache); if (clientLargeMessage.isCompressed()) { clientLargeMessage.setLargeMessageController(new CompressedLargeMessageControllerImpl(currentLargeMessageController)); } else { clientLargeMessage.setLargeMessageController(currentLargeMessageController); } handleRegularMessage(clientLargeMessage); }
ServerLocator locator = sf.getServerLocator(); long callTimeout = locator.getCallTimeout();
private String getTargetNodeId(ClientSessionFactory sessionFactory) { return sessionFactory.getServerLocator().getTopology().getMember(sessionFactory.getConnection()).getNodeId(); }
public void waitForBackupTopologyAnnouncement(ClientSessionFactory sf) throws Exception { long start = System.currentTimeMillis(); ServerLocator locator = sf.getServerLocator(); do { Collection<TopologyMemberImpl> members = locator.getTopology().getMembers(); for (TopologyMemberImpl member : members) { if (member.getBackup() != null) { return; } } Thread.sleep(10); } while (System.currentTimeMillis() - start < ActiveMQTestBase.WAIT_TIMEOUT); throw new IllegalStateException("Timed out waiting for backup announce"); }
@Override protected ClientSession createSession(ClientSessionFactory sf, boolean xa, boolean autoCommitSends, boolean autoCommitAcks) throws Exception { return createSession(sf, xa, autoCommitSends, autoCommitAcks, sf.getServerLocator().getAckBatchSize()); }
@Override protected ClientSession createSession(ClientSessionFactory sf, boolean autoCommitSends, boolean autoCommitAcks) throws Exception { return createSession(sf, autoCommitSends, autoCommitAcks, sf.getServerLocator().getAckBatchSize()); }
@Override protected ClientSession createSession(ClientSessionFactory sf) throws Exception { return createSession(sf, true, true, sf.getServerLocator().getAckBatchSize()); }
protected ClientSession createSession(ClientSessionFactory sf, boolean isXA, boolean autoCommitSends, boolean autoCommitAcks, int ackBatchSize) throws Exception { ClientSession session = sf.createSession("a", "b", isXA, autoCommitSends, autoCommitAcks, sf.getServerLocator().isPreAcknowledge(), ackBatchSize); addClientSession(session); return session; }
@Override protected ClientSession createSession(ClientSessionFactory sf, boolean autoCommitSends, boolean autoCommitAcks, int ackBatchSize) throws Exception { ClientSession session = sf.createSession("a", "b", false, autoCommitSends, autoCommitAcks, sf.getServerLocator().isPreAcknowledge(), ackBatchSize); addClientSession(session); return session; }
@Override public synchronized void handleLargeMessage(final ClientLargeMessageInternal clientLargeMessage, long largeMessageSize) throws Exception { if (closing) { // This is ok - we just ignore the message return; } // Flow control for the first packet, we will have others File largeMessageCache = null; if (session.isCacheLargeMessageClient()) { largeMessageCache = File.createTempFile("tmp-large-message-" + clientLargeMessage.getMessageID() + "-", ".tmp"); largeMessageCache.deleteOnExit(); } ClientSessionFactory sf = session.getSessionFactory(); ServerLocator locator = sf.getServerLocator(); long callTimeout = locator.getCallTimeout(); currentLargeMessageController = new LargeMessageControllerImpl(this, largeMessageSize, callTimeout, largeMessageCache); if (clientLargeMessage.isCompressed()) { clientLargeMessage.setLargeMessageController(new CompressedLargeMessageControllerImpl(currentLargeMessageController)); } else { clientLargeMessage.setLargeMessageController(currentLargeMessageController); } handleRegularMessage(clientLargeMessage); }
@Override public synchronized void handleLargeMessage(final ClientLargeMessageInternal clientLargeMessage, long largeMessageSize) throws Exception { if (closing) { // This is ok - we just ignore the message return; } // Flow control for the first packet, we will have others File largeMessageCache = null; if (session.isCacheLargeMessageClient()) { largeMessageCache = File.createTempFile("tmp-large-message-" + clientLargeMessage.getMessageID() + "-", ".tmp"); largeMessageCache.deleteOnExit(); } ClientSessionFactory sf = session.getSessionFactory(); ServerLocator locator = sf.getServerLocator(); long callTimeout = locator.getCallTimeout(); currentLargeMessageController = new LargeMessageControllerImpl(this, largeMessageSize, callTimeout, largeMessageCache); if (clientLargeMessage.isCompressed()) { clientLargeMessage.setLargeMessageController(new CompressedLargeMessageControllerImpl(currentLargeMessageController)); } else { clientLargeMessage.setLargeMessageController(currentLargeMessageController); } handleRegularMessage(clientLargeMessage); }
@Override public synchronized void handleLargeMessage(final ClientLargeMessageInternal clientLargeMessage, long largeMessageSize) throws Exception { if (closing) { // This is ok - we just ignore the message return; } // Flow control for the first packet, we will have others File largeMessageCache = null; if (session.isCacheLargeMessageClient()) { largeMessageCache = File.createTempFile("tmp-large-message-" + clientLargeMessage.getMessageID() + "-", ".tmp"); largeMessageCache.deleteOnExit(); } ClientSessionFactory sf = session.getSessionFactory(); ServerLocator locator = sf.getServerLocator(); long callTimeout = locator.getCallTimeout(); currentLargeMessageController = new LargeMessageControllerImpl(this, largeMessageSize, callTimeout, largeMessageCache); if (clientLargeMessage.isCompressed()) { clientLargeMessage.setLargeMessageController(new CompressedLargeMessageControllerImpl(currentLargeMessageController)); } else { clientLargeMessage.setLargeMessageController(currentLargeMessageController); } handleRegularMessage(clientLargeMessage); }
@Test public void testCreateProducer1() throws Exception { ClientProducer producer = clientSession.createProducer("testAddress"); Assert.assertNotNull(producer.getAddress()); Assert.assertEquals(cf.getServerLocator().getProducerMaxRate(), producer.getMaxRate()); Assert.assertEquals(cf.getServerLocator().isBlockOnNonDurableSend(), producer.isBlockOnNonDurableSend()); Assert.assertEquals(cf.getServerLocator().isBlockOnDurableSend(), producer.isBlockOnDurableSend()); Assert.assertFalse(producer.isClosed()); }
@Test public void testCreateAnonProducer() throws Exception { ClientProducer producer = clientSession.createProducer(); Assert.assertNull(producer.getAddress()); Assert.assertEquals(cf.getServerLocator().getProducerMaxRate(), producer.getMaxRate()); Assert.assertEquals(cf.getServerLocator().isBlockOnNonDurableSend(), producer.isBlockOnNonDurableSend()); Assert.assertEquals(cf.getServerLocator().isBlockOnDurableSend(), producer.isBlockOnDurableSend()); Assert.assertFalse(producer.isClosed()); }
@Test public void testConnectIntoNonBackup() throws Exception { setupServer(false); try { ClientSessionFactory sf = createSessionFactory(locator); manager = new ReplicationManager((CoreRemotingConnection) sf.getConnection(), sf.getServerLocator().getCallTimeout(), sf.getServerLocator().getCallTimeout(), factory); addActiveMQComponent(manager); manager.start(); Assert.fail("Exception was expected"); } catch (ActiveMQNotConnectedException nce) { // ok } catch (ActiveMQException expected) { fail("Invalid Exception type:" + expected.getType()); } }
@Test public void testSynchronousClose() throws Exception { Assert.assertEquals(0, server.getActiveMQServerControl().listRemoteAddresses().length); ClientSessionFactory sf = createSessionFactory(); for (int i = 0; i < 2000; i++) { ClientSession session = sf.createSession(false, true, true); session.close(); } sf.close(); sf.getServerLocator().close(); } }
@Test public void testClientInterceptorRejectPacket() throws Exception { ClientSessionFactory sf = createSessionFactory(locator); MyInterceptor4 interceptor = new MyInterceptor4(); sf.getServerLocator().addIncomingInterceptor(interceptor); ClientSession session = sf.createSession(false, true, true, true); session.createQueue(QUEUE, QUEUE, null, false); ClientProducer producer = session.createProducer(QUEUE); final int numMessages = 10; for (int i = 0; i < numMessages; i++) { ClientMessage message = session.createMessage(false); producer.send(message); } ClientConsumer consumer = session.createConsumer(QUEUE); session.start(); ClientMessage message = consumer.receive(100); Assert.assertNull(message); session.close(); }
@Test public void testClientOutgoingInterceptorRejectPacketOnBlockingSend() throws Exception { // must make the call block to exercise the right logic locator.setBlockOnNonDurableSend(true); ClientSessionFactory sf = createSessionFactory(locator); MyOutgoingInterceptor4 interceptor = new MyOutgoingInterceptor4(); sf.getServerLocator().addOutgoingInterceptor(interceptor); ClientSession session = sf.createSession(false, true, true, true); session.createQueue(QUEUE, QUEUE, null, false); ClientProducer producer = session.createProducer(QUEUE); ClientMessage message = session.createMessage(false); try { producer.send(message); Assert.fail(); } catch (ActiveMQException e) { // expected exception Assert.assertTrue(e.getType().getCode() == ActiveMQExceptionType.INTERCEPTOR_REJECTED_PACKET.getCode()); } }
@Test public void testClientOutgoingInterceptorRejectPacketOnNonBlockingSend() throws Exception { locator.setBlockOnNonDurableSend(false); ClientSessionFactory sf = createSessionFactory(locator); MyOutgoingInterceptor4 interceptor = new MyOutgoingInterceptor4(); sf.getServerLocator().addOutgoingInterceptor(interceptor); ClientSession session = sf.createSession(false, true, true, true); session.createQueue(QUEUE, QUEUE, null, false); ClientProducer producer = session.createProducer(QUEUE); final int numMessages = 10; for (int i = 0; i < numMessages; i++) { ClientMessage message = session.createMessage(false); producer.send(message); } ClientConsumer consumer = session.createConsumer(QUEUE); session.start(); ClientMessage message = consumer.receive(100); Assert.assertNull(message); session.close(); }