d_test_stubs.cc 6.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
// Copyright (C) 2013  Internet Systems Consortium, Inc. ("ISC")
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
// AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.

#include <d2/spec_config.h>
#include <d2/tests/d_test_stubs.h>

using namespace asio;

namespace isc {
namespace d2 {

23
// Initialize the static failure flag.
24 25
SimFailure::FailureType SimFailure::failure_type_ = SimFailure::ftNoFailure;

26 27
// Define custom process command supported by DStubProcess.
const std::string DStubProcess::stub_proc_command_("cool_proc_cmd");
28

29
DStubProcess::DStubProcess(const char* name, IOServicePtr io_service)
30 31 32 33 34
    : DProcessBase(name, io_service) {
};

void
DStubProcess::init() {
35
    LOG_DEBUG(d2_logger, DBGLVL_START_SHUT, D2PRC_PROCESS_INIT);
36
    if (SimFailure::shouldFailOn(SimFailure::ftProcessInit)) {
37 38
        // Simulates a failure to instantiate the process.
        isc_throw(DProcessBaseError, "DStubProcess simulated init() failure");
39 40 41
    }
};

42
void
43 44 45 46
DStubProcess::run() {
    // Until shut down or an fatal error occurs, wait for and
    // execute a single callback. This is a preliminary implementation
    // that is likely to evolve as development progresses.
47
    // To use run(), the "managing" layer must issue an io_service::stop
48 49 50 51 52 53 54 55 56
    // or the call to run will continue to block, and shutdown will not
    // occur.
    LOG_DEBUG(d2_logger, DBGLVL_START_SHUT, D2PRC_RUN_ENTER);
    IOServicePtr& io_service = getIoService();
    while (!shouldShutdown()) {
        try {
            io_service->run_one();
        } catch (const std::exception& ex) {
            LOG_FATAL(d2_logger, D2PRC_FAILED).arg(ex.what());
57 58
            isc_throw (DProcessBaseError,
                std::string("Process run method failed:") + ex.what());
59 60 61 62 63 64
        }
    }

    LOG_DEBUG(d2_logger, DBGLVL_START_SHUT, D2PRC_RUN_EXIT);
};

65
void
66 67
DStubProcess::shutdown() {
    LOG_DEBUG(d2_logger, DBGLVL_START_SHUT, D2PRC_SHUTDOWN);
68 69 70 71
    if (SimFailure::shouldFailOn(SimFailure::ftProcessShutdown)) {
        // Simulates a failure during shutdown process.
        isc_throw(DProcessBaseError, "DStubProcess simulated shutdown failure");
    }
72
    setShutdownFlag(true);
73
}
74

75
isc::data::ConstElementPtr
76
DStubProcess::configure(isc::data::ConstElementPtr config_set) {
77
    LOG_DEBUG(d2_logger, DBGLVL_TRACE_BASIC,
78 79 80
              D2PRC_CONFIGURE).arg(config_set->str());

    if (SimFailure::shouldFailOn(SimFailure::ftProcessConfigure)) {
81
        // Simulates a process configure failure.
82 83 84 85 86 87 88
        return (isc::config::createAnswer(1,
                "Simulated process configuration error."));
    }

    return (isc::config::createAnswer(0, "Configuration accepted."));
}

89 90 91 92
isc::data::ConstElementPtr
DStubProcess::command(const std::string& command,
                      isc::data::ConstElementPtr args) {
    LOG_DEBUG(d2_logger, DBGLVL_TRACE_BASIC,
93 94 95 96
              D2PRC_COMMAND).arg(command).arg(args->str());

    isc::data::ConstElementPtr answer;
    if (SimFailure::shouldFailOn(SimFailure::ftProcessCommand)) {
97
        // Simulates a process command execution failure.
98 99
        answer = isc::config::createAnswer(COMMAND_ERROR,
                                          "SimFailure::ftProcessCommand");
100
    } else if (command.compare(stub_proc_command_) == 0) {
101 102 103 104 105 106 107 108 109 110 111 112 113 114
        answer = isc::config::createAnswer(COMMAND_SUCCESS, "Command accepted");
    } else {
        answer = isc::config::createAnswer(COMMAND_INVALID,
                                           "Unrecognized command:" + command);
    }

    return (answer);
}

DStubProcess::~DStubProcess() {
};

//************************** DStubController *************************

115 116 117 118 119
// Define custom controller command supported by DStubController.
const std::string DStubController::stub_ctl_command_("spiffy");

// Define custom command line option command supported by DStubController.
const char* DStubController::stub_option_x_ = "x";
120 121 122

DControllerBasePtr&
DStubController::instance() {
123
    // If the singleton hasn't been created, do it now.
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
    if (!getController()) {
        setController(new DStubController());
    }

    return (getController());
}

DStubController::DStubController()
    : DControllerBase(D2_MODULE_NAME) {

    if (getenv("B10_FROM_BUILD")) {
        setSpecFileName(std::string(getenv("B10_FROM_BUILD")) +
            "/src/bin/d2/d2.spec");
    } else {
        setSpecFileName(D2_SPECFILE_LOCATION);
    }
}

bool
DStubController::customOption(int option, char* /* optarg */)
{
145 146 147
    // Check for the custom option supported by DStubController.
    if ((char)(option) == *stub_option_x_) {
        return (true);
148
    }
149

150 151 152 153 154
    return (false);
}

DProcessBase* DStubController::createProcess() {
    if (SimFailure::shouldFailOn(SimFailure::ftCreateProcessException)) {
155
        // Simulates a failure to instantiate the process due to exception.
156 157 158 159
        throw std::runtime_error("SimFailure::ftCreateProcess");
    }

    if (SimFailure::shouldFailOn(SimFailure::ftCreateProcessNull)) {
160
        // Simulates a failure to instantiate the process.
161 162 163 164 165 166 167 168 169 170 171 172
        return (NULL);
    }

    // This should be a successful instantiation.
    return (new DStubProcess(getName().c_str(), getIOService()));
}

isc::data::ConstElementPtr
DStubController::customControllerCommand(const std::string& command,
                                     isc::data::ConstElementPtr /* args */) {
    isc::data::ConstElementPtr answer;
    if (SimFailure::shouldFailOn(SimFailure::ftControllerCommand)) {
173
        // Simulates command failing to execute.
174 175
        answer = isc::config::createAnswer(COMMAND_ERROR,
                                          "SimFailure::ftControllerCommand");
176
    } else if (command.compare(stub_ctl_command_) == 0) {
177 178 179 180 181 182 183 184 185 186
        answer = isc::config::createAnswer(COMMAND_SUCCESS, "Command accepted");
    } else {
        answer = isc::config::createAnswer(COMMAND_INVALID,
                                           "Unrecognized command:" + command);
    }

    return (answer);
}

const std::string DStubController::getCustomOpts(){
187 188
    // Return the "list" of custom options supported by DStubController.
    return (std::string(stub_option_x_));
189 190 191 192 193
}

DStubController::~DStubController() {
}

194
// Initialize controller wrapper's static instance getter member.
195 196
DControllerTest::InstanceGetter DControllerTest::instanceGetter_ = NULL;

197
}; // namespace isc::d2
198
}; // namespace isc