d_controller.h

Go to the documentation of this file.

// Copyright (C) 2013-2018 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef D_CONTROLLER_H
#define D_CONTROLLER_H

#include <asiolink/io_service.h>
#include <cc/data.h>
#include <exceptions/exceptions.h>
#include <log/logger_support.h>
#include <process/daemon.h>
#include <process/d_log.h>
#include <process/d_process.h>
#include <process/io_service_signal.h>

#include <boost/shared_ptr.hpp>
#include <boost/noncopyable.hpp>

#include <string>
#include <set>

namespace isc {
namespace process {

class InvalidUsage : public isc::Exception {
public:
    InvalidUsage(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};

class VersionMessage : public isc::Exception {
public:
    VersionMessage(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};

class LaunchError: public isc::Exception {
public:
    LaunchError (const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};

class ProcessInitError: public isc::Exception {
public:
    ProcessInitError (const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};

class ProcessRunError: public isc::Exception {
public:
    ProcessRunError (const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};

class DControllerBaseError : public isc::Exception {
public:
    DControllerBaseError (const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};


class DControllerBase;
typedef boost::shared_ptr<DControllerBase> DControllerBasePtr;

class DControllerBase : public Daemon {
public:
    DControllerBase(const char* app_name, const char* bin_name);

    virtual ~DControllerBase();

    std::string getVersion(bool extended);

    virtual void launch(int argc, char* argv[], const bool test_mode);

    virtual isc::data::ConstElementPtr updateConfig(isc::data::ConstElementPtr
                                                    new_config);

    virtual isc::data::ConstElementPtr checkConfig(isc::data::ConstElementPtr
                                                   new_config);

    virtual isc::data::ConstElementPtr configFromFile();

    std::string getAppName() const {
        return (app_name_);
    }

    std::string getBinName() const {
        return (bin_name_);
    }

    isc::data::ConstElementPtr
    versionGetHandler(const std::string& command,
                      isc::data::ConstElementPtr args);

    isc::data::ConstElementPtr
    buildReportHandler(const std::string& command,
                       isc::data::ConstElementPtr args);

    isc::data::ConstElementPtr
    configGetHandler(const std::string& command,
                     isc::data::ConstElementPtr args);

    isc::data::ConstElementPtr
    configWriteHandler(const std::string& command,
                       isc::data::ConstElementPtr args);

    isc::data::ConstElementPtr
    configTestHandler(const std::string& command,
                      isc::data::ConstElementPtr args);

    isc::data::ConstElementPtr
    shutdownHandler(const std::string& command,
                    isc::data::ConstElementPtr args);

protected:
    virtual bool customOption(int option, char *optarg);

    virtual DProcessBase* createProcess() = 0;

    virtual const std::string getUsageText() const {
        return ("");
    }

    virtual const std::string getCustomOpts() const {
        return ("");
    }

    void checkConfigOnly();

    virtual void processSignal(int signum);

    bool isVerbose() const {
        return (verbose_);
    }

    void setVerbose(bool value) {
        verbose_ = value;
    }

    bool isCheckOnly() const {
        return (check_only_);
    }

    void setCheckOnly(bool value) {
        check_only_ = value;
    }

    asiolink::IOServicePtr& getIOService() {
        return (io_service_);
    }

    static DControllerBasePtr& getController() {
        return (controller_);
    }

    static void setController(const DControllerBasePtr& controller);

    void parseArgs(int argc, char* argv[]);


    virtual isc::data::ConstElementPtr parseFile(const std::string& file_name);

    virtual isc::data::ConstElementPtr parseText(const std::string& input) {
        static_cast<void>(input); // just tu shut up the unused parameter warning
        isc::data::ConstElementPtr elements;
        return (elements);
    }

    void initProcess();

    // @throw throws DControllerBaseError or indirectly DProcessBaseError
    void runProcess();

    isc::data::ConstElementPtr shutdownProcess(isc::data::ConstElementPtr args);

    void initSignalHandling();

    bool osSignalHandler(int signum);

    void ioSignalHandler(IOSignalId sequence_id);

    DProcessBasePtr getProcess() {
        return (process_);
    }

    void usage(const std::string& text);

    virtual std::string getVersionAddendum() { return (""); }

private:
    std::string app_name_;

    std::string bin_name_;

    bool verbose_;

    bool check_only_;

    DProcessBasePtr process_;

    asiolink::IOServicePtr io_service_;

    IOSignalQueuePtr io_signal_queue_;

    static DControllerBasePtr controller_;

// DControllerTest is named a friend class to facilitate unit testing while
// leaving the intended member scopes intact.
friend class DControllerTest;
};

}; // namespace isc::process
}; // namespace isc

#endif