path: root/src/mongo/util/fail_point_test.cpp

/**
 *    Copyright (C) 2012 10gen Inc.
 *
 *    This program is free software: you can redistribute it and/or  modify
 *    it under the terms of the GNU Affero General Public License, version 3,
 *    as published by the Free Software Foundation.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU Affero General Public License for more details.
 *
 *    You should have received a copy of the GNU Affero General Public License
 *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *    As a special exception, the copyright holders give permission to link the
 *    code of portions of this program with the OpenSSL library under certain
 *    conditions as described in each individual source file and distribute
 *    linked combinations including the program with the OpenSSL library. You
 *    must comply with the GNU Affero General Public License in all respects
 *    for all of the code used other than as permitted herein. If you modify
 *    file(s) with this exception, you may extend this exception to your
 *    version of the file(s), but you are not obligated to do so. If you do not
 *    wish to do so, delete this exception statement from your version. If you
 *    delete this exception statement from all source files in the program,
 *    then also delete it in the license file.
 */

#define MONGO_LOG_DEFAULT_COMPONENT ::mongo::logger::LogComponent::kDefault

#include "mongo/platform/basic.h"

#include <stdexcept>
#include <string>
#include <vector>

#include "mongo/stdx/functional.h"
#include "mongo/stdx/thread.h"
#include "mongo/unittest/unittest.h"
#include "mongo/util/fail_point.h"
#include "mongo/util/log.h"
#include "mongo/util/time_support.h"

using mongo::FailPoint;
namespace stdx = mongo::stdx;

namespace mongo_test {
TEST(FailPoint, InitialState) {
    FailPoint failPoint;
    ASSERT_FALSE(failPoint.shouldFail());
}

TEST(FailPoint, AlwaysOn) {
    FailPoint failPoint;
    failPoint.setMode(FailPoint::alwaysOn);
    ASSERT(failPoint.shouldFail());

    MONGO_FAIL_POINT_BLOCK(failPoint, scopedFp) {
        ASSERT(scopedFp.getData().isEmpty());
    }

    for (size_t x = 0; x < 50; x++) {
        ASSERT(failPoint.shouldFail());
    }
}

TEST(FailPoint, NTimes) {
    FailPoint failPoint;
    failPoint.setMode(FailPoint::nTimes, 4);
    ASSERT(failPoint.shouldFail());
    ASSERT(failPoint.shouldFail());
    ASSERT(failPoint.shouldFail());
    ASSERT(failPoint.shouldFail());

    for (size_t x = 0; x < 50; x++) {
        ASSERT_FALSE(failPoint.shouldFail());
    }
}

TEST(FailPoint, BlockOff) {
    FailPoint failPoint;
    bool called = false;

    MONGO_FAIL_POINT_BLOCK(failPoint, scopedFp) {
        called = true;
    }

    ASSERT_FALSE(called);
}

TEST(FailPoint, BlockAlwaysOn) {
    FailPoint failPoint;
    failPoint.setMode(FailPoint::alwaysOn);
    bool called = false;

    MONGO_FAIL_POINT_BLOCK(failPoint, scopedFp) {
        called = true;
    }

    ASSERT(called);
}

TEST(FailPoint, BlockNTimes) {
    FailPoint failPoint;
    failPoint.setMode(FailPoint::nTimes, 1);
    size_t counter = 0;

    for (size_t x = 0; x < 10; x++) {
        MONGO_FAIL_POINT_BLOCK(failPoint, scopedFp) {
            counter++;
        }
    }

    ASSERT_EQUALS(1U, counter);
}

TEST(FailPoint, BlockWithException) {
    FailPoint failPoint;
    failPoint.setMode(FailPoint::alwaysOn);
    bool threw = false;

    try {
        MONGO_FAIL_POINT_BLOCK(failPoint, scopedFp) {
            throw std::logic_error("BlockWithException threw");
        }
    } catch (const std::logic_error&) {
        threw = true;
    }

    ASSERT(threw);
    // This will get into an infinite loop if reference counter was not
    // properly decremented
    failPoint.setMode(FailPoint::off);
}

TEST(FailPoint, SetGetParam) {
    FailPoint failPoint;
    failPoint.setMode(FailPoint::alwaysOn, 0, BSON("x" << 20));

    MONGO_FAIL_POINT_BLOCK(failPoint, scopedFp) {
        ASSERT_EQUALS(20, scopedFp.getData()["x"].numberInt());
    }
}

TEST(FailPoint, SetInvalidMode) {
    FailPoint failPoint;

    ASSERT_THROWS(failPoint.setMode(static_cast<FailPoint::Mode>(9999)), mongo::UserException);
    ASSERT_FALSE(failPoint.shouldFail());

    ASSERT_THROWS(failPoint.setMode(static_cast<FailPoint::Mode>(-1)), mongo::UserException);
    ASSERT_FALSE(failPoint.shouldFail());
}

class FailPointStress : public mongo::unittest::Test {
public:
    void setUp() {
        _fp.setMode(FailPoint::alwaysOn, 0, BSON("a" << 44));
    }

    void tearDown() {
        // Note: This can loop indefinitely if reference counter was off
        _fp.setMode(FailPoint::off, 0, BSON("a" << 66));
    }

    void startTest() {
        ASSERT_EQUALS(0U, _tasks.size());

        _tasks.emplace_back(&FailPointStress::blockTask, this);
        _tasks.emplace_back(&FailPointStress::blockWithExceptionTask, this);
        _tasks.emplace_back(&FailPointStress::simpleTask, this);
        _tasks.emplace_back(&FailPointStress::flipTask, this);
    }

    void stopTest() {
        {
            stdx::lock_guard<stdx::mutex> lk(_mutex);
            _inShutdown = true;
        }
        for (auto& t : _tasks) {
            t.join();
        }
        _tasks.clear();
    }

private:
    void blockTask() {
        while (true) {
            MONGO_FAIL_POINT_BLOCK(_fp, scopedFp) {
                const mongo::BSONObj& data = scopedFp.getData();

                // Expanded ASSERT_EQUALS since the error is not being
                // printed out properly
                if (data["a"].numberInt() != 44) {
                    mongo::error() << "blockTask thread detected anomaly"
                                   << " - data: " << data << std::endl;
                    ASSERT(false);
                }
            }

            stdx::lock_guard<stdx::mutex> lk(_mutex);
            if (_inShutdown)
                break;
        }
    }

    void blockWithExceptionTask() {
        while (true) {
            try {
                MONGO_FAIL_POINT_BLOCK(_fp, scopedFp) {
                    const mongo::BSONObj& data = scopedFp.getData();

                    if (data["a"].numberInt() != 44) {
                        mongo::error() << "blockWithExceptionTask thread detected anomaly"
                                       << " - data: " << data << std::endl;
                        ASSERT(false);
                    }

                    throw std::logic_error("blockWithExceptionTask threw");
                }
            } catch (const std::logic_error&) {
            }

            stdx::lock_guard<stdx::mutex> lk(_mutex);
            if (_inShutdown)
                break;
        }
    }

    void simpleTask() {
        while (true) {
            static_cast<void>(MONGO_FAIL_POINT(_fp));
            stdx::lock_guard<stdx::mutex> lk(_mutex);
            if (_inShutdown)
                break;
        }
    }

    void flipTask() {
        while (true) {
            if (_fp.shouldFail()) {
                _fp.setMode(FailPoint::off, 0);
            } else {
                _fp.setMode(FailPoint::alwaysOn, 0, BSON("a" << 44));
            }

            stdx::lock_guard<stdx::mutex> lk(_mutex);
            if (_inShutdown)
                break;
        }
    }

    FailPoint _fp;
    std::vector<stdx::thread> _tasks;
    stdx::mutex _mutex;
    bool _inShutdown = false;
};

TEST_F(FailPointStress, Basic) {
    startTest();
    mongo::sleepsecs(30);
    stopTest();
}

static void parallelFailPointTestThread(FailPoint* fp,
                                        const int64_t numIterations,
                                        const int32_t seed,
                                        int64_t* outNumActivations) {
    fp->setThreadPRNGSeed(seed);
    int64_t numActivations = 0;
    for (int64_t i = 0; i < numIterations; ++i) {
        if (fp->shouldFail()) {
            ++numActivations;
        }
    }
    *outNumActivations = numActivations;
}
/**
 * Encounters a failpoint with the given fpMode and fpVal numEncountersPerThread
 * times in each of numThreads parallel threads, and returns the number of total
 * times that the failpoint was activiated.
 */
static int64_t runParallelFailPointTest(FailPoint::Mode fpMode,
                                        FailPoint::ValType fpVal,
                                        const int32_t numThreads,
                                        const int32_t numEncountersPerThread) {
    ASSERT_GT(numThreads, 0);
    ASSERT_GT(numEncountersPerThread, 0);
    FailPoint failPoint;
    failPoint.setMode(fpMode, fpVal);
    std::vector<stdx::thread*> tasks;
    std::vector<int64_t> counts(numThreads, 0);
    ASSERT_EQUALS(static_cast<uint32_t>(numThreads), counts.size());
    for (int32_t i = 0; i < numThreads; ++i) {
        tasks.push_back(new stdx::thread(parallelFailPointTestThread,
                                         &failPoint,
                                         numEncountersPerThread,
                                         i,  // hardcoded seed, different for each thread.
                                         &counts[i]));
    }
    int64_t totalActivations = 0;
    for (int32_t i = 0; i < numThreads; ++i) {
        tasks[i]->join();
        delete tasks[i];
        totalActivations += counts[i];
    }
    return totalActivations;
}

TEST(FailPoint, RandomActivationP0) {
    ASSERT_EQUALS(0, runParallelFailPointTest(FailPoint::random, 0, 1, 1000000));
}

TEST(FailPoint, RandomActivationP5) {
    ASSERT_APPROX_EQUAL(500000,
                        runParallelFailPointTest(
                            FailPoint::random, std::numeric_limits<int32_t>::max() / 2, 10, 100000),
                        500);
}

TEST(FailPoint, RandomActivationP01) {
    ASSERT_APPROX_EQUAL(
        10000,
        runParallelFailPointTest(
            FailPoint::random, std::numeric_limits<int32_t>::max() / 100, 10, 100000),
        500);
}

TEST(FailPoint, RandomActivationP001) {
    ASSERT_APPROX_EQUAL(
        1000,
        runParallelFailPointTest(
            FailPoint::random, std::numeric_limits<int32_t>::max() / 1000, 10, 100000),
        500);
}
}