src/tools/log.cpp

Go to the documentation of this file.

#include <string>
#include <errno.h>
#include <tools/conf.h>
#include "log.h"

Log  __libldsw_thread_log;

Log::Log() : Mutex(RECURSIVE_MUTEX)
{
        inited = false;
}

Log::~Log()
{
        std::map<std::string, LineLogger*>::iterator log_obj;
        for(log_obj = inited_loggers.begin(); log_obj != inited_loggers.end(); ++log_obj)
        {
                if(log_obj->second)
                        delete log_obj->second;
        }
}

void Log::Init()
{
        if(!inited)
        {
                int log_no = LogLast;
                while(log_no--)
                        loggers.push_back(NULL);
                
                LoadLogObj(std::string("log_debug"), LogDebug);
                LoadLogObj(std::string("log_panic"), LogPanic);
                LoadLogObj(std::string("log_error"), LogError);
                LoadLogObj(std::string("log_warning"), LogWarning);
                LoadLogObj(std::string("log_info"), LogInfo);
                inited = true;
        }
}

void Log::Reload()
{
        Lock();
        inited = false;
        Init();
        Unlock();
}
 
void Log::LoadLogObj(std::string logger_name, enum LogLevel logger_no)
{
        Config conf;
        std::string logger = "";
        if(conf.Get(logger_name, logger))
        {
                // If an object is already initialized for this logger, reuse it:
                std::map<std::string, LineLogger*>::iterator log_obj;
                log_obj = inited_loggers.find(logger);
                if(log_obj != inited_loggers.end())
                        loggers[logger_no] = log_obj->second;
                else
                {
                        LineLogger* initialized_logger = NULL;
                        if(logger == "stdout")
                                initialized_logger = new StdoutLogger;
                        else
                        if(logger == "stderr")
                                initialized_logger = new StderrLogger;
                        else
                        if(logger == "none")
                                initialized_logger = NULL;
                        else
                        if(logger.substr(0, 5) == "file:")
                                initialized_logger = new FileLogger(logger.substr(5, std::string::npos));
                        else
                        if(logger.substr(0, 4) == "net:")
                                initialized_logger = new NetLogger(logger.substr(4, std::string::npos));
                        else
                                fprintf(stderr, "Unknown log target : %s -> %s\n", logger_name.c_str(), logger.c_str());
                        if(initialized_logger)
                                inited_loggers[logger] = initialized_logger;
                        loggers[logger_no] = initialized_logger;
                }
        }
}

LineLogger* Log::GetLogger(enum LogLevel log_level)
{
        Lock();
        if(!inited)
        {
                Unlock();
                return NULL;
        }
        if((unsigned int)log_level < loggers.size())
        {
                Unlock();
                return loggers[log_level];
        }
        Unlock();
        return NULL;
}

void LineLogger::Write(enum LogLevel log_level, const char* debug_info, const char* msg)
{
        Lock();
        std::string line = "";
        if(log_level < LogWarning)
                line += std::string(debug_info);

        if(log_level == LogPanic) line += "PANIC   ";
        if(log_level == LogError) line += "ERROR   ";
        if(log_level == LogWarning) line += "WARNING ";

        line += std::string(msg);
        WriteToLog(line.c_str());
        Unlock();
}

void StdoutLogger::WriteToLog(const char* msg)
{
        printf("%s\n", msg);
}

void StderrLogger::WriteToLog(const char* msg)
{
        fprintf(stderr, "%s\n", msg);
}

FileLogger::FileLogger(std::string filename)
{
        f = fopen(filename.c_str(), "a+");
        if(!f)
        {
                fprintf(stderr, "Unable to open log file \"%s\" : %s\n", filename.c_str(), strerror(errno));
                exit(EXIT_FAILURE);
        }
}

FileLogger::~FileLogger()
{
        fclose(f);
}

void FileLogger::WriteToLog(const char* msg)
{
        fprintf(f, "%s\n", msg);
        fflush(f);
}

NetLogger::NetLogger(std::string hostport)
{
        host_is_valid = false;

        size_t split = hostport.find(':');

        if(split == std::string::npos)
                return;
        std::string host = hostport.substr(0, split);
        std::string port = hostport.substr(split + 1);

        Connect(host, atoi(port.c_str()));
}

NetLogger::~NetLogger()
{
        Disconnect();
}

void NetLogger::WriteToLog(const char* msg)
{
        Send(msg + std::string("\n"));
}

---