1 files changed, 62 insertions, 60 deletions

diff --git a/src/Core/LogManager.cpp b/src/Core/LogManager.cpp
index b255c04..8fe7428 100644
--- a/src/Core/LogManager.cpp
+++ b/src/Core/LogManager.cpp
@@ -27,24 +27,41 @@
 namespace Mad {
 namespace Core {
 
-void LogManager::ConsoleLogger::logMessage(MessageCategory /*category*/, MessageLevel level, boost::posix_time::ptime /*timestamp*/, const std::string &message) {
-  if(level != LOG_CRITICAL) {// Critical messages are printed to cerr directly, so don't print them a second time
-    cerrLock.lock();
-    std::cerr << message << std::endl;
-    cerrLock.unlock();
+void LogManager::ConsoleLogger::logMessage(MessageCategory category, MessageLevel level, boost::posix_time::ptime timestamp, const std::string &message, const std::string &source) {
+  if(!(level == LOG_CRITICAL && source.empty())) {// Critical messages are printed to cerr directly, so don't print them a second time
+    boost::lock_guard<boost::mutex> lock(cerrMutex);
+    logMessageDirect(category, level, timestamp, message, source);
   }
 }
 
-void LogManager::ConsoleLogger::logMessage(MessageCategory /*category*/, MessageLevel /*level*/, boost::posix_time::ptime /*timestamp*/, const std::string &message, const std::string &messageSource) {
-  cerrLock.lock();
-  std::cerr << message << " from " << messageSource << std::endl;
-  cerrLock.unlock();
+void LogManager::ConsoleLogger::logMessageDirect(MessageCategory /*category*/, MessageLevel /*level*/, boost::posix_time::ptime /*timestamp*/, const std::string &message, const std::string &source) {
+  if(source.empty())
+    std::cerr << message << std::endl;
+  else
+    std::cerr << message << " from " << source << std::endl;
 }
 
-void LogManager::ConsoleLogger::logMessageDirect(MessageCategory /*category*/, MessageLevel /*level*/, boost::posix_time::ptime /*timestamp*/, const std::string &message) {
-  cerrLock.lock();
-  std::cerr << message << std::endl;
-  cerrLock.unlock();
+
+LogManager::MessageLevel LogManager::parseLevel(const std::string &str) throw (Exception) {
+  if(str.empty())
+    return Logger::LOG_DEFAULT;
+
+  std::string lowerStr = boost::algorithm::to_lower_copy(str);
+
+  if(lowerStr == "debug")
+    return Logger::LOG_DEBUG;
+  else if(lowerStr == "verbose")
+    return Logger::LOG_VERBOSE;
+  else if(lowerStr == "default")
+    return Logger::LOG_DEFAULT;
+  else if(lowerStr == "warning")
+    return Logger::LOG_WARNING;
+  else if(lowerStr == "error")
+    return Logger::LOG_ERROR;
+  else if(lowerStr == "critical")
+    return Logger::LOG_CRITICAL;
+  else
+    throw Exception(Exception::INVALID_INPUT);
 }
 
 
@@ -58,19 +75,30 @@ LogManager::~LogManager() {
 
 
 bool LogManager::handleConfigEntry(const ConfigEntry &entry, bool handled) {
-  if(handled)
-    return false;
-
-  if(entry[0].getKey().matches("Logger")) {
+  if(entry[0].getKey().matches("Log")) {
     if(entry[0][0].matches("Console")) {
       if(entry[1].empty()) {
-        registerLogger(boost::static_pointer_cast<Logger>(consoleLogger));
+        registerLogger(consoleLogger);
         return true;
       }
+      else if(entry[1].getKey().matches("Level")) {
+        if(entry[2].empty()) {
+          try {
+            consoleLogger->setLevel(parseLevel(entry[1][0]));
+          }
+          catch(Core::Exception e) {
+            application->logf(Logger::LOG_WARNING, "Unknown log level '%s'.", entry[1][0].c_str());
+          }
+
+          return true;
+        }
+      }
     }
     else if(entry[1].empty()) {
-      application->logf(Logger::LOG_WARNING, "Unknown logger '%s'.", entry[0][0].c_str());
-      return true;
+      if(!handled) {
+        application->logf(Logger::LOG_WARNING, "Unknown logger '%s'.", entry[0][0].c_str());
+        return true;
+      }
     }
   }
 
@@ -79,38 +107,26 @@ bool LogManager::handleConfigEntry(const ConfigEntry &entry, bool handled) {
 
 void LogManager::configFinished() {
   if(loggers.empty())
-    registerLogger(boost::static_pointer_cast<Logger>(consoleLogger));
+    registerLogger(consoleLogger);
 
-  // TODO Debug
-  consoleLogger->Logger::setLevel(LoggerBase::LOG_VERBOSE);
 
-  queueLock.lock();
+  boost::lock_guard<boost::mutex> lock(queueMutex);
   configured = true;
-  queueLock.unlock();
   queueCond.notify_one();
 }
 
-void LogManager::log(MessageCategory category, MessageLevel level, boost::posix_time::ptime timestamp, const std::string &message) {
-  if(level == LoggerBase::LOG_CRITICAL)
-    consoleLogger->logMessageDirect(category, level, timestamp, message);
+void LogManager::log(MessageCategory category, MessageLevel level, boost::posix_time::ptime timestamp, const std::string &message, const std::string &source) {
+  if(level == Logger::LOG_CRITICAL && source.empty())
+    consoleLogger->logMessageDirect(category, level, timestamp, message, source);
 
-  queueLock.lock();
-  Message m = {category, level, timestamp, message};
+  boost::lock_guard<boost::mutex> lock(queueMutex);
+  Message m = {category, level, timestamp, message, source};
   messageQueue.push(m);
-  queueLock.unlock();
   queueCond.notify_one();
 }
 
-void LogManager::log(MessageCategory category, MessageLevel level, boost::posix_time::ptime timestamp, const std::string &message, const std::string &source) {
-  queueLock.lock();
-  RemoteMessage m = {category, level, timestamp, message, source};
-  remoteMessageQueue.push(m);
-  queueLock.unlock();
-    queueCond.notify_one();
-}
-
 void LogManager::loggerThread() {
-  boost::unique_lock<boost::mutex> lock(queueLock);
+  boost::unique_lock<boost::mutex> lock(queueMutex);
 
   running = true;
 
@@ -123,27 +139,13 @@ void LogManager::loggerThread() {
       messageQueue.pop();
       lock.unlock();
 
-      loggerLock.lock();
-      for(std::set<boost::shared_ptr<Logger> >::iterator logger = loggers.begin(); logger != loggers.end(); ++logger) {
-        if((*logger)->getLevel() >= message.level && (*logger)->isCategorySet(message.category))
-          (*logger)->logMessage(message.category, message.level, message.timestamp, message.message);
-      }
-      loggerLock.unlock();
-
-      lock.lock();
-    }
-
-    while(!remoteMessageQueue.empty()) {
-      RemoteMessage message = remoteMessageQueue.front();
-      remoteMessageQueue.pop();
-      lock.unlock();
-
-      remoteLoggerLock.lock();
-      for(std::set<boost::shared_ptr<RemoteLogger> >::iterator logger = remoteLoggers.begin(); logger != remoteLoggers.end(); ++logger) {
-        if((*logger)->getLevel() >= message.level && (*logger)->isCategorySet(message.category))
-          (*logger)->logMessage(message.category, message.level, message.timestamp, message.message, message.source);
+      {
+        boost::lock_guard<boost::mutex> loggerLock(loggerMutex);
+        for(std::set<boost::shared_ptr<Logger> >::iterator logger = loggers.begin(); logger != loggers.end(); ++logger) {
+          if((*logger)->getLevel() >= message.level && (*logger)->isCategorySet(message.category))
+            (*logger)->logMessage(message.category, message.level, message.timestamp, message.message, message.source);
+        }
       }
-      remoteLoggerLock.unlock();
 
       lock.lock();
     }