ThreadManager angefangen; Logger laeuft jetzt in eigenem Thread

1 files changed, 82 insertions, 33 deletions

diff --git a/src/Common/LogManager.cpp b/src/Common/LogManager.cpp
index 61c4bb6..22c688f 100644
--- a/src/Common/LogManager.cpp
+++ b/src/Common/LogManager.cpp
@@ -19,6 +19,9 @@
 
 #include "LogManager.h"
 #include "ConfigEntry.h"
+#include "ThreadManager.h"
+
+#include <iostream>
 
 namespace Mad {
 namespace Common {
@@ -26,6 +29,27 @@ namespace Common {
 LogManager LogManager::logManager;
 
 
+void LogManager::ConsoleLogger::logMessage(MessageCategory category _UNUSED_PARAMETER_, MessageLevel level, time_t timestamp _UNUSED_PARAMETER_, const std::string &message) {
+  if(level != CRITICAL) {// Critical messages are printed to cerr directly, so don't print them a second time
+    gl_lock_lock(cerrLock);
+    std::cerr << message << std::endl;
+    gl_lock_unlock(cerrLock);
+  }
+}
+
+void LogManager::ConsoleLogger::logMessage(MessageCategory category _UNUSED_PARAMETER_, MessageLevel, time_t timestamp _UNUSED_PARAMETER_, const std::string &message, const std::string &messageSource) {
+  gl_lock_lock(cerrLock);
+  std::cerr << message << " from " << messageSource << std::endl;
+  gl_lock_unlock(cerrLock);
+}
+
+void LogManager::ConsoleLogger::logMessageDirect(MessageCategory category _UNUSED_PARAMETER_, MessageLevel level _UNUSED_PARAMETER_, time_t timestamp _UNUSED_PARAMETER_, const std::string &message) {
+  gl_lock_lock(cerrLock);
+  std::cerr << message << std::endl;
+  gl_lock_unlock(cerrLock);
+}
+
+
 bool LogManager::handleConfigEntry(const ConfigEntry &entry, bool handled) {
   if(handled)
     return false;
@@ -50,47 +74,72 @@ void LogManager::configFinished() {
   if(loggers.empty())
     registerLogger(static_cast<Logger*>(&consoleLogger));
 
-  std::auto_ptr<std::queue<Message> > queue = messageQueue;
-
-  while(!queue->empty()) {
-    const Message &message = queue->front();
-    log(message.category, message.level, message.timestamp, message.message);
-    queue->pop();
-  }
-
-  std::auto_ptr<std::queue<RemoteMessage> > queue2 = remoteMessageQueue;
-
-  while(!queue2->empty()) {
-    const RemoteMessage &message = queue2->front();
-    log(message.category, message.level, message.timestamp, message.message, message.source);
-    queue2->pop();
-  }
+  gl_lock_lock(lock);
+  configured = true;
+  gl_cond_signal(queueCond);
+  gl_lock_unlock(lock);
 }
 
 void LogManager::log(MessageCategory category, MessageLevel level, time_t timestamp, const std::string &message) {
-  if(messageQueue.get()) { // Queue message if loggers aren't configured yet
-    Message m = {category, level, timestamp, message};
-    messageQueue->push(m);
-    return;
-  }
-
-  for(std::set<Logger*>::iterator logger = loggers.begin(); logger != loggers.end(); ++logger) {
-    if((*logger)->getLevel() >= level && (*logger)->isCategorySet(category))
-      (*logger)->logMessage(category, level, timestamp, message);
-  }
+  if(level == LoggerBase::CRITICAL)
+    consoleLogger.logMessageDirect(category, level, timestamp, message);
+
+  gl_lock_lock(lock);
+  Message m = {category, level, timestamp, message};
+  messageQueue.push(m);
+  gl_cond_signal(queueCond);
+  gl_lock_unlock(lock);
 }
 
 void LogManager::log(MessageCategory category, MessageLevel level, time_t timestamp, const std::string &message, const std::string &source) {
-  if(remoteMessageQueue.get()) { // Queue message if loggers aren't configured yet
-    RemoteMessage m = {category, level, timestamp, message, source};
-    remoteMessageQueue->push(m);
-    return;
-  }
+  gl_lock_lock(lock);
+  RemoteMessage m = {category, level, timestamp, message, source};
+  remoteMessageQueue.push(m);
+  gl_cond_signal(queueCond);
+  gl_lock_unlock(lock);
+}
+
+void LogManager::loggerThread() {
+  gl_lock_lock(lock);
+
+  running = true;
+
+  while(running) {
+    while(running && ((messageQueue.empty() && messageQueue.empty()) || !configured))
+      gl_cond_wait(queueCond, lock);
+
+    while(!messageQueue.empty()) {
+      Message message = messageQueue.front();
+      messageQueue.pop();
+      gl_lock_unlock(lock);
+
+      gl_lock_lock(loggerLock);
+      for(std::set<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);
+      }
+      gl_lock_unlock(loggerLock);
+
+      gl_lock_lock(lock);
+    }
+
+    while(!remoteMessageQueue.empty()) {
+      RemoteMessage message = remoteMessageQueue.front();
+      remoteMessageQueue.pop();
+      gl_lock_unlock(lock);
 
-  for(std::set<RemoteLogger*>::iterator logger = remoteLoggers.begin(); logger != remoteLoggers.end(); ++logger) {
-    if((*logger)->getLevel() >= level && (*logger)->isCategorySet(category))
-          (*logger)->logMessage(category, level, timestamp, message, source);
+      gl_lock_lock(remoteLoggerLock);
+      for(std::set<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);
+      }
+      gl_lock_unlock(remoteLoggerLock);
+
+      gl_lock_lock(lock);
+    }
   }
+
+  gl_lock_unlock(lock);
 }
 
 }