public synchronized void setClientFailureCheckPeriod(final long clientFailureCheckPeriod) { checkWrite(); serverLocator.setClientFailureCheckPeriod(clientFailureCheckPeriod); }
public synchronized void setClientFailureCheckPeriod(final long clientFailureCheckPeriod) { checkWrite(); serverLocator.setClientFailureCheckPeriod(clientFailureCheckPeriod); }
public synchronized void setClientFailureCheckPeriod(final long clientFailureCheckPeriod) { checkWrite(); serverLocator.setClientFailureCheckPeriod(clientFailureCheckPeriod); }
public synchronized void setClientFailureCheckPeriod(final long clientFailureCheckPeriod) { checkWrite(); serverLocator.setClientFailureCheckPeriod(clientFailureCheckPeriod); }
public synchronized void setClientFailureCheckPeriod(final long clientFailureCheckPeriod) { checkWrite(); serverLocator.setClientFailureCheckPeriod(clientFailureCheckPeriod); }
public static void main(final String[] args) throws Exception { try { CrashClient.log.debug("args = " + Arrays.asList(args)); ServerLocator locator = ActiveMQClient.createServerLocatorWithoutHA(new TransportConfiguration(NettyConnectorFactory.class.getName())); locator.setClientFailureCheckPeriod(ClientCrashTest.PING_PERIOD); locator.setConnectionTTL(ClientCrashTest.CONNECTION_TTL); ClientSessionFactory sf = locator.createSessionFactory(); ClientSession session = sf.createSession(false, true, true); ClientProducer producer = session.createProducer(ClientCrashTest.QUEUE); // it has to be durable otherwise it may race dying before the client is killed ClientMessage message = session.createMessage(ActiveMQTextMessage.TYPE, true, 0, System.currentTimeMillis(), (byte) 1); message.getBodyBuffer().writeString(ClientCrashTest.MESSAGE_TEXT_FROM_CLIENT); producer.send(message); // exit without closing the session properly System.exit(OK); } catch (Throwable t) { CrashClient.log.error(t.getMessage(), t); System.exit(NOT_OK); } }
@Test public void testCloseSessionFactory() throws Exception { ServerLocator locator = createInVMNonHALocator().setReconnectAttempts(-1).setConnectionTTL(1000).setClientFailureCheckPeriod(100).setConsumerWindowSize(10 * 1024 * 1024).setCallTimeout(1000); ClientSessionFactory sf = locator.createSessionFactory(); final CountDownLatch latch = new CountDownLatch(1); sf.addFailoverListener(eventType -> { if (eventType == FailoverEventType.FAILURE_DETECTED) { try { /** * We close client session factory during this period and * expect reconnection stopped without exception which notifies * FAILOVER_FAILED event. See ARTEMIS-1949. */ Thread.sleep(1000L); } catch (InterruptedException e) { e.printStackTrace(); } } else if (eventType == FailoverEventType.FAILOVER_FAILED) { latch.countDown(); } }); server.stop(); Thread.sleep(600); sf.close(); assertTrue(latch.await(1000, TimeUnit.MILLISECONDS)); } }
@Override @Before public void setUp() throws Exception { super.setUp(); locator = createNettyNonHALocator(); addServerLocator(locator); locator.setClientFailureCheckPeriod(ClientCrashTest.PING_PERIOD); locator.setConnectionTTL(ClientCrashTest.CONNECTION_TTL); sf = createSessionFactory(locator); } }
public static void main(final String[] args) throws Exception { try { log.debug("args = " + Arrays.asList(args)); ServerLocator locator = ActiveMQClient.createServerLocatorWithoutHA(new TransportConfiguration(NettyConnectorFactory.class.getName())); locator.setClientFailureCheckPeriod(ClientCrashTest.PING_PERIOD); locator.setConnectionTTL(ClientCrashTest.CONNECTION_TTL); ClientSessionFactory sf = locator.createSessionFactory(); ClientSession session = sf.createSession(true, true, 1000000); ClientProducer producer = session.createProducer(ClientCrashTest.QUEUE2); ClientMessage message = session.createMessage(true); message.getBodyBuffer().writeString(ClientCrashTest.MESSAGE_TEXT_FROM_CLIENT); producer.send(message); //Now consume the message, but don't let ack get to server //Consume the message ClientConsumer cons = session.createConsumer(ClientCrashTest.QUEUE2); session.start(); ClientMessage msg = cons.receive(10000); if (msg == null) { log.error("Didn't receive msg"); System.exit(1); } // exit without closing the session properly System.exit(OK); } catch (Throwable t) { log.error(t.getMessage(), t); System.exit(1); } }
ServerLocator locator = createFactory(isNetty).setClientFailureCheckPeriod(pingPeriod).setRetryInterval(500).setRetryIntervalMultiplier(1d).setReconnectAttempts(-1).setConfirmationWindowSize(1024 * 1024); ClientSessionFactory factory = createSessionFactory(locator);
TransportConfiguration transportConfig = new TransportConfiguration(INVM_CONNECTOR_FACTORY); ServerLocator locator = addServerLocator(ActiveMQClient.createServerLocatorWithoutHA(transportConfig)); locator.setClientFailureCheckPeriod(-1); locator.setConnectionTTL(-1); ClientSessionFactory csf = createSessionFactory(locator);
ServerLocator locator = createNettyNonHALocator(); locator.setClientFailureCheckPeriod(PingTest.CLIENT_FAILURE_CHECK_PERIOD); locator.setConnectionTTL(PingTest.CLIENT_FAILURE_CHECK_PERIOD * 2);
@Test public void testNoCheckFailoverMessage() throws Exception { final int pingPeriod = 1000; ActiveMQServer server = createServer(false, true); server.start(); ClientSessionInternal session = null; try { ServerLocator locator = createFactory(true).setClientFailureCheckPeriod(pingPeriod).setRetryInterval(500).setRetryIntervalMultiplier(1d).setReconnectAttempts(-1).setConfirmationWindowSize(1024 * 1024); locator.setProtocolManagerFactory(new HornetQClientProtocolManagerFactory()); ClientSessionFactory factory = createSessionFactory(locator); session = (ClientSessionInternal) factory.createSession(); server.stop(); Thread.sleep((pingPeriod * 2)); List<String> incomings = server.getConfiguration().getIncomingInterceptorClassNames(); incomings.add(UnsupportedPacketInterceptor.class.getName()); server.start(); //issue a query to make sure session is reconnected. ClientSession.QueueQuery query = session.queueQuery(new SimpleString("anyvalue")); assertFalse(query.isExists()); locator.close(); UnsupportedPacketInterceptor.checkReceivedTypes(); } finally { try { session.close(); } catch (Throwable e) { } server.stop(); } }
for (int i = 0; i < 100; i++) { ServerLocator locator = createFactory(isNetty); locator.setClientFailureCheckPeriod(pingPeriod); locator.setRetryInterval(1); locator.setRetryIntervalMultiplier(1d);
@Test public void testOrder1() throws Throwable { boolean persistentMessages = true; Configuration config = createDefaultInVMConfig().setJournalSyncNonTransactional(false); ActiveMQServer server = createServer(true, config, PAGE_SIZE, PAGE_MAX, new HashMap<String, AddressSettings>()); server.start(); final int messageSize = 1024; final int numberOfMessages = 500; ServerLocator locator = createInVMNonHALocator().setClientFailureCheckPeriod(1000).setConnectionTTL(2000).setReconnectAttempts(0).setBlockOnNonDurableSend(false).setBlockOnDurableSend(false).setBlockOnAcknowledge(false).setConsumerWindowSize(1024 * 1024); ClientSessionFactory sf = createSessionFactory(locator); ClientSession session = sf.createSession(false, false, false); server.addAddressInfo(new AddressInfo(ADDRESS, RoutingType.ANYCAST)); server.createQueue(ADDRESS, RoutingType.ANYCAST, ADDRESS, null, true, false); ClientProducer producer = session.createProducer(PagingTest.ADDRESS); byte[] body = new byte[messageSize]; ByteBuffer bb = ByteBuffer.wrap(body); for (int j = 1; j <= messageSize; j++) { bb.put(getSamplebyte(j)); } for (int i = 0; i < numberOfMessages; i++) { ClientMessage message = session.createMessage(persistentMessages); ActiveMQBuffer bodyLocal = message.getBodyBuffer(); bodyLocal.writeBytes(body); message.putIntProperty(new SimpleString("id"), i); producer.send(message); } session.commit(); session.close(); }
@Test public void testRecreateConsumerOverServerFailure() throws Exception { ServerLocator serverWithReattach = createInVMNonHALocator().setReconnectAttempts(30).setRetryInterval(1000).setConfirmationWindowSize(-1).setConnectionTTL(TemporaryQueueTest.CONNECTION_TTL).setClientFailureCheckPeriod(TemporaryQueueTest.CONNECTION_TTL / 3); ClientSessionFactory reattachSF = createSessionFactory(serverWithReattach); ClientSession session = reattachSF.createSession(false, false); session.createTemporaryQueue("tmpAd", "tmpQ"); ClientConsumer consumer = session.createConsumer("tmpQ"); ClientProducer prod = session.createProducer("tmpAd"); session.start(); RemotingConnectionImpl conn = (RemotingConnectionImpl) ((ClientSessionInternal) session).getConnection(); conn.fail(new ActiveMQIOErrorException()); prod.send(session.createMessage(false)); session.commit(); assertNotNull(consumer.receive(1000)); session.close(); reattachSF.close(); serverWithReattach.close(); }
ServerLocator locator = createInVMNonHALocator().setClientFailureCheckPeriod(120000).setConnectionTTL(5000000).setCallTimeout(120000).setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
ServerLocator locator = createInVMNonHALocator().setClientFailureCheckPeriod(120000).setConnectionTTL(5000000).setCallTimeout(120000).setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
ServerLocator locator = createInVMNonHALocator().setClientFailureCheckPeriod(120000).setConnectionTTL(5000000).setCallTimeout(120000).setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);
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);