int main(int argc, char ** argv) {
LoggerPtr logger = Logger::getLogger("main");
Memkeys * app = NULL;
int rc = EXIT_SUCCESS;
logger->setLevel(Level::INFO);
// configure and initialize the app
try {
app = Memkeys::getInstance(argc, argv);
} catch(...) {
return handleConfigurationError(logger, argv[0]);
}
// run the app
try {
app->run();
} catch (const exception &ex) {
logger->fatal(CONTEXT, "Error running application: %s", ex.what());
rc = EXIT_FAILURE;
}
logger->info(CONTEXT, "Shutting down");
// handle cleanup
delete logger;
delete app;
delete Config::getInstance();
delete Logger::getRootLogger();
return rc;
}
// Used for initializing app main()
Memkeys * Memkeys::getInstance(int argc, char ** argv)
{
Config * cfg = Config::getInstance();
LoggerPtr mainLogger = Logger::getLogger("main");
try {
Cli::parse(argc, argv, cfg);
} catch (const exception &ex) {
throw MemkeysConfigurationError(ex.what());
}
mainLogger->setLevel(Level::INFO);
mainLogger->info(CONTEXT,
"Starting application %s. PID %d", argv[0], getpid());
Logger::getRootLogger()->setLevel(cfg->verbosity());
mainLogger->debug("Configuration\n" + cfg->toString());
return Memkeys::getInstance(cfg);
}
LoggerPtr Logger::getLogger(const string &name)
{
Loggers::iterator it = loggers.find(name);
if (it != loggers.end()) {
return it->second;
} else {
LoggerPtr logger = new Logger(name);
if (!logger->isRootLogger()) {
LoggerPtr root = Logger::getRootLogger();
logger->setParent(root);
logger->setUseParent(true);
logger->setLevel(root->getLevel());
}
logger->trace("Created logger");
loggers.insert(it, Loggers::value_type(name, logger));
return logger;
}
}
/**
* sets the root level for the logger.
*/
void Log4cxxLogger::setLevel(std::string esyslog, LoggerPtr rootLogger){
//LoggerPtr rootLogger = Logger::getRootLogger();
if (esyslog == "debug"){
rootLogger->setLevel(Level::DEBUG);
}
else if (esyslog == "info")
rootLogger->setLevel(Level::INFO);
else if (esyslog == "notice")
rootLogger->setLevel(Level::INFO);
else if (esyslog == "warning"){
rootLogger->setLevel(Level::WARN);
}
else if (esyslog == "err"){
rootLogger->setLevel(Level::ERROR);
}
else if (esyslog == "crit")
rootLogger->setLevel(Level::FATAL);
else if (esyslog == "alert")
rootLogger->setLevel(Level::WARN);
else if (esyslog == "emerg")
rootLogger->setLevel(Level::FATAL);
else {
rootLogger->setLevel(Level::INFO);
rootLogger->error("Unknown syslog level: " + esyslog);
}
}
void Server::setupLogging() {
using namespace boost;
using namespace log4cxx;
using namespace log4cxx::helpers;
using namespace log4cxx::xml;
LoggerPtr rootLogger = Logger::getRootLogger();
rootLogger->addAppender(new ConsoleAppender(new PatternLayout("%d | %5p | %m%n")));
rootLogger->setLevel(Level::getDebug());
bool directoryCreationFailed = false;
bool configurationFileMissing = false;
if (!filesystem::is_directory(LOGGING_DIRECTORY)) {
system::error_code error;
if (filesystem::create_directory(LOGGING_DIRECTORY, error)) {
chmod(LOGGING_DIRECTORY.c_str(), S_IRWXU);
}
else {
directoryCreationFailed = true;
}
}
// sadly we cannot check whether we were successful or not :(
if (filesystem::is_regular_file(LOGGING_CONFIGURATION_FILE) || filesystem::is_symlink(LOGGING_CONFIGURATION_FILE)) {
DOMConfigurator::configureAndWatch(LOGGING_CONFIGURATION_FILE);
}
else {
configurationFileMissing = true;
}
LOGi(std::setfill('-') << std::setw(90) << "");
LOGi(SOFTWARE_NAME " " SOFTWARE_VERSION " for Tibia(R) " SOFTWARE_PROTOCOL);
LOGi(X_PROJECT_URL);
LOGi(std::setfill('-') << std::setw(90) << "");
if (configurationFileMissing) {
LOGe("Cannot find logging configuration file '" << LOGGING_CONFIGURATION_FILE << "'. Using defaults.");
}
if (directoryCreationFailed) {
LOGe("Cannot create logging directory '" << LOGGING_DIRECTORY << "'. No log files will be written.");
}
}
void common()
{
int i = 0;
// In the lines below, the category names are chosen as an aid in
// remembering their level values. In general, the category names
// have no bearing to level values.
LoggerPtr ERR = Logger::getLogger(_T("ERR"));
ERR->setLevel(Level::ERROR);
LoggerPtr INF = Logger::getLogger(_T("INF"));
INF->setLevel(Level::INFO);
LoggerPtr INF_ERR = Logger::getLogger(_T("INF.ERR"));
INF_ERR->setLevel(Level::ERROR);
LoggerPtr DEB = Logger::getLogger(_T("DEB"));
DEB->setLevel(Level::DEBUG);
// Note: categories with undefined level
LoggerPtr INF_UNDEF = Logger::getLogger(_T("INF.UNDEF"));
LoggerPtr INF_ERR_UNDEF = Logger::getLogger(_T("INF.ERR.UNDEF"));
LoggerPtr UNDEF = Logger::getLogger(_T("UNDEF"));
// These should all log.----------------------------
LOG4CXX_FATAL(ERR, _T("Message ") << i);
i++; //0
LOG4CXX_ERROR(ERR, _T("Message ") << i);
i++;
LOG4CXX_FATAL(INF, _T("Message ") << i);
i++; // 2
LOG4CXX_ERROR(INF, _T("Message ") << i);
i++;
LOG4CXX_WARN(INF, _T("Message ") << i);
i++;
LOG4CXX_INFO(INF, _T("Message ") << i);
i++;
LOG4CXX_FATAL(INF_UNDEF, _T("Message ") << i);
i++; //6
LOG4CXX_ERROR(INF_UNDEF, _T("Message ") << i);
i++;
LOG4CXX_WARN(INF_UNDEF, _T("Message ") << i);
i++;
LOG4CXX_INFO(INF_UNDEF, _T("Message ") << i);
i++;
LOG4CXX_FATAL(INF_ERR, _T("Message ") << i);
i++; // 10
LOG4CXX_ERROR(INF_ERR, _T("Message ") << i);
i++;
LOG4CXX_FATAL(INF_ERR_UNDEF, _T("Message ") << i);
i++;
LOG4CXX_ERROR(INF_ERR_UNDEF, _T("Message ") << i);
i++;
LOG4CXX_FATAL(DEB, _T("Message ") << i);
i++; //14
LOG4CXX_ERROR(DEB, _T("Message ") << i);
i++;
LOG4CXX_WARN(DEB, _T("Message ") << i);
i++;
LOG4CXX_INFO(DEB, _T("Message ") << i);
i++;
LOG4CXX_DEBUG(DEB, _T("Message ") << i);
i++;
// defaultLevel=DEBUG
LOG4CXX_FATAL(UNDEF, _T("Message ") << i);
i++; // 19
LOG4CXX_ERROR(UNDEF, _T("Message ") << i);
i++;
LOG4CXX_WARN(UNDEF, _T("Message ") << i);
i++;
LOG4CXX_INFO(UNDEF, _T("Message ") << i);
i++;
LOG4CXX_DEBUG(UNDEF, _T("Message ") << i);
i++;
// -------------------------------------------------
// The following should not log
LOG4CXX_WARN(ERR, _T("Message ") << i);
i++;
LOG4CXX_INFO(ERR, _T("Message ") << i);
i++;
LOG4CXX_DEBUG(ERR, _T("Message ") << i);
i++;
LOG4CXX_DEBUG(INF, _T("Message ") << i);
i++;
LOG4CXX_DEBUG(INF_UNDEF, _T("Message ") << i);
i++;
LOG4CXX_WARN(INF_ERR, _T("Message ") << i);
i++;
LOG4CXX_INFO(INF_ERR, _T("Message ") << i);
i++;
LOG4CXX_DEBUG(INF_ERR, _T("Message ") << i);
i++;
LOG4CXX_WARN(INF_ERR_UNDEF, _T("Message ") << i);
i++;
LOG4CXX_INFO(INF_ERR_UNDEF, _T("Message ") << i);
i++;
LOG4CXX_DEBUG(INF_ERR_UNDEF, _T("Message ") << i);
i++;
// -------------------------------------------------
LOG4CXX_INFO(INF, _T("Messages should bear numbers 0 through 23."));
}
void common()
{
int i = 0;
// In the lines below, the logger names are chosen as an aid in
// remembering their level values. In general, the logger names
// have no bearing to level values.
LoggerPtr ERRlogger = Logger::getLogger(LOG4CXX_TEST_STR("ERR"));
ERRlogger->setLevel(Level::getError());
LoggerPtr INF = Logger::getLogger(LOG4CXX_TEST_STR("INF"));
INF->setLevel(Level::getInfo());
LoggerPtr INF_ERR = Logger::getLogger(LOG4CXX_TEST_STR("INF.ERR"));
INF_ERR->setLevel(Level::getError());
LoggerPtr DEB = Logger::getLogger(LOG4CXX_TEST_STR("DEB"));
DEB->setLevel(Level::getDebug());
// Note: categories with undefined level
LoggerPtr INF_UNDEF = Logger::getLogger(LOG4CXX_TEST_STR("INF.UNDEF"));
LoggerPtr INF_ERR_UNDEF = Logger::getLogger(LOG4CXX_TEST_STR("INF.ERR.UNDEF"));
LoggerPtr UNDEF = Logger::getLogger(LOG4CXX_TEST_STR("UNDEF"));
std::string msg("Message ");
Pool pool;
// These should all log.----------------------------
LOG4CXX_FATAL(ERRlogger, createMessage(i, pool));
i++; //0
LOG4CXX_ERROR(ERRlogger, createMessage(i, pool));
i++;
LOG4CXX_FATAL(INF, createMessage(i, pool));
i++; // 2
LOG4CXX_ERROR(INF, createMessage(i, pool));
i++;
LOG4CXX_WARN(INF, createMessage(i, pool));
i++;
LOG4CXX_INFO(INF, createMessage(i, pool));
i++;
LOG4CXX_FATAL(INF_UNDEF, createMessage(i, pool));
i++; //6
LOG4CXX_ERROR(INF_UNDEF, createMessage(i, pool));
i++;
LOG4CXX_WARN(INF_UNDEF, createMessage(i, pool));
i++;
LOG4CXX_INFO(INF_UNDEF, createMessage(i, pool));
i++;
LOG4CXX_FATAL(INF_ERR, createMessage(i, pool));
i++; // 10
LOG4CXX_ERROR(INF_ERR, createMessage(i, pool));
i++;
LOG4CXX_FATAL(INF_ERR_UNDEF, createMessage(i, pool));
i++;
LOG4CXX_ERROR(INF_ERR_UNDEF, createMessage(i, pool));
i++;
LOG4CXX_FATAL(DEB, createMessage(i, pool));
i++; //14
LOG4CXX_ERROR(DEB, createMessage(i, pool));
i++;
LOG4CXX_WARN(DEB, createMessage(i, pool));
i++;
LOG4CXX_INFO(DEB, createMessage(i, pool));
i++;
LOG4CXX_DEBUG(DEB, createMessage(i, pool));
i++;
// defaultLevel=DEBUG
LOG4CXX_FATAL(UNDEF, createMessage(i, pool));
i++; // 19
LOG4CXX_ERROR(UNDEF, createMessage(i, pool));
i++;
LOG4CXX_WARN(UNDEF, createMessage(i, pool));
i++;
LOG4CXX_INFO(UNDEF, createMessage(i, pool));
i++;
LOG4CXX_DEBUG(UNDEF, createMessage(i, pool));
i++;
// -------------------------------------------------
// The following should not log
LOG4CXX_WARN(ERRlogger, createMessage(i, pool));
i++;
LOG4CXX_INFO(ERRlogger, createMessage(i, pool));
i++;
LOG4CXX_DEBUG(ERRlogger, createMessage(i, pool));
i++;
LOG4CXX_DEBUG(INF, createMessage(i, pool));
i++;
LOG4CXX_DEBUG(INF_UNDEF, createMessage(i, pool));
i++;
LOG4CXX_WARN(INF_ERR, createMessage(i, pool));
i++;
LOG4CXX_INFO(INF_ERR, createMessage(i, pool));
i++;
LOG4CXX_DEBUG(INF_ERR, createMessage(i, pool));
i++;
LOG4CXX_WARN(INF_ERR_UNDEF, createMessage(i, pool));
i++;
LOG4CXX_INFO(INF_ERR_UNDEF, createMessage(i, pool));
i++;
LOG4CXX_DEBUG(INF_ERR_UNDEF, createMessage(i, pool));
i++;
// -------------------------------------------------
LOG4CXX_INFO(INF, LOG4CXX_TEST_STR("Messages should bear numbers 0 through 23."));
}