32 调试

例子 32-1. 一个错误脚本

脚本的输出:

上边的脚本究竟哪错了(提示: 注意if的后边)

例子 32-2. 缺少关键字

  1. #!/bin/bash
  2. # missing-keyword.sh
  3. # 这个脚本会提示什么错误信息？
  5. for a in 1 2 3
  6. do
  7.   echo "$a"
  8. # done     #所需关键字'done'在第8行被注释掉.
  10. exit 0     # 将不会在这退出!
  12. #在命令行执行完此脚本后
  13. 输入：echo $?    
  14. 输出：2

脚本的输出:

  1. missing-keyword.sh: line 10: syntax error: unexpected end of file

注意, 其实不必参考错误信息中指出的错误行号. 这行只不过是Bash解释器最终认定错误的地方.
出错信息在报告产生语法错误的行号时, 可能会忽略脚本的注释行.
如果脚本可以执行, 但并不如你所期望的那样工作, 怎么办? 通常情况下, 这都是由常见的逻辑错误所
产生的.

例子 32-3.

  1. #!/bin/bash
  3. #  这个脚本应该删除在当前目录下所有文件名中含有空格的文件
  4. #  它不能正常运行，为什么？
  6. badname=`ls | grep ' '`
  8. # Try this:
  9. # echo "$badname"
  11. rm "$badname"
  13. exit 0

可以通过把echo “$badname”行的注释符去掉，找出例子 29-3中的错误， 看一下echo出来的信息，是否按你期望的方式运行.

在这种特殊的情况下，rm “$badname”不能得到预期的结果，因为$badname不应该加双引号。加上双引号会让rm只有一个参数(这就只能匹配一个文件名).一种不完善的解决办法是去掉$badname外 面的引号, 并且重新设置$IFS, 让$IFS只包含一个换行符, IFS=$’\n’. 但是, 下面这个方法更简单.

总结一下这个问题脚本的症状:
>

  1. 由于”syntax error”(语法错误)使得脚本停止运行,
  2. 或者脚本能够运行, 但是并不是按照我们所期望的那样运行(逻辑错误).
  3. 脚本能够按照我们所期望的那样运行, 但是有烦人的副作用(逻辑炸弹).

如果想调试脚本, 可以用以下方式:

  1. echo语句可以放在脚本中存在疑问的位置上, 观察变量的值, 来了解脚本运行时的情况.

    1.  ### debecho (debug-echo), by Stefano Falsetto ###
    2.  ### Will echo passed parameters only if DEBUG is set to a value. ###
    3.  debecho () {
    4.        if [ ! -z "$DEBUG" ]; then
    5.           echo "$1" >&2
    6.           # ^^^ to stderr
    7.        fi
    8.  }
    10.  DEBUG=on
    11.  Whatever=whatnot
    12.  debecho $Whatever   # whatnot
    14.  DEBUG=
    15.  Whatever=notwhat
    16.  debecho $Whatever   # (Will not echo.)
  1. 使用过滤器tee来检查临界点上的进程或数据流.

  2. sh -n scriptname不会运行脚本, 只会检查脚本的语法错误. 这等价于把set -n或set -o noexec插入脚本中. 注意, 某些类型的语法错误不会被这种方式检查出来.

    sh -v scriptname将会在运行脚本之前, 打印出每一个命令. 这等价于把set -v或set -o verbose插入到脚本中.

    选项-n和-v可以同时使用. sh -nv scriptname将会给出详细的语法检查.

    sh -x scriptname会打印出每个命令执行的结果, 但只使用缩写形式. 这等价于在脚本中插入set
    -x或set -o xtrace.

    把set -u或set -o nounset插入到脚本中, 并运行它, 就会在每个试图使用未声明变量的地方给出一个unbound variable错误信息.

    1.  set -u   # Or   set -o nounset
    3.  # Setting a variable to null will not trigger the error/abort.
    4.  # unset_var=
    6.  echo $unset_var   # Unset (and undeclared) variable.
    7.  echo "Should not echo!"
    9.  #sh t2.sh
    10.  #t2.sh: line 6: unset_var: unbound variable

  3. 使用“断言”功能在脚本的关键点进行测试的变量或条件。 （这是从C借来的一个想法）

    Example 32-4. Testing a condition with an assert

    ```

    !/bin/bash

    assert.sh

    #

    assert () # If condition false,
    { #+ exit from script

    1.                        #+ with appropriate error message.

    E_PARAM_ERR=98
    E_ASSERT_FAILED=99

  1.   if [ -z "$2" ]          #  Not enough parameters passed
  2.   then                    #+ to assert() function.
  3.     return $E_PARAM_ERR   #  No damage done.
  4.   fi
  6.   lineno=$2
  8.   if [ ! $1 ] 
  9.   then
  10.     echo "Assertion failed:  \"$1\""
  11.     echo "File \"$0\", line $lineno"    # Give name of file and line number.
  12.     exit $E_ASSERT_FAILED
  13.   # else
  14.   #   return
  15.   #   and continue executing the script.
  16.   fi  
  17. } # Insert a similar assert() function into a script you need to debug.    
  18. #######################################################################
  21. a=5
  22. b=4
  23. condition="$a -lt $b"     #  Error message and exit from script.
  24.                           #  Try setting "condition" to something else
  25.                           #+ and see what happens.
  27. assert "$condition" $LINENO
  28. # The remainder of the script executes only if the "assert" does not fail.
  31. # Some commands.
  32. # Some more commands . . .
  33. echo "This statement echoes only if the \"assert\" does not fail."
  34. # . . .
  35. # More commands . . .
  37. exit $?
  38. ```

  1. 使用变量$LINENO和内建命令caller.

  2. 捕获exit返回值.

捕获信号

trap
Specifies an action on receipt of a signal; also useful for debugging.

A signal is a message sent to a process, either by the kernel or another process, telling it to take some specified action (usually to terminate). For example, hitting a Control-C sends a user interrupt, an INT signal, to a running program.

A simple instance:

Example 32-5. Trapping at exit

  1. #!/bin/bash
  2. # Hunting variables with a trap.
  4. trap 'echo Variable Listing --- a = $a  b = $b' EXIT
  5. #  EXIT is the name of the signal generated upon exit from a script.
  6. #
  7. #  The command specified by the "trap" doesn't execute until
  8. #+ the appropriate signal is sent.
  10. echo "This prints before the \"trap\" --"
  11. echo "even though the script sees the \"trap\" first."
  12. echo
  14. a=39
  15. b=36
  17. exit 0
  20. #  Note that commenting out the 'exit' command makes no difference,
  21. #+ since the script exits in any case after running out of commands.

Example 32-6. Cleaning up after Control-C

  1. #!/bin/bash
  2. # logon.sh: A quick 'n dirty script to check whether you are on-line yet.
  4. umask 177  # Make sure temp files are not world readable.
  7. TRUE=1
  8. LOGFILE=/var/log/messages
  9. #  Note that $LOGFILE must be readable
  10. #+ (as root, chmod 644 /var/log/messages).
  11. TEMPFILE=temp.$$
  12. #  Create a "unique" temp file name, using process id of the script.
  13. #     Using 'mktemp' is an alternative.
  14. #     For example:
  15. #     TEMPFILE=`mktemp temp.XXXXXX`
  16. #  At logon, the line "remote IP address xxx.xxx.xxx.xxx"
  17. #                      appended to /var/log/messages.
  18. ONLINE=22
  19. USER_INTERRUPT=13
  20. CHECK_LINES=100
  21. #  How many lines in log file to check.
  23. trap 'rm -f $TEMPFILE; exit $USER_INTERRUPT' TERM INT
  26. echo
  28. while [ $TRUE ]  #Endless loop.
  29. do
  30.   tail -n $CHECK_LINES $LOGFILE> $TEMPFILE
  31.   #  Saves last 100 lines of system log file as temp file.
  32.   #  Necessary, since newer kernels generate many log messages at log on.
  33.   search=`grep $KEYWORD $TEMPFILE`
  34.   #  Checks for presence of the "IP address" phrase,
  35.   #+ indicating a successful logon.
  37.   if [ ! -z "$search" ] #  Quotes necessary because of possible spaces.
  38.   then
  39.      echo "On-line"
  40.      rm -f $TEMPFILE    #  Clean up temp file.
  41.      exit $ONLINE
  42.   else
  43.      echo -n "."        #  The -n option to echo suppresses newline,
  44.                         #+ so you get continuous rows of dots.
  45.   fi
  47.   sleep 1  
  48. done  
  51. #  Note: if you change the KEYWORD variable to "Exit",
  52. #+ this script can be used while on-line
  53. #+ to check for an unexpected logoff.
  55. # Exercise: Change the script, per the above note,
  56. #           and prettify it.
  58. exit 0
  61. # Nick Drage suggests an alternate method:
  63. while true
  64.   do ifconfig ppp0 | grep UP 1> /dev/null && echo "connected" && exit 0
  65.   echo -n "."   # Prints dots (.....) until connected.
  66.   sleep 2
  67. done
  69. # Problem: Hitting Control-C to terminate this process may be insufficient.
  70. #+         (Dots may keep on echoing.)
  71. # Exercise: Fix this.
  75. # Stephane Chazelas has yet another alternative:
  77. CHECK_INTERVAL=1
  79. while ! tail -n 1 "$LOGFILE" | grep -q "$KEYWORD"
  80. do echo -n .
  81.    sleep $CHECK_INTERVAL
  82. done
  83. echo "On-line"
  85. # Exercise: Discuss the relative strengths and weaknesses
  86. #           of each of these various approaches.
  87. Example 32-7. A Simple Implementation of a Progress Bar
  89. #! /bin/bash
  90. # progress-bar2.sh
  91. # Author: Graham Ewart (with reformatting by ABS Guide author).
  92. # Used in ABS Guide with permission (thanks!).
  94. # Invoke this script with bash. It doesn't work with sh.
  96. interval=1
  97. long_interval=10
  99. {
  100.      trap "exit" SIGUSR1
  101.      sleep $interval; sleep $interval
  102.      while true
  103.      do
  104.        echo -n '.'     # Use dots.
  105.        sleep $interval
  106.      done; } &         # Start a progress bar as a background process.
  108. pid=$!
  109. trap "echo !; kill -USR1 $pid; wait $pid"  EXIT        # To handle ^C.
  111. echo -n 'Long-running process '
  112. sleep $long_interval
  113. echo ' Finished!'
  115. kill -USR1 $pid
  116. wait $pid              # Stop the progress bar.
  117. trap EXIT
  119. exit $?

Note
The DEBUG argument to trap causes a specified action to execute after every command in a script. This permits tracing variables, for example.

Example 32-8. Tracing a variable

  2. #!/bin/bash
  4. trap 'echo "VARIABLE-TRACE> \$variable = \"$variable\""' DEBUG
  5. # Echoes the value of $variable after every command.
  7. variable=29; line=$LINENO
  9. echo "  Just initialized \$variable to $variable in line number $line."
  11. let "variable *= 3"; line=$LINENO
  12. echo "  Just multiplied \$variable by 3 in line number $line."
  14. exit 0
  16. #  The "trap 'command1 . . . command2 . . .' DEBUG" construct is
  17. #+ more appropriate in the context of a complex script,
  18. #+ where inserting multiple "echo $variable" statements might be
  19. #+ awkward and time-consuming.
  21. # Thanks, Stephane Chazelas for the pointer.

Output of script:

VARIABLE-TRACE> $variable = “”
VARIABLE-TRACE> $variable = “29”
Just initialized $variable to 29.
VARIABLE-TRACE> $variable = “29”
VARIABLE-TRACE> $variable = “87”
Just multiplied $variable by 3.
VARIABLE-TRACE> $variable = “87”
Of course, the trap command has other uses aside from debugging, such as disabling certain keystrokes within a script (see Example A-43).

Example 32-9. Running multiple processes (on an SMP box)

  2. #!/bin/bash
  3. # parent.sh
  4. # Running multiple processes on an SMP box.
  5. # Author: Tedman Eng
  7. #  This is the first of two scripts,
  8. #+ both of which must be present in the current working directory.
  13. LIMIT=$1         # Total number of process to start
  14. NUMPROC=4        # Number of concurrent threads (forks?)
  15. PROCID=1         # Starting Process ID
  16. echo "My PID is $$"
  18.         if [ $PROCID -le $LIMIT ] ; then
  19.                 ./child.sh $PROCID&
  20.                 let "PROCID++"
  21.         else
  23.            wait
  24.            exit
  25.         fi
  26. }
  28. while [ "$NUMPROC" -gt 0 ]; do
  29.         start_thread;
  30.         let "NUMPROC--"
  31. done
  34. while true
  35. do
  37. trap "start_thread" SIGRTMIN
  39. done
  41. exit 0
  45. # ======== Second script follows ========
  48. #!/bin/bash
  49. # child.sh
  50. # Running multiple processes on an SMP box.
  51. # This script is called by parent.sh.
  52. # Author: Tedman Eng
  54. temp=$RANDOM
  55. index=$1
  56. shift
  57. let "temp %= 5"
  58. let "temp += 4"
  59. echo "Starting $index  Time:$temp" "$@"
  60. sleep ${temp}
  61. echo "Ending $index"
  62. kill -s SIGRTMIN $PPID
  64. exit 0
  67. # ======================= SCRIPT AUTHOR'S NOTES ======================= #
  68. #  It's not completely bug free.
  69. #  I ran it with limit = 500 and after the first few hundred iterations,
  70. #+ one of the concurrent threads disappeared!
  71. #  Not sure if this is collisions from trap signals or something else.
  72. #  Once the trap is received, there's a brief moment while executing the
  73. #+ trap handler but before the next trap is set.  During this time, it may
  74. #+ be possible to miss a trap signal, thus miss spawning a child process.
  76. #  No doubt someone may spot the bug and will be writing 
  77. #+ . . . in the future.
  81. # ===================================================================== #
  85. # ----------------------------------------------------------------------#
  89. #################################################################
  90. # The following is the original script written by Vernia Damiano.
  91. # Unfortunately, it doesn't work properly.
  92. #################################################################
  94. #!/bin/bash
  96. #  Must call script with at least one integer parameter
  97. #+ (number of concurrent processes).
  98. #  All other parameters are passed through to the processes started.
  101. INDICE=8        # Total number of process to start
  102. TEMPO=5         # Maximum sleep time per process
  103. E_BADARGS=65    # No arg(s) passed to script.
  105. if [ $# -eq 0 ] # Check for at least one argument passed to script.
  106. then
  107.   echo "Usage: `basename $0` number_of_processes [passed params]"
  108.   exit $E_BADARGS
  109. fi
  111. NUMPROC=$1              # Number of concurrent process
  112. shift
  113. PARAMETRI=( "$@" )      # Parameters of each process
  115. function avvia() {
  116.          local temp
  117.          local index
  118.          temp=$RANDOM
  119.          index=$1
  120.          shift
  121.          let "temp %= $TEMPO"
  122.          let "temp += 1"
  123.          echo "Starting $index Time:$temp" "$@"
  124.          sleep ${temp}
  125.          echo "Ending $index"
  126.          kill -s SIGRTMIN $$
  127. }
  129. function parti() {
  130.          if [ $INDICE -gt 0 ] ; then
  131.               avvia $INDICE "${PARAMETRI[@]}" &
  132.                 let "INDICE--"
  133.          else
  134.                 trap : SIGRTMIN
  135.          fi
  136. }
  138. trap parti SIGRTMIN
  140. while [ "$NUMPROC" -gt 0 ]; do
  141.          parti;
  142.          let "NUMPROC--"
  143. done
  145. wait
  146. trap - SIGRTMIN
  148. exit $?
  150. : <<SCRIPT_AUTHOR_COMMENTS
  151. I had the need to run a program, with specified options, on a number of
  152. different files, using a SMP machine. So I thought [I'd] keep running
  153. a specified number of processes and start a new one each time . . . one
  154. of these terminates.
  156. The "wait" instruction does not help, since it waits for a given process
  157. or *all* process started in background. So I wrote [this] bash script
  158. that can do the job, using the "trap" instruction.
  159.   --Vernia Damiano

Note
trap ‘’ SIGNAL (two adjacent apostrophes) disables SIGNAL for the remainder of the script. trap SIGNAL restores the functioning of SIGNAL once more. This is useful to protect a critical portion of a script from an undesirable interrupt.