Examples with ActiveMQTransactionOutcomeUnknownException org.apache.activemq.artemis.api.core.ActiveMQTransactionOutcomeUnknownException used on opensource projects

Example 1 with ActiveMQTransactionOutcomeUnknownException

use of org.apache.activemq.artemis.api.core.ActiveMQTransactionOutcomeUnknownException in project activemq-artemis by apache.

the class BMFailoverTest method testFailoverOnCommit.

@Test
@BMRules(rules = { @BMRule(name = "trace clientsessionimpl commit", targetClass = "org.apache.activemq.artemis.core.client.impl.ClientSessionImpl", targetMethod = "commit", targetLocation = "ENTRY", action = "org.apache.activemq.artemis.tests.extras.byteman.BMFailoverTest.serverToStop.getServer().stop(true)") })
public void testFailoverOnCommit() throws Exception {
    serverToStop = liveServer;
    locator = getServerLocator().setFailoverOnInitialConnection(true);
    createSessionFactory();
    ClientSession session = createSessionAndQueue();
    ClientProducer producer = addClientProducer(session.createProducer(FailoverTestBase.ADDRESS));
    sendMessages(session, producer, 10);
    try {
        session.commit();
        fail("should have thrown an exception");
    } catch (ActiveMQTransactionOutcomeUnknownException e) {
    // pass
    }
    sendMessages(session, producer, 10);
    session.commit();
    Queue bindable = (Queue) backupServer.getServer().getPostOffice().getBinding(FailoverTestBase.ADDRESS).getBindable();
    assertEquals(10, getMessageCount(bindable));
}

Example 2 with ActiveMQTransactionOutcomeUnknownException

use of org.apache.activemq.artemis.api.core.ActiveMQTransactionOutcomeUnknownException in project activemq-artemis by apache.

the class BMFailoverTest method testFailoverOnReceiveCommit.

@Test
@BMRules(rules = { @BMRule(name = "trace clientsessionimpl commit", targetClass = "org.apache.activemq.artemis.core.client.impl.ClientSessionImpl", targetMethod = "commit", targetLocation = "ENTRY", action = "org.apache.activemq.artemis.tests.extras.byteman.BMFailoverTest.serverToStop.getServer().stop(true)") })
public void testFailoverOnReceiveCommit() throws Exception {
    serverToStop = liveServer;
    locator = getServerLocator().setFailoverOnInitialConnection(true);
    createSessionFactory();
    ClientSession session = createSessionAndQueue();
    ClientSession sendSession = createSession(sf, true, true);
    ClientProducer producer = addClientProducer(sendSession.createProducer(FailoverTestBase.ADDRESS));
    sendMessages(sendSession, producer, 10);
    ClientConsumer consumer = session.createConsumer(FailoverTestBase.ADDRESS);
    session.start();
    for (int i = 0; i < 10; i++) {
        ClientMessage m = consumer.receive(500);
        assertNotNull(m);
        m.acknowledge();
    }
    try {
        session.commit();
        fail("should have thrown an exception");
    } catch (ActiveMQTransactionOutcomeUnknownException e) {
    // pass
    } catch (ActiveMQTransactionRolledBackException e1) {
    // pass
    }
    Queue bindable = (Queue) backupServer.getServer().getPostOffice().getBinding(FailoverTestBase.ADDRESS).getBindable();
    assertEquals(10, getMessageCount(bindable));
}

Example 3 with ActiveMQTransactionOutcomeUnknownException

use of org.apache.activemq.artemis.api.core.ActiveMQTransactionOutcomeUnknownException in project activemq-artemis by apache.

the class FailoverTest method testCommitDidNotOccurUnblockedAndResend.

@Test(timeout = 120000)
public void testCommitDidNotOccurUnblockedAndResend() throws Exception {
    locator.setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true).setReconnectAttempts(300).setRetryInterval(100);
    sf = createSessionFactoryAndWaitForTopology(locator, 2);
    final ClientSession session = createSession(sf, false, false);
    session.createQueue(FailoverTestBase.ADDRESS, RoutingType.MULTICAST, FailoverTestBase.ADDRESS, null, true);
    ClientProducer producer = session.createProducer(FailoverTestBase.ADDRESS);
    sendMessages(session, producer, NUM_MESSAGES);
    class Committer extends Thread {

        @Override
        public void run() {
            Interceptor interceptor = new DelayInterceptor3();
            try {
                liveServer.addInterceptor(interceptor);
                session.commit();
            } catch (ActiveMQTransactionRolledBackException trbe) {
                // Ok - now we retry the commit after removing the interceptor
                liveServer.removeInterceptor(interceptor);
                try {
                    session.commit();
                    failed = false;
                } catch (ActiveMQException e2) {
                }
            } catch (ActiveMQTransactionOutcomeUnknownException toue) {
                // Ok - now we retry the commit after removing the interceptor
                liveServer.removeInterceptor(interceptor);
                try {
                    session.commit();
                    failed = false;
                } catch (ActiveMQException e2) {
                }
            } catch (ActiveMQException e) {
            // ignore
            }
        }

        volatile boolean failed = true;
    }
    Committer committer = new Committer();
    committer.start();
    crash(session);
    committer.join();
    Assert.assertFalse("commiter failed should be false", committer.failed);
    session.close();
    ClientSession session2 = createSession(sf, false, false);
    producer = session2.createProducer(FailoverTestBase.ADDRESS);
    // We now try and resend the messages since we get a transaction rolled back exception
    sendMessages(session2, producer, NUM_MESSAGES);
    session2.commit();
    ClientConsumer consumer = session2.createConsumer(FailoverTestBase.ADDRESS);
    session2.start();
    receiveMessages(consumer);
    ClientMessage message = consumer.receiveImmediate();
    Assert.assertNull("expecting null message", message);
}

Example 4 with ActiveMQTransactionOutcomeUnknownException

use of org.apache.activemq.artemis.api.core.ActiveMQTransactionOutcomeUnknownException in project activemq-artemis by apache.

the class AsynchronousFailoverTest method doTestTransactional.

private void doTestTransactional(final TestRunner runner) throws Throwable {
    // For duplication detection
    int executionId = 0;
    while (!runner.isFailed()) {
        ClientSession session = null;
        executionId++;
        log.info("#test doTestTransactional starting now. Execution " + executionId);
        try {
            boolean retry = false;
            final int numMessages = 1000;
            session = sf.createSession(false, false);
            listener = new CountDownSessionFailureListener(session);
            session.addFailureListener(listener);
            do {
                try {
                    ClientProducer producer = session.createProducer(FailoverTestBase.ADDRESS);
                    for (int i = 0; i < numMessages; i++) {
                        ClientMessage message = session.createMessage(true);
                        message.getBodyBuffer().writeString("message" + i);
                        message.putIntProperty("counter", i);
                        message.putStringProperty(Message.HDR_DUPLICATE_DETECTION_ID, new SimpleString("id:" + i + ",exec:" + executionId));
                        addPayload(message);
                        if (log.isDebugEnabled()) {
                            log.debug("Sending message " + message);
                        }
                        producer.send(message);
                    }
                    log.debug("Sending commit");
                    session.commit();
                    retry = false;
                } catch (ActiveMQDuplicateIdException die) {
                    logAndSystemOut("#test duplicate id rejected on sending");
                    break;
                } catch (ActiveMQTransactionRolledBackException trbe) {
                    log.info("#test transaction rollback retrying on sending");
                    // OK
                    retry = true;
                } catch (ActiveMQUnBlockedException ube) {
                    log.info("#test transaction rollback retrying on sending");
                    // OK
                    retry = true;
                } catch (ActiveMQTransactionOutcomeUnknownException toue) {
                    log.info("#test transaction rollback retrying on sending");
                    // OK
                    retry = true;
                } catch (ActiveMQException e) {
                    log.info("#test Exception " + e, e);
                    throw e;
                }
            } while (retry);
            logAndSystemOut("#test Finished sending, starting consumption now");
            boolean blocked = false;
            retry = false;
            ClientConsumer consumer = null;
            do {
                ArrayList<Integer> msgs = new ArrayList<>();
                try {
                    if (consumer == null) {
                        consumer = session.createConsumer(FailoverTestBase.ADDRESS);
                        session.start();
                    }
                    for (int i = 0; i < numMessages; i++) {
                        if (log.isDebugEnabled()) {
                            log.debug("Consumer receiving message " + i);
                        }
                        ClientMessage message = consumer.receive(10000);
                        if (message == null) {
                            break;
                        }
                        if (log.isDebugEnabled()) {
                            log.debug("Received message " + message);
                        }
                        int count = message.getIntProperty("counter");
                        if (count != i) {
                            log.warn("count was received out of order, " + count + "!=" + i);
                        }
                        msgs.add(count);
                        message.acknowledge();
                    }
                    log.info("#test commit");
                    try {
                        session.commit();
                    } catch (ActiveMQTransactionRolledBackException trbe) {
                        // we know the tx has been rolled back so we just consume again
                        retry = true;
                        continue;
                    } catch (ActiveMQException e) {
                        // This could eventually happen
                        // We will get rid of this when we implement 2 phase commit on failover
                        log.warn("exception during commit, it will be ignored for now" + e.getMessage(), e);
                    }
                    try {
                        if (blocked) {
                            assertTrue("msgs.size is expected to be 0 or " + numMessages + " but it was " + msgs.size(), msgs.size() == 0 || msgs.size() == numMessages);
                        } else {
                            assertTrue("msgs.size is expected to be " + numMessages + " but it was " + msgs.size(), msgs.size() == numMessages);
                        }
                    } catch (Throwable e) {
                        log.info(threadDump("Thread dump, messagesReceived = " + msgs.size()));
                        logAndSystemOut(e.getMessage() + " messages received");
                        for (Integer msg : msgs) {
                            logAndSystemOut(msg.toString());
                        }
                        throw e;
                    }
                    int i = 0;
                    for (Integer msg : msgs) {
                        assertEquals(i++, (int) msg);
                    }
                    retry = false;
                    blocked = false;
                } catch (ActiveMQTransactionRolledBackException trbe) {
                    logAndSystemOut("Transaction rolled back with " + msgs.size(), trbe);
                    // TODO: https://jira.jboss.org/jira/browse/HORNETQ-369
                    // ATM RolledBack exception is being called with the transaction is committed.
                    // the test will fail if you remove this next line
                    blocked = true;
                    retry = true;
                } catch (ActiveMQTransactionOutcomeUnknownException tou) {
                    logAndSystemOut("Transaction rolled back with " + msgs.size(), tou);
                    // TODO: https://jira.jboss.org/jira/browse/HORNETQ-369
                    // ATM RolledBack exception is being called with the transaction is committed.
                    // the test will fail if you remove this next line
                    blocked = true;
                    retry = true;
                } catch (ActiveMQUnBlockedException ube) {
                    logAndSystemOut("Unblocked with " + msgs.size(), ube);
                    // TODO: https://jira.jboss.org/jira/browse/HORNETQ-369
                    // This part of the test is never being called.
                    blocked = true;
                    retry = true;
                } catch (ActiveMQException e) {
                    logAndSystemOut(e.getMessage(), e);
                    throw e;
                }
            } while (retry);
        } finally {
            if (session != null) {
                session.close();
            }
        }
        listener = null;
    }
}

Example 5 with ActiveMQTransactionOutcomeUnknownException

use of org.apache.activemq.artemis.api.core.ActiveMQTransactionOutcomeUnknownException in project activemq-artemis by apache.

the class FailoverTest method testCommitOccurredUnblockedAndResendNoDuplicates.

@Test(timeout = 120000)
public void testCommitOccurredUnblockedAndResendNoDuplicates() throws Exception {
    locator.setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setReconnectAttempts(300).setRetryInterval(100).setBlockOnAcknowledge(true);
    sf = createSessionFactoryAndWaitForTopology(locator, 2);
    final ClientSession session = createSession(sf, false, false);
    session.createQueue(FailoverTestBase.ADDRESS, RoutingType.MULTICAST, FailoverTestBase.ADDRESS, null, true);
    ClientProducer producer = session.createProducer(FailoverTestBase.ADDRESS);
    String txID = "my-tx-id";
    for (int i = 0; i < NUM_MESSAGES; i++) {
        ClientMessage message = session.createMessage(true);
        if (i == 0) {
            // Only need to add it on one message per tx
            message.putStringProperty(Message.HDR_DUPLICATE_DETECTION_ID, new SimpleString(txID));
        }
        setBody(i, message);
        message.putIntProperty("counter", i);
        producer.send(message);
    }
    class Committer extends Thread {

        DelayInterceptor2 interceptor = new DelayInterceptor2();

        @Override
        public void run() {
            try {
                sf.getServerLocator().addIncomingInterceptor(interceptor);
                session.commit();
            } catch (ActiveMQTransactionRolledBackException trbe) {
                // Ok - now we retry the commit after removing the interceptor
                sf.getServerLocator().removeIncomingInterceptor(interceptor);
                try {
                    session.commit();
                    failed = false;
                } catch (ActiveMQException e2) {
                    throw new RuntimeException(e2);
                }
            } catch (ActiveMQTransactionOutcomeUnknownException toue) {
                // Ok - now we retry the commit after removing the interceptor
                sf.getServerLocator().removeIncomingInterceptor(interceptor);
                try {
                    session.commit();
                    failed = false;
                } catch (ActiveMQException e2) {
                    throw new RuntimeException(e2);
                }
            } catch (ActiveMQException e) {
            // ignore
            }
        }

        volatile boolean failed = true;
    }
    Committer committer = new Committer();
    // Commit will occur, but response will never get back, connection is failed, and commit
    // should be unblocked with transaction rolled back
    committer.start();
    // Wait for the commit to occur and the response to be discarded
    Assert.assertTrue(committer.interceptor.await());
    crash(session);
    committer.join();
    Assert.assertFalse("second attempt succeed?", committer.failed);
    session.close();
    ClientSession session2 = createSession(sf, false, false);
    producer = session2.createProducer(FailoverTestBase.ADDRESS);
    for (int i = 0; i < NUM_MESSAGES; i++) {
        ClientMessage message = session2.createMessage(true);
        if (i == 0) {
            // Only need to add it on one message per tx
            message.putStringProperty(Message.HDR_DUPLICATE_DETECTION_ID, new SimpleString(txID));
        }
        setBody(i, message);
        message.putIntProperty("counter", i);
        producer.send(message);
    }
    try {
        session2.commit();
        Assert.fail("expecting DUPLICATE_ID_REJECTED exception");
    } catch (ActiveMQDuplicateIdException dide) {
    // ok
    } catch (ActiveMQException e) {
        Assert.fail("Invalid Exception type:" + e.getType());
    }
    ClientConsumer consumer = session2.createConsumer(FailoverTestBase.ADDRESS);
    session2.start();
    receiveMessages(consumer);
    ClientMessage message = consumer.receiveImmediate();
    Assert.assertNull(message);
}