src/external/3rd/library/platform/utils/Base/linux/Logger.cpp

   1 #include "../Logger.h"
   2 #include "Mutex.h"
   3 #include <sys/stat.h>
   4
   5 using namespace std;
   6
   7 #ifdef EXTERNAL_DISTRO
   8 namespace NAMESPACE
   9 {
  10
  11 #endif
  12 namespace Base
  13 {
  14
  15 const char file_sep = '/';
  16
  17 Logger::Logger(const char *prefix, int level, unsigned size, bool rollDate)
  18 : m_defaultLevel(level), m_defaultSize(size), m_dirPrefix(prefix), m_rollDate(rollDate)
  19 {
  20         char buf[1024];
  21         FILE *logDir = NULL;
  22
  23         logDir = fopen(m_dirPrefix.c_str(), "r+");
  24         if(errno == ENOENT)
  25         {
  26                 cmkdir(m_dirPrefix.c_str(), 0755);
  27         }
  28         else if(logDir != NULL)
  29         {
  30                 fclose(logDir);
  31         }
  32
  33         tm now;
  34         time_t t = time(NULL);
  35         localtime_r(&t, &now);
  36
  37         memcpy(&m_lastDateTime, &now, sizeof(tm));
  38         if(m_rollDate)
  39         {
  40                 sprintf(buf, "%s%c%2.2d-%2.2d-%2.2d", m_dirPrefix.c_str(), file_sep, (now.tm_mon + 1), now.tm_mday, (now.tm_year % 100));
  41         }
  42         else
  43         {
  44                 sprintf(buf, "%s", m_dirPrefix.c_str());
  45         }
  46         logDir = fopen(buf, "r+");
  47         if(errno == ENOENT)
  48         {
  49                 cmkdir(buf, 0755);
  50         }
  51         else if(logDir != NULL)
  52         {
  53                 fclose(logDir);
  54         }
  55         m_logPrefix = buf;
  56 }
  57
  58 Logger::~Logger()
  59 {
  60         map<unsigned, LogInfo *>::iterator iter;
  61         for(iter = m_logTable.begin(); iter != m_logTable.end(); iter++)
  62         {
  63                 log((*iter).first, LOG_FILEONLY, "---=== Log Stopped ===---");
  64                 fflush((*iter).second->file);
  65                 fclose((*iter).second->file);
  66                 delete((*iter).second);
  67
  68         }
  69         m_logTable.clear();
  70 }
  71
  72 void Logger::flush(unsigned logenum)
  73 {
  74         map<unsigned, LogInfo *>::iterator iter = m_logTable.find(logenum);
  75
  76         if(iter != m_logTable.end())
  77         {
  78                 LogInfo *info = (*iter).second;
  79                 fflush(info->file);
  80                 info->used = 0;
  81         }
  82 }
  83
  84 void Logger::flushAll()
  85 {
  86         map<unsigned, LogInfo *>::iterator iter;
  87
  88         for(iter = m_logTable.begin(); iter != m_logTable.end(); iter++)
  89         {
  90                 LogInfo *info = (*iter).second;
  91                 fflush(info->file);
  92                 info->used = 0;
  93         }
  94 }
  95
  96 void Logger::addLog(const char *id, unsigned logenum, int level, unsigned size)
  97 {
  98         LogInfo *newLog = new LogInfo;
  99         newLog->filename = m_logPrefix + file_sep + id + ".log";
 100         newLog->name = id;
 101         newLog->used = 0;
 102         newLog->max = size;
 103         newLog->last = 0;
 104         newLog->level = level;
 105
 106         m_logTable.insert(pair<unsigned, LogInfo *>(logenum, newLog));
 107
 108         if(strcmp("stdout", id) == 0)
 109         {
 110                 newLog->file = stdout;
 111         }
 112         else if(strcmp("stderr", id) == 0)
 113         {
 114                 newLog->file = stderr;
 115         }
 116         else
 117         {
 118                 newLog->file = fopen(newLog->filename.c_str(), "a+");
 119         }
 120         log(logenum, LOG_FILEONLY, "---=== Log Started ===---");
 121 }
 122
 123 void Logger::addLog(const char *id, unsigned logenum)
 124 {
 125         LogInfo *newLog = new LogInfo;
 126         newLog->filename = m_logPrefix + file_sep + id + ".log";
 127         newLog->name = id;
 128         newLog->used = 0;
 129         newLog->max = m_defaultSize;
 130         newLog->last = 0;
 131         newLog->level = m_defaultLevel;
 132
 133         m_logTable.insert(pair<unsigned, LogInfo *>(logenum, newLog));
 134
 135         if(strcmp("stdout", id) == 0)
 136         {
 137                 newLog->file = stdout;
 138         }
 139         else if(strcmp("stderr", id) == 0)
 140         {
 141                 newLog->file = stderr;
 142         }
 143         else
 144         {
 145                 newLog->file = fopen(newLog->filename.c_str(), "a+");
 146         }
 147         log(logenum, LOG_FILEONLY, "---===Log Started ===---");
 148 }
 149
 150 void Logger::updateLog(unsigned logenum, int level, unsigned size)
 151 {
 152         map<unsigned, LogInfo *>::iterator iter = m_logTable.find(logenum);
 153
 154         if(iter != m_logTable.end())
 155         {
 156                 (*iter).second->level = level;
 157                 (*iter).second->max = size;
 158         }
 159 }
 160
 161 void Logger::removeLog(unsigned logenum)
 162 {
 163         map<unsigned, LogInfo *>::iterator iter = m_logTable.find(logenum);
 164
 165         if(iter != m_logTable.end())
 166         {
 167                 log((*iter).first, LOG_ALWAYS, "---=== Log Stopped ===---");
 168                 fflush((*iter).second->file);
 169                 fclose((*iter).second->file);
 170                 delete((*iter).second);
 171         }
 172 }
 173
 174 void Logger::logSimple(unsigned logenum, int level, const char *message)
 175 {
 176         map<unsigned, LogInfo *>::iterator iter = m_logTable.find(logenum);
 177         if(iter == m_logTable.end())
 178         {
 179                 return;
 180         }
 181         time_t t = time(NULL);
 182         LogInfo *info = (*iter).second;
 183         if(level >= info->level)
 184         {
 185                 return;
 186         }
 187         if(level == LOG_FILEONLY && ((info->file  == stderr) || (info->file == stdout)))
 188         {
 189                 return;
 190         }
 191         if(info->last != t)
 192         {
 193                 memcpy(&info->ts, localtime(&t), sizeof(tm));
 194                 info->last = t;
 195         }
 196
 197         if(m_rollDate && info->ts.tm_mday != m_lastDateTime.tm_mday)
 198         {
 199 #if defined(_REENTRANT)
 200                 rLock.Lock();
 201 #endif
 202                 if(info->ts.tm_mday != m_lastDateTime.tm_mday)
 203                 {
 204                         memcpy(&m_lastDateTime, &info->ts, sizeof(tm));
 205                         rollDate(t);
 206                 }
 207 #if defined(_REENTRANT)
 208                 rLock.Unlock();
 209 #endif
 210         }
 211         if(iter != m_logTable.end())
 212         {
 213                 if(info->max > 0)
 214                 {
 215                         int tmp = fprintf(info->file, "[%2.2d/%2.2d/%2.2d %2.2d:%2.2d:%2.2d] %s\n", (info->ts.tm_mon + 1), info->ts.tm_mday, (info->ts.tm_year % 100), info->ts.tm_hour, info->ts.tm_min, info->ts.tm_sec, message);
 216                         info->used += tmp;
 217                         if(info->used > info->max)
 218                         {
 219                                 fflush(info->file);
 220                                 info->used = 0;
 221                         }
 222                 }
 223                 else
 224                 {
 225                         fprintf(info->file, "[%2.2d/%2.2d/%2.2d %2.2d:%2.2d:%2.2d] %s\n", (info->ts.tm_mon + 1), info->ts.tm_mday, (info->ts.tm_year % 100), info->ts.tm_hour, info->ts.tm_min, info->ts.tm_sec, message);
 226                         fflush(info->file);
 227                 }
 228         }
 229 }
 230 void Logger::log(unsigned logenum, int level, const char *message, ...)
 231 {
 232         char buf[2048];
 233         va_list varg;
 234         va_start(varg, message);
 235         vsnprintf(buf, 2047, message, varg);
 236         buf[2047] = 0;
 237         va_end(varg);
 238
 239         map<unsigned, LogInfo *>::iterator iter = m_logTable.find(logenum);
 240         if(iter == m_logTable.end())
 241         {
 242                 return;
 243         }
 244         time_t t = time(NULL);
 245         LogInfo *info = (*iter).second;
 246         if(level >= info->level)
 247         {
 248                 return;
 249         }
 250         if(level == LOG_FILEONLY && ((info->file  == stderr) || (info->file == stdout)))
 251         {
 252                 return;
 253         }
 254         if(info->last != t)
 255         {
 256                 localtime_r(&t, &info->ts);
 257                 info->last = t;
 258         }
 259         if(m_rollDate && info->ts.tm_mday != m_lastDateTime.tm_mday)
 260         {
 261 #if defined(_REENTRANT)
 262                 rLock.Lock();
 263 #endif
 264                 if(info->ts.tm_mday != m_lastDateTime.tm_mday)
 265                 {
 266                         memcpy(&m_lastDateTime, &info->ts, sizeof(tm));
 267                         rollDate(t);
 268                 }
 269 #if defined(_REENTRANT)
 270                 rLock.Unlock();
 271 #endif
 272         }
 273
 274         if(iter != m_logTable.end())
 275         {
 276                 if(info->max > 0)
 277                 {
 278                         int tmp = fprintf(info->file, "[%2.2d/%2.2d/%2.2d %2.2d:%2.2d:%2.2d] %s\n", (info->ts.tm_mon + 1), info->ts.tm_mday, (info->ts.tm_year % 100), info->ts.tm_hour, info->ts.tm_min, info->ts.tm_sec, buf);
 279                         info->used += tmp;
 280                         if(info->used > info->max)
 281                         {
 282                                 fflush(info->file);
 283                                 info->used = 0;
 284                         }
 285                 }
 286                 else
 287                 {
 288                         fprintf(info->file, "[%2.2d/%2.2d/%2.2d %2.2d:%2.2d:%2.2d] %s\n", (info->ts.tm_mon + 1), info->ts.tm_mday, (info->ts.tm_year % 100), info->ts.tm_hour, info->ts.tm_min, info->ts.tm_sec, buf);
 289                         fflush(info->file);
 290                 }
 291         }
 292 }
 293
 294 void Logger::rollDate(time_t t)
 295 {
 296         char buf[80];
 297         FILE *logDir = NULL;
 298
 299         logDir = fopen(m_dirPrefix.c_str(), "r+");
 300         if(errno == ENOENT)
 301         {
 302                 cmkdir(m_dirPrefix.c_str(), 0755);
 303         }
 304         else if(logDir != NULL)
 305         {
 306                 fclose(logDir);
 307         }
 308
 309         tm now;
 310         localtime_r(&t, &now);
 311
 312         sprintf(buf, "%s%c%2.2d-%2.2d-%2.2d", m_dirPrefix.c_str(), file_sep, (now.tm_mon + 1), now.tm_mday, (now.tm_year % 100));
 313         logDir = fopen(buf, "r+");
 314
 315         if(errno == ENOENT)
 316         {
 317                 cmkdir(buf, 0755);
 318         }
 319         else if(logDir != NULL)
 320         {
 321                 fclose(logDir);
 322         }
 323         m_logPrefix = buf;
 324
 325         map<unsigned, LogInfo *>::iterator iter;
 326         for(iter = m_logTable.begin(); iter != m_logTable.end(); iter++)
 327         {
 328                 (*iter).second->filename = m_logPrefix + file_sep + (*iter).second->name.c_str() + ".log";
 329                 fflush((*iter).second->file);
 330                 fclose((*iter).second->file);
 331                 (*iter).second->file = fopen((*iter).second->filename.c_str(), "a+");
 332                 memcpy(&((*iter).second->ts), &now, sizeof(tm));
 333         }
 334 }
 335
 336 // mkdir function that creates intermediate directories
 337 void Logger::cmkdir(const char *dir, int mode)
 338 {
 339         char dirbuf[128];
 340         strncpy(dirbuf, dir, 127);
 341         dirbuf[127] = 0;
 342         char *j = dirbuf, *i = dirbuf;
 343         int handle;
 344
 345         while(*i)
 346         {
 347                 if(*i == file_sep)
 348                 {
 349                         (*i) = 0;
 350 //                      handle = open(j, O_EXCL);               // Ben's original code
 351 //                      if((handle > 0) || (errno != EISDIR && errno != ENOENT))
 352 //                      {
 353 //                              perror("Logger::cmkdir():");
 354 //                              abort();
 355 //                      }
 356
 357 //                      This doesnt work under Linux, it returns a valid handle
 358 //                      Instead: see if file exists. If it doesnt, create directory ok
 359 //                      If it exists, do  stat to see if it is a dir.
 360 //                      If it is a dir, then ok, create the directory.
 361 //                      If it is a file, error
 362 //                      ging 9-16-2002
 363
 364                         handle = open(j, O_RDONLY);
 365                         if (handle > 0)
 366                         {
 367                                 struct stat stat_buffer;
 368                                 int ret = fstat(handle,&stat_buffer);
 369                                 if ((ret == -1) || ((stat_buffer.st_mode | S_IFDIR) == 0))
 370                                 {
 371                                         perror("Logger::cmkdir():");
 372                                         abort();
 373                                 }
 374                         }
 375
 376                         mkdir(j, mode);
 377                         close(handle);
 378                         (*i) = file_sep;
 379                 }
 380                 else if(*(i + 1) == 0)
 381                 {
 382                         mkdir(j, mode);
 383                 }
 384                 i++;
 385         }
 386 }
 387 #ifdef EXTERNAL_DISTRO
 388 };
 389 #endif
 390 };