/**
   * Basic fail-back test.
   *
   * @throws Exception
   */
  @Test
  public void testFailBack() throws Exception {
    createSessionFactory();
    ClientSession session = sendAndConsume(sf, true);

    ClientProducer producer = session.createProducer(FailoverTestBase.ADDRESS);

    sendMessages(session, producer, NUM_MESSAGES);
    session.commit();

    crash(session);

    session.start();
    ClientConsumer consumer = session.createConsumer(FailoverTestBase.ADDRESS);
    receiveMessages(consumer, 0, NUM_MESSAGES, true);
    producer = session.createProducer(FailoverTestBase.ADDRESS);
    sendMessages(session, producer, 2 * NUM_MESSAGES);
    session.commit();
    assertFalse("must NOT be a backup", liveServer.getServer().getConfiguration().isBackup());
    adaptLiveConfigForReplicatedFailBack(liveServer.getServer().getConfiguration());

    CountDownSessionFailureListener listener = new CountDownSessionFailureListener();
    session.addFailureListener(listener);

    liveServer.start();

    assertTrue(listener.getLatch().await(5, TimeUnit.SECONDS));
    assertTrue(
        "live initialized after restart",
        liveServer.getServer().waitForActivation(15, TimeUnit.SECONDS));

    session.start();
    receiveMessages(consumer, 0, NUM_MESSAGES, true);
  }
  public void testCommitPreparedTransactions() throws Exception {
    SimpleString recQueue = new SimpleString("BasicXaTestqRec");
    SimpleString sendQueue = new SimpleString("BasicXaTestqSend");

    byte[] globalTransactionId = UUIDGenerator.getInstance().generateStringUUID().getBytes();
    Xid xid = new XidImpl("xa1".getBytes(), 1, globalTransactionId);
    Xid xid2 = new XidImpl("xa2".getBytes(), 1, globalTransactionId);
    ServerLocator locator =
        HornetQClient.createServerLocatorWithoutHA(
            new TransportConfiguration(UnitTestCase.INVM_CONNECTOR_FACTORY));
    ClientSessionFactory csf = locator.createSessionFactory();
    ClientSession clientSession = csf.createSession(true, false, false);
    clientSession.createQueue(recQueue, recQueue, null, true);
    clientSession.createQueue(sendQueue, sendQueue, null, true);
    ClientMessage m1 = createTextMessage(clientSession, "");
    m1.putStringProperty("m1", "m1");
    ClientProducer clientProducer = clientSession.createProducer(recQueue);
    clientProducer.send(m1);
    locator.close();

    ServerLocator receiveLocator =
        HornetQClient.createServerLocatorWithoutHA(
            new TransportConfiguration(UnitTestCase.INVM_CONNECTOR_FACTORY));
    ClientSessionFactory receiveCsf = receiveLocator.createSessionFactory();
    ClientSession receiveClientSession = receiveCsf.createSession(true, false, false);
    ClientConsumer consumer = receiveClientSession.createConsumer(recQueue);

    ServerLocator sendLocator =
        HornetQClient.createServerLocatorWithoutHA(
            new TransportConfiguration(UnitTestCase.INVM_CONNECTOR_FACTORY));
    ClientSessionFactory sendCsf = sendLocator.createSessionFactory();
    ClientSession sendClientSession = sendCsf.createSession(true, false, false);
    ClientProducer producer = sendClientSession.createProducer(sendQueue);

    receiveClientSession.start(xid, XAResource.TMNOFLAGS);
    receiveClientSession.start();
    sendClientSession.start(xid2, XAResource.TMNOFLAGS);

    ClientMessage m = consumer.receive(5000);
    assertNotNull(m);

    producer.send(m);

    receiveClientSession.end(xid, XAResource.TMSUCCESS);
    sendClientSession.end(xid2, XAResource.TMSUCCESS);

    receiveClientSession.prepare(xid);
    sendClientSession.prepare(xid2);

    HornetQServerControl serverControl = createManagementControl();

    sendLocator.close();
    receiveLocator.close();

    boolean success = serverControl.commitPreparedTransaction(XidImpl.toBase64String(xid));

    success = serverControl.commitPreparedTransaction(XidImpl.toBase64String(xid));

    System.out.println("HornetQServerControlTest.testCommitPreparedTransactions");
  }
Esempio n. 3
0
  /**
   * Connects to the yamcs server. This method blocks until a connection is established or some
   * error has occurred, thus this should be called in a separate thread. Hornetq will try
   * indefinitely to establish the connection and also provides automatic re-connection afterwards.
   *
   * @throws Exception if the hornetq session could not be established due to some error
   */
  public void connect() throws Exception {
    for (ConnectionListener cl : connectionListeners) {
      cl.connecting(connParams.getUrl());
    }

    Map<String, Object> tcpConfig = new HashMap<String, Object>();
    tcpConfig.put(TransportConstants.HOST_PROP_NAME, connParams.host);
    tcpConfig.put(TransportConstants.PORT_PROP_NAME, connParams.port);

    locator =
        HornetQClient.createServerLocatorWithoutHA(
            new TransportConfiguration(NettyConnectorFactory.class.getName(), tcpConfig));

    locator.setInitialConnectAttempts(initialConnectAttempts);
    locator.setReconnectAttempts(reconnectAttempts);
    locator.setRetryInterval(retryInterval);
    locator.setRetryIntervalMultiplier(retryIntervalMultiplier);
    locator.setMaxRetryInterval(maxRetryInterval);
    locator.setAckBatchSize(ackBatchSize);

    sessionFactory = locator.createSessionFactory();

    // TODO Use hornetq auth (like YamcsConnector), or keep anonymous connection?
    session = sessionFactory.createSession(false, true, true, preAcknowledge);
    session.addFailureListener(YamcsAckConnector.this);
    session.start();

    for (ConnectionListener cl : connectionListeners) {
      cl.connected(connParams.getUrl());
    }
  }
Esempio n. 4
0
  private void receiveMessages() throws Exception {
    ClientSession session = sf.createSession(true, true);
    session.start();
    ClientConsumer consumer = session.createConsumer(ADDRESS);
    for (int i = 0; i < numMessages; i++) {
      ClientMessage message = consumer.receive(100);
      assertNotNull("Expecting a message " + i, message);
      assertMessageBody(i, message);
      assertEquals(i, message.getIntProperty("int").intValue());
      assertEquals((short) i, message.getShortProperty("short").shortValue());
      assertEquals((byte) i, message.getByteProperty("byte").byteValue());
      assertEquals(floatValue(i), message.getFloatProperty("float").floatValue(), 0.001);
      assertEquals(
          new SimpleString(Integer.toString(i)),
          message.getSimpleStringProperty(SIMPLE_STRING_KEY.toString()));
      assertEqualsByteArrays(byteArray(i), message.getBytesProperty("byte[]"));

      assertTrue(message.containsProperty("null-value"));
      assertEquals(message.getObjectProperty("null-value"), null);

      message.acknowledge();
    }
    assertNull("no more messages", consumer.receive(50));
    consumer.close();
    session.commit();
  }
Esempio n. 5
0
      @Override
      public void run() {
        ClientSession session = null;
        latchReady.countDown();
        try {
          UnitTestCase.waitForLatch(latchStart);
          session = sf.createSession(true, true);
          session.start();
          ClientConsumer cons = session.createConsumer(CompactingStressTest.Q2);
          for (int i = 0; i < NUMBER_OF_FAST_MESSAGES; i++) {
            ClientMessage msg = cons.receive(60 * 1000);
            msg.acknowledge();
          }

          Assert.assertNull(cons.receiveImmediate());
        } catch (Throwable e) {
          this.e = e;
        } finally {
          try {
            session.close();
          } catch (Throwable e) {
            this.e = e;
          }
        }
      }
  /**
   * Remove any old message queues that have a 0 message count in them. This lets us not worry about
   * changing around the registered listeners.
   */
  private void cleanupOldQueues() {
    log.debug("Cleaning old message queues");
    try {
      String[] queues = hornetqServer.getHornetQServer().getHornetQServerControl().getQueueNames();

      ServerLocator locator =
          HornetQClient.createServerLocatorWithoutHA(
              new TransportConfiguration(InVMConnectorFactory.class.getName()));

      ClientSessionFactory factory = locator.createSessionFactory();
      ClientSession session = factory.createSession(true, true);
      session.start();

      for (int i = 0; i < queues.length; i++) {
        long msgCount = session.queueQuery(new SimpleString(queues[i])).getMessageCount();
        if (msgCount == 0) {
          log.debug(String.format("found queue '%s' with 0 messages. deleting", queues[i]));
          session.deleteQueue(queues[i]);
        } else {
          log.debug(String.format("found queue '%s' with %d messages. kept", queues[i], msgCount));
        }
      }

      session.stop();
      session.close();
    } catch (HornetQException e) {
      log.error("Problem cleaning old message queues:", e);
      throw new RuntimeException(e);
    } catch (Exception e) {
      log.error("Problem cleaning old message queues:", e);
      throw new RuntimeException(e);
    }
  }
Esempio n. 7
0
  public void testConsumerAckImmediateAutoCommitFalse() throws Exception {

    ClientSessionFactory sf = createSessionFactory(locator);

    ClientSession session = sf.createSession(false, true, false, true);

    session.createQueue(QUEUE, QUEUE, null, false);

    ClientProducer producer = session.createProducer(QUEUE);

    final int numMessages = 100;

    for (int i = 0; i < numMessages; i++) {
      ClientMessage message = createTextMessage(session, "m" + i);
      producer.send(message);
    }

    ClientConsumer consumer = session.createConsumer(QUEUE);
    session.start();
    for (int i = 0; i < numMessages; i++) {
      ClientMessage message2 = consumer.receive(1000);

      Assert.assertEquals("m" + i, message2.getBodyBuffer().readString());
    }
    // assert that all the messages are there and none have been acked
    Assert.assertEquals(
        0, ((Queue) server.getPostOffice().getBinding(QUEUE).getBindable()).getDeliveringCount());
    Assert.assertEquals(
        0, ((Queue) server.getPostOffice().getBinding(QUEUE).getBindable()).getMessageCount());

    session.close();
  }
Esempio n. 8
0
  public void testRestartJournal() throws Throwable {
    runExternalProcess(0, JournalCrashTest.FIRST_RUN);
    runExternalProcess(JournalCrashTest.FIRST_RUN, JournalCrashTest.SECOND_RUN);
    runExternalProcess(JournalCrashTest.SECOND_RUN, JournalCrashTest.THIRD_RUN);
    runExternalProcess(JournalCrashTest.THIRD_RUN, JournalCrashTest.FOURTH_RUN);

    printJournal();

    ClientSession session = null;
    try {
      startServer();

      session = factory.createSession(true, true);
      ClientConsumer consumer = session.createConsumer(QUEUE);
      session.start();

      for (int i = 0; i < JournalCrashTest.FOURTH_RUN; i++) {
        ClientMessage msg = consumer.receive(5000);

        Assert.assertNotNull("Msg at " + i, msg);

        msg.acknowledge();

        Assert.assertEquals(i, msg.getObjectProperty(new SimpleString("key")));
      }
      session.close();
    } finally {
      try {
        session.close();
      } catch (Throwable ignored) {
      }
    }
  }
Esempio n. 9
0
  // https://jira.jboss.org/browse/HORNETQ-410
  public void testConsumeWithNoConsumerFlowControl() throws Exception {

    ServerLocator locator = createInVMNonHALocator();

    locator.setConsumerWindowSize(-1);

    ClientSessionFactory sf = createSessionFactory(locator);

    ClientSession session = sf.createSession(false, true, true);

    session.createQueue(QUEUE, QUEUE, null, false);

    session.start();

    ClientProducer producer = session.createProducer(QUEUE);

    final int numMessages = 100;

    for (int i = 0; i < numMessages; i++) {
      ClientMessage message = createTextMessage(session, "m" + i);
      producer.send(message);
    }

    ClientConsumer consumer = session.createConsumer(QUEUE);

    for (int i = 0; i < numMessages; i++) {
      ClientMessage message = consumer.receive(10000);
      assertNotNull(message);
      message.acknowledge();
    }

    session.close();
    sf.close();
    locator.close();
  }
Esempio n. 10
0
  private void drainQueue() throws Exception {
    PerfBase.log.info("Draining queue");

    ClientSession session = null;

    try {
      session = factory.createSession();

      ClientConsumer consumer = session.createConsumer(perfParams.getQueueName());

      session.start();

      ClientMessage message = null;

      int count = 0;
      do {
        message = consumer.receive(3000);

        if (message != null) {
          message.acknowledge();

          count++;
        }
      } while (message != null);

      PerfBase.log.info("Drained " + count + " messages");
    } finally {
      if (session != null) {
        session.close();
      }
    }
  }
  public void testSSL() throws Exception {
    String text = RandomUtil.randomString();

    tc.getParams().put(TransportConstants.SSL_ENABLED_PROP_NAME, true);
    tc.getParams()
        .put(TransportConstants.KEYSTORE_PATH_PROP_NAME, TransportConstants.DEFAULT_KEYSTORE_PATH);
    tc.getParams()
        .put(
            TransportConstants.KEYSTORE_PASSWORD_PROP_NAME,
            TransportConstants.DEFAULT_KEYSTORE_PASSWORD);

    ServerLocator locator = addServerLocator(HornetQClient.createServerLocatorWithoutHA(tc));
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, true);
    session.createQueue(CoreClientOverSSLTest.QUEUE, CoreClientOverSSLTest.QUEUE, false);
    ClientProducer producer = session.createProducer(CoreClientOverSSLTest.QUEUE);

    ClientMessage message = createTextMessage(session, text);
    producer.send(message);

    ClientConsumer consumer = session.createConsumer(CoreClientOverSSLTest.QUEUE);
    session.start();

    Message m = consumer.receive(1000);
    Assert.assertNotNull(m);
    Assert.assertEquals(text, m.getBodyBuffer().readString());
  }
Esempio n. 12
0
  /**
   * Setup the activation
   *
   * @throws Exception Thrown if an error occurs
   */
  protected synchronized void setup() throws Exception {
    HornetQRALogger.LOGGER.debug("Setting up " + spec);

    setupCF();

    setupDestination();
    for (int i = 0; i < spec.getMaxSession(); i++) {
      ClientSession session = null;

      try {
        ClientSessionFactory cf = factory.getServerLocator().createSessionFactory();
        session = setupSession(cf);
        HornetQMessageHandler handler =
            new HornetQMessageHandler(this, ra.getTM(), (ClientSessionInternal) session, cf, i);
        handler.setup();
        session.start();
        handlers.add(handler);
      } catch (Exception e) {
        if (session != null) {
          session.close();
        }

        throw e;
      }
    }

    resourceRecovery =
        ra.getRecoveryManager().register(factory, spec.getUser(), spec.getPassword());

    HornetQRALogger.LOGGER.debug("Setup complete " + this);
  }
Esempio n. 13
0
  // An exception during delivery shouldn't make the message disappear
  @Test
  public void testExceptionWhileDelivering() throws Exception {
    queue = server.createQueue(QUEUE, QUEUE, null, true, false);

    HangInterceptor hangInt = new HangInterceptor();
    try {
      locator.addInterceptor(hangInt);

      ClientSessionFactory factory = locator.createSessionFactory();
      ClientSession session = factory.createSession(false, false, false);

      ClientProducer producer = session.createProducer(QUEUE);

      ClientConsumer consumer = session.createConsumer(QUEUE);

      producer.send(session.createMessage(true));
      session.commit();

      hangInt.close();

      session.start();

      Assert.assertTrue(hangInt.reusableLatch.await(10, TimeUnit.SECONDS));

      hangInt.pendingException = new HornetQException();

      hangInt.open();

      session.close();

      session = factory.createSession(false, false);
      session.start();

      consumer = session.createConsumer(QUEUE);

      ClientMessage msg = consumer.receive(5000);
      Assert.assertNotNull(msg);
      msg.acknowledge();

      session.commit();
    } finally {
      hangInt.open();
    }
  }
Esempio n. 14
0
  @Test
  public void testLargeMessageCompression2() throws Exception {
    final int messageSize = (int) (3.5 * HornetQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE);

    HornetQServer server = createServer(true, isNetty());

    server.start();

    ClientSessionFactory sf = createSessionFactory(locator);

    ClientSession session = addClientSession(sf.createSession(false, false, false));

    session.createTemporaryQueue(ADDRESS, ADDRESS);

    ClientProducer producer = session.createProducer(ADDRESS);

    Message clientFile = createLargeClientMessageStreaming(session, messageSize, true);

    producer.send(clientFile);

    session.commit();

    session.start();

    ClientConsumer consumer = session.createConsumer(ADDRESS);
    ClientMessage msg1 = consumer.receive(1000);
    Assert.assertNotNull(msg1);

    String testDir = getTestDir();
    File testFile = new File(testDir, "async_large_message");
    FileOutputStream output = new FileOutputStream(testFile);

    msg1.setOutputStream(output);

    msg1.waitOutputStreamCompletion(0);

    msg1.acknowledge();

    output.close();

    session.commit();

    consumer.close();

    session.close();

    // verify
    FileInputStream input = new FileInputStream(testFile);
    for (int i = 0; i < messageSize; i++) {
      byte b = (byte) input.read();
      assertEquals("position = " + i, getSamplebyte(i), b);
    }
    input.close();
    testFile.delete();
    validateNoFilesOnLargeDir();
  }
 public MessageProducer(String addressName, ClientSessionFactory factory) {
   this.addressName = addressName;
   try {
     producerSession = factory.createSession(true, true);
     producer = producerSession.createProducer(addressName);
     producerSession.start();
   } catch (HornetQException ex) {
     Logger.getLogger(MessageProducer.class.getName()).log(Level.SEVERE, null, ex);
   }
 }
Esempio n. 16
0
  @Test
  public void testDelayedRedeliveryDefaultOnRollback() throws Exception {
    ClientSessionFactory sessionFactory = createSessionFactory(locator);
    ClientSession session = sessionFactory.createSession(false, false, false);

    session.createQueue(qName, qName, null, true);
    session.close();

    ClientSession session1 = sessionFactory.createSession(false, true, true);
    ClientProducer producer = session1.createProducer(qName);

    final int NUM_MESSAGES = 5;

    for (int i = 0; i < NUM_MESSAGES; i++) {
      ClientMessage tm = createDurableMessage(session1, "message" + i);
      producer.send(tm);
    }
    session1.close();

    ClientSession session2 = sessionFactory.createSession(false, false, false);
    ClientConsumer consumer2 = session2.createConsumer(qName);

    session2.start();

    for (int i = 0; i < NUM_MESSAGES; i++) {
      ClientMessage tm = consumer2.receive(500);
      Assert.assertNotNull(tm);
      Assert.assertEquals("message" + i, tm.getBodyBuffer().readString());
    }

    // Now rollback
    long now = System.currentTimeMillis();

    session2.rollback();

    // This should redeliver with a delayed redelivery

    for (int i = 0; i < NUM_MESSAGES; i++) {
      ClientMessage tm = consumer2.receive(DelayedMessageTest.DELAY + 1000);
      Assert.assertNotNull(tm);

      long time = System.currentTimeMillis();

      Assert.assertTrue(time - now >= DelayedMessageTest.DELAY);

      // Hudson can introduce a large degree of indeterminism
      Assert.assertTrue(
          time - now + ">" + (DelayedMessageTest.DELAY + 1000),
          time - now < DelayedMessageTest.DELAY + 1000);
    }

    session2.commit();
    session2.close();
  }
Esempio n. 17
0
  @Test
  public void testSendPacketsWithFailure() throws Exception {
    final int nMsg = 100;
    final int stop = 37;
    setupServer(true, TestInterceptor.class.getName());

    manager = liveServer.getReplicationManager();
    waitForComponent(manager);
    ClientSessionFactory sf = createSessionFactory(locator);
    final ClientSession session = sf.createSession();
    final ClientSession session2 = sf.createSession();
    session.createQueue(ADDRESS, ADDRESS, null, true);

    final ClientProducer producer = session.createProducer(ADDRESS);

    session.start();
    session2.start();
    try {
      final ClientConsumer consumer = session2.createConsumer(ADDRESS);
      for (int i = 0; i < nMsg; i++) {

        ClientMessage message = session.createMessage(true);
        setBody(i, message);
        message.putIntProperty("counter", i);
        producer.send(message);
        if (i == stop) {
          // Now we start intercepting the communication with the backup
          TestInterceptor.value.set(false);
        }
        ClientMessage msgRcvd = consumer.receive(1000);
        Assert.assertNotNull("Message should exist!", msgRcvd);
        assertMessageBody(i, msgRcvd);
        Assert.assertEquals(i, msgRcvd.getIntProperty("counter").intValue());
        msgRcvd.acknowledge();
      }
    } finally {
      TestInterceptor.value.set(false);
      if (!session.isClosed()) session.close();
      if (!session2.isClosed()) session2.close();
    }
  }
Esempio n. 18
0
 private void init() throws YamcsApiException {
   try {
     String username = null;
     String password = null;
     if (invm) {
       locator =
           HornetQClient.createServerLocatorWithoutHA(
               new TransportConfiguration(Protocol.IN_VM_FACTORY));
       sessionFactory = locator.createSessionFactory();
       username = hornetqInvmUser;
       password = hornetqInvmPass;
     } else {
       if (ycd.host != null) {
         Map<String, Object> tcpConfig = new HashMap<String, Object>();
         tcpConfig.put(TransportConstants.HOST_PROP_NAME, ycd.host);
         tcpConfig.put(TransportConstants.PORT_PROP_NAME, ycd.port);
         locator =
             HornetQClient.createServerLocatorWithoutHA(
                 new TransportConfiguration(NettyConnectorFactory.class.getName(), tcpConfig));
         sessionFactory = locator.createSessionFactory();
       } else {
         locator =
             HornetQClient.createServerLocatorWithoutHA(
                 new TransportConfiguration(NettyConnectorFactory.class.getName()));
         sessionFactory = locator.createSessionFactory();
       }
       username = ycd.username;
       password = ycd.password;
     }
     // All sessions are authenticated, a null username translates to
     // guest auth and authz (if allowed by server)
     session =
         sessionFactory.createSession(username, password, false, true, true, preAcknowledge, 1);
     session.start();
   } catch (HornetQException e) {
     // Pass specific HornetQExceptions as our cause, helps identify
     // permissions problems
     try {
       close();
     } catch (HornetQException e1) {
     }
     throw new YamcsApiException(e.getMessage(), e);
   } catch (Exception e) {
     // Pass Exception's cause as our cause.
     System.out.println(e);
     // close everything
     try {
       close();
     } catch (HornetQException e1) {
     }
     throw new YamcsApiException(e.getMessage(), e.getCause());
   }
 }
  @Test
  public void testSessionClosedOnRemotingConnectionFailure() throws Exception {
    ClientSession session = addClientSession(sf.createSession());

    session.createQueue("fooaddress", "fooqueue");

    ClientProducer prod = session.createProducer("fooaddress");

    ClientConsumer cons = session.createConsumer("fooqueue");

    session.start();

    prod.send(session.createMessage(false));

    Assert.assertNotNull(cons.receive());

    // Now fail the underlying connection

    RemotingConnection connection = ((ClientSessionInternal) session).getConnection();

    connection.fail(new HornetQNotConnectedException());

    Assert.assertTrue(session.isClosed());

    Assert.assertTrue(prod.isClosed());

    Assert.assertTrue(cons.isClosed());

    // Now try and use the producer

    try {
      prod.send(session.createMessage(false));

      Assert.fail("Should throw exception");
    } catch (HornetQObjectClosedException oce) {
      // ok
    } catch (HornetQException e) {
      fail("Invalid Exception type:" + e.getType());
    }

    try {
      cons.receive();

      Assert.fail("Should throw exception");
    } catch (HornetQObjectClosedException oce) {
      // ok
    } catch (HornetQException e) {
      fail("Invalid Exception type:" + e.getType());
    }

    session.close();
  }
Esempio n. 20
0
  public void testAcksWithSmallSendWindow() throws Exception {
    ClientSessionFactory sf = createSessionFactory(locator);

    ClientSession session = sf.createSession(false, true, true);

    session.createQueue(QUEUE, QUEUE, null, false);

    ClientProducer producer = session.createProducer(QUEUE);

    final int numMessages = 10000;

    for (int i = 0; i < numMessages; i++) {
      ClientMessage message = createTextMessage(session, "m" + i);
      producer.send(message);
    }
    session.close();
    sf.close();
    final CountDownLatch latch = new CountDownLatch(numMessages);
    server
        .getRemotingService()
        .addInterceptor(
            new Interceptor() {
              public boolean intercept(final Packet packet, final RemotingConnection connection)
                  throws HornetQException {
                if (packet.getType() == PacketImpl.SESS_ACKNOWLEDGE) {
                  latch.countDown();
                }
                return true;
              }
            });
    ServerLocator locator = createInVMNonHALocator();
    locator.setConfirmationWindowSize(100);
    locator.setAckBatchSize(-1);
    ClientSessionFactory sfReceive = createSessionFactory(locator);
    ClientSession sessionRec = sfReceive.createSession(false, true, true);
    ClientConsumer consumer = sessionRec.createConsumer(QUEUE);
    consumer.setMessageHandler(
        new MessageHandler() {
          public void onMessage(final ClientMessage message) {
            try {
              message.acknowledge();
            } catch (HornetQException e) {
              e.printStackTrace();
            }
          }
        });
    sessionRec.start();
    Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
    sessionRec.close();
    locator.close();
  }
Esempio n. 21
0
  @Test
  public void testMultipleMessagesAfterRecovery() throws Exception {
    Xid xid = new XidImpl("bq1".getBytes(), 4, "gtid1".getBytes());
    ClientProducer producer = clientSessionXa.createProducer(address);
    SimpleString messageId1 = new SimpleString("SMID1");
    SimpleString messageId2 = new SimpleString("SMID2");
    clientSessionXa.start(xid, XAResource.TMNOFLAGS);
    ClientMessage m1 = createTextMessage(clientSession, "m1");
    m1.putStringProperty(Message.HDR_LAST_VALUE_NAME, messageId1);
    ClientMessage m2 = createTextMessage(clientSession, "m2");
    m2.putStringProperty(Message.HDR_LAST_VALUE_NAME, messageId2);
    ClientMessage m3 = createTextMessage(clientSession, "m3");
    m3.putStringProperty(Message.HDR_LAST_VALUE_NAME, messageId1);
    ClientMessage m4 = createTextMessage(clientSession, "m4");
    m4.putStringProperty(Message.HDR_LAST_VALUE_NAME, messageId2);
    producer.send(m1);
    producer.send(m2);
    producer.send(m3);
    producer.send(m4);
    clientSessionXa.end(xid, XAResource.TMSUCCESS);
    clientSessionXa.prepare(xid);

    clientSession.close();
    clientSessionXa.close();
    restartServer();

    clientSessionXa.commit(xid, false);
    ClientConsumer consumer = clientSession.createConsumer(qName1);
    clientSession.start();
    ClientMessage m = consumer.receive(1000);
    Assert.assertNotNull(m);
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "m3");
    m = consumer.receive(1000);
    Assert.assertNotNull(m);
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "m4");
  }
Esempio n. 22
0
  // https://jira.jboss.org/jira/browse/HORNETQ-111
  // Test that, on rollback credits are released for messages cleared in the buffer
  public void testConsumerCreditsOnRollbackLargeMessages() throws Exception {

    locator.setConsumerWindowSize(10000);
    locator.setMinLargeMessageSize(1000);

    ClientSessionFactory sf = createSessionFactory(locator);

    ClientSession session = sf.createTransactedSession();

    session.createQueue(QUEUE, QUEUE, null, false);

    ClientProducer producer = session.createProducer(QUEUE);

    final int numMessages = 100;

    final byte[] bytes = new byte[10000];

    for (int i = 0; i < numMessages; i++) {
      ClientMessage message = session.createMessage(false);

      message.getBodyBuffer().writeBytes(bytes);

      message.putIntProperty("count", i);

      producer.send(message);
    }

    session.commit();

    ClientConsumer consumer = session.createConsumer(QUEUE);
    session.start();

    for (int i = 0; i < 110; i++) {
      ClientMessage message = consumer.receive();

      int count = message.getIntProperty("count");

      boolean redelivered = message.getDeliveryCount() > 1;

      if (count % 2 == 0 && !redelivered) {
        session.rollback();
      } else {
        session.commit();
      }
    }

    session.close();
  }
 /**
  * @throws Exception
  * @throws HornetQException
  */
 private void verifyMessageOnServer(final int server, final int numberOfMessages)
     throws Exception, HornetQException {
   ServerLocator backupLocator = createInVMLocator(server);
   ClientSessionFactory factorybkp = addSessionFactory(createSessionFactory(backupLocator));
   ClientSession sessionbkp = factorybkp.createSession(false, false);
   sessionbkp.start();
   ClientConsumer consumerbkp = sessionbkp.createConsumer(ADDRESS);
   for (int i = 0; i < numberOfMessages; i++) {
     ClientMessage msg = consumerbkp.receive(1000);
     assertNotNull(msg);
     msg.acknowledge();
     sessionbkp.commit();
   }
   sessionbkp.close();
   factorybkp.close();
   backupLocator.close();
 }
  public void testListPreparedTransactionDetails() throws Exception {
    SimpleString atestq = new SimpleString("BasicXaTestq");
    Xid xid = newXID();

    ServerLocator locator =
        HornetQClient.createServerLocatorWithoutHA(
            new TransportConfiguration(UnitTestCase.INVM_CONNECTOR_FACTORY));
    ClientSessionFactory csf = locator.createSessionFactory();
    ClientSession clientSession = csf.createSession(true, false, false);
    clientSession.createQueue(atestq, atestq, null, true);

    ClientMessage m1 = createTextMessage(clientSession, "");
    ClientMessage m2 = createTextMessage(clientSession, "");
    ClientMessage m3 = createTextMessage(clientSession, "");
    ClientMessage m4 = createTextMessage(clientSession, "");
    m1.putStringProperty("m1", "m1");
    m2.putStringProperty("m2", "m2");
    m3.putStringProperty("m3", "m3");
    m4.putStringProperty("m4", "m4");
    ClientProducer clientProducer = clientSession.createProducer(atestq);
    clientSession.start(xid, XAResource.TMNOFLAGS);
    clientProducer.send(m1);
    clientProducer.send(m2);
    clientProducer.send(m3);
    clientProducer.send(m4);
    clientSession.end(xid, XAResource.TMSUCCESS);
    clientSession.prepare(xid);

    HornetQServerControl serverControl = createManagementControl();

    JSONArray jsonArray = new JSONArray(serverControl.listProducersInfoAsJSON());

    assertEquals(1, jsonArray.length());
    assertEquals(4, ((JSONObject) jsonArray.get(0)).getInt("msgSent"));

    clientSession.close();
    locator.close();

    String txDetails = serverControl.listPreparedTransactionDetailsAsJSON();

    Assert.assertTrue(txDetails.matches(".*m1.*"));
    Assert.assertTrue(txDetails.matches(".*m2.*"));
    Assert.assertTrue(txDetails.matches(".*m3.*"));
    Assert.assertTrue(txDetails.matches(".*m4.*"));
  }
Esempio n. 25
0
 public void start() throws Exception {
   serverLocator =
       HornetQClient.createServerLocatorWithoutHA(
           new TransportConfiguration(NettyConnectorFactory.class.getName()));
   sf = serverLocator.createSessionFactory();
   clientSession =
       sf.createSession(
           HornetQDefaultConfiguration.DEFAULT_CLUSTER_USER,
           HornetQDefaultConfiguration.DEFAULT_CLUSTER_PASSWORD,
           false,
           true,
           true,
           false,
           1);
   requestor =
       new ClientRequestor(clientSession, HornetQDefaultConfiguration.DEFAULT_MANAGEMENT_ADDRESS);
   clientSession.start();
 }
  private ClientSession sendAndConsume(final ClientSessionFactory sf, final boolean createQueue)
      throws Exception {
    ClientSession session = sf.createSession(false, true, true);

    if (createQueue) {
      session.createQueue(FailoverTestBase.ADDRESS, FailoverTestBase.ADDRESS, null, true);
    }

    ClientProducer producer = session.createProducer(FailoverTestBase.ADDRESS);

    final int numMessages = 1000;

    for (int i = 0; i < numMessages; i++) {
      ClientMessage message =
          session.createMessage(
              HornetQTextMessage.TYPE, false, 0, System.currentTimeMillis(), (byte) 1);
      message.putIntProperty(new SimpleString("count"), i);
      message.getBodyBuffer().writeString("aardvarks");
      producer.send(message);
    }

    ClientConsumer consumer = session.createConsumer(FailoverTestBase.ADDRESS);

    session.start();

    for (int i = 0; i < numMessages; i++) {
      ClientMessage message2 = consumer.receive();

      Assert.assertEquals("aardvarks", message2.getBodyBuffer().readString());

      Assert.assertEquals(i, message2.getObjectProperty(new SimpleString("count")));

      message2.acknowledge();
    }

    ClientMessage message3 = consumer.receiveImmediate();

    consumer.close();

    Assert.assertNull(message3);

    return session;
  }
  public void testReuseConsumersFlowControl0() throws Throwable {
    shareConnectionFactory = true;
    openConsumerOnEveryLoop = false;
    numberOfProducers = 1;
    numberOfConsumers = 1;

    sharedLocator = createInVMNonHALocator();
    sharedLocator.setConsumerWindowSize(0);

    sharedSf = createSessionFactory(sharedLocator);

    try {
      internalMultipleConsumers();
    } catch (Throwable e) {
      TestConsumer tstConsumer = consumers.get(0);
      System.out.println("first retry: " + tstConsumer.consumer.receive(1000));

      System.out.println(pagedServerQueue.debug());

      pagedServerQueue.forceDelivery();
      System.out.println("Second retry: " + tstConsumer.consumer.receive(1000));

      System.out.println(pagedServerQueue.debug());

      tstConsumer.session.commit();
      System.out.println("Third retry:" + tstConsumer.consumer.receive(1000));

      tstConsumer.close();

      ClientSession session = sharedSf.createSession();
      session.start();
      ClientConsumer consumer = session.createConsumer(ADDRESS);

      pagedServerQueue.forceDelivery();

      System.out.println("Fourth retry: " + consumer.receive(1000));

      System.out.println(pagedServerQueue.debug());

      throw e;
    }
  }
Esempio n. 28
0
  @Test
  public void testLargeMessageCompression() throws Exception {
    final int messageSize = (int) (3.5 * HornetQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE);

    HornetQServer server = createServer(true, isNetty());

    server.start();

    ClientSessionFactory sf = createSessionFactory(locator);

    ClientSession session = addClientSession(sf.createSession(false, false, false));

    session.createTemporaryQueue(ADDRESS, ADDRESS);

    ClientProducer producer = session.createProducer(ADDRESS);

    Message clientFile = createLargeClientMessageStreaming(session, messageSize, true);

    producer.send(clientFile);

    session.commit();

    session.start();

    ClientConsumer consumer = session.createConsumer(ADDRESS);
    ClientMessage msg1 = consumer.receive(1000);
    Assert.assertNotNull(msg1);

    for (int i = 0; i < messageSize; i++) {
      byte b = msg1.getBodyBuffer().readByte();
      assertEquals("position = " + i, getSamplebyte(i), b);
    }

    msg1.acknowledge();
    session.commit();

    consumer.close();

    session.close();

    validateNoFilesOnLargeDir();
  }
Esempio n. 29
0
  @Override
  @Before
  public void setUp() throws Exception {
    super.setUp();

    Configuration conf = createBasicConfig();
    conf.setSecurityEnabled(false);
    conf.setJMXManagementEnabled(true);
    conf.getAcceptorConfigurations()
        .add(new TransportConfiguration(InVMAcceptorFactory.class.getName()));
    server = createServer(false, conf, mbeanServer);
    server.start();

    locator = createInVMNonHALocator();
    locator.setBlockOnNonDurableSend(true);
    locator.setBlockOnNonDurableSend(true);
    sf = createSessionFactory(locator);
    session = sf.createSession(false, true, false);
    session.start();
    addClientSession(session);
  }
Esempio n. 30
0
  protected void runListener() {
    ClientSession session = null;

    try {
      init(perfParams.isSessionTransacted(), perfParams.getQueueName());

      session =
          factory.createSession(
              !perfParams.isSessionTransacted(), !perfParams.isSessionTransacted());

      if (perfParams.isDrainQueue()) {
        drainQueue();
      }

      ClientConsumer consumer = session.createConsumer(perfParams.getQueueName());

      session.start();

      PerfBase.log.info("READY!!!");

      CountDownLatch countDownLatch = new CountDownLatch(1);
      consumer.setMessageHandler(new PerfListener(session, countDownLatch, perfParams));
      countDownLatch.await();
      long end = System.currentTimeMillis();
      // start was set on the first received message
      displayAverage(perfParams.getNoOfMessagesToSend(), start, end);
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      if (factory != null) {
        try {
          factory.close();
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    }
  }