daemon.h

Go to the documentation of this file.

// Copyright (C) 2014-2026 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 DAEMON_H
#define DAEMON_H
 
#include <cc/data.h>
#include <process/config_base.h>
#include <util/pid_file.h>
#include <asiolink/io_service_signal.h>
 
#include <boost/noncopyable.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
 
#include <list>
#include <string>
 
namespace isc {
namespace process {

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

class Daemon : public boost::noncopyable {
 
public:
    Daemon();

    virtual ~Daemon();

    virtual void cleanup();

    virtual void shutdown();

    static void loggerInit(const char* log_name, bool verbose);

    static void configureLogger(const isc::data::ConstElementPtr& log_config,
                                const isc::process::ConfigPtr& storage);

    static void setVerbose(const bool verbose);

    static bool getVerbose();

    static std::string getVersion(bool extended);

    std::string getConfigFile() const;

    void setConfigFile(const std::string& config_file);

    void checkConfigFile() const;

    void checkWriteConfigFile(std::string& file);

    virtual size_t
    writeConfigFile(const std::string& config_file,
                    isc::data::ConstElementPtr cfg = isc::data::ConstElementPtr()) const;

    static std::string getProcName();

    static void setProcName(const std::string& proc_name);

    std::string getPIDFileDir() const;

    void setPIDFileDir(const std::string& pid_file_dir);

    std::string getPIDFileName() const;

    std::string getPIDLockName() const;

    void setPIDFileName(const std::string& pid_file_name);

    void createPIDFile(int pid = 0);

    static std::string getDefaultLoggerName() {
        return (default_logger_name_);
    }

    static void setDefaultLoggerName(const std::string& logger) {
        default_logger_name_ = logger;
    }

    int getExitValue() {
        return (exit_value_);
    }

    void setExitValue(int value) {
        exit_value_ = value;
    }

    virtual std::list<std::list<std::string>> jsonPathsToRedact() const;

    isc::data::ConstElementPtr redactConfig(isc::data::ConstElementPtr const& config);

    static bool getShutdownOnFailure() {
        return (shutdown_on_failure_);
    }

    static void setShutdownOnFailure(bool shutdown) {
        shutdown_on_failure_ = shutdown;
    }

    static bool getCBRepairMode() {
        return (cb_repair_mode_);
    }

    static void setCBRepairMode(bool cb_repair_mode) {
        cb_repair_mode_ = cb_repair_mode;
    }
 
protected:

    isc::asiolink::IOSignalSetPtr signal_set_;

    std::string makePIDFileName() const;

    boost::posix_time::ptime start_;
 
private:
    std::string config_file_;

    static std::string proc_name_;

    std::string pid_file_dir_;

    isc::util::PIDFilePtr pid_file_;

    static bool verbose_;

    static std::string default_logger_name_;

    bool am_file_author_;

    int exit_value_;

    static bool shutdown_on_failure_;

    static bool cb_repair_mode_;
};
 
} // namespace process
} // namespace isc
 
#endif