utils::ConfigRoot Class Reference

#include <Config.h>

Inheritance diagram for utils::ConfigRoot:

Collaboration diagram for utils::ConfigRoot:

Public Member Functions
	~ConfigRoot () override
ConfigRoot *	addRootOptions (const std::string &applicationName, const std::string &userName, const std::string &groupName, const std::string &configDirectory, const std::string &logDirectory, const std::string &pidDirectory)
bool	parse1 (int argc, char *argv[])
bool	bootstrap (int argc, char *argv[])
void	terminate ()
Public Member Functions inherited from utils::SubCommand
	SubCommand (const SubCommand &)=delete
	SubCommand (SubCommand &&)=delete
SubCommand &	operator= (const SubCommand &)=delete
SubCommand &	operator= (SubCommand &&)=delete
virtual	~SubCommand ()
std::string	getName () const
std::string	version () const
void	parse (int argc, char *argv[])
CLI::Option *	setConfig (const std::string &defaultConfigFile) const
CLI::Option *	setLogFile (const std::string &defaultLogFile) const
CLI::Option *	setVersionFlag (const std::string &version) const
bool	hasParent () const
SubCommand *	getParent ()
SubCommand *	allowExtras (bool allow=true)
SubCommand *	required (bool required=true, bool force=true)
SubCommand *	required (SubCommand *subCommand, bool required=true)
SubCommand *	required (CLI::Option *option, bool required=true)
SubCommand *	needs (SubCommand *subCommand, bool needs=true)
SubCommand *	disabled (SubCommand *subCommand, bool disabled=true)
SubCommand *	setRequireCallback (const std::function< void(void)> &callback)
SubCommand *	finalCallback (const std::function< void()> &finalCallback)
std::string	configToStr () const
std::string	help (const CLI::App *helpApp, const CLI::AppFormatMode &mode) const
template<typename NewSubCommand, typename... Args>
NewSubCommand *	newSubCommand (Args &&... args)
template<typename RequestedSubCommand>
RequestedSubCommand *	getSubCommand ()
template<typename RequestedSubCommand>
RequestedSubCommand *	getSubCommand () const
CLI::Option *	getOption (const std::string &name) const
CLI::Option *	addOption (const std::string &name, const std::string &description, const std::string &typeName, const CLI::Validator &validator) const
template<typename ValueTypeT>
CLI::Option *	addOption (const std::string &name, const std::string &description, const std::string &typeName, ValueTypeT defaultValue, const CLI::Validator &validator) const
template<typename ValueTypeT>
CLI::Option *	addOptionVariable (const std::string &name, ValueTypeT &variable, const std::string &description, const std::string &typeName, const CLI::Validator &additionalValidator) const
template<typename ValueTypeT>
CLI::Option *	addOptionVariable (const std::string &name, ValueTypeT &variable, const std::string &description, const std::string &typeName, ValueTypeT defaultValue, const CLI::Validator &additionalValidator) const
CLI::Option *	addOptionFunction (const std::string &name, std::function< void(const std::string &)> &callback, const std::string &description, const std::string &typeName, const CLI::Validator &validator) const
template<typename ValueTypeT>
CLI::Option *	addOptionFunction (const std::string &name, std::function< void(const std::string &)> &callback, const std::string &description, const std::string &typeName, ValueTypeT defaultValue, const CLI::Validator &validator) const
CLI::Option *	addFlag (const std::string &name, const std::string &description, const std::string &typeName, const CLI::Validator &validator) const
template<typename ValueTypeT>
CLI::Option *	addFlag (const std::string &name, const std::string &description, const std::string &typeName, ValueTypeT defaultValue, const CLI::Validator &validator) const
CLI::Option *	addFlagFunction (const std::string &name, const std::function< void()> &callback, const std::string &description, const std::string &typeName, const CLI::Validator &validator)
CLI::Option *	addFlagFunction (const std::string &name, const std::function< void()> &callback, const std::string &description, const std::string &typeName, const std::string &defaultValue, const CLI::Validator &validator)

Protected Member Functions
bool	parse2 (int argc, char *argv[], bool parse1=false)
Protected Member Functions inherited from utils::SubCommand
	SubCommand (SubCommand *parent, std::shared_ptr< utils::AppWithPtr > appWithPtr, const std::string &group, bool final)
template<typename ConcretSubCommand>
	SubCommand (SubCommand *parent, ConcretSubCommand *concretSubCommand, const std::string &group, bool final=true)
SubCommand *	description (const std::string &description)
SubCommand *	footer (const std::string &footer)
template<typename ValueTypeT>
CLI::Option *	setDefaultValue (CLI::Option *option, const ValueTypeT &value, bool clear=true) const
CLI::Option *	setConfigurable (CLI::Option *option, bool configurable) const

Private Member Functions
	ConfigRoot ()

Private Attributes
std::string	applicationName
std::string	pidDirectory
CLI::Option *	daemonizeOpt = nullptr
CLI::Option *	logFileOpt = nullptr
CLI::Option *	monochromLogOpt = nullptr
CLI::Option *	userNameOpt = nullptr
CLI::Option *	groupNameOpt = nullptr
CLI::Option *	enforceLogFileOpt = nullptr
CLI::Option *	logLevelOpt = nullptr
CLI::Option *	verboseLevelOpt = nullptr
CLI::Option *	quietOpt = nullptr
CLI::Option *	versionOpt = nullptr
CLI::Option *	writeConfigOpt = nullptr
CLI::Option *	killOpt = nullptr
CLI::Option *	aliasOpt = nullptr

Friends
class	Config

Additional Inherited Members
Static Public Member Functions inherited from utils::SubCommand
static CLI::App *	getHelpTriggerApp ()
static CLI::App *	getShowConfigTriggerApp ()
static CLI::App *	getCommandlineTriggerApp ()
Static Public Attributes inherited from utils::SubCommand
static std::shared_ptr< CLI::Formatter >	sectionFormatter = makeSectionFormatter()
Static Protected Attributes inherited from utils::SubCommand
static std::map< std::string, std::string >	aliases
static CLI::App *	helpTriggerApp = nullptr
static CLI::App *	showConfigTriggerApp = nullptr
static CLI::App *	commandlineTriggerApp = nullptr

Detailed Description

Definition at line 58 of file Config.h.

Constructor & Destructor Documentation

ConfigRoot()

utils::ConfigRoot::ConfigRoot ( )

private

Definition at line 357 of file Config.cpp.

        : utils::SubCommand(
              nullptr, utils::Config::configRootApp = std::make_shared<utils::AppWithPtr>("Root of config", "", this, false), "", false) {
        logger::Logger::init();
    }

References utils::Config::configRootApp, logger::Logger::init(), and utils::SubCommand::SubCommand().

Here is the call graph for this function:

~ConfigRoot()

utils::ConfigRoot::~ConfigRoot ( )

override

Definition at line 363 of file Config.cpp.

                            {
    }

Member Function Documentation

addRootOptions()

ConfigRoot * utils::ConfigRoot::addRootOptions	(	const std::string &	applicationName,
		const std::string &	userName,
		const std::string &	groupName,
		const std::string &	configDirectory,
		const std::string &	logDirectory,
		const std::string &	pidDirectory )

Definition at line 366 of file Config.cpp.

                                                                          {
        this->applicationName = applicationName;
        this->pidDirectory = pidDirectory;
 
        description("Configuration for Application '" + applicationName + "'");
 
        footer("Application '" + applicationName +
               "' powered by SNode.C\n"
               "(C) 2020-2026 Volker Christian <me@vchrist.at>\n"
               "https://github.com/SNodeC/snode.c");
 
        setConfig(configDirectory + "/" + applicationName + ".conf");
 
        writeConfigOpt = setConfigurable(addOption( //
                                             "-w,--write-config",
                                             "Write config file and exit",
                                             "configfile",
                                             configDirectory + "/" + applicationName + ".conf",
                                             !CLI::ExistingDirectory),
                                         false)
                             ->expected(0, 1);
 
        killOpt = setConfigurable(addFlag("-k,--kill", "Kill running daemon", "", CLI::Validator()), false);
 
        logLevelOpt = setConfigurable(addOption("--log-level", "Log level", "level", 4, CLI::Range(0, 6)), true);
 
        verboseLevelOpt = setConfigurable(addOption("--verbose-level", "Verbose level", "level", 2, CLI::Range(0, 10)), true);
 
        logFileOpt = setConfigurable(setLogFile(logDirectory + "/" + applicationName + ".log"), true);
 
        monochromLogOpt = setConfigurable(addFlagFunction( //
                                              "-m{true},--monochrom-logmonochromLogOption{true}",
                                              [&monochromLogOpt = this->monochromLogOpt]() {
                                                  if (monochromLogOpt->as<bool>()) {
                                                      logger::Logger::setDisableColor(true);
                                                  } else {
                                                      logger::Logger::setDisableColor(false);
                                                  }
                                              },
                                              "Monochrom log output",
                                              "bool",
                                              logger::Logger::getDisableColor() ? "true" : "false",
                                              CLI::IsMember({"true", "false"})),
                                          true)
                              ->trigger_on_parse();
 
        quietOpt = setConfigurable(addFlag( //
                                       "-q{true},--quiet{true}",
                                       "Quiet mode",
                                       "bool",
                                       "false",
                                       CLI::IsMember({"true", "false"})),
                                   true);
 
        enforceLogFileOpt = setConfigurable(addFlag( //
                                                "-e{true},--enforce-log-file{true}",
                                                "Enforce writing of logs to file for foreground applications",
                                                "bool",
                                                "false",
                                                CLI::IsMember({"true", "false"})),
                                            true);
 
        daemonizeOpt = setConfigurable(addFlag( //
                                           "-d{true},--daemonize{true}",
                                           "Start application as daemon",
                                           "bool",
                                           "false",
                                           CLI::IsMember({"true", "false"})),
                                       true);
 
        userNameOpt = setConfigurable(addOption( //
                                          "-u,--user-name",
                                          "Run daemon under specific user permissions",
                                          "username",
                                          userName,
                                          CLI::TypeValidator<std::string>()),
                                      true);
 
        groupNameOpt = setConfigurable(addOption( //
                                           "-g,--group-name",
                                           "Run daemon under specific group permissions",
                                           "groupname",
                                           groupName,
                                           CLI::TypeValidator<std::string>()),
                                       true);
 
        aliasOpt = setConfigurable(addOption("-a,--aliases",
                                             "Make an instance also known as an alias in configuration files",
                                             "instance=instance_alias [instance=instance_alias [...]]",
                                             CLI::TypeValidator<std::string>()),
                                   false);
 
        versionOpt = setVersionFlag("1.0-rc1");
 
        return this;
    }

References utils::SubCommand::addFlag(), utils::SubCommand::addFlag(), utils::SubCommand::addFlagFunction(), utils::SubCommand::addOption(), utils::SubCommand::addOption(), aliasOpt, applicationName, daemonizeOpt, utils::SubCommand::description(), enforceLogFileOpt, utils::SubCommand::footer(), logger::Logger::getDisableColor(), groupNameOpt, killOpt, logFileOpt, logLevelOpt, monochromLogOpt, pidDirectory, quietOpt, utils::SubCommand::setConfig(), utils::SubCommand::setConfigurable(), logger::Logger::setDisableColor(), utils::SubCommand::setLogFile(), utils::SubCommand::setVersionFlag(), userNameOpt, verboseLevelOpt, versionOpt, and writeConfigOpt.

Referenced by utils::Config::init().

Here is the call graph for this function:

Here is the caller graph for this function:

bootstrap()

bool utils::ConfigRoot::bootstrap	(	int	argc,
		char *	argv[] )

Definition at line 500 of file Config.cpp.

                                                     {
        finalCallback([this]() {
            if (daemonizeOpt->as<bool>() && helpTriggerApp == nullptr && showConfigTriggerApp == nullptr && writeConfigOpt->count() == 0 &&
                commandlineTriggerApp == nullptr) {
                std::cout << "Running as daemon (double fork)" << std::endl;
 
                utils::Daemon::startDaemon(
                    pidDirectory + "/" + applicationName + ".pid", userNameOpt->as<std::string>(), groupNameOpt->as<std::string>());
 
                logger::Logger::setQuiet();
 
                const std::string logFile = logFileOpt->as<std::string>();
                if (!logFile.empty()) {
                    logger::Logger::logToFile(logFile);
                }
            } else if (enforceLogFileOpt->as<bool>()) {
                const std::string logFile = logFileOpt->as<std::string>();
                if (!logFile.empty()) {
                    std::cout << "Writing logs to file " << logFile << std::endl;
 
                    logger::Logger::logToFile(logFile);
                }
            }
        });
 
        return parse2(argc, argv);
    }

References applicationName, utils::SubCommand::commandlineTriggerApp, daemonizeOpt, enforceLogFileOpt, utils::SubCommand::finalCallback(), groupNameOpt, utils::SubCommand::helpTriggerApp, logFileOpt, logger::Logger::logToFile(), parse2(), pidDirectory, logger::Logger::setQuiet(), utils::SubCommand::showConfigTriggerApp, utils::Daemon::startDaemon(), userNameOpt, and writeConfigOpt.

Referenced by utils::Config::bootstrap().

Here is the call graph for this function:

Here is the caller graph for this function:

parse1()

bool utils::ConfigRoot::parse1	(	int	argc,
		char *	argv[] )

Definition at line 468 of file Config.cpp.

                                                  {
        bool proceed = parse2(argc, argv, true);
 
        if (proceed) {
            if (killOpt->count() > 0) {
                try {
                    const pid_t daemonPid =
                        utils::Daemon::stopDaemon(pidDirectory + "/" + std::string(std::filesystem::path(argv[0]).filename()) + ".pid");
                    std::cout << "Daemon terminated: Pid = " << daemonPid << std::endl;
                } catch (const DaemonError& e) {
                    std::cout << "DaemonError: " << e.what() << std::endl;
                } catch (const DaemonFailure& e) {
                    std::cout << "DaemonFailure: " << e.what() << std::endl;
                }
 
                proceed = false;
            } else {
                if (helpTriggerApp == nullptr && showConfigTriggerApp == nullptr && commandlineTriggerApp == nullptr &&
                    versionOpt->count() == 0) {
                    logger::Logger::setLogLevel(logLevelOpt->as<int>());
                    logger::Logger::setVerboseLevel(verboseLevelOpt->as<int>());
                }
 
                logger::Logger::setQuiet(quietOpt->as<bool>());
 
                allowExtras(false);
            }
        }
 
        return proceed;
    }

References utils::SubCommand::allowExtras(), utils::SubCommand::commandlineTriggerApp, utils::SubCommand::helpTriggerApp, killOpt, logLevelOpt, parse2(), pidDirectory, quietOpt, logger::Logger::setLogLevel(), logger::Logger::setQuiet(), logger::Logger::setVerboseLevel(), utils::SubCommand::showConfigTriggerApp, utils::Daemon::stopDaemon(), verboseLevelOpt, and versionOpt.

Referenced by utils::Config::init().

Here is the call graph for this function:

Here is the caller graph for this function:

parse2()

bool utils::ConfigRoot::parse2 ( int argc, char * argv[], bool parse1 = false )

protected

Definition at line 547 of file Config.cpp.

                                                               {
        bool proceed = false;
 
        try {
            try {
                try {
                    aliases.clear();
 
                    helpTriggerApp = nullptr;
                    showConfigTriggerApp = nullptr;
                    commandlineTriggerApp = nullptr;
 
                    parse(argc, argv);
 
                    if (!parse1) {
                        if (showConfigTriggerApp != nullptr) {
                            std::cout << getConfig(showConfigTriggerApp);
                        } else if (commandlineTriggerApp != nullptr) {
                            std::cout << getCommandLine(commandlineTriggerApp);
                        } else if (getOption("--write-config")->count() > 0) {
                            std::cout << doWriteConfig(this);
                        } else {
                            proceed = true;
                        }
                    } else {
                        proceed = true;
                    }
                } catch (const CLI::Success&) {
                    if (!parse1) {
                        throw;
                    }
 
                    proceed = true;
                } catch (const CLI::ParseError& e) {
                    if (helpTriggerApp != nullptr || showConfigTriggerApp != nullptr || commandlineTriggerApp != nullptr ||
                        versionOpt->count() > 0) {
                        std::cout << std::string{"["} << Color::Code::FG_RED << e.get_name() << Color::Code::FG_DEFAULT << "] " << e.what()
                                  << std::endl
                                  << std::endl;
 
                        if (versionOpt->count() > 0) {
                            throw CLI::CallForVersion();
                        }
                        if (helpTriggerApp != nullptr) {
                            throw CLI::CallForHelp();
                        }
                        if (showConfigTriggerApp != nullptr) {
                            std::cout << getConfig(showConfigTriggerApp);
                        } else if (commandlineTriggerApp != nullptr) {
                            std::cout << getCommandLine(commandlineTriggerApp);
                        }
                    } else {
                        logger::Logger::setQuiet();
                        throw;
                    }
                }
            } catch (const DaemonError& e) {
                std::cout << std::string{"["} << Color::Code::FG_RED << "Error" << Color::Code::FG_DEFAULT << "] Daemonize: " << e.what()
                          << " ... exiting" << std::endl;
            } catch (const DaemonFailure& e) {
                std::cout << std::string{"["} << Color::Code::FG_RED << "Failure" << Color::Code::FG_DEFAULT << "] Daemonize: " << e.what()
                          << " ... exiting" << std::endl;
            } catch (const DaemonSignaled& e) {
                std::cout << "Pid: " << getpid() << ", child pid: " << e.getPid() << ": " << e.what() << std::endl;
            } catch (const CLI::CallForHelp&) {
                std::cout << getHelp(this, helpTriggerApp);
            } catch (const CLI::CallForVersion&) {
                std::cout << version() << std::endl << std::endl;
            } catch (const CLI::ConversionError& e) {
                std::cout << std::string{"["} << Color::Code::FG_RED << e.get_name() << Color::Code::FG_DEFAULT << "] " << e.what()
                          << std::endl;
                throw;
            } catch (const CLI::ArgumentMismatch& e) {
                std::cout << std::string{"["} << Color::Code::FG_RED << e.get_name() << Color::Code::FG_DEFAULT << "] " << e.what()
                          << std::endl;
                throw;
            } catch (const CLI::ConfigError& e) {
                std::cout << std::string{"["} << Color::Code::FG_RED << e.get_name() << Color::Code::FG_DEFAULT << "] " << e.what()
                          << std::endl;
                std::cout << "              Adding '-w' on the command line may solve this problem" << std::endl;
                throw;
            } catch (const CLI::ParseError& e) {
                const std::string what = e.what();
                if (what.find("[Option Group: ") != std::string::npos) { // If CLI11 throws that error it means for us there are
                                                                         // unconfigured anonymous instances
                    std::cout << Color::Code::FG_RED << e.get_name() << Color::Code::FG_DEFAULT
                              << " Anonymous instance(s) not configured in source code " << std::endl;
                } else {
                    std::cout << std::string{"["} << Color::Code::FG_RED << e.get_name() << Color::Code::FG_DEFAULT << "] " << what
                              << std::endl;
                }
                throw;
            }
        } catch ([[maybe_unused]] const CLI::ParseError& e) {
            std::cout << std::endl << "Append -h or --help to your command line for more information." << std::endl;
        } catch (const CLI::Error& e) {
            std::cout << std::string{"["} << Color::Code::FG_RED << e.get_name() << Color::Code::FG_DEFAULT << "] " << e.what()
                      << std::endl;
 
            std::cout << std::endl << "Append -h or --help to your command line for more information." << std::endl;
        }
 
        return proceed;
    }

References utils::SubCommand::aliases, utils::SubCommand::commandlineTriggerApp, utils::doWriteConfig(), Color::FG_DEFAULT, Color::FG_RED, utils::getCommandLine(), utils::getConfig(), utils::getHelp(), utils::SubCommand::getOption(), utils::DaemonSignaled::getPid(), utils::SubCommand::helpTriggerApp, utils::SubCommand::parse(), logger::Logger::setQuiet(), utils::SubCommand::showConfigTriggerApp, utils::SubCommand::version(), and versionOpt.

Referenced by bootstrap(), and parse1().

Here is the call graph for this function:

Here is the caller graph for this function:

terminate()

void utils::ConfigRoot::terminate

(

)

Definition at line 528 of file Config.cpp.

                               {
        if (daemonizeOpt->as<bool>()) {
            std::ifstream pidFile(pidDirectory + "/" + applicationName + ".pid", std::ifstream::in);
 
            if (pidFile.good()) {
                pid_t pid = 0;
                pidFile >> pid;
 
                if (getpid() == pid) {
                    Daemon::erasePidFile(pidDirectory + "/" + applicationName + ".pid");
                }
            }
        } else if (fcntl(STDIN_FILENO, F_SETFL, O_NONBLOCK) >= 0) {
            char buf[1024];
            while (read(STDIN_FILENO, buf, 1024) > 0) {
            }
        }
    }

References applicationName, daemonizeOpt, utils::Daemon::erasePidFile(), and pidDirectory.

Referenced by utils::Config::terminate().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

Config

friend class Config

friend

Definition at line 97 of file Config.h.

Member Data Documentation

aliasOpt

CLI::Option* utils::ConfigRoot::aliasOpt = nullptr

private

Definition at line 95 of file Config.h.

Referenced by addRootOptions().

applicationName

std::string utils::ConfigRoot::applicationName

private

Definition at line 80 of file Config.h.

Referenced by addRootOptions(), bootstrap(), and terminate().

daemonizeOpt

CLI::Option* utils::ConfigRoot::daemonizeOpt = nullptr

private

Definition at line 83 of file Config.h.

Referenced by addRootOptions(), bootstrap(), and terminate().

enforceLogFileOpt

CLI::Option* utils::ConfigRoot::enforceLogFileOpt = nullptr

private

Definition at line 88 of file Config.h.

Referenced by addRootOptions(), and bootstrap().

groupNameOpt

CLI::Option* utils::ConfigRoot::groupNameOpt = nullptr

private

Definition at line 87 of file Config.h.

Referenced by addRootOptions(), and bootstrap().

killOpt

CLI::Option* utils::ConfigRoot::killOpt = nullptr

private

Definition at line 94 of file Config.h.

Referenced by addRootOptions(), and parse1().

logFileOpt

CLI::Option* utils::ConfigRoot::logFileOpt = nullptr

private

Definition at line 84 of file Config.h.

Referenced by addRootOptions(), and bootstrap().

logLevelOpt

CLI::Option* utils::ConfigRoot::logLevelOpt = nullptr

private

Definition at line 89 of file Config.h.

Referenced by addRootOptions(), utils::Config::getLogLevel(), and parse1().

monochromLogOpt

CLI::Option* utils::ConfigRoot::monochromLogOpt = nullptr

private

Definition at line 85 of file Config.h.

Referenced by addRootOptions().

pidDirectory

std::string utils::ConfigRoot::pidDirectory

private

Definition at line 81 of file Config.h.

Referenced by addRootOptions(), bootstrap(), parse1(), and terminate().

quietOpt

CLI::Option* utils::ConfigRoot::quietOpt = nullptr

private

Definition at line 91 of file Config.h.

Referenced by addRootOptions(), and parse1().

userNameOpt

CLI::Option* utils::ConfigRoot::userNameOpt = nullptr

private

Definition at line 86 of file Config.h.

Referenced by addRootOptions(), and bootstrap().

verboseLevelOpt

CLI::Option* utils::ConfigRoot::verboseLevelOpt = nullptr

private

Definition at line 90 of file Config.h.

Referenced by addRootOptions(), utils::Config::getVerboseLevel(), and parse1().

versionOpt

CLI::Option* utils::ConfigRoot::versionOpt = nullptr

private

Definition at line 92 of file Config.h.

Referenced by addRootOptions(), parse1(), and parse2().

writeConfigOpt

CLI::Option* utils::ConfigRoot::writeConfigOpt = nullptr

private

Definition at line 93 of file Config.h.

Referenced by addRootOptions(), and bootstrap().

---

The documentation for this class was generated from the following files:

• utils/Config.h
• utils/Config.cpp