d_test_stubs.cc 6.91 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14
// 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.

15
#include <d2/d2_log.h>
16 17 18 19 20 21 22 23
#include <d2/spec_config.h>
#include <d2/tests/d_test_stubs.h>

using namespace asio;

namespace isc {
namespace d2 {

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

27
// Define custom process command supported by DStubProcess.
28
const char*  DStubProcess::stub_proc_command_("cool_proc_cmd");
29

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

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

43
void
44 45 46 47
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.
48
    // To use run(), the "managing" layer must issue an io_service::stop
49 50 51 52 53 54 55 56 57
    // 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());
58 59
            isc_throw (DProcessBaseError,
                std::string("Process run method failed:") + ex.what());
60 61 62 63 64 65
        }
    }

    LOG_DEBUG(d2_logger, DBGLVL_START_SHUT, D2PRC_RUN_EXIT);
};

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

    DProcessBase::shutdown();
75
}
76

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

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

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

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

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

    return (answer);
}

DStubProcess::~DStubProcess() {
};

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

117
// Define custom controller command supported by DStubController.
118
const char* DStubController::stub_ctl_command_("spiffy");
119 120 121

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

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

    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 */)
{
149
    // Check for the custom option supported by DStubController.
150
    if (static_cast<char>(option) == *stub_option_x_) {
151
        return (true);
152
    }
153

154 155 156 157 158
    return (false);
}

DProcessBase* DStubController::createProcess() {
    if (SimFailure::shouldFailOn(SimFailure::ftCreateProcessException)) {
159
        // Simulates a failure to instantiate the process due to exception.
160 161 162 163
        throw std::runtime_error("SimFailure::ftCreateProcess");
    }

    if (SimFailure::shouldFailOn(SimFailure::ftCreateProcessNull)) {
164
        // Simulates a failure to instantiate the process.
165 166 167 168 169 170 171 172 173 174 175 176
        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)) {
177
        // Simulates command failing to execute.
178 179
        answer = isc::config::createAnswer(COMMAND_ERROR,
                                          "SimFailure::ftControllerCommand");
180
    } else if (command.compare(stub_ctl_command_) == 0) {
181 182 183 184 185 186 187 188 189
        answer = isc::config::createAnswer(COMMAND_SUCCESS, "Command accepted");
    } else {
        answer = isc::config::createAnswer(COMMAND_INVALID,
                                           "Unrecognized command:" + command);
    }

    return (answer);
}

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

DStubController::~DStubController() {
}

198
// Initialize controller wrapper's static instance getter member.
199 200
DControllerTest::InstanceGetter DControllerTest::instanceGetter_ = NULL;

201
}; // namespace isc::d2
202
}; // namespace isc