ServerApplication.cpp

Go to the documentation of this file.

#include <unistd.h>

#include "ServerApplication.hpp"

namespace HCE {   
    Poco::AutoPtr<Poco::Util::AbstractConfiguration> _config = NULL;
    
    namespace database {
        Poco::SharedPtr<HCE::database::DBSession> Session = NULL;
    }
}

HCE::ServerApplication::ServerApplication():_configFileRequest(false),_configFile(),_initializedHCEServerApplication(false)
{}

HCE::ServerApplication::~ServerApplication() throw() {
    if ( (HCE::database::Session.isNull() == false) && HCE::database::Session->isConnected()) {
        HCE::database::Session->close();
    }
}

void HCE::ServerApplication::initialize (Poco::Util::Application& self) {
    if (Poco::Util::Application::initialized() == true || this->_initializedHCEServerApplication == true) {
        throw HCE::AlreadyInitializedException(MESSAGE_ALREADY_INITIALIZED_EXCEPTION);
    }
    else {
        try {
            Poco::Util::ServerApplication::initialize(self);

            this->initializeConfigurationFile();
            this->initializeLoggers();
            this->initializeDataBaseSession ();
        
            this->_initializedHCEServerApplication = true;
        }
        catch (const Poco::NotFoundException& exception) {
                Poco::Message msg ("Application",exception.displayText() + this->ADDITION_INFORM_STRING_NOT_FOUND, Poco::Message::PRIO_CRITICAL,__FILE__,__LINE__);
                HCE::Logger::writeLog(msg);
        }
        catch (const Poco::Exception& exception) {
            Poco::Message msg ("Application",exception.displayText(),Poco::Message::PRIO_CRITICAL,__FILE__,__LINE__);
            HCE::Logger::writeLog(msg);
        }
        catch (const std::exception& exception) {
            Poco::Message msg ("Application",exception.what(),Poco::Message::PRIO_CRITICAL,__FILE__,__LINE__);
            HCE::Logger::writeLog(msg);
        }
    
        if (this->_initializedHCEServerApplication == false) {
            HCE::ServerApplication::uninitialize();
            //this exception catching in global main function.
            throw Poco::ApplicationException(APPLICATION_NOT_INITIALIZED_EXCEPTION);
        }
    }
}

void HCE::ServerApplication::reinitialize (Poco::Util::Application& self) {
    Poco::Util::ServerApplication::reinitialize(self);
    //...
}

void HCE::ServerApplication::uninitialize () {
    this->uninitializeDataBaseSession();
    //...
    Poco::Util::ServerApplication::uninitialize();
}

void HCE::ServerApplication::initializeConfigurationFile () {
    if (this->_configFileRequest == false) {
#ifdef PATH_TO_CONFIG_FILE
          try{
              Poco::Util::ServerApplication::loadConfiguration(PATH_TO_CONFIG_FILE);
          }
          catch(Poco::FileNotFoundException &exception){
              Poco::Util::ServerApplication::loadConfiguration();
          }
#else
          Poco::Util::ServerApplication::loadConfiguration();
#endif
    }
    else {
        Poco::Util::ServerApplication::loadConfiguration(this->_configFile);
    }
    //true - flag for duplicating counter
    HCE::_config = Poco::AutoPtr<Poco::Util::AbstractConfiguration>(&config(),true);
    poco_check_ptr (HCE::_config);
}

void HCE::ServerApplication::initializeDataBaseSession () {
        if (this->isDataBaseSectionExists()) {
                this->dataBaseType = this->getDBType();
                std::string initializeString;
                if (this->dataBaseType == SQLITE) {
                        initializeString = this->initializeSQLiteConnectionString();
                        Poco::Data::SQLite::Connector::registerConnector();
                        HCE::database::Session = new HCE::database::DBSession(SQLITE_KEY,initializeString);
                }
                //default type of database
                else {
                        initializeString = this->initializeMySQLConnectionString();
                        Poco::Data::MySQL::Connector::registerConnector();
                        HCE::database::Session = new HCE::database::DBSession(MYSQL_KEY,initializeString);
                }
                poco_check_ptr (HCE::database::Session);
        }
}

void HCE::ServerApplication::uninitializeDataBaseSession () {
        if (this->isDataBaseSectionExists()) {
                if (this->dataBaseType == SQLITE) {
                        Poco::Data::SQLite::Connector::unregisterConnector();
                }
                else {
                        Poco::Data::MySQL::Connector::unregisterConnector();
                }
        }
}

bool HCE::ServerApplication::isDataBaseSectionExists() {
        bool returnValue = false;
        Poco::Util::AbstractConfiguration::Keys keysInConfigurationFile;
        HCE::_config->keys(keysInConfigurationFile);
        auto it = find(keysInConfigurationFile.begin(),keysInConfigurationFile.end(),DataBase_KEY);
        if (it != keysInConfigurationFile.end()) {
                returnValue = true;
        }
        return returnValue;
}

std::string HCE::ServerApplication::initializeMySQLConnectionString() const {
    std::string host = HCE::_config->getString(DataBase_HOST);
    std::string user = HCE::_config->getString(DataBase_USER);
    std::string password = HCE::_config->getString(DataBase_PASSWORD);
    std::string db = HCE::_config->getString(DataBase_DB);
    std::string compress = HCE::_config->getString(DataBase_COMPRESS,DataBase_COMPRESS_DEFAULT);
    std::string auto_reconnect = HCE::_config->getString(DataBase_AUTO_RECONNECT,DataBase_AUTO_RECONNECT_DEFAULT);
    //set initialize string
    std::string initializeString("host=" + host + ";user=" + user + ";password=" + password + ";db=" + db + ";compress=" + compress + ";auto-reconnect=" + auto_reconnect);

    Poco::Message msg ("PocoWrapperSession",initializeString,Poco::Message::PRIO_INFORMATION,__FILE__,__LINE__);
    HCE::Logger::writeLog(msg);
        
    return initializeString;
}

std::string HCE::ServerApplication::initializeSQLiteConnectionString() const {
    std::string db = HCE::_config->getString(DataBase_DB);
    std::string initializeString("db=" + db);

    Poco::Message msg ("PocoWrapperSession",initializeString,Poco::Message::PRIO_INFORMATION,__FILE__,__LINE__);
    HCE::Logger::writeLog(msg);

    return initializeString;
}

std::string HCE::ServerApplication::getDBType () const {
    std::string type = HCE::_config->getString(DataBase_TYPE);
    return type;
}

void HCE::ServerApplication::initializeLoggers () {
    HCE::Logger::initializeLoggers();
}

void HCE::ServerApplication::defineOptions (Poco::Util::OptionSet& options) {
    Poco::Util::ServerApplication::defineOptions(options);

    options.addOption (
            Poco::Util::Option("config-file","f")
            .description ("Load configuration data from a file.")
            .required(false)
            .repeatable(false)
            .argument("file")
            .callback(Poco::Util::OptionCallback<HCE::ServerApplication>(this,&HCE::ServerApplication::handleConfigFile))
            );
    options.addOption (
                Poco::Util::Option("help","h")
                .description ("Show help information.")
                .required(false)
                .repeatable(false)
                .callback(Poco::Util::OptionCallback<HCE::ServerApplication>(this,&HCE::ServerApplication::handleHelp))
                );
    options.addOption (
                Poco::Util::Option("version","v")
                .description ("Show version information.")
                .required(false)
                .repeatable(false)
                .callback(Poco::Util::OptionCallback<HCE::ServerApplication>(this,&HCE::ServerApplication::handleVersion))
                );    
}

void HCE::ServerApplication::handleConfigFile (const std::string&,const std::string& value) {
    this->_configFileRequest = true;
    this->_configFile = value;
}

void HCE::ServerApplication::handleHelp (const std::string& name,const std::string& value) {
        this->_showHelpInfo = true;
        Poco::Util::HelpFormatter helpFormatter(options());
        helpFormatter.setCommand(commandName());
        helpFormatter.setUsage("OPTIONS");
        helpFormatter.setHeader("Some options that demonstrates some of the features of the HCE::Application");
        helpFormatter.format(std::cout);
}

void HCE::ServerApplication::handleVersion (const std::string& name,const std::string& value) {       
}