@Override public void close() { ServerLocator locator0 = serverLocator; if (locator0 != null) locator0.close(); }
public synchronized DiscoveryGroupConfiguration getDiscoveryGroupConfiguration() { return serverLocator.getDiscoveryGroupConfiguration(); }
public synchronized TransportConfiguration[] getStaticConnectors() { return serverLocator.getStaticTransportConfigurations(); }
public URI toURI() throws IOException { ConnectionFactoryParser parser = new ConnectionFactoryParser(); String scheme; if (serverLocator.getDiscoveryGroupConfiguration() != null) { if (serverLocator.getDiscoveryGroupConfiguration().getBroadcastEndpointFactory() instanceof UDPBroadcastEndpointFactory) { scheme = "udp"; } else { scheme = "jgroups"; } } else { if (serverLocator.allInVM()) { scheme = "vm"; } else { scheme = "tcp"; } } URI uri; try { uri = parser.createSchema(scheme, this); } catch (Exception e) { if (e instanceof IOException) { throw (IOException) e; } throw new IOException(e); } return uri; }
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); session.addFailureListener(listener); session.addFailoverListener(failoverListener); session.start();
TransportConfiguration[] tc = new TransportConfiguration[]{liveTC}; ServerLocator locator = ActiveMQClient.createServerLocatorWithoutHA(tc).setClientFailureCheckPeriod(clientFailureCheckPeriod).setConnectionTTL(connectionTTL).setCallTimeout(callTimeout).setMinLargeMessageSize(minLargeMessageSize).setConsumerWindowSize(consumerWindowSize).setConsumerMaxRate(consumerMaxRate).setConfirmationWindowSize(confirmationWindowSize).setProducerMaxRate(producerMaxRate).setBlockOnAcknowledge(blockOnAcknowledge).setBlockOnDurableSend(blockOnDurableSend).setBlockOnNonDurableSend(blockOnNonDurableSend).setAutoGroup(autoGroup).setPreAcknowledge(preAcknowledge).setConnectionLoadBalancingPolicyClassName(loadBalancingPolicyClassName).setAckBatchSize(ackBatchSize).setUseGlobalPools(useGlobalPools).setScheduledThreadPoolMaxSize(scheduledThreadPoolMaxSize).setThreadPoolMaxSize(threadPoolMaxSize).setRetryInterval(retryInterval).setRetryIntervalMultiplier(retryIntervalMultiplier).setReconnectAttempts(reconnectAttempts); assertEqualsTransportConfigurations(tc, locator.getStaticTransportConfigurations()); Assert.assertEquals(clientFailureCheckPeriod, locator.getClientFailureCheckPeriod()); Assert.assertEquals(connectionTTL, locator.getConnectionTTL()); Assert.assertEquals(callTimeout, locator.getCallTimeout()); Assert.assertEquals(minLargeMessageSize, locator.getMinLargeMessageSize()); Assert.assertEquals(consumerWindowSize, locator.getConsumerWindowSize()); Assert.assertEquals(consumerMaxRate, locator.getConsumerMaxRate()); Assert.assertEquals(confirmationWindowSize, locator.getConfirmationWindowSize()); Assert.assertEquals(producerMaxRate, locator.getProducerMaxRate()); Assert.assertEquals(blockOnAcknowledge, locator.isBlockOnAcknowledge()); Assert.assertEquals(blockOnDurableSend, locator.isBlockOnDurableSend()); Assert.assertEquals(blockOnNonDurableSend, locator.isBlockOnNonDurableSend()); Assert.assertEquals(autoGroup, locator.isAutoGroup()); Assert.assertEquals(preAcknowledge, locator.isPreAcknowledge()); Assert.assertEquals(loadBalancingPolicyClassName, locator.getConnectionLoadBalancingPolicyClassName()); Assert.assertEquals(ackBatchSize, locator.getAckBatchSize()); Assert.assertEquals(useGlobalPools, locator.isUseGlobalPools()); Assert.assertEquals(scheduledThreadPoolMaxSize, locator.getScheduledThreadPoolMaxSize()); Assert.assertEquals(threadPoolMaxSize, locator.getThreadPoolMaxSize()); Assert.assertEquals(retryInterval, locator.getRetryInterval()); Assert.assertEquals(retryIntervalMultiplier, locator.getRetryIntervalMultiplier(), 0.000001); Assert.assertEquals(reconnectAttempts, locator.getReconnectAttempts());
@Test public void testBasicPluginAuthorization() throws Exception { server.start(); ClientSessionFactory cf = locator.createSessionFactory(); String name = "queue1"; try { ClientSession session = cf.createSession("first", "secret", false, true, true, false, 0); session.createQueue(SimpleString.toSimpleString(name), SimpleString.toSimpleString(name)); ClientProducer producer = session.createProducer(); producer.send(name, session.createMessage(false)); session.close(); } catch (ActiveMQException e) { e.printStackTrace(); Assert.fail("should not throw exception"); } cf.close(); }
server.getAddressSettingsRepository().addMatch("#", defaultSetting); server.start(); ServerLocator locator = createInVMNonHALocator().setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true); ClientSession session = addClientSession(factory.createSession(false, true, true)); session.createQueue(MY_ADDRESS, MY_QUEUE, true); ClientProducer producer = addClientProducer(session.createProducer(MY_ADDRESS)); ClientMessage message = session.createMessage(true); message.getBodyBuffer().writeBytes(new byte[1024]); message.putIntProperty("order", i); producer.send(message); session.close(); factory.close(); locator.close(); Queue queue = ((LocalQueueBinding) server.getPostOffice().getBinding(new SimpleString(MY_QUEUE))).getQueue(); LinkedListIterator<MessageReference> totalIterator = queue.browserIterator();
@Test public void testCONSUMER_CLOSED() throws Exception { ClientSessionFactory sf = createSessionFactory(locator); ClientSession mySession = sf.createSession("myUser", "myPassword", false, true, true, locator.isPreAcknowledge(), locator.getAckBatchSize()); mySession.start(); SimpleString queue = RandomUtil.randomSimpleString(); SimpleString address = RandomUtil.randomSimpleString(); boolean durable = RandomUtil.randomBoolean(); mySession.createQueue(address, queue, durable); ClientConsumer consumer = mySession.createConsumer(queue); SimpleString sessionName = SimpleString.toSimpleString(((ClientSessionInternal) mySession).getName()); NotificationTest.flush(notifConsumer); consumer.close(); ClientMessage[] notifications = NotificationTest.consumeMessages(1, notifConsumer); Assert.assertEquals(CONSUMER_CLOSED.toString(), notifications[0].getObjectProperty(ManagementHelper.HDR_NOTIFICATION_TYPE).toString()); Assert.assertEquals(queue.toString(), notifications[0].getObjectProperty(ManagementHelper.HDR_ROUTING_NAME).toString()); Assert.assertEquals(address.toString(), notifications[0].getObjectProperty(ManagementHelper.HDR_ADDRESS).toString()); Assert.assertEquals(0, notifications[0].getObjectProperty(ManagementHelper.HDR_CONSUMER_COUNT)); Assert.assertEquals(SimpleString.toSimpleString("myUser"), notifications[0].getSimpleStringProperty(ManagementHelper.HDR_USER)); Assert.assertEquals(SimpleString.toSimpleString("invm:0"), notifications[0].getSimpleStringProperty(ManagementHelper.HDR_REMOTE_ADDRESS)); Assert.assertEquals(sessionName, notifications[0].getSimpleStringProperty(ManagementHelper.HDR_SESSION_NAME)); session.deleteQueue(queue); }
@Test public void testNoCursors() throws Exception { Configuration config = createDefaultInVMConfig().setJournalSyncNonTransactional(false); server = createServer(true, config, PagingTest.PAGE_SIZE, PagingTest.PAGE_MAX); server.start(); ServerLocator locator = createInVMNonHALocator(); ClientSessionFactory sf = locator.createSessionFactory(); ClientSession session = sf.createSession(); session.createQueue(ADDRESS, ADDRESS, true); ClientProducer prod = session.createProducer(ADDRESS); for (int i = 0; i < 100; i++) { Message msg = session.createMessage(true); msg.toCore().getBodyBuffer().writeBytes(new byte[1024]); prod.send(msg); } session.commit(); session.deleteQueue(ADDRESS); session.close(); sf.close(); locator.close(); server.stop(); server.start(); waitForNotPaging(server.getPagingManager().getPageStore(ADDRESS)); server.stop(); }
server.start(); locator = createInVMNonHALocator().setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true); ClientSession session = sf.createSession(false, true, true); session.createQueue(PagingTest.ADDRESS, RoutingType.MULTICAST, PagingTest.ADDRESS, null, true); ClientProducer producer = session.createProducer(PagingTest.ADDRESS); message = session.createMessage(true); bodyLocal.writeBytes(body); message.putIntProperty(new SimpleString("id"), i); assertTrue(Wait.waitFor(() -> server.getState() == ActiveMQServer.SERVER_STATE.STOPPED, 5000, 200)); session.close(); sf.close(); locator.close();
public void verifyServer() throws Exception { ServerLocator locator; ClientSessionFactory factory; ClientSession session; ActiveMQServer server = PagingWithFailoverServer.createServer(getTestDir(), PORT1, PORT2, false); server.start(); waitForServerToStart(server); Queue queue = server.locateQueue(SimpleString.toSimpleString("cons2")); int messageCount = getMessageCount(queue); assertTrue(messageCount >= 0); locator = SpawnedServerSupport.createLocator(PORT1).setInitialConnectAttempts(100).setReconnectAttempts(300).setRetryInterval(100); factory = locator.createSessionFactory(); session = factory.createSession(); session.start(); try { drainConsumer(session.createConsumer("cons2"), "cons2", messageCount); } finally { session.close(); factory.close(); locator.close(); server.stop(); } }
@Test public void testHeadersSet() throws Exception { final int NUM_MESSAGES = 5; SimpleString ea = new SimpleString("DLA"); SimpleString qName = new SimpleString("q1"); AddressSettings addressSettings = new AddressSettings().setExpiryAddress(ea); server.getAddressSettingsRepository().addMatch(qName.toString(), addressSettings); SimpleString eq = new SimpleString("EA1"); clientSession.createQueue(ea, eq, null, false); clientSession.createQueue(qName, qName, null, false); ServerLocator locator1 = createInVMNonHALocator(); ClientSession sendSession = sessionFactory.createSession(false, true, true); ClientProducer producer = sendSession.createProducer(qName); String text = tm.getBodyBuffer().readString(); Assert.assertEquals("Message:" + i, text); sendSession.close(); locator1.close();
long sleepTime, int destinationMessageCount) throws Exception { SimpleString source = SimpleString.toSimpleString("source"); SimpleString destination = SimpleString.toSimpleString("destination"); server0.createQueue(source, sourceRoutingType, source, null, true, false); server1.createQueue(destination, destinationRoutingType, destination, null, true, false); server0.deployBridge(new BridgeConfiguration() .setRoutingType(bridgeRoutingType) .setName("bridge") .setForwardingAddress(destination.toString()) .setQueueName(source.toString()) .setConfirmationWindowSize(10) ClientSessionFactory sessionFactory = locator.createSessionFactory(); ClientSession session = sessionFactory.createSession(); ClientProducer producer = session.createProducer(source)) { producer.send(session.createMessage(true).setRoutingType(sourceRoutingType));
@Test public void testTotalMessageCount() throws Exception { String random1 = RandomUtil.randomString(); String random2 = RandomUtil.randomString(); ActiveMQServerControl serverControl = createManagementControl(); ServerLocator locator = createInVMNonHALocator(); ClientSessionFactory csf = createSessionFactory(locator); ClientSession session = csf.createSession(); session.createQueue(random1, RoutingType.ANYCAST, random1); session.createQueue(random2, RoutingType.ANYCAST, random2); ClientProducer producer1 = session.createProducer(random1); ClientProducer producer2 = session.createProducer(random2); ClientMessage message = session.createMessage(true); producer1.send(message); producer2.send(message); session.commit(); // flush executors on queues so we can get precise number of messages Queue queue1 = server.locateQueue(SimpleString.toSimpleString(random1)); queue1.flushExecutor(); Queue queue2 = server.locateQueue(SimpleString.toSimpleString(random1)); queue2.flushExecutor(); assertEquals(2, serverControl.getTotalMessageCount()); session.deleteQueue(random1); session.deleteQueue(random2); session.close(); locator.close(); }
protected void scaleDown(ScaleDownHandler handler) throws Exception { SimpleString address = new SimpleString("testQueue"); HashMap<String, Object> params = new HashMap<>(); params.put(TransportConstants.SERVER_ID_PROP_NAME, "2"); server2.start(); server.addAddressInfo(new AddressInfo(address, RoutingType.ANYCAST)); server.createQueue(address, RoutingType.ANYCAST, address, null, true, false, -1, false, false); server2.addAddressInfo(new AddressInfo(address, RoutingType.ANYCAST)); server2.createQueue(address, RoutingType.ANYCAST, address, null, true, false, -1, false, false); ServerLocator locator = createInVMNonHALocator(); ClientSessionFactory csf = createSessionFactory(locator); ClientSession session = csf.createSession(); ClientProducer producer = session.createProducer(address); for (int i = 0; i < 100; i++) { ClientMessage message = session.createMessage(true); message.getBodyBuffer().writeString("m" + i); producer.send(message); locator.close(); locator = addServerLocator(ActiveMQClient.createServerLocatorWithoutHA(new TransportConfiguration(INVM_CONNECTOR_FACTORY, params))); csf = createSessionFactory(locator); session = csf.createSession(); session.start(); ClientConsumer consumer = session.createConsumer(address); for (int i = 0; i < 100; i++) {
final int reconnectAttempts) { if (staticConnectors == null) { Assert.assertTrue("no static connectors", Arrays.equals(new String[]{}, locator.getStaticTransportConfigurations())); } else { assertEqualsTransportConfigurations(staticConnectors, locator.getStaticTransportConfigurations()); Assert.assertEquals(locator.getDiscoveryGroupConfiguration(), discoveryGroupConfiguration); Assert.assertEquals(locator.getClientFailureCheckPeriod(), clientFailureCheckPeriod); Assert.assertEquals(locator.getConnectionTTL(), connectionTTL); Assert.assertEquals(locator.getCallTimeout(), callTimeout); Assert.assertEquals(locator.getMinLargeMessageSize(), minLargeMessageSize); Assert.assertEquals(locator.getConsumerWindowSize(), consumerWindowSize); Assert.assertEquals(locator.getConsumerMaxRate(), consumerMaxRate); Assert.assertEquals(locator.getConfirmationWindowSize(), confirmationWindowSize); Assert.assertEquals(locator.getProducerMaxRate(), producerMaxRate); Assert.assertEquals(locator.isBlockOnAcknowledge(), blockOnAcknowledge); Assert.assertEquals(locator.isBlockOnDurableSend(), blockOnDurableSend); Assert.assertEquals(locator.isBlockOnNonDurableSend(), blockOnNonDurableSend); Assert.assertEquals(locator.isAutoGroup(), autoGroup); Assert.assertEquals(locator.isPreAcknowledge(), preAcknowledge); Assert.assertEquals(locator.getConnectionLoadBalancingPolicyClassName(), loadBalancingPolicyClassName); Assert.assertEquals(locator.getAckBatchSize(), ackBatchSize); Assert.assertEquals(locator.isUseGlobalPools(), useGlobalPools); Assert.assertEquals(locator.getScheduledThreadPoolMaxSize(), scheduledThreadPoolMaxSize); Assert.assertEquals(locator.getThreadPoolMaxSize(), threadPoolMaxSize); Assert.assertEquals(locator.getRetryInterval(), retryInterval); Assert.assertEquals(locator.getRetryIntervalMultiplier(), retryIntervalMultiplier, 0.000001); Assert.assertEquals(locator.getReconnectAttempts(), reconnectAttempts);
@Test public void testProducerWithSmallWindowSizeAndLargeMessage() throws Exception { final CountDownLatch latch = new CountDownLatch(1); server.getRemotingService().addIncomingInterceptor(new Interceptor() { @Override public boolean intercept(final Packet packet, final RemotingConnection connection) throws ActiveMQException { if (packet.getType() == PacketImpl.SESS_SEND) { latch.countDown(); } return true; } }); ServerLocator locator = createInVMNonHALocator().setConfirmationWindowSize(100); ClientSessionFactory cf = locator.createSessionFactory(); ClientSession session = cf.createSession(false, true, true); ClientProducer producer = session.createProducer(QUEUE); ClientMessage message = session.createMessage(true); byte[] body = new byte[1000]; message.getBodyBuffer().writeBytes(body); producer.send(message); Assert.assertTrue(latch.await(5, TimeUnit.SECONDS)); session.close(); locator.close(); }
@Test public void testConcurrentProduceCreateAndDelete() throws Throwable { ClientSessionFactory factory = locator.createSessionFactory(); ClientSession session = factory.createSession(true, true); ClientProducer producer = session.createProducer(ADDRESS); // just to make it page forever Queue serverQueue = server.createQueue(ADDRESS, RoutingType.ANYCAST, SimpleString.toSimpleString("everPage"), null, true, false); serverQueue.getPageSubscription().getPagingStore().startPaging(); Consumer[] consumers = new Consumer[10]; for (int i = 0; i < consumers.length; i++) { consumers[i] = new Consumer(); consumers[i].start(); } for (int i = 0; i < 50000 && running; i++) { producer.send(session.createMessage(true)); //Thread.sleep(10); } session.close(); running = false; for (Consumer consumer : consumers) { consumer.join(); if (consumer.ex != null) { throw consumer.ex; } } }
@Test public void testJAASSecurityManagerAuthenticationBadPassword() throws Exception { server.start(); ClientSessionFactory cf = locator.createSessionFactory(); try { cf.createSession("first", "badpassword", false, true, true, false, 0); Assert.fail("should throw exception here"); } catch (Exception e) { // ignore } cf.close(); }