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