Example #1
0
  @Test
  public void testCreateTopic() throws Exception {
    liveJMSService.createTopic(true, "topic", "/topic/t1");
    assertNotNull(ctx1.lookup("//topic/t1"));

    ActiveMQConnectionFactory jbcf =
        ActiveMQJMSClient.createConnectionFactoryWithHA(JMSFactoryType.CF, livetc);

    jbcf.setReconnectAttempts(-1);

    Connection conn = null;

    try {
      conn = JMSUtil.createConnectionAndWaitForTopology(jbcf, 2, 5);

      Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);

      ClientSession coreSession = ((ActiveMQSession) sess).getCoreSession();

      JMSUtil.crash(liveService, coreSession);

      assertNotNull(ctx2.lookup("/topic/t1"));
    } finally {
      if (conn != null) {
        conn.close();
      }
    }
  }
Example #2
0
  @Test
  public void testSendReceiveLargeMessages() throws Exception {
    SimpleString QUEUE = new SimpleString("jms.queue.somequeue");

    ActiveMQConnectionFactory jbcf =
        ActiveMQJMSClient.createConnectionFactoryWithHA(JMSFactoryType.CF, livetc, backuptc);
    jbcf.setReconnectAttempts(-1);
    jbcf.setBlockOnDurableSend(true);
    jbcf.setBlockOnNonDurableSend(true);
    jbcf.setMinLargeMessageSize(1024);
    // jbcf.setConsumerWindowSize(0);
    // jbcf.setMinLargeMessageSize(1024);

    final CountDownLatch flagAlign = new CountDownLatch(1);

    final CountDownLatch waitToKill = new CountDownLatch(1);

    final AtomicBoolean killed = new AtomicBoolean(false);

    jbcf.getServerLocator()
        .addIncomingInterceptor(
            new Interceptor() {
              int count = 0;

              @Override
              public boolean intercept(Packet packet, RemotingConnection connection)
                  throws ActiveMQException {

                if (packet instanceof SessionReceiveContinuationMessage) {
                  if (count++ == 300 && !killed.get()) {
                    System.out.println("sending countDown on latch waitToKill");
                    killed.set(true);
                    waitToKill.countDown();
                  }
                }
                return true;
              }
            });

    Connection conn = JMSUtil.createConnectionAndWaitForTopology(jbcf, 2, 5);
    Session sess = conn.createSession(true, Session.SESSION_TRANSACTED);
    final ClientSession coreSession = ((ActiveMQSession) sess).getCoreSession();

    // The thread that will fail the server
    Thread spoilerThread =
        new Thread() {
          public void run() {
            flagAlign.countDown();
            // a large timeout just to help in case of debugging
            try {
              waitToKill.await(120, TimeUnit.SECONDS);
            } catch (Exception e) {
              e.printStackTrace();
            }

            try {
              System.out.println("Killing server...");

              JMSUtil.crash(liveService, coreSession);
            } catch (Exception e) {
              e.printStackTrace();
            }
          }
        };

    coreSession.createQueue(QUEUE, QUEUE, true);

    Queue queue = sess.createQueue("somequeue");

    MessageProducer producer = sess.createProducer(queue);
    producer.setDeliveryMode(DeliveryMode.PERSISTENT);

    for (int i = 0; i < 100; i++) {
      TextMessage message = sess.createTextMessage(new String(new byte[10 * 1024]));
      producer.send(message);

      if (i % 10 == 0) {
        sess.commit();
      }
    }

    sess.commit();

    conn.start();

    spoilerThread.start();

    assertTrue(flagAlign.await(10, TimeUnit.SECONDS));

    MessageConsumer consumer = sess.createConsumer(queue);

    // We won't receive the whole thing here.. we just want to validate if message will arrive or
    // not...
    // this test is not meant to validate transactionality during Failover as that would require XA
    // and recovery
    for (int i = 0; i < 90; i++) {
      TextMessage message = null;

      int retryNrs = 0;
      do {
        retryNrs++;
        try {
          message = (TextMessage) consumer.receive(5000);
          assertNotNull(message);
          break;
        } catch (JMSException e) {
          new Exception("Exception on receive message", e).printStackTrace();
        }
      } while (retryNrs < 10);

      assertNotNull(message);

      try {
        sess.commit();
      } catch (Exception e) {
        new Exception("Exception during commit", e);
        sess.rollback();
      }
    }

    conn.close();

    spoilerThread.join();
  }
Example #3
0
  @Test
  public void testManualFailover() throws Exception {
    ActiveMQConnectionFactory jbcfLive =
        ActiveMQJMSClient.createConnectionFactoryWithoutHA(
            JMSFactoryType.CF, new TransportConfiguration(INVM_CONNECTOR_FACTORY));

    jbcfLive.setBlockOnNonDurableSend(true);
    jbcfLive.setBlockOnDurableSend(true);

    ActiveMQConnectionFactory jbcfBackup =
        ActiveMQJMSClient.createConnectionFactoryWithoutHA(
            JMSFactoryType.CF, new TransportConfiguration(INVM_CONNECTOR_FACTORY, backupParams));
    jbcfBackup.setBlockOnNonDurableSend(true);
    jbcfBackup.setBlockOnDurableSend(true);
    jbcfBackup.setInitialConnectAttempts(-1);
    jbcfBackup.setReconnectAttempts(-1);

    Connection connLive = jbcfLive.createConnection();

    MyExceptionListener listener = new MyExceptionListener();

    connLive.setExceptionListener(listener);

    Session sessLive = connLive.createSession(false, Session.AUTO_ACKNOWLEDGE);

    ClientSession coreSessionLive = ((ActiveMQSession) sessLive).getCoreSession();

    RemotingConnection coreConnLive = ((ClientSessionInternal) coreSessionLive).getConnection();

    SimpleString jmsQueueName =
        new SimpleString(ActiveMQDestination.JMS_QUEUE_ADDRESS_PREFIX + "myqueue");

    coreSessionLive.createQueue(jmsQueueName, jmsQueueName, null, true);

    Queue queue = sessLive.createQueue("myqueue");

    final int numMessages = 1000;

    MessageProducer producerLive = sessLive.createProducer(queue);

    for (int i = 0; i < numMessages; i++) {
      TextMessage tm = sessLive.createTextMessage("message" + i);

      producerLive.send(tm);
    }

    // Note we block on P send to make sure all messages get to server before failover

    JMSUtil.crash(liveService, coreSessionLive);

    connLive.close();

    // Now recreate on backup

    Connection connBackup = jbcfBackup.createConnection();

    Session sessBackup = connBackup.createSession(false, Session.AUTO_ACKNOWLEDGE);

    MessageConsumer consumerBackup = sessBackup.createConsumer(queue);

    connBackup.start();

    for (int i = 0; i < numMessages; i++) {
      TextMessage tm = (TextMessage) consumerBackup.receive(1000);

      Assert.assertNotNull(tm);

      Assert.assertEquals("message" + i, tm.getText());
    }

    TextMessage tm = (TextMessage) consumerBackup.receiveNoWait();

    Assert.assertNull(tm);

    connBackup.close();
  }
Example #4
0
  @Test
  public void testAutomaticFailover() throws Exception {
    ActiveMQConnectionFactory jbcf =
        ActiveMQJMSClient.createConnectionFactoryWithHA(JMSFactoryType.CF, livetc);
    jbcf.setReconnectAttempts(-1);
    jbcf.setBlockOnDurableSend(true);
    jbcf.setBlockOnNonDurableSend(true);

    // Note we set consumer window size to a value so we can verify that consumer credit re-sending
    // works properly on failover
    // The value is small enough that credits will have to be resent several time

    final int numMessages = 10;

    final int bodySize = 1000;

    jbcf.setConsumerWindowSize(numMessages * bodySize / 10);

    Connection conn = JMSUtil.createConnectionAndWaitForTopology(jbcf, 2, 5);

    MyExceptionListener listener = new MyExceptionListener();

    conn.setExceptionListener(listener);

    Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);

    ClientSession coreSession = ((ActiveMQSession) sess).getCoreSession();

    SimpleString jmsQueueName =
        new SimpleString(ActiveMQDestination.JMS_QUEUE_ADDRESS_PREFIX + "myqueue");

    coreSession.createQueue(jmsQueueName, jmsQueueName, null, true);

    Queue queue = sess.createQueue("myqueue");

    MessageProducer producer = sess.createProducer(queue);

    producer.setDeliveryMode(DeliveryMode.PERSISTENT);

    MessageConsumer consumer = sess.createConsumer(queue);

    byte[] body = RandomUtil.randomBytes(bodySize);

    for (int i = 0; i < numMessages; i++) {
      BytesMessage bm = sess.createBytesMessage();

      bm.writeBytes(body);

      producer.send(bm);
    }

    conn.start();

    JMSFailoverTest.log.info("sent messages and started connection");

    Thread.sleep(2000);

    JMSUtil.crash(liveService, ((ActiveMQSession) sess).getCoreSession());

    for (int i = 0; i < numMessages; i++) {
      JMSFailoverTest.log.info("got message " + i);

      BytesMessage bm = (BytesMessage) consumer.receive(1000);

      Assert.assertNotNull(bm);

      Assert.assertEquals(body.length, bm.getBodyLength());
    }

    TextMessage tm = (TextMessage) consumer.receiveNoWait();

    Assert.assertNull(tm);

    conn.close();
  }