1 files changed, 54 insertions, 11 deletions

diff --git a/src/Common/LogManager.h b/src/Common/LogManager.h
index 5f2fb17..34a4689 100644
--- a/src/Common/LogManager.h
+++ b/src/Common/LogManager.h
@@ -20,20 +20,27 @@
 #ifndef MAD_COMMON_LOGMANAGER_H_
 #define MAD_COMMON_LOGMANAGER_H_
 
+#include <config.h>
+
 #include "Configurable.h"
 #include "Logger.h"
 #include "RemoteLogger.h"
 
-#include <iostream>
-#include <memory>
 #include <queue>
 #include <set>
 
+#include "glthread/lock.h"
+#include "glthread/cond.h"
+
 namespace Mad {
 namespace Common {
 
+class ThreadManager;
+
 class LogManager : public Configurable {
   private:
+    friend class ThreadManager;
+
     typedef LoggerBase::MessageCategory MessageCategory;
     typedef LoggerBase::MessageLevel MessageLevel;
 
@@ -53,16 +60,19 @@ class LogManager : public Configurable {
     };
 
     class ConsoleLogger : public Logger, public RemoteLogger {
+      private:
+        // For long messages, writing to cerr is not atomic
+        // -> lock cerr to prevent mixing messages up
+        gl_lock_t cerrLock;
+
       protected:
-        virtual void logMessage(MessageCategory, MessageLevel, time_t, const std::string &message) {
-          std::cerr << message << std::endl;
-        }
-        virtual void logMessage(MessageCategory, MessageLevel, time_t, const std::string &message, const std::string &messageSource) {
-          std::cerr << message << " from "<< messageSource << std::endl;
-        }
+        virtual void logMessage(MessageCategory category _UNUSED_PARAMETER_, MessageLevel level, time_t timestamp _UNUSED_PARAMETER_, const std::string &message);
+        virtual void logMessage(MessageCategory category _UNUSED_PARAMETER_, MessageLevel, time_t timestamp _UNUSED_PARAMETER_, const std::string &message, const std::string &messageSource);
 
       public:
         ConsoleLogger() {}
+
+        void logMessageDirect(MessageCategory category _UNUSED_PARAMETER_, MessageLevel level _UNUSED_PARAMETER_, time_t timestamp _UNUSED_PARAMETER_, const std::string &message);
     };
 
 
@@ -72,34 +82,67 @@ class LogManager : public Configurable {
 
     std::set<Logger*> loggers;
     std::set<RemoteLogger*> remoteLoggers;
+    bool configured, running;
+
+    gl_lock_t lock;
+    gl_cond_t queueCond;
 
-    std::auto_ptr<std::queue<Message> > messageQueue;
-    std::auto_ptr<std::queue<RemoteMessage> > remoteMessageQueue;
+    gl_lock_t loggerLock;
+    gl_lock_t remoteLoggerLock;
 
-    LogManager() : messageQueue(new std::queue<Message>()), remoteMessageQueue(new std::queue<RemoteMessage>()) {}
+    std::queue<Message> messageQueue;
+    std::queue<RemoteMessage> remoteMessageQueue;
+
+    void loggerThread();
+    void stopLoggerThread() {
+      gl_lock_lock(lock);
+      running = false;
+      gl_cond_signal(queueCond);
+      gl_lock_unlock(lock);
+    }
+
+    LogManager() : configured(false), running(false) {
+      gl_lock_init(lock);
+      gl_lock_init(loggerLock);
+      gl_lock_init(remoteLoggerLock);
+    }
 
   protected:
     virtual bool handleConfigEntry(const ConfigEntry &entry, bool handled);
     virtual void configFinished();
 
   public:
+    ~LogManager() {
+      gl_lock_destroy(remoteLoggerLock);
+      gl_lock_destroy(loggerLock);
+      gl_lock_destroy(lock);
+    }
+
     void log(MessageCategory category, MessageLevel level, time_t timestamp, const std::string &message);
     void log(MessageCategory category, MessageLevel level, time_t timestamp, const std::string &message, const std::string &source);
 
     void registerLogger(Logger *logger) {
+      gl_lock_lock(loggerLock);
       loggers.insert(logger);
+      gl_lock_unlock(loggerLock);
     }
 
     void unregisterLogger(Logger *logger) {
+      gl_lock_lock(loggerLock);
       loggers.erase(logger);
+      gl_lock_unlock(loggerLock);
     }
 
     void registerLogger(RemoteLogger *logger) {
+      gl_lock_lock(remoteLoggerLock);
       remoteLoggers.insert(logger);
+      gl_lock_unlock(remoteLoggerLock);
     }
 
     void unregisterLogger(RemoteLogger *logger) {
+      gl_lock_lock(remoteLoggerLock);
       remoteLoggers.erase(logger);
+      gl_lock_unlock(remoteLoggerLock);
     }
 
     static LogManager *get() {