Update from trunk r1375509 through r1450773asyncstore

git-svn-id: https://svn.apache.org/repos/asf/qpid/branches/asyncstore@1451244 13f79535-47bb-0310-9956-ffa450edef68

1 files changed, 351 insertions, 0 deletions

diff --git a/cpp/src/tests/legacystore/TransactionalTest.cpp b/cpp/src/tests/legacystore/TransactionalTest.cpp
new file mode 100644
index 0000000000..2d3f6f922c
--- /dev/null
+++ b/cpp/src/tests/legacystore/TransactionalTest.cpp
@@ -0,0 +1,351 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+
+#include "unit_test.h"
+
+#include "qpid/legacystore/MessageStoreImpl.h"
+#include <iostream>
+#include "MessageUtils.h"
+#include "qpid/legacystore/StoreException.h"
+#include "qpid/broker/Queue.h"
+#include "qpid/broker/RecoveryManagerImpl.h"
+#include "qpid/framing/AMQHeaderBody.h"
+#include "qpid/log/Statement.h"
+#include "qpid/log/Logger.h"
+#include "qpid/sys/Timer.h"
+
+using namespace mrg::msgstore;
+using namespace qpid;
+using namespace qpid::broker;
+using namespace qpid::framing;
+using namespace std;
+
+namespace {
+qpid::broker::Broker::Options opts;
+qpid::broker::Broker br(opts);
+}
+
+QPID_AUTO_TEST_SUITE(TransactionalTest)
+
+#define SET_LOG_LEVEL(level) \
+    qpid::log::Options opts(""); \
+    opts.selectors.clear(); \
+    opts.selectors.push_back(level); \
+    qpid::log::Logger::instance().configure(opts);
+
+const string test_filename("TransactionalTest");
+const char* tdp = getenv("TMP_DATA_DIR");
+const string test_dir(tdp && strlen(tdp) > 0 ? tdp : "/tmp/TransactionalTest");
+
+// Test txn context which has special setCompleteFailure() method which prevents entire "txn complete" process from hapenning
+class TestTxnCtxt : public TxnCtxt
+{
+  public:
+    TestTxnCtxt(IdSequence* _loggedtx) : TxnCtxt(_loggedtx) {}
+    void setCompleteFailure(const unsigned num_queues_rem) {
+        // Remove queue members from back of impactedQueues until queues_rem reamin.
+        // to end to simulate multi-queue txn complete failure.
+        while (impactedQueues.size() > num_queues_rem) impactedQueues.erase(impactedQueues.begin());
+    }
+    void resetPreparedXidStorePtr() { preparedXidStorePtr = 0; }
+};
+
+// Test store which has special begin() which returns a TestTPCTxnCtxt, and a method to check for
+// remaining open transactions.
+// begin(), commit(), and abort() all hide functions in MessageStoreImpl. To avoid the compiler
+// warnings/errors these are renamed with a 'TMS' prefix.
+class TestMessageStore: public MessageStoreImpl
+{
+  public:
+    TestMessageStore(qpid::broker::Broker* br, const char* envpath = 0) : MessageStoreImpl(br, envpath) {}
+    std::auto_ptr<qpid::broker::TransactionContext> TMSbegin() {
+        checkInit();
+        // pass sequence number for c/a
+        return auto_ptr<TransactionContext>(new TestTxnCtxt(&messageIdSequence));
+    }
+    void TMScommit(TransactionContext& ctxt, const bool complete_prepared_list) {
+        checkInit();
+        TxnCtxt* txn(check(&ctxt));
+        if (!txn->isTPC()) {
+            localPrepare(dynamic_cast<TxnCtxt*>(txn));
+            if (!complete_prepared_list) dynamic_cast<TestTxnCtxt*>(txn)->resetPreparedXidStorePtr();
+        }
+        completed(*dynamic_cast<TxnCtxt*>(txn), true);
+    }
+    void TMSabort(TransactionContext& ctxt, const bool complete_prepared_list)
+    {
+        checkInit();
+        TxnCtxt* txn(check(&ctxt));
+        if (!txn->isTPC()) {
+            localPrepare(dynamic_cast<TxnCtxt*>(txn));
+            if (!complete_prepared_list) dynamic_cast<TestTxnCtxt*>(txn)->resetPreparedXidStorePtr();
+        }
+        completed(*dynamic_cast<TxnCtxt*>(txn), false);
+    }
+};
+
+// === Helper fns ===
+
+const string nameA("queueA");
+const string nameB("queueB");
+//const Uuid messageId(true);
+std::auto_ptr<MessageStoreImpl> store;
+std::auto_ptr<QueueRegistry> queues;
+Queue::shared_ptr queueA;
+Queue::shared_ptr queueB;
+
+template <class T>
+void setup()
+{
+    store = std::auto_ptr<T>(new T(&br));
+    store->init(test_dir, 4, 1, true); // truncate store
+
+    //create two queues:
+    queueA = Queue::shared_ptr(new Queue(nameA, 0, store.get(), 0));
+    queueA->create();
+    queueB = Queue::shared_ptr(new Queue(nameB, 0, store.get(), 0));
+    queueB->create();
+}
+
+template <class T>
+void restart()
+{
+    queueA.reset();
+    queueB.reset();
+    queues.reset();
+    store.reset();
+
+    store = std::auto_ptr<T>(new T(&br));
+    store->init(test_dir, 4, 1);
+    queues = std::auto_ptr<QueueRegistry>(new QueueRegistry);
+    ExchangeRegistry exchanges;
+    LinkRegistry links;
+    sys::Timer t;
+    DtxManager mgr(t);
+    mgr.setStore (store.get());
+    RecoveryManagerImpl recovery(*queues, exchanges, links, mgr, br.getProtocolRegistry());
+    store->recover(recovery);
+
+    queueA = queues->find(nameA);
+    queueB = queues->find(nameB);
+}
+
+Message createMessage(const string& id, const string& exchange="exchange", const string& key="routing_key")
+{
+    return MessageUtils::createMessage(exchange, key, Uuid(), true, 0, id);
+}
+
+void checkMsg(Queue::shared_ptr& queue, u_int32_t size, const string& msgid = "<none>")
+{
+    BOOST_REQUIRE(queue);
+    BOOST_CHECK_EQUAL(size, queue->getMessageCount());
+    if (size > 0) {
+        Message msg = MessageUtils::get(*queue);
+        BOOST_REQUIRE(msg);
+        BOOST_CHECK_EQUAL(msgid, MessageUtils::getCorrelationId(msg));
+    }
+}
+
+void swap(bool commit)
+{
+    setup<MessageStoreImpl>();
+
+    //create message and enqueue it onto first queue:
+    Message msgA = createMessage("Message", "exchange", "routing_key");
+    queueA->deliver(msgA);
+
+    QueueCursor cursorB;
+    Message msgB = MessageUtils::get(*queueA, &cursorB);
+    BOOST_REQUIRE(msgB);
+    //move the message from one queue to the other as a transaction
+    std::auto_ptr<TransactionContext> txn = store->begin();
+    TxBuffer tx;
+    queueB->deliver(msgB, &tx);//note: need to enqueue it first to avoid message being deleted
+
+    queueA->dequeue(txn.get(), cursorB);
+    tx.prepare(txn.get());
+    if (commit) {
+        store->commit(*txn);
+    } else {
+        store->abort(*txn);
+    }
+
+    restart<MessageStoreImpl>();
+
+    // Check outcome
+    BOOST_REQUIRE(queueA);
+    BOOST_REQUIRE(queueB);
+
+    Queue::shared_ptr x;//the queue from which the message was swapped
+    Queue::shared_ptr y;//the queue on which the message is expected to be
+
+    if (commit) {
+        x = queueA;
+        y = queueB;
+    } else {
+        x = queueB;
+        y = queueA;
+    }
+
+    checkMsg(x, 0);
+    checkMsg(y, 1, "Message");
+    checkMsg(y, 0);
+}
+
+void testMultiQueueTxn(const unsigned num_queues_rem, const bool complete_prepared_list, const bool commit)
+{
+    setup<TestMessageStore>();
+    TestMessageStore* tmsp = static_cast<TestMessageStore*>(store.get());
+    std::auto_ptr<TransactionContext> txn(tmsp->TMSbegin());
+    TxBuffer tx;
+
+    //create two messages and enqueue them onto both queues:
+    Message msgA = createMessage("MessageA", "exchange", "routing_key");
+    queueA->deliver(msgA, &tx);
+    queueB->deliver(msgA, &tx);
+    Message msgB = createMessage("MessageB", "exchange", "routing_key");
+    queueA->deliver(msgB, &tx);
+    queueB->deliver(msgB, &tx);
+
+    tx.prepare(txn.get());
+    static_cast<TestTxnCtxt*>(txn.get())->setCompleteFailure(num_queues_rem);
+    if (commit)
+        tmsp->TMScommit(*txn, complete_prepared_list);
+    else
+        tmsp->TMSabort(*txn, complete_prepared_list);
+    restart<TestMessageStore>();
+
+    // Check outcome
+    if (commit)
+    {
+        checkMsg(queueA, 2, "MessageA");
+        checkMsg(queueB, 2, "MessageA");
+        checkMsg(queueA, 1, "MessageB");
+        checkMsg(queueB, 1, "MessageB");
+    }
+    checkMsg(queueA, 0);
+    checkMsg(queueB, 0);
+}
+
+// === Test suite ===
+
+QPID_AUTO_TEST_CASE(Commit)
+{
+    SET_LOG_LEVEL("error+"); // This only needs to be set once.
+
+    cout << test_filename << ".Commit: " << flush;
+    swap(true);
+    cout << "ok" << endl;
+}
+
+QPID_AUTO_TEST_CASE(Abort)
+{
+    cout << test_filename << ".Abort: " << flush;
+    swap(false);
+    cout << "ok" << endl;
+}
+
+QPID_AUTO_TEST_CASE(MultiQueueCommit)
+{
+    cout << test_filename << ".MultiQueueCommit: " << flush;
+    testMultiQueueTxn(2, true, true);
+    cout << "ok" << endl;
+}
+
+QPID_AUTO_TEST_CASE(MultiQueueAbort)
+{
+    cout << test_filename << ".MultiQueueAbort: " << flush;
+    testMultiQueueTxn(2, true, false);
+    cout << "ok" << endl;
+}
+
+QPID_AUTO_TEST_CASE(MultiQueueNoQueueCommitRecover)
+{
+    cout << test_filename << ".MultiQueueNoQueueCommitRecover: " << flush;
+    testMultiQueueTxn(0, false, true);
+    cout << "ok" << endl;
+}
+
+QPID_AUTO_TEST_CASE(MultiQueueNoQueueAbortRecover)
+{
+    cout << test_filename << ".MultiQueueNoQueueAbortRecover: " << flush;
+    testMultiQueueTxn(0, false, false);
+    cout << "ok" << endl;
+}
+
+QPID_AUTO_TEST_CASE(MultiQueueSomeQueueCommitRecover)
+{
+    cout << test_filename << ".MultiQueueSomeQueueCommitRecover: " << flush;
+    testMultiQueueTxn(1, false, true);
+    cout << "ok" << endl;
+}
+
+QPID_AUTO_TEST_CASE(MultiQueueSomeQueueAbortRecover)
+{
+    cout << test_filename << ".MultiQueueSomeQueueAbortRecover: " << flush;
+    testMultiQueueTxn(1, false, false);
+    cout << "ok" << endl;
+}
+
+QPID_AUTO_TEST_CASE(MultiQueueAllQueueCommitRecover)
+{
+    cout << test_filename << ".MultiQueueAllQueueCommitRecover: " << flush;
+    testMultiQueueTxn(2, false, true);
+    cout << "ok" << endl;
+}
+
+QPID_AUTO_TEST_CASE(MultiQueueAllQueueAbortRecover)
+{
+    cout << test_filename << ".MultiQueueAllQueueAbortRecover: " << flush;
+    testMultiQueueTxn(2, false, false);
+    cout << "ok" << endl;
+}
+
+QPID_AUTO_TEST_CASE(LockedRecordTest)
+{
+    cout << test_filename << ".LockedRecordTest: " << flush;
+
+    setup<MessageStoreImpl>();
+    queueA->deliver(createMessage("Message", "exchange", "routingKey"));
+    std::auto_ptr<TransactionContext> txn = store->begin();
+
+    QueueCursor cursor;
+    Message msg = MessageUtils::get(*queueA, &cursor);
+    queueA->dequeue(txn.get(), cursor);
+
+    try {
+        store->dequeue(0, msg.getPersistentContext(), *queueA);
+        BOOST_ERROR("Did not throw JERR_MAP_LOCKED exception as expected.");
+    }
+    catch (const mrg::msgstore::StoreException& e) {
+        if (std::strstr(e.what(), "JERR_MAP_LOCKED") == 0)
+            BOOST_ERROR("Unexpected StoreException: " << e.what());
+    }
+    catch (const std::exception& e) {
+        BOOST_ERROR("Unexpected exception: " << e.what());
+    }
+    store->commit(*txn);
+    checkMsg(queueA, 0);
+
+    cout << "ok" << endl;
+}
+
+QPID_AUTO_TEST_SUITE_END()