守护进程应用，监控应用程序状态

在实际的项目中，运用守护进程（精灵进程）监控我们的应用程序是否异常中断，如果中断则重新启动该应用程序，并以日志文件的形式记录下来。似乎是项目开发中通用的一种技巧。

下面是我个人为了实现这一目的，而写的一个简单的demo，没有精心的设计，粗糙的实现了该功能，供菜鸟学习！如果是老鸟，请留下你宝贵的建议！

环境：ubuntu

应用程序路径：/home/bsj/Desktop/test/aa

应用程序代码：

#include <stdio.h>
#include<fcntl.h>

int main(void)
{
    int iTmp;
    while(1)
    {
        sleep(30);
        printf("I am is aa\n");
    }
}

编译生成：aa，在目录/home/bsj/Desktop/test/ 下。

守护进程代码如下：

#include <unistd.h>
#include <signal.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>
#include <dirent.h>


typedef int s_32;
#define PROCESS_NAME "/home/bsj/Desktop/test/aa &"
#define FILE_NAME      "/home/bsj/Desktop/test/aa"
void init_daemon(void)
{
    int pid;
    int i;

    umask(0);
    if(pid=fork())
    {
        exit(0);
    }
    else if(pid< 0)
    {
        exit(1);
    }
 
    setsid();
 
    if(pid=fork())
    {
        exit(0);
    }
    else if(pid< 0)
    {
        exit(1);
    }
   

    for(i=0;i< NOFILE;++i)
    {
        close(i);
    }
    chdir("/var");
    umask(0);
    return;
}


static s_32 Scan_File_For_Process(char *basePath, char *name, char *PID)
{
    DIR *dir;
    struct dirent *ptr;
    char base[100] = {0}, process_name[100] = {0};
    FILE *fp = NULL;
    
    if ((dir=opendir((char*)basePath)) == NULL)
    {
        perror("Open dir error...");
        return -1;
    }
    while ((ptr=readdir(dir)) != NULL)
    {
       //printf("%s/%s type is %d...\n", basePath, ptr->d_name, ptr->d_type);
       if(strcmp(ptr->d_name,".")==0 || strcmp(ptr->d_name,"..")==0)
       {
           continue;
       }
       else if(ptr->d_type == 8)    //file
       {
           /*file name */
           if(strcmp(ptr->d_name,"cmdline")==0)
           {
              sprintf((char *)base, "%s/%s", basePath, ptr->d_name);
              if(( fp = fopen((char *)base,"r")) == NULL)
              {
                 return -1;
              }
              fgets((char *)process_name, 100, fp);
              if(memcmp(process_name, name, strlen((char *)name)) == 0)
              {
                   memcpy(PID, &basePath[6], strlen((char *)basePath)-6);
                   fclose(fp);
                   closedir(dir);
                   return 0;
              }
              fclose(fp);         
          }
      }
   }
   
   closedir(dir);
   return -1;
}

static s_32 Process_Name_Analyze(char * name)
{   
    s_32 Tmp;
    
    for(Tmp = 0; Tmp < strlen(name); Tmp++)
    {
        if((name[Tmp] < '0') || (name[Tmp] > '9'))
        {
            break;
        }
    }
    if(Tmp >= strlen((char *)name))
    {
        return 0;
    }
    else
    {
        return -1;
    }
}


static s_32 Scan_Dir_For_Process(char *basePath, char *name, char *PID)
{
    DIR *dir;
    struct dirent *ptr;
    char base[100];

    if ((dir=opendir((char*)basePath)) == NULL)
    {
        perror("Open dir error...");
        return -1;
    }
    
    while ((ptr=readdir(dir)) != NULL)
    {
       if((strcmp(ptr->d_name,".")==0) || (strcmp(ptr->d_name,"..")==0))  
           continue;
            
       else if(ptr->d_type == 4)    //dir
       {
           /*file name*/
           if(!Process_Name_Analyze(ptr->d_name))
           {
               if(memcmp(ptr->d_name, name, strlen((char *)name)) == 0)
               {
                  memcpy(PID, &basePath[6], strlen((char *)basePath)-6);
                  return 0;
               }
               memset(base,'\0',sizeof(base));
               strcpy((char *)base,(char *)basePath);
               strcat((char *)base,"/");
               strcat((char *)base,ptr->d_name);
               if(!Scan_File_For_Process(base, name, PID))
               {
                   closedir(dir);
                   return 0;
               }
           }
       }
    }
   closedir(dir);
   return -1;

}

main()
{
    FILE *fp;
    time_t t;    
    char pid[10] = {0};
    
    init_daemon();
    system(PROCESS_NAME);
    
    while(1)
    {
        sleep(60);
        if((fp=fopen("test.log","a")) >= 0)
        {
            memset(pid, 0, 10);
            t=time(0);
            if(!(Scan_Dir_For_Process("/proc", FILE_NAME, pid)))
            {
                fprintf(fp,"%s proc is exit, pid = %s, at %s\n", FILE_NAME, pid, asctime(localtime(&t)));
            }
            else
            {
                fprintf(fp,"%s proc is not exit!, at %s\n", FILE_NAME, asctime(localtime(&t)));
                if(!access(FILE_NAME, F_OK))
                {
                    system(PROCESS_NAME);
                    fprintf(fp,"%s restart! %s\n", FILE_NAME, asctime(localtime(&t)));
                }
                else
                {
                    fprintf(fp,"/******%s file lost!!!! %s******/\n", FILE_NAME, asctime(localtime(&t)));
                }
            }
            fclose(fp);
        }
    }
}

编译生成可执行程序:deamon

# ./deamon

每过一分钟，守护进程将查询应用程序是否存在，并在 /var/test.log 记录：查询记录

该demo有个问题，因为是在守护进程（deamon）中启动的应用程序（aa），应用程序继承了守护进程的文件描速符，所以标准输入、输出、错误都被关闭了，不能在终端打印消息。该问题留给网友给我指点一下吧！！