碼上快樂

相關內容    簡體    繁體

Linux監控重要進程的實現方法

本文轉載自   查看原文   2018-01-09 10:36   5853    linux 系統調用

Linux監控重要進程的實現方法

不管后台服務程序寫的多么健壯，還是可能會出現core dump等程序異常退出的情況，但是一般情況下需要在無

人為干預情況下，能夠自動重新啟動，保證服務進程能夠服務用戶。這時就需要一個監控程序來實現能夠讓服務進程自動重新啟動。查閱相關資料及嘗試一些方法之后，總結linux系統監控重要進程的實現方法：腳本檢測和子進程替換。

1、腳本檢測 (1) 基本思路: 通過shell命令(ps -e | grep "$1" | grep -v "grep" | wc -l) 獲取 $1 ($1 代表進程的名字)的進程數，腳本根據進程數來決定下一步的操作。通過一個死循環，每隔幾秒檢查一次系統中的指定程序的進程數，這里也可使用crontab來實現。 (2) 具體實現過程的代碼如下: [ supervisor.sh ]

 

[plain] view plain copy print?
  1. #! /bin/sh  
  2. # supervisor process   
  3.   
  4. LOG_FILE=/var/log/supervisor_sh.log  
  5.   
  6. # log function   
  7. function log() {  
  8.     local t=$(date +"%F %X")  
  9.     echo "[ $t ] $0 : $1 " >> ${LOG_FILE}  
  10. }  
  11.   
  12. # check process number   
  13. # $1 : process name   
  14. function check_process() {  
  15.     if [ -z $1 ]; then  
  16.         log "Input parameter is empty."  
  17.         return 0       
  18.     fi  
  19.       
  20.     p_num=$(ps -e | grep "$1" | grep -v "grep" | wc -l)  
  21.     log "p_num = $p_num"   
  22.     echo $p_num  
  23. }  
  24.   
  25. # supervisor process   
  26. while [ 1 ]  
  27. do   
  28.     declare -i ch_num  
  29.     p_name="apache2"  
  30.     ch_num=$(check_process $p_name)  
  31.     if [ $ch_num -eq 0 ]; then  
  32.         killall $p_name  
  33.         service $p_name start    
  34.     fi  
  35.     sleep 3   
  36. done  
#! /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

 

[cpp] view plain copy print?
  1. /** 
  2.  * 
  3.  * supervisor  
  4.  * 
  5.  * date: 2016-08-10  
  6.  *  
  7.  */  
  8.   
  9. #include <stdio.h>  
  10. #include <unistd.h>  
  11. #include <errno.h>  
  12. #include <string.h>  
  13. #include <sys/types.h>  
  14. #include <sys/wait.h>  
  15. #include <stdlib.h>  
  16. #include <time.h>  
  17.   
  18. #define LOG_FILE "/var/log/supervisor.log"  
  19.   
  20. void s_log(char *text) {  
  21.     time_t      t;  
  22.     struct tm  *tm;  
  23.     char *log_file;  
  24.     FILE *fp_log;  
  25.     char date[128];  
  26.       
  27.     log_file = LOG_FILE;  
  28.     fp_log = fopen(log_file, "a+");  
  29.     if (NULL == fp_log) {  
  30.         fprintf(stderr, "Could not open logfile '%s' for writing\n", log_file);  
  31.     }  
  32.       
  33.     time(&t);  
  34.     tm = localtime(&t);  
  35.     strftime(date, 127, "%Y-%m-%d %H:%M:%S", tm);  
  36.       
  37.     /* write the message to stdout and/or logfile */      
  38.     fprintf(fp_log, "[%s] %s\n", date, text);  
  39.     fflush(fp_log);  
  40.     fclose(fp_log);  
  41. }   
  42.   
  43. int main(int argc, char **argv) {  
  44.     int ret, i, status;  
  45.     char *child_argv[100] = {0};  
  46.     pid_t pid;  
  47.     if (argc < 2) {  
  48.         fprintf(stderr, "Usage:%s <exe_path> <args...>", argv[0]);  
  49.         return -1;  
  50.     }  
  51.       
  52.     for (i = 1; i < argc; ++i) {  
  53.         child_argv[i-1] = (char *)malloc(strlen(argv[i])+1);  
  54.         strncpy(child_argv[i-1], argv[i], strlen(argv[i]));  
  55.         //child_argv[i-1][strlen(argv[i])] = '0';  
  56.     }  
  57.       
  58.     while(1) {  
  59.         pid = fork();   
  60.         if (pid == -1) {  
  61.             fprintf(stderr, "fork() error.errno:%d error:%s", errno, strerror(errno));  
  62.             break;  
  63.         }  
  64.         if (pid == 0) {  
  65.             s_log(child_argv[0]);  
  66.             ret = execv(child_argv[0], (char **)child_argv);  
  67.             s_log("execv return");  
  68.             if (ret < 0) {  
  69.                 fprintf(stderr, "execv ret:%d errno:%d error:%s", ret, errno, strerror(errno));  
  70.                 continue;  
  71.             }  
  72.             s_log("exit child process");  
  73.             exit(0);  
  74.         }  
  75.         if (pid > 0) {  
  76.             pid = wait(&status);  
  77.             fprintf(stdout, "Child process id: %d\n", pid);  
  78.             //fprintf(stdout, "wait return");  
  79.             s_log("Wait child process return");  
  80.         }  
  81.     }  
  82.       
  83.     return 0;  
  84. }  
/**
 *
 * 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;
}

(4) 測試驗證 a. 假設需要自動重啟的程序為demo.c，其代碼實現如下所示：

 

[cpp] view plain copy print?
  1. /* 
  2. * 
  3. * demo   
  4. * 
  5. */  
  6.   
  7. #include <stdio.h>  
  8. #include <unistd.h>  
  9. #include <errno.h>  
  10. #include <string.h>  
  11. #include <sys/types.h>  
  12. #include <sys/wait.h>  
  13. #include <stdlib.h>  
  14. #include <time.h>  
  15.   
  16. #define LOG_FILE "/var/log/demo.log"  
  17.   
  18. void demo_log(int num) {  
  19.     time_t      t;  
  20.     struct tm  *tm;  
  21.     char *log_file;  
  22.     FILE *fp_log;  
  23.     char date[128];  
  24.       
  25.     log_file = LOG_FILE;  
  26.     fp_log = fopen(log_file, "a+");  
  27.     if (NULL == fp_log) {  
  28.         fprintf(stderr, "Could not open logfile '%s' for writing\n", log_file);  
  29.     }  
  30.       
  31.     time(&t);  
  32.     tm = localtime(&t);  
  33.     strftime(date,127,"%Y-%m-%d %H:%M:%S",tm);  
  34.       
  35.     /* write the message to stdout and/or logfile */      
  36.     fprintf(fp_log, "[%s] num = %d\n", date, num);  
  37.     fflush(fp_log);  
  38.     fclose(fp_log);  
  39. }   
  40.   
  41. int main(int argc, char **argv[]) {  
  42.     int num = 0;  
  43.       
  44.     while(1) {  
  45.         sleep(10);  
  46.         num++;  
  47.         demo_log(num);  
  48.     }  
  49. }  
/*
*
* demo  
*
*/

#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/demo.log"

void demo_log(int num) {
	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] num = %d\n", date, num);
	fflush(fp_log);
	fclose(fp_log);
} 

int main(int argc, char **argv[]) {
	int num = 0;
	
	while(1) {
		sleep(10);
		num++;
		demo_log(num);
	}
}

b. 測試准備和說明:

b1. 以上相關服務程序編譯后的二進制文件為: supervisor 和 demo 

b2. 執行如下測試命令 ./supervisor ./demo  

c. 測試的結果:

c1. execv(progname, arg) 執行成功后，其后的代碼不會執行；只有當執行錯誤時，才會返回 -1。原來調用execv進程的代碼段會被progname應用程序的代碼段替換。

c2. 當kill掉子進程時，父進程wait函數會接收到子進程退出的信號，進而循環再啟動子進程，此過程實時性非常高。

c3. 當kill掉父進程時，子進程會被init進程接管，如果此時再kill掉子進程，則子進程會退出。

c4. 當同時kill掉父子進程，則父子進程都會退出。


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 linux 進程監控和自動重啟的簡單實現 【swoole】PHP＋Swoole+Linux實現進程監控 Linux 監控文件被什么進程修改 NetHogs監控Linux的每個進程流量 【JVM】jconsole遠程監控linux上的java進程 【JVM】jvisualvm遠程監控linux上java進程 shell腳本實現進程狀態監控 Bat 腳本實現監控進程功能 Bat腳本實現監控進程功能 Linux 進程資源用量監控和按用戶設置進程限制
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM