详解Linux监控重要进程的实现方法

发布时间:2019-10-13 08:45 来源:互联网 当前栏目:网站服务器

不管后台服务程序写的多么健壮,还是可能会出现core dump等程序异常退出的情况,但是一般情况下需要在无

人为干预情况下,能够自动重新启动,保证服务进程能够服务用户。这时就需要一个监控程序来实现能够让服务进程自动重新启动。查阅相关资料及尝试一些方法之后,总结linux系统监控重要进程的实现方法:脚本检测和子进程替换。

1、脚本检测

(1) 基本思路: 通过shell命令(ps -e | grep "$1" | grep -v "grep" | wc -l) 获取 $1 ($1 代表进程的名字)的进程数,脚本根据进程数来决定下一步的操作。通过一个死循环,每隔几秒检查一次系统中的指定程序的进程数,这里也可使用crontab来实现。

(2) 具体实现过程的代码如下: [ supervisor.sh ]

#! /bin/sh 
# supervisor process  
 
LOG_FILE=/var/log/supervisor_sh.log 
 
# log function  
function log() { 
  local t=$(date +"%F %X") 
  echo "[ $t ] $0 : $1 " >> ${LOG_FILE} 
} 
 
# check process number  
# $1 : process name  
function check_process() { 
  if [ -z $1 ]; then 
    log "Input parameter is empty." 
    return 0    
  fi 
   
  p_num=$(ps -e | grep "$1" | grep -v "grep" | wc -l) 
  log "p_num = $p_num"  
  echo $p_num 
} 
 
# supervisor process  
while [ 1 ] 
do  
  declare -i ch_num 
  p_name="apache2" 
  ch_num=$(check_process $p_name) 
  if [ $ch_num -eq 0 ]; then 
    killall $p_name 
    service $p_name start  
  fi 
  sleep 3  
done 

2、子进程替换

(1) 基本思路:

a. 使用fork函数创建一个新的进程,在进程表中创建一个新的表项,而创建者(即父进程)按原来的流程继续执行,子进程执行自己的控制流程

b. 运用execv函数把当前进程替换为一个新的进程,新进程由path或file参数指定,可以使用execv函数将程序的执行从一个程序切换到另一个程序

c. 当fork启动一个子进程时,子进程就有了它自己的生命周期并将独立运行,此时可以在父进程中调用wait函数让父进程等待子进程的结束

(2) 基本的实现步骤:

a. 首先使用fork系统调用,创建子进程

b. 在子进程中使用execv函数,执行需要自动重启的程序

c. 在父进程中执行wait函数等待子进程的结束,然后重新创建一个新的子进程

(3) 具体实现的代码如下: supervisor.c

/** 
 * 
 * supervisor 
 * 
 * date: 2016-08-10 
 * 
 */ 
 
#include <stdio.h> 
#include <unistd.h> 
#include <errno.h> 
#include <string.h> 
#include <sys/types.h> 
#include <sys/wait.h> 
#include <stdlib.h> 
#include <time.h> 
 
#define LOG_FILE "/var/log/supervisor.log" 
 
void s_log(char *text) { 
  time_t   t; 
  struct tm *tm; 
  char *log_file; 
  FILE *fp_log; 
  char date[128]; 
   
  log_file = LOG_FILE; 
  fp_log = fopen(log_file, "a+"); 
  if (NULL == fp_log) { 
    fprintf(stderr, "Could not open logfile '%s' for writing\n", log_file); 
  } 
   
  time(&t); 
  tm = localtime(&t); 
  strftime(date, 127, "%Y-%m-%d %H:%M:%S", tm); 
   
  /* write the message to stdout and/or logfile */   
  fprintf(fp_log, "[%s] %s\n", date, text); 
  fflush(fp_log); 
  fclose(fp_log); 
}  
 
int main(int argc, char **argv) { 
  int ret, i, status; 
  char *child_argv[100] = {0}; 
  pid_t pid; 
  if (argc < 2) { 
    fprintf(stderr, "Usage:%s <exe_path> <args...>", argv[0]); 
    return -1; 
  } 
   
  for (i = 1; i < argc; ++i) { 
    child_argv[i-1] = (char *)malloc(strlen(argv[i])+1); 
    strncpy(child_argv[i-1], argv[i], strlen(argv[i])); 
    //child_argv[i-1][strlen(argv[i])] = '0'; 
  } 
   
  while(1) { 
    pid = fork();  
    if (pid == -1) { 
      fprintf(stderr, "fork() error.errno:%d error:%s", errno, strerror(errno)); 
      break; 
    } 
    if (pid == 0) { 
      s_log(child_argv[0]); 
      ret = execv(child_argv[0], (char **)child_argv); 
      s_log("execv return"); 
      if (ret < 0) { 
        fprintf(stderr, "execv ret:%d errno:%d error:%s", ret, errno, strerror(errno)); 
        continue; 
      } 
      s_log("exit child process"); 
      exit(0); 
    } 
    if (pid > 0) { 
      pid = wait(&status); 
      fprintf(stdout, "Child process id: %d\n", pid); 
      //fprintf(stdout, "wait return"); 
      s_log("Wait child process return"); 
    } 
  } 
   
  return 0; 
} 

        
 
  • 1、
  • 2、
  • 3、
  • 4、
  • 5、
  • 6、
  • 7、
  • 8、
  • 9、
  • 10、
  • 11、
  • 12、
  • 13、
  • 14、
  • 15、
  • 16、
  • 17、
  • 18、
  • 19、
  • 20、
  • 21、
  • 22、
  • 23、
  • 24、
  • 25、
  • 1、
  • 2、
  • 3、
  • 4、
  • 5、
  • 6、
  • 7、
  • 8、
  • 9、
  • 10、
  • 11、
  • 12、
  • 13、
  • 14、
  • 15、
  • 16、
  • 17、
  • 18、
  • 19、
  • 20、
  • 21、
  • 22、
  • 23、
  • 24、
  • 25、