威尼斯城所有登入网址


单引号定义的字符串,威尼斯城所有登入网址:字符串的定义可以使用英文单引号’ ‘
威尼斯城所有登入网址 6
查看一下仓库的列表威尼斯城所有登入网址: ..,MySQL作为数据库

如果需要则杀掉进程删除RunFile文件

PHP也是足以平素开展照拂进度的运行与终止的,绝对于shell来讲会轻便非常多,明白更便于,当然了PHP守护进度要落实自动重启依然要依据于shell的crontab日程表,每间距一段时间去实行一遍脚本看脚本是不是供给重启,借使急需则杀掉进度删除RunFile文件,重新开动并在RunFile文件中写入pid。

协和编写服务运转脚本(一卡塔尔(قطر‎:functions文件详细解析和表达,脚本functions

本文目录:

1.几个彰显函数
2.action函数
3.is_true和is_false函数
4.confirm函数
5.pid检验相关函数
  5.1 checkpid、__pids_var_run和__pids_pidof函数
  5.2 pidfileofproc和pidofproc函数
6.重头戏(一):daemon函数
7.重头戏(二):killproc函数
8.重头戏(三):status函数
9.多少个主要函数的下结论和选拔表达
  9.1 pid相关
  9.2 daemon的使用
  9.3 killproc的使用
  9.4 status的使用
10.memcached服务运维脚本示例


/etc/rc.d/init.d/functions大约被/etc/rc.d/init.d/下全体的Sysv服务运营脚本加载,也是读书shell脚本时贰个可怜不易的素材,在在那之中使用了无数技艺。

在该公文中提供了多少个有效的函数:

  • daemon:运营二个服务程序。运营前还检查进度是不是已在运作。
  • killproc:杀掉给定的服务进度。
  • status:检查给定进程的运维意况。
  • success:显示深铜锈绿的”OK”,表示成功。图片 1
  • failure:呈现鲜黄的”FAILED”,表示失败。图片 2
  • passed:彰显深紫灰的”PASSED”,表示pass该职分。图片 3
  • warning:展现深湖蓝的”warning”,表示警告。图片 4
  • action:依照进度退出状态码自行决断是实行success依然failure。
  • confirm:提示”(Y)es/(N)o/(C)ontinue? [Y]”并认清、传递输入的值。
  • is_true:”$1″的布尔值代表为真时,再次回到状态码0,不然重返1。饱含t、y、yes和true,不区分抑扬顿挫写。
  • is_false:”$1″的布尔值代表为假时,再次来到状态码0。不然再次来到1。包罗f、n、no和false,不区分朗朗上口写。
  • checkpid:检查/proc下是不是有给定pid对应的目录。给定多少个pid时,只要存在三个目录都回来状态码0。
  • __pids_var_run:检查pid是或不是存在,并保留到变量pid中,同期重返二种进程状态码。是functions中器重函数之一。
  • __pids_pidof:获取进程pid。
  • pidfileofproc:获取进度的pid。但只好获得/var/run下的pid文件中的值。
  • pidofproc:获取进度的pid。可获得自便给定pidfile或暗许/var/run下pidfile中的值。

前多少个是functions文件最重大的3个函数,还用到了有的额外的赞助函数,微微有一点点复杂。所以由简至繁,先介绍并出示后边多少个函数,再回头解释前3个函数。

以下是/etc/init.d/functions文件的开头定义的口舌。设置umask值,使得加载该文件的本子所在shell的umask为22。导出路线变量。但说实话,那么些导出的路子变量并不能,因为要为非rpm包安装的次第设计服务运营脚本时,必得写全路径命令,比方/usr/local/mysql/bin/mysql。因而,能够虚构将/etc/init.d/functions中的语句注释掉。

umask 022

# Set up a default search path.
PATH="/sbin:/usr/sbin:/bin:/usr/bin"
export PATH

PS:本文解析的/etc/init.d/functions文件是CentOS 7上的,和CentOS
6某些许界别,但该有的指标和动作都有。

<?php       
function start($file){
    $path = dirname(__FILE__).'/';
    $runfile = $path.$file.'.run';
    $diefile = $path.$file.'.die';
    $file = $path."data/{$file}.php";
    clearstatcache();
    if(file_exists($runfile)){
        $oldpid = file_get_contents($runfile);
        $nowpid = shell_exec("ps aux | grep 'php -f process.php' | grep ${oldpid} | awk '{print $2}'");
        //如果runfile中的pid号可以匹配到正在运行的,并且上次访问runfile的时间和现在相差小于5min则返回
        if(($oldpid == $nowpid) && (time() - fileatime($runfile) < 300)){
            echo "$file is circle runing no";
            return;
        }else{
            //pid号不匹配或者已经有300秒没有运行循环语句,直接杀掉进程,重新启动
            $pid = file_get_contents($runfile);
            shell_exec("ps aux | grep 'php -f process.php' | grep {$pid} | xargs --if-no-run-empty kill");
        }
    }else{
        //将文件pid写入run文件
        if(!($newpid = getmypid()) || !file_put_contents($runfile,$newpid)){
            return;
        }
        while(true){
            //收到结束进程新号,结束进程,并删除相关文件
            if(file_exists($diefile) && unlink($runfile) && unlink($diefile)){
                return;
            }
            /*这里是守护进程要做的事*/
            file_put_contents($file,"I'm Runing Now".PHP_EOL,FILE_APPEND);
            /***********************/
            touch($runfile);
            sleep(5);
        }
    }
}
start("test");

1.多少个显示函数

包括echo_success、success、echo_failure、failure、echo_passed、passed、echo_warning和warning函数。那多少个函数的定义方式和应用格局完全同样。

以下是echo_success和success函数的定义语句。

echo_success() {
  [ "$BOOTUP" = "color" ] && $MOVE_TO_COL
  echo -n "["
  [ "$BOOTUP" = "color" ] && $SETCOLOR_SUCCESS
  echo -n $"  OK  "
  [ "$BOOTUP" = "color" ] && $SETCOLOR_NORMAL
  echo -n "]"
  echo -ne "\r"
  return 0
}

success() {
  [ "$BOOTUP" != "verbose" -a -z "${LSB:-}" ] && echo_success
  return 0
}

很简短,即是不换行带颜色输出”[ OK ]”字样。

[root@xuexi ~]# . /etc/init.d/functions

[root@xuexi ~]# success
[root@xuexi ~]#                                            [  OK  ]
[root@xuexi ~]# echo_success
[root@xuexi ~]#                                            [  OK  ]

同理,剩余的多少个情景呈现函数也一模二样。

[root@xuexi ~]# echo_failure
[root@xuexi ~]#                                            [FAILED]
[root@xuexi ~]# failure
[root@xuexi ~]#                                            [FAILED]

PHP写守护进程时要细心几点:

2.action函数

那一个函数在写脚本时还相比较有用,能够依赖退出状态码自动推断是实行success如故实施failure函数。

action函数定义语句如下:

action() {
  local STRING rc

  STRING=$1
  echo -n "$STRING "
  shift
  "[email protected]" && success $"$STRING" || failure $"$STRING"
  rc=$?
  echo
  return $rc
}

本条函数定义的很有手艺。先将第一个参数保存并踢掉,再推行后面包车型地铁命令(“[email protected]”表示试行后边的吩咐卡塔尔国。所以,当action函数只有多个参数时,action直接重返OK,状态码为0,当胜过二个参数时,第叁个参数先被打字与印刷,再实行从第一个参数开端的指令。

例如:

[root@xuexi ~]# action
                                                           [  OK  ]
[root@xuexi ~]# action 5
5                                                          [  OK  ]
[root@xuexi ~]# action sleeping sleep 3
sleeping                                                   [  OK  ]
[root@xuexi ~]# action "moving file" mv xxxxxx.sh aaaaa.sh
moving file mv: cannot stat ‘xxxxxx.sh’: No such file or directory
                                                           [FAILED]

于是,在剧本中接纳action函数时,能够让命令施行成功与否的论断显得更”专门的学问”。算是叁个比较有意思的函数。

日常性,该函数会构成/bin/true和/bin/false命令使用,它们无条件重临0或1状态码。

action $"MESSAGES: " /bin/true
action $"MESSAGES: " /bin/false

比方说,mysqld运维脚本中,判别mysqld已在运行时,直接出口运行ok的消息。(但实际根本没做任何事State of Qatar

if [ $MYSQLDRUNNING = 1 ] && [ $? = 0 ]; then
    # already running, do nothing
    action $"Starting $prog: " /bin/true
    ret=0

1.首先就是函数clearstatcache(卡塔尔函数这里,查官方手册能够驾驭该函数是死灭文件状态缓存的,当在二个本子中往往反省同一个文书的缓存状态时假诺不用该函数就能出错,受该函数影响的有:stat(卡塔尔国,
lstat(卡塔尔国, file_exists(), is_writable(),is_readable(),
is_executable(), is_file(), is_dir(), is_link(),filectime(),
fileatime(), filemtime(), fileinode(), filegroup(),fileowner(),
filesize(), filetype(), fileperms().

3.is_true和is_false函数

那八个函数的功能是改造输入的布尔值为状态码。

is_true() {
    case "$1" in
    [tT] | [yY] | [yY][eE][sS] | [tT][rR][uU][eE])
    return 0
    ;;
    esac
    return 1
}

is_false() {
    case "$1" in
    [fF] | [nN] | [nN][oO] | [fF][aA][lL][sS][eE])
    return 0
    ;;
    esac
    return 1
}

当is_true函数的第八个参数(前面的参数会忽视掉卡塔尔为忽视大小写的t、y、yes或true时,重临状态码0,不然再次回到1。
当is_false函数的第2个参数(后边的参数会忽视掉State of Qatar为忽视大小写的f、n、no或false时,重返状态码0,否则重临1。

2.在反复运行该脚本时,会在运行前开展检验,上次实践循环的小时间隔今后过量300s或许pid号不合作都会重启该进度(时间在历次实践循环式都要修改touch)。

4.confirm函数

那么些函数常常用不上,因为脚本本来正是为了制止交互作用式的。在CentOS
7的functions中一度删除了该函数概念语句。可是,借鉴下它的管理方法可能不错的。

以下摘自CentOS 6.6的/etc/init.d/functions文件。

# returns OK if $1 contains $2
strstr() {
  [ "${1#*$2*}" = "$1" ] && return 1   # 参数$1中不包含$2时,返回1,否则返回0
  return 0
}

# Confirm whether we really want to run this service
confirm() {
  [ -x /bin/plymouth ] && /bin/plymouth --hide-splash
  while : ; do 
      echo -n $"Start service $1 (Y)es/(N)o/(C)ontinue? [Y] "
      read answer
      if strstr $"yY" "$answer" || [ "$answer" = "" ] ; then
         return 0
      elif strstr $"cC" "$answer" ; then
     rm -f /var/run/confirm
     [ -x /bin/plymouth ] && /bin/plymouth --show-splash
         return 2
      elif strstr $"nN" "$answer" ; then
         return 1
      fi
  done
}

先是个函数strstr的功力是推断第一个参数”$1″中是或不是带有了”$2″,要是含有了则赶回状态码0。这函数也是贰个不易的本事。

其次个函数confirm的机能是基于交互作用式输入的值再次回到分歧的状态码,假使输入的是y或Y或不输入时,再次来到0。输入的是c或C时,再次回到状态码2,输入的是n或N时再次回到状态码1。

于是能够依附confirm的情事值决定是或不是要继续实施某些程序。

用法和意义如下:

[root@xuexi ~]# confirm
Start service  (Y)es/(N)o/(C)ontinue? [Y] Y
[root@xuexi ~]# echo $?
0
[root@xuexi ~]# confirm
Start service  (Y)es/(N)o/(C)ontinue? [Y] 
[root@xuexi ~]# echo $?
0
[root@xuexi ~]# confirm
Start service  (Y)es/(N)o/(C)ontinue? [Y] n
[root@xuexi ~]# echo $?
1
[root@xuexi ~]# confirm
Start service  (Y)es/(N)o/(C)ontinue? [Y] c
[root@xuexi ~]# echo $?
2

3.电动重启也接受了crontab的日程表,将该文件添到场日程表:

5.pid检查评定相关函数

起步进度时,pid文件特别主要。不只能够通过它决断进程是或不是在运作,还是能从当中读取pid号用来杀进程。

crontab -e
#打开日程表,inset模式
*/3 * * * * /usr/bin/php -f process.php
#每3分钟执行一次,放置进程挂掉

5.1 checkpid、__pids_var_run和__pids_pidof函数

以下是函数checkpid__pids_var_run__pids_pidof的概念语句。

# Check if any of $pid (could be plural) are running
checkpid() {
    local i

    for i in $* ; do          # 检测/proc目录下是否存在给定的进程目录
        [ -d "/proc/$i" ] && return 0
    done
    return 1
}

# __proc_pids {program} [pidfile]
# Set $pid to pids from /var/run* for {program}.  $pid should be declared
# local in the caller.
# Returns LSB exit code for the 'status' action.
__pids_var_run() {                # 通过检测pid判断程序是否已在运行
    local base=${1##*/}           # 获取进程名的basename
    local pid_file=${2:-/var/run/$base.pid}     # 定义pid文件路径

    pid=
    if [ -f "$pid_file" ] ; then        # 给定的pid文件是否存在
            local line p

        [ ! -r "$pid_file" ] && return 4   # "user had insufficient privilege"
        while : ; do                       # 将pid文件中的pid值(可能有多行)赋值给pid变量
            read line
            [ -z "$line" ] && break
            for p in $line ; do
                [ -z "${p//[0-9]/}" ] && [ -d "/proc/$p" ] && pid="$pid $p"
            done
        done < "$pid_file"

            if [ -n "$pid" ]; then  # pid存在,则返回0。否则表示pid文件存在,但/proc下没有对应命令
                    return 0        # 即进程已死,但pid文件却存在,返回状态码1。
            fi
        return 1 # "Program is dead and /var/run pid file exists"
    fi
    return 3 # "Program is not running"    # pid文件不存在时,表示进程未运行,返回状态码3
}

# Output PIDs of matching processes, found using pidof
__pids_pidof() {             # 下面的pidof命令的意义见稍后解释
    pidof -c -m -o $$ -o $PPID -o %PPID -x "$1" || \   # 忽略当前shell的PID,父shell的pid和
                                                       # 调用pidof程序的shell的pid
        pidof -c -m -o $$ -o $PPID -o %PPID -x "${1##*/}"    # 总之就是找出合理的pid
}

__pidsvar_run函数的定义语句中能够了然到,独有当pid文件存在,且/proc下有pid对应的目录时,才代表经过在运作(当然,线程未有pid文件卡塔尔(قطر‎。__pids_var_run函数调用方法:

__pids_var_run program [pidfile]

若是不给定pidfile,则默以为/var/run/$base.pid文件。函数的执行结果为4种状态码:

  • 0:program正在周转。
  • 1:program进度已死。pid文件存在,但/proc目录下未有对应的公文。
  • 3:pid文件不设有。
  • 4:pid文件的权力错误,不可读。

除去回到状态码,__pids_var_run函数还大概会保留变量pid的结果,以供其余程序援引。

__pids_pidof中使用了pidof命令,此中使用了多少个”-o”选项,它用来忽视内定的pid。但看起来”$$””$PPID””%PPID”不是很好精通。”-o
$$”是忽略的是shell进度,大好多时候它会继续父shell的pid,但在本子中时它象征的是本子所在shell的pid。”-o
$PPID”忽视的是父shell。”-o
%PPID”忽视的是调用pidof命令的shell。不是很好通晓,能够参见上面包车型地铁测验语句。

测验脚本:

#!/bin/bash

echo 'pidof bash: '`pidof bash`
echo 'script shell pid: '`echo $$`
echo 'script parent shell pid: '`echo $PPID`
echo 'pidof -o $$ bash: '`pidof -o $$ bash`
echo 'pidof -o $PPID bash: '`pidof -o $PPID bash`
echo 'pidof -o %PPID bash: '`pidof -o %PPID bash`
echo 'pidof -o $$ -o $PPID -o %PPID bash: '`pidof -o $$ -o $PPID -o %PPID bash`

测验语句:

[root@xuexi ~]# pidof bash
3306 2436 2302
[root@xuexi ~]# (echo 'parent shell: '$$;echo "current bash pid: `pidof bash`";./test.sh)|cat -n
 1  parent shell: 2302
 2  current bash pid: 3745 3306 2436 2302
 3  pidof bash: 3748 3745 3306 2436 2302
 4  script shell pid: 3748
 5  script parent shell pid: 3745
 6  pidof -o $$ bash: 3745 3306 2436 2302
 7  pidof -o $PPID bash: 3748 3306 2436 2302
 8  pidof -o %PPID bash: 3745 3306 2436 2302
 9  pidof -o $$ -o $PPID -o %PPID bash: 3306 2436 2302

率先个pidof命令:表达当前已有3个bash,pid为:3306、2436和2302。
其次个指令:

  • 行1表明括号的父shell为2302。
  • 行5表明脚本的父shell为3745。即括号的父shell为当下bash景况,脚本的父shell为括号所在shell。
  • 行2减第2个指令的结果印证括号所在子shell的pid为3745。
  • 行3减行2表达shell脚本所在子shell的pid为3748。
  • “-o
    $$”忽视的是现阶段shell,即脚本所在shell的pid,因为在shell脚本中时,$$不一而再三回九转父shell的pid。
  • “-o $PPID”忽视的是pidof所在父shell,即括号所在shell。
  • “-o %PPID”忽视的是调用调用pidof程序所在的shell,即脚本所在shell。

这么就基本ok了,假若有实际功用的话还需更动代码。

5.2 pidfileofproc和pidofproc函数

除去上述3个pid相关函数,functions文件中,还提供了四个函数pidfileofprocpidofproc,均用于获取给定程序的pid值。

以下是pidfileofproc函数的定义语句。注意,该函数不是获得pidfile,而是获取pid值。

# A function to find the pid of a program. Looks *only* at the pidfile
pidfileofproc() {
    local pid

    # Test syntax.
    if [ "$#" = 0 ] ; then
        echo $"Usage: pidfileofproc {program}"
        return 1
    fi

    __pids_var_run "$1"          # 不提供pidfile,因此认为是/var/run/$base.pid
    [ -n "$pid" ] && echo $pid
    return 0
}

因此,pidfileofproc函数只可以得到/var/run下的pid。

以下是pidofproc函数的概念语句:

# A function to find the pid of a program.
pidofproc() {
    local RC pid pid_file=

    # Test syntax.
    if [ "$#" = 0 ]; then
        echo $"Usage: pidofproc [-p pidfile] {program}"
        return 1
    fi
    if [ "$1" = "-p" ]; then    # 既可以获取/var/run/$base.pid中的pid,
        pid_file=$2             # 也可以获取自给定pid文件中的pid
        shift 2
    fi
    fail_code=3 # "Program is not running"

    # First try "/var/run/*.pid" files
    __pids_var_run "$1" "$pid_file"
    RC=$?
    if [ -n "$pid" ]; then     # $pid不为空时,输出program的pid值
        echo $pid
        return 0
    fi

    [ -n "$pid_file" ] && return $RC   # $pid为空,但使用了"-p"指定pidfile时,返回$RC。
    __pids_pidof "$1" || return $RC    # $pid为空,且$pidfile为空时,获取进程号pid并输出
}

这四个函数的分别在于pidfileofproc只可以寻觅/var/run下的pid,而pidofproc能够寻找自给定的pidfile或/var/run/下的pid。而眼下的__pids_pidof函数,独有在获取bash进程时更标准(因为它会忽视父shell进程State of Qatar。至于选哪一个,见文末计算。

那多个函数用的比少之又少,但确实有利用它的本子。如crond运行脚本中借助pidfileofproc来杀进度:

echo -n $"Stopping $prog: "
if [ -n "`pidfileofproc $exec`" ]; then
        killproc $exec
        RETVAL=3
else
        failure $"Stopping $prog"
fi

dnsbind的named服务运维脚本中依赖pidofproc来推断进度是不是已在运转。

pidofnamed() {
        pidofproc -p "$ROOTDIR$PIDFILE" "$named";
}

if [ -n "`pidofnamed`" ]; then
  echo -n $"named: already running"
  success
  echo
  exit 0;
fi;

6.重头戏(一):daemon函数

daemon函数用于运维三个主次,并基于结果输出success或failure。

概念语句如下:

# A function to start a program.
daemon() {
    # Test syntax.
    local gotbase= force= nicelevel corelimit    # 定义一大堆变量
    local pid base= user= nice= bg= pid_file=
    local cgroup=
    nicelevel=0
    while [ "$1" != "${1##[-+]}" ]; do   # 当参数$1以"-"或"+"开头时进入循环,但$1为空时也满足
      case $1 in
        '')    echo $"$0: Usage: daemon [+/-nicelevel] {program}" "[arg1]..."
               return 1;;
        --check)                 # daemon接受"--arg value"和"--arg=value"两种格式的参数
           base=$2
           gotbase="yes"
           shift 2
           ;;
        --check=?*)
               base=${1#--check=}
           gotbase="yes"
           shift
           ;;
        --user)
           user=$2
           shift 2
           ;;
        --user=?*)
               user=${1#--user=}
           shift
           ;;
        --pidfile)
           pid_file=$2
           shift 2
           ;;
        --pidfile=?*)
           pid_file=${1#--pidfile=}
           shift
           ;;
        --force)
               force="force"
           shift
           ;;
        [-+][0-9]*)
               nice="nice -n $1"
               shift
           ;;
        *)     echo $"$0: Usage: daemon [+/-nicelevel] {program}" "[arg1]..."
               return 1;;
      esac
    done

        # Save basename.
        [ -z "$gotbase" ] && base=${1##*/}   # 若未传递"--check",则此处获取bashname

        # See if it's already running. Look *only* at the pid file.
    __pids_var_run "$base" "$pid_file"

    [ -n "$pid" -a -z "$force" ] && return    # 如进程已在运行(已检测出pid),且没有使用force
                                              # 强制启动,则退出daemon函数

    # make sure it doesn't core dump anywhere unless requested   
    corelimit="ulimit -S -c ${DAEMON_COREFILE_LIMIT:-0}"  # corelimit、cgroup和资源控制有关,忽略它

    # if they set NICELEVEL in /etc/sysconfig/foo, honor it
    [ -n "${NICELEVEL:-}" ] && nice="nice -n $NICELEVEL"

    # if they set CGROUP_DAEMON in /etc/sysconfig/foo, honor it
    if [ -n "${CGROUP_DAEMON}" ]; then
        if [ ! -x /bin/cgexec ]; then
            echo -n "Cgroups not installed"; warning
            echo
        else
            cgroup="/bin/cgexec";
            for i in $CGROUP_DAEMON; do
                cgroup="$cgroup -g $i";
            done
        fi
    fi

    # Echo daemon
        [ "${BOOTUP:-}" = "verbose" -a -z "${LSB:-}" ] && echo -n " $base"

    # And start it up.      # 启动程序。runuser的"-s"指定执行程序的shell,$user指定运行的身份
                            # "$*"是剔除掉daemon选项后程序的启动指令。
    if [ -z "$user" ]; then
       $cgroup $nice /bin/bash -c "$corelimit >/dev/null 2>&1 ; $*"
    else
       $cgroup $nice runuser -s /bin/bash $user -c "$corelimit >/dev/null 2>&1 ; $*"
    fi

    [ "$?" -eq 0 ] && success $"$base startup" || failure $"$base startup"
}

daemon函数调用方法:

daemon [--check=servicename] [--user=USER] [--pidfile=PIDFILE] [--force] program [prog_args]

内需小心的是:

举例说httpd的起步脚本中。

echo -n $"Starting $prog: "
daemon --pidfile=${pidfile} $httpd $OPTIONS

这么的说话的实行结果大约如下:

[[email protected] ~]# service httpd start
Starting httpd:                            [  OK  ]

还需注意,日常program的周转参数也许也是”–“开头的,要和program后边的选项界别。比如:

daemon --pidfile $pidfile --check $servicename $processname --pid-file=$pidfile

其次个”–pid-file”是”$processname”的运作参数,第一个”–pidfile”是daemon检查测试”$processname”是还是不是已运营的选项。由于提供了”–check
$servicename”,所以函数调用语句__pids_var_run $base [pidfile]中的$base等于$servicename,即表示检讨$servicename进度是或不是同意。若无提供该选项,则检查的是$processname。

由来,daemon函数已经解析到位。实际上超级轻松,正是为daemon提供多少个选用,再提供要实施的一声令下,并为该命令提供运转参数。

7.重头戏(二):killproc函数

killproc函数的职能是依据给定程序名杀进程。中间它会获取程序名对应的pid号,且保障/proc目录下并未有pid对应的目录才代表经过关闭成功。

# A function to stop a program.
killproc() {
    local RC killlevel= base pid pid_file= delay try

    RC=0; delay=3; try=0
    # Test syntax.
    if [ "$#" -eq 0 ]; then
        echo $"Usage: killproc [-p pidfile] [ -d delay] {program} [-signal]"
        return 1
    fi
    if [ "$1" = "-p" ]; then  # 指定pid_file。不给"-p"时,"__pids_var_run"将检查/var/run下的文件
        pid_file=$2
        shift 2
    fi
    if [ "$1" = "-d" ]; then  # awk的多目运算符。delay的有效值单位为d(天)、时(h)、分(m)、秒(s)。
                              # 不写单位时默认为秒。该语句将所给时间转换成秒,接受小数,做四舍五入计算
        delay=$(echo $2 | awk -v RS=' ' -v IGNORECASE=1 '{if($1!~/^[0-9.]+[smhd]?$/) exit 1;d=$1~/s$|^[0-9.]*$/?1:$1~/m$/?60:$1~/h$/?60*60:$1~/d$/?24*60*60:-1;if(d==-1) exit 1;delay+=d*$1} END {printf("%d",delay+0.5)}')
        if [ "$?" -eq 1 ]; then
            echo $"Usage: killproc [-p pidfile] [ -d delay] {program} [-signal]
            return 1
        fi
        shift 2
    fi


    # check for second arg to be kill level
    [ -n "${2:-}" ] && killlevel=$2     # 获取稍后的kill程序将要发送的信号

        # Save basename.
        base=${1##*/}

    # Find pid.                       # 获取program的pid号,以让kill程序杀掉
    __pids_var_run "$1" "$pid_file"   # 检查program是否已有对应pid文件,并返回pidfile中所有pid值
    RC=$?
    if [ -z "$pid" ]; then
        if [ -z "$pid_file" ]; then
            pid="$(__pids_pidof "$1")"  # pid为空,且没有pidfile时,获取program的pid
        else
            [ "$RC" = "4" ] && { failure $"$base shutdown" ; return $RC ;}
        fi
    fi

    # Kill it.    # 根据pid,杀掉已存在的进程
    if [ -n "$pid" ] ; then    # 如果进程pid存在,则杀死它
        [ "$BOOTUP" = "verbose" -a -z "${LSB:-}" ] && echo -n "$base "
        if [ -z "$killlevel" ] ; then       # 没有指定要传递的信号时
            if checkpid $pid 2>&1; then  # 给定pid在/proc目录中是否有对应目录
                # TERM first, then KILL if not dead
                kill -TERM $pid >/dev/null 2>&1   # 先发送TERM信号
                usleep 50000
                if checkpid $pid ; then           # 0.5秒后还没死透,则
                    try=0
                    while [ $try -lt $delay ] ; do   # 在给定delay时间内不断检测是否已死
                        checkpid $pid || break
                        sleep 1
                        let try+=1
                    done
                    if checkpid $pid ; then          # 超出delay后,发送KILL信号强制杀死
                        kill -KILL $pid >/dev/null 2>&1
                        usleep 50000
                    fi
                fi
            fi
            checkpid $pid   # 若/proc下还有pid对应的目录,则进程关闭失败
            RC=$?
            [ "$RC" -eq 0 ] && failure $"$base shutdown" || success $"$base shutdown"
            RC=$((! $RC))
        # use specified level only
        else                            # 使用指定的信号杀进程
            if checkpid $pid; then
                kill $killlevel $pid >/dev/null 2>&1
                RC=$?
                [ "$RC" -eq 0 ] && success $"$base $killlevel" || failure $"$base $killlevel"
            elif [ -n "${LSB:-}" ]; then
                RC=7 # Program is not running
            fi
        fi
    else                              # 如果进程pid不存在,表示未运行
        if [ -n "${LSB:-}" -a -n "$killlevel" ]; then
            RC=7 # Program is not running
        else
            failure $"$base shutdown"
            RC=0
        fi
    fi

    # Remove pid file if any.
    if [ -z "$killlevel" ]; then    # 未给定信号时,可能KILL信号强杀时使得pid文件还存在,手动移除它
            rm -f "${pid_file:-/var/run/$base.pid}"
    fi
    return $RC
}

据他们说此脚本,能够清楚关闭进度时,必要频仍鲜明pid文件是还是不是留存,/proc下是还是不是有和pid对应的目录。直至/proc下已经没有了和pid对应的目录时,才代表经过真正杀死了。但当时pid文件仍也许存在,因而还要确认保障pid文件已被移除。

该函数的调用方法:

killproc [-p pidfile] [ -d delay] {program} [-signal]

相关文章

No Comments, Be The First!
近期评论
    功能
    网站地图xml地图