ProcessConfigurationImpl.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/Utilities/ProcessConfigurationImpl.h>

#include <fesa-core/Exception/FesaException.h>

#include <cmw-util/FileUtils.h>

#include <iostream>
#include <sstream>
#include <boost/assign/list_of.hpp>


namespace
{

const std::string helpArg1 = "-h";
const std::string helpArg2 = "-help";
const std::string cmwServerNameArg = "-cmwServerName";
const std::string instanceFileArg = "-instance";
const std::string timingSimulationArg = "-timsim";
const std::string noRTSchedulingArg = "-noRTSched";
const std::string verboseModeArg = "-v";
const std::string veryVerboseModeArg = "-vv";
const std::string cfgFesaArg = "-cfgfesa";
const std::string cfgLogArg = "-cfglog";
const std::string cfgMsgArg = "-cfgmsg";
const std::string cfgMsgLabArg = "-cfgmsglab";
const std::string cfgCMWArg = "-cfgcmw";
const std::string confDirArg = "-confdir";

const std::string fesaCfgFileName = "fesa.cfg";
const std::string logCfgFileName = "log.cfg";
const std::string msgCfgFileName = "messages.cfg";
const std::string msgLabCfgFileName = "messagesLab.cfg";
const std::string cmwCfgFileName = "cmw.cfg";
const std::string defaultTimSimCfgFileName = "./TimingSimulationConfig.xml";

CMW::Util::CmdOptions::CmdArgList cmdArgList = boost::assign::list_of<CMW::Util::CmdArg*>
    (new CMW::Util::CmdArg(helpArg1, "Display usage", false))
    (new CMW::Util::CmdArg(helpArg2, "Display usage", false))
    (new CMW::Util::CmdArgString(cmwServerNameArg, "Set CMW server name", false))
    (new CMW::Util::CmdArgString(instanceFileArg, "Specify location and name of the instantiation file", false))
    (new CMW::Util::CmdArgString(timingSimulationArg, "Enable simulated timing. It will be configured either from the xml-file specified with this argument or from TimingSimulationConfig.xml in the current directory by default", false))
    (new CMW::Util::CmdArg(noRTSchedulingArg, "Start FESA process without RT scheduling", false))
    (new CMW::Util::CmdArg(verboseModeArg, "Enable verbose mode", false))
    (new CMW::Util::CmdArg(veryVerboseModeArg, "Enable very verbose mode", false))
    (new CMW::Util::CmdArgString(cfgFesaArg, "Specify location and name of custom FESA configuration file", false))
    (new CMW::Util::CmdArgString(cfgLogArg, "Specify location and name of custom logging configuration file", false))
    (new CMW::Util::CmdArgString(cfgMsgArg, "Specify location and name of custom file with exception messages", false))
    (new CMW::Util::CmdArgString(cfgMsgLabArg, "Specify location and name of custom file with lab specific exception messages", false))
    (new CMW::Util::CmdArgString(cfgCMWArg, "Specify location and name of custom middleware configuration file", false))
    (new CMW::Util::CmdArgString(confDirArg, "Specify directory where configuration files are", false));


std::string
lookUpFile(const std::vector<std::string>& dirs, const std::string& fileName)
{
    std::string file;
    std::vector<std::string>::const_iterator iter;
    for (iter = dirs.begin(); iter != dirs.end(); ++iter)
    {
        const std::string name = *iter + fileName;
        if (CMW::Util::FileUtils::fileExists(name) == true)
        {
            file = name;
            break;
        }
    }
    return file;
}

} // namespace


namespace fesa
{

ProcessConfigurationImpl::ProcessConfigurationImpl(int argc, char* argv[]) 
    : cmdOptions_(cmdArgList),
      timingSimulationMode_(false),
      loggingMode_(LoggingMode::normal)
{
    try
    {
        cmdOptions_.parse(argc, argv);
    }
    catch (const CMW::Util::UtilException& ex)
    {
        std::ostringstream errorStrStream;
        errorStrStream << ex.what() << ". Run " << argv[0] << " -h to get usage information";
        throw FesaException(__FILE__, __LINE__, errorStrStream.str());
    }
}


ProcessConfigurationImpl::~ProcessConfigurationImpl()
{
}


bool
ProcessConfigurationImpl::isHelpNeeded() const
{
    if (cmdOptions_.isOptionDefined(helpArg1) == true || cmdOptions_.isOptionDefined(helpArg2) == true)
    {
        return true;
    }
    return false;
}


void
ProcessConfigurationImpl::printHelp() const
{
    std::cout << cmdOptions_.usage() << std::endl;
}


void
ProcessConfigurationImpl::load(const ConfigDirs& configDirs)
{
    // Configuration files directory
    ConfigDirs dirs(configDirs);
    if (cmdOptions_.isOptionDefined(confDirArg) == true)
    {
        dirs.insert(dirs.begin(), cmdOptions_.getOption(confDirArg));
    }
    // FESA configuration file
    if (cmdOptions_.isOptionDefined(cfgFesaArg) == true)
    {
        fesaCfgFile_ = cmdOptions_.getOption(cfgFesaArg);
    }
    else
    {
        fesaCfgFile_ = lookUpFile(dirs, fesaCfgFileName);
    }
    properties_ = CMW::Util::Properties(fesaCfgFile_);
    std::cout << "FESA configuration loaded from " << fesaCfgFile_ << std::endl; // Logging is not initialized at this point
    // Logging configuration file
    if (cmdOptions_.isOptionDefined(cfgLogArg) == true)
    {
        logCfgFile_ = cmdOptions_.getOption(cfgLogArg);
    }
    else
    {
        logCfgFile_ = lookUpFile(dirs, logCfgFileName);
    }
    // Exception messages file
    if (cmdOptions_.isOptionDefined(cfgMsgArg) == true)
    {
        msgCfgFile_ = cmdOptions_.getOption(cfgMsgArg);
    }
    else
    {
        msgCfgFile_ = lookUpFile(dirs, msgCfgFileName);
    }
    // Lab-specific exception messages file
    if (cmdOptions_.isOptionDefined(cfgMsgLabArg) == true)
    {
        msgLabCfgFile_ = cmdOptions_.getOption(cfgMsgLabArg);
    }
    else
    {
        msgLabCfgFile_ = lookUpFile(dirs, msgLabCfgFileName);
    }
    // CMW configuration file
    if (cmdOptions_.isOptionDefined(cfgCMWArg) == true)
    {
        cmwCfgFile_ = cmdOptions_.getOption(cfgCMWArg);
    }
    else
    {
        cmwCfgFile_ = lookUpFile(dirs, cmwCfgFileName);
    }
    // CMW server name
    if (cmdOptions_.isOptionDefined(cmwServerNameArg) == true)
    {
        cmwServerName_ = cmdOptions_.getOption(cmwServerNameArg);
    }
    // Instantiation file
    if (cmdOptions_.isOptionDefined(instanceFileArg) == true)
    {
        properties_.setProperty(PropertyTag::INSTANCE_FILE, cmdOptions_.getOption(instanceFileArg) );
    }
    // Timing simulation
    if (cmdOptions_.isOptionDefined(timingSimulationArg) == true)
    {
        timingSimulationMode_ = true;
        timingSimulationCfgFile_ = cmdOptions_.getOption(timingSimulationArg);
        if (timingSimulationCfgFile_.empty() == true)
        {
            timingSimulationCfgFile_ = defaultTimSimCfgFileName;
        }
        properties_.setProperty(PropertyTag::TIMING_SIMULATION, timingSimulationCfgFile_);
    }
    // RT scheduling
    if (cmdOptions_.isOptionDefined(noRTSchedulingArg) == true)
    {
        properties_.setProperty(PropertyTag::NO_RT_SCHEDULING, "true");
    }
    // Verbose mode
    if (cmdOptions_.isOptionDefined(verboseModeArg) == true)
    {
        loggingMode_ = LoggingMode::verbose;
    }
    // Very verbose mode
    if (cmdOptions_.isOptionDefined(veryVerboseModeArg) == true)
    {
        loggingMode_ = LoggingMode::veryVerbose;
    }
}


const std::string&
ProcessConfigurationImpl::getLogConfigFile() const
{
    return logCfgFile_;
}


const std::string&
ProcessConfigurationImpl::getCMWConfigFile() const
{
    return cmwCfgFile_;
}


const std::string&
ProcessConfigurationImpl::getMsgConfigFile() const
{
    return msgCfgFile_;
}


const std::string&
ProcessConfigurationImpl::getLabMsgConfigFile() const
{
    return msgLabCfgFile_;
}


bool
ProcessConfigurationImpl::isInTimingSimulationMode() const
{
    return timingSimulationMode_;
}


const std::string&
ProcessConfigurationImpl::getCMWServerName() const
{
    return cmwServerName_;
}


void
ProcessConfigurationImpl::setCMWServerName(const std::string& name)
{
    cmwServerName_ = name;
}


LoggingMode::LoggingMode
ProcessConfigurationImpl::getLoggingMode() const
{
    return loggingMode_;
}


bool
ProcessConfigurationImpl::isDefined(const std::string& tag) const
{
    std::string value;
    if (properties_.getProperty(tag, value) == false)
    {
        return false;
    }
    return true;
}


std::string
ProcessConfigurationImpl::getStringValue(const std::string& tag) const
{
    std::string value;
    if (properties_.getProperty(tag, value) == false)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorCFGParameterNotFound.c_str(), tag.c_str());
    }
    return value;
}


int
ProcessConfigurationImpl::getIntValue(const std::string& tag) const
{
    std::string valueStr = getStringValue(tag);
    const size_t found = valueStr.find_first_not_of("0123456789"); // Is string numerical?
    if (found != valueStr.npos)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorCFGParameterIsNotNumeric.c_str(), tag.c_str());
    }
    int value = 0;
    std::istringstream valueStrStream(valueStr);
    valueStrStream >> value;
    return value;
}


bool
ProcessConfigurationImpl::getBoolValue(const std::string& tag) const
{
    std::string valueStr = getStringValue(tag);
    bool value = false;
    if (valueStr == "true" || valueStr == "yes" || valueStr == "1")
    {
        value = true;
    }
    else if (valueStr == "false" || valueStr == "no" || valueStr == "0")
    {
        value = false;
    }
    else
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorCFGParameterIsNotBoolean.c_str(), tag.c_str());
    }
    return value;
}

} // fesa