logger.c

日志模块

#include "Logger.h"

static int bSwitch = 0;
static int bStarted = 0;
static LOG_LIST log_list;
static pthread_t tid = 0;
static CFG cfg;

static void TrimChar (char *ptr, char c);
static void *Worker (void *arg);
static void *Gzip (void *arg);
static void *Dispose (void *arg);
static void Push (LOG * log);
static LOG *Pop ();
static void CleanUp (void *arg);
static void WakeUp (int sig);
static int ReadConfig (const char *szConfig);

int
StartLogger (const char *szProgName)
{
  int err = 0;
  pthread_t tid;
  pthread_attr_t attr;
	struct sigaction act;
	
  if (bStarted)
    return 0;

  if (szProgName == NULL)
    return -1;

  /*初始化 */
  memset (&log_list, 0, sizeof (log_list));
  pthread_mutex_init (&(log_list.mtx), NULL);

  if (ReadConfig (szProgName) < 0)
  {
    printf ("ReadConfig error!\n");
    return -1;
  }

  if (signal (SIGUSR1, WakeUp) == SIG_ERR)
  {
    perror ("Set SIGUSR1 error!");

    return errno;
  }

  /*get ride of defunct*/
  sigaction(SIGCHLD, NULL, &act);
  /*act.sa_handler = SIG_IGN; 
  sigemptyset(&act.sa_mask);*/
  act.sa_flags |= SA_NOCLDWAIT;
  sigaction(SIGCHLD,&act,NULL);   

  pthread_attr_init (&attr);
  pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
  pthread_create (&tid, &attr, Worker, NULL);
  if (cfg.period > 0 && cfg.compress_log > 0)
  {
    pthread_create (&tid, &attr, Gzip, NULL);
  }
  if (cfg.period > 0 && cfg.delete_log_day > 0)
  {
    pthread_create (&tid, &attr, Dispose, NULL);
  }

  pthread_attr_destroy (&attr);

  printf ("Start logger service...\n");
  bStarted = 1;

  return 0;
}

int
ReadConfig (const char *szConfig)
{
  FILE *fp;
  char str[128];
  char szConfigName[128] = {0};
  int i = 0, j;

  memset (&cfg, 0, sizeof (cfg));

	if (getenv("LOGGER") != NULL)
	{
		sprintf(szConfigName, "%s/Logger.cfg", getenv("LOGGER"));
	}
	else
	{
		sprintf(szConfigName, "%s/misc/Logger.cfg", getenv("HOME"));	
	}
	
	if (GetPrivateProfileString(szConfig,"LOG_PATH","",cfg.log_path, \
	sizeof(cfg.log_path),szConfigName) < 0)
	{
		return -1;
	}
	TrimChar (cfg.log_path, ' ');
	
	if (GetPrivateProfileString(szConfig,"LOG_NAME1","",cfg.log_name[i], \
	sizeof(cfg.log_path),szConfigName) < 0)
	{
		return -1;
	}
	TrimChar (cfg.log_name[i], ' ');
	i++;
	
	if (GetPrivateProfileString(szConfig,"LOG_NAME2","",cfg.log_name[i], \
	sizeof(cfg.log_path),szConfigName) < 0)
	{
		return -1;
	}
	TrimChar (cfg.log_name[i], ' ');
	i++;

	memset (str, 0, sizeof (str));
	if (GetPrivateProfileString(szConfig,"LOG_PERIOD","",str, \
	sizeof(str),szConfigName) < 0)
	{
		return -1;
	}
	TrimChar (str, ' ');
  cfg.period = atoi(str);

	memset (str, 0, sizeof (str));
	if (GetPrivateProfileString(szConfig,"LOG_COMPRESS","",str, \
	sizeof(str),szConfigName) < 0)
	{
		return -1;
	}
	TrimChar (str, ' ');
  cfg.compress_log = atoi(str);

	memset (str, 0, sizeof (str));
	if (GetPrivateProfileString(szConfig,"LOG_DELETE","",str, \
	sizeof(str),szConfigName) < 0)
	{
		return -1;
	}
	TrimChar (str, ' ');
  cfg.delete_log_day = atoi(str);

  return 0;
}

static void
WakeUp (int sig)
{
  if (signal (SIGUSR1, WakeUp) == SIG_ERR)
  {
    perror ("Set SIGUSR1 error!");

    return;
  }
  if (bSwitch)
    bSwitch = 0;
  else
    bSwitch = 1;
}

static void
Push (LOG * log)
{
  pthread_mutex_lock (&(log_list.mtx));
  if (log_list.head == NULL)
    log_list.head = log_list.tail = log;
  else
  {
    (log_list.tail)->next = log;
    log_list.tail = log;
  }
  log_list.count++;
  pthread_mutex_unlock (&(log_list.mtx));
}

static LOG *
Pop ()
{

  LOG *log;
  pthread_mutex_lock (&(log_list.mtx));
  if (log_list.head == NULL)
  {
    log = log_list.head;
  }
  else
  {
    log = log_list.head;
    log_list.head = log_list.head->next;
    log_list.count--;
  }
  pthread_mutex_unlock (&(log_list.mtx));

  return log;
}

int
WriteLog (const char *fmt, ...)
{
  char szTmp[512] = { 0 };
  LOG *log;
  va_list argptr;

  va_start (argptr, fmt);
  vsnprintf (szTmp, sizeof (szTmp), fmt, argptr);
  va_end (argptr);

  printf ("%s", szTmp);
  if (!bSwitch && bStarted)
    return 0;
  if (fmt == NULL)
    return -1;

  log = (LOG *) malloc (sizeof (LOG));
  if (log == NULL)
    return -1;

  memset (log, 0, sizeof (LOG));
  log->next = NULL;
  log->content = (char *) malloc (strlen (szTmp) + 64);
  if (log->content == NULL)
  {
    free (log);
    return -1;
  }
  snprintf (log->content, strlen (szTmp) + 64, "pid(%d) thr(%d):%s",
	    getpid (), pthread_self (), szTmp);

  log->length = strlen (szTmp) + 64;
  Push (log);

  return 1;
}

int
GetLogNums ()
{
  int ret;

  pthread_mutex_lock (&(log_list.mtx));
  ret = log_list.count;
  pthread_mutex_unlock (&(log_list.mtx));

  return ret;
}

static void
CleanUp (void *arg)
{
  LOG *log;
  /*printf ("In CleanUp.\n");
     printf ("items(%d)\n", GetLogNums ()); */

  while ((log = Pop ()) != NULL)
  {
    if (log->content)
      free (log->content);
    if (log)
      free (log);

    printf ("freed a item\n");
  }
  /*printf ("released items(%d)\n", GetLogNums ()); */
}

void
TrimChar (char *ptr, char c)
{
  int i, min, max, len;

  if (*ptr == 0)
    return;
  for (i = 0; i < strlen (ptr); i++)
  {
    if (ptr[i] != c && ptr[i] != '\r' && ptr[i] != '\n')
      break;
  }
  min = i;
  for (i = strlen (ptr) - 1; i > -1; i--)
  {
    if (ptr[i] != c && ptr[i] != '\r' && ptr[i] != '\n')
      break;
  }
  max = i + 1;
  len = max - min;
  for (i = 0; i < len; i++)
    ptr[i] = ptr[i + min];
  ptr[i] = 0;
  return;
}

static void *
Gzip (void *arg)
{
  char szTemp[64];
  char szFileName[128];
  char szList[128];
  char szCmd[512];
  FILE *fp;
  struct stat st;
  time_t mt, now;
  struct tm *tim;

  printf ("In Gzip!\n");

  for (;;)
  {
    sleep (cfg.period);

    sprintf (szList, "ls %s|grep -v \".gz$\"", cfg.log_path);
    fp = popen (szList, "r");
    while (fgets (szTemp, sizeof (szTemp) - 1, fp) != NULL)
    {
      TrimChar (szTemp, ' ');
      sprintf (szFileName, "%s/%s", cfg.log_path, szTemp);

      printf ("Gzip %s\n", szFileName);

      memset (&st, 0, sizeof (st));
      if (stat (szFileName, &st) < 0)
      {
	printf ("%s doesn't exist!\n", szFileName);
	continue;
      }
      if (S_ISDIR(st.st_mode))
      {
      	continue;
      }
      now = time (NULL);
      mt = now - st.st_mtime;
      tim = localtime (&mt);

      if (tim->tm_mday - 1 > cfg.compress_log)
      {
	sprintf (szCmd, "/bin/gzip -c %s>>%s.gz", szFileName, szFileName);

	printf ("%s\n", szCmd);
	system (szCmd);
	sprintf (szCmd, "/bin/rm -f %s", szFileName);
	system (szCmd);
      }
    }
    pclose (fp);
  }
}

static void *
Dispose (void *arg)
{
  char szTemp[64];
  char szFileName[128];
  char szList[128];
  char szCmd[512];
  FILE *fp;
  struct stat st;
  time_t mt, now;
  struct tm *tim;

  printf ("In Dispose\n");

  for (;;)
  {
    sleep (cfg.period);

    sprintf (szList, "ls %s|grep \".gz$\"", cfg.log_path);
    fp = popen (szList, "r");
    while (fgets (szTemp, sizeof (szTemp) - 1, fp) != NULL)
    {
      TrimChar (szTemp, ' ');
      sprintf (szFileName, "%s/%s", cfg.log_path, szTemp);

      printf ("Dispose %s\n", szFileName);

      memset (&st, 0, sizeof (st));
      if (stat (szFileName, &st) < 0)
      {
	printf ("%s doesn't exist!\n", szFileName);
	continue;
      }
      if (S_ISDIR(st.st_mode))
      {
      	continue;
      }
      
      now = time (NULL);
      mt = now - st.st_mtime;
      tim = localtime (&mt);

      if (tim->tm_mday - 1 > cfg.delete_log_day)
      {
	sprintf (szCmd, "/bin/rm -f %s", szFileName);
	printf ("%s\n", szCmd);
	system (szCmd);
      }
    }
    pclose (fp);
  }

}

static void *
Worker (void *arg)
{
  char szFilename[128] = { 0 };
  char szTemp[32];
  char szScript[256];

  FILE *fp;
  FILE *pp;
  time_t tt;
  struct tm *tim;
  LOG *log;
  int i, j;

  pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL);
  pthread_cleanup_push (CleanUp, (void *) NULL);
  printf ("In Worker procedure...\n");
  for (;;)
  {
    if (!bSwitch)
    {
      CleanUp (NULL);
      usleep (5 * 1000);
      continue;
    }

    if ((log = Pop ()) == NULL)
    {
      usleep (3 * 1000);
    }
    else
    {
      memset (szFilename, 0, sizeof (szFilename));
      for (i = 0; strlen (cfg.log_name[i]) > 0; i++)
      {
	if (strstr (cfg.log_name[i], "`"))
	{
	  memset (szTemp, 0, sizeof (szTemp));
	  sscanf (cfg.log_name[i], "`%s`", szTemp);
	  for (j = 0; szTemp[j]; j++)
	  {
	    if (szTemp[j] == '_')
	      szTemp[j] = ' ';
	  }
	  TrimChar (szTemp, '`');
	  printf ("szTemp(%s)\n", szTemp);
	  pp = popen (szTemp, "r");
	  if (pp == NULL)
	    continue;
	  memset (szScript, 0, sizeof (szScript));
	  if (fgets (szScript, sizeof (szScript) - 1, pp) == NULL)
	  {
	  	pclose (pp);
	    continue;
		}
	  pclose (pp);
	  TrimChar (szScript, ' ');
	  strcat (szFilename, szScript);
	}
	else
	{
	  strcat (szFilename, cfg.log_name[i]);
	}
	strcat (szFilename, " ");
      }
      TrimChar (szFilename, ' ');
      memset (szScript, 0, sizeof (szScript));
      sprintf (szScript, "%s/%s", cfg.log_path, szFilename);
      for (i = 0; szScript[i]; i++)
      {
	if (szScript[i] == ' ')
	  szScript[i] = '_';
      }

      printf ("file name is : %s\n", szScript);

      fp = fopen (szScript, "a+");
      if (fp == NULL)
	continue;
      tt = time (NULL);
      tim = localtime (&tt);
      fprintf (fp, "[%04d%02d%02d %02d:%02d:%02d]\n",
	       tim->tm_year + 1900,
	       tim->tm_mon + 1,
	       tim->tm_mday, tim->tm_hour, tim->tm_min, tim->tm_sec);
      fprintf (fp, "%s\n", log->content);
      fclose (fp);
      if (log->content != NULL)
	free (log->content);
      if (log != NULL)
	free (log);
    }
  }
  return NULL;
}

}