Shell 程序设计：错误报告

herberteuler

Shell 是一门高级语言，使用它可以方便地完成许多功能。但是，写 Shell 程序时一定要注意被调用的程序是在哪个 Shell 里执行：当前的 Shell 或者子 Shell。在极少数的情况下，这两种方式有着微妙的区别。我们用错误报告来说明这种差别。

对于一个 C 程序员来说，写出这样的代码是很自然的事情：

1. #include <stdio.h>
   
2. #include <stdarg.h>
   
3. #include <errno.h>
   
4. #include <string.h>
   
5. #include <stdlib.h>
   
6. 
   
7. void error(int n, char *fmt, ...)
   
8. {
   
9.     extern char *progname;
   
10.     va_list v;
    
11. 
    
12.     if (!progname)
    
13.         fprintf(stderr, "%s: ", progname);
    
14.     va_start(v, fmt);
    
15.     vfprintf(stderr, fmt, v);
    
16.     va_end(v);
    
17.     if (errno)
    
18.         fprintf(stderr, ": %s", strerror(errno));
    
19.     fprintf(stderr, "\n");
    
20.     exit(n);
    
21. }

复制代码

这个函数集中处理了错误报告。我们可以在代码中调用它来完成 UNIX Shell 里的日常操作：

1. char *progname = argv[0];
   
2. char *datafile="somefile";
   
3. /* ... ... */
   
4. error(1, "cannot open file %s", datafile);

复制代码

如果要用 Shell 来写一个希望具有良好用户界面的程序，可能会需要类似的代码。同大多数情况一样，Shell 版本的程序比 C 版本的简单许多：

1. die()
   
2. {
   
3.     local n=$1
   
4.     shift
   
5.     test ! -z $PROGNAME && echo -n "${PROGNAME}: " 1>&2
   
6.     echo $* 1>&2
   
7.     exit $n
   
8. }

复制代码

通常，这种函数都会被写在一个单独的文件里，以便随时通过文件名来引用到这个函数。我们可以写一个简单的程序来验证它：

1. $ ls
   
2. environ  f
   
3. $ cat environ
   
4. # die(int n, string s1, string s2, ...)
   
5. die()
   
6. {
   
7.         local n=$1
   
8.         shift
   
9.         test ! -z $PROGNAME && echo -n "${PROGNAME}: " 1>&2
   
10.         echo "$*" 1>&2
    
11.         exit $n
    
12. }
    
13. $ cat f
    
14. #!/bin/sh
    
15. 
    
16. . environ
    
17. 
    
18. g()
    
19. {
    
20.         test -z $ABC && die 1 "ABC does not exist"
    
21.         echo ABC exists
    
22. }
    
23. 
    
24. g
    
25. $ ./f
    
26. ABC does not exist
    
27. $ ABC=aaa ./f
    
28. ABC exists
    
29. $

复制代码

这看上去很成功。但是，这样写是有问题的。考虑下面的代码：

1. $ cat g
   
2. #!/bin/sh
   
3. 
   
4. . environ
   
5. 
   
6. g()
   
7. {
   
8.         test -z $ABC && die 1 "ABC does not exist"
   
9.         echo $ABC
   
10. }
    
11. 
    
12. COPY_OF_ABC=$(g)
    
13. echo The value of ABC is: $COPY_OF_ABC
    
14. $ ./g
    
15. ABC does not exist
    
16. The value of ABC is:
    
17. $

复制代码

函数 g 的目的很明显：如果 ABC 存在，就打印 ABC 的值，这个值可以被其他的程序得到；否则，就 (向标准错误上) 输出 ABC does not exist 并且结束 Shell 程序的执行。$() 的作用与 `` 相同：用 $() 中程序执行的结果来代替 $() 本身。不过一些 Shell 会使用子 Shell 来执行 $() 或 `` 中的内容，在这样的 Shell 里 (如 Bash) 上面这样写是无效的，甚至有时连返回值也无法取到：

1. $ cat g
   
2. #!/bin/sh
   
3. 
   
4. . environ
   
5. 
   
6. g()
   
7. {
   
8.         test -z $ABC && die 1 "ABC does not exist"
   
9.         echo $ABC $1
   
10. }
    
11. 
    
12. f()
    
13. {
    
14.         local COPY_OF_ABC=$(g)
    
15.         echo $?
    
16.         echo The value of ABC is: $COPY_OF_ABC
    
17. }
    
18. 
    
19. f
    
20. $ ./g
    
21. ABC does not exist
    
22. 0
    
23. The value of ABC is:
    
24. $

复制代码

只有依靠临时文件避免使用 $() 或 `` 才能解决这个问题。不过这就需要做好善后工作，避免进程意外退出时留下垃圾。下面是一个例子。

1. $ cat g
   
2. #!/bin/sh
   
3. 
   
4. . environ
   
5. 
   
6. g()
   
7. {
   
8.         test -z $ABC && die 1 "ABC does not exist"
   
9.         echo $ABC $1
   
10. }
    
11. 
    
12. f()
    
13. {
    
14.         local tmpfile="/tmp/f.$$"
    
15.         trap "rm -f $tmpfile" 0 SIGINT SIGQUIT SIGKILL SIGTERM
    
16.         g >$tmpfile
    
17.         COPY_OF_ABC=$(cat $tmpfile)
    
18.         echo The value of ABC is: $COPY_OF_ABC
    
19.         rm -f $tmpfile
    
20. }
    
21. 
    
22. f
    
23. $ ./g
    
24. ABC does not exist
    
25. $

复制代码

现在似乎可以了：调用 die 可以保证 Shell 程序的结束，而且 trap 的使用导致不会留下任何垃圾。但是这样做还是有问题的，因为如果有一连串的动作的话，仍然会留下垃圾。

1. $ cat g
   
2. #!/bin/sh
   
3. 
   
4. . environ
   
5. 
   
6. g()
   
7. {
   
8.         test -z $ABC && die 1 "ABC does not exist"
   
9.         echo $ABC $1
   
10. }
    
11. 
    
12. f()
    
13. {
    
14.         local tmpfile="/tmp/f.$$"
    
15.         trap "rm -f $tmpfile" 0 SIGINT SIGQUIT SIGKILL SIGTERM
    
16.         g >$tmpfile
    
17.         COPY_OF_ABC=$(cat $tmpfile)
    
18.         echo $COPY_OF_ABC
    
19.         rm -f $tmpfile
    
20. }
    
21. 
    
22. h()
    
23. {
    
24.         local tmpfile="/tmp/h.$$"
    
25.         trap "rm -f $tmpfile" 0 SIGINT SIGQUIT SIGKILL SIGTERM
    
26.         f >$tmpfile
    
27.         local COPY_OF_COPY_OF_ABC=$(cat $tmpfile)
    
28.         echo The value of COPY_OF_COPY_OF_ABC is: $COPY_OF_COPY_OF_ABC
    
29.         rm -f $tmpfile
    
30. }
    
31. 
    
32. h
    
33. $ ls /tmp
    
34. 
    
35. $ ./g
    
36. ABC does not exist
    
37. $ ls /tmp
    
38. h.7776
    
39. $

复制代码

这是因为函数 h 创建了临时文件，而函数 f 只考虑删除自己的临时文件。因此，我们需要维护一个完整的临时文件的列表，并保证所有的垃圾在退出时都可以被清理掉。最后的版本是这样的：

1. $ cat environ
   
2. # die(int n, string s1, string s2, ...)
   
3. die()
   
4. {
   
5.         local n=$1
   
6.         shift
   
7.         test ! -z $PROGNAME && echo -n "${PROGNAME}: " 1>&2
   
8.         echo "$*" 1>&2
   
9.         exit $n
   
10. }
    
11. 
    
12. # append(string env, string file)
    
13. append()
    
14. {
    
15.         if eval test -z "\$$1" ; then
    
16.                 eval $1=$2
    
17.         else
    
18.                 eval $1="\$$1 $2"
    
19.         fi
    
20. }
    
21. 
    
22. # deappend(string env, string file)
    
23. deappend()
    
24. {
    
25.         eval $1="$(eval echo \$$1 | awk '{ printf "%s", $1
    
26.                 for (i = 2; i < NF; i++)
    
27.                         printf " %s", $i
    
28.                 if ($i != "'$2'")
    
29.                         printf " %s", $i
    
30.                 }')"
    
31. }
    
32. 
    
33. $ cat g
    
34. #!/bin/sh
    
35. 
    
36. . environ
    
37. 
    
38. g()
    
39. {
    
40.         test -z $ABC && die 1 "ABC does not exist"
    
41.         echo $ABC $1
    
42. }
    
43. 
    
44. f()
    
45. {
    
46.         local tmpfile="/tmp/f.$$"
    
47.         append TMPFILE $tmpfile
    
48.         trap "rm -f $TMPFILE" 0 SIGINT SIGQUIT SIGKILL SIGTERM
    
49.         g >$tmpfile
    
50.         COPY_OF_ABC=$(cat $tmpfile)
    
51.         echo $COPY_OF_ABC
    
52.         rm -f $tmpfile
    
53.         deappend TMPFILE $tmpfile
    
54. }
    
55. 
    
56. h()
    
57. {
    
58.         local tmpfile="/tmp/h.$$"
    
59.         append TMPFILE $tmpfile
    
60.         trap "rm -f $TMPFILE" 0 SIGINT SIGQUIT SIGKILL SIGTERM
    
61.         f >$tmpfile
    
62.         local COPY_OF_COPY_OF_ABC=$(cat $tmpfile)
    
63.         echo The value of COPY_OF_COPY_OF_ABC is: $COPY_OF_COPY_OF_ABC
    
64.         rm -f $tmpfile
    
65.         deappend TMPFILE $tmpfile
    
66. }
    
67. 
    
68. h
    
69. $ ls /tmp
    
70. 
    
71. $ ./g
    
72. ABC does not exist
    
73. $ ls /tmp
    
74. 
    
75. $

复制代码

这里主要添加了 append 函数和 deappend 函数。append 函数的作用很简单，就是将一个值追加到一个环境变量的最后；deappend 则用来去掉一个环境变量最后的字符串，但前提是最后的字符串与要去掉的相同。这样，就可以保证无论在什么情况下都能即时地从 Shell 程序里退出并且不留垃圾了。

最后要说明的是，虽然上面的程序看起来是无用的，但是在实际情况中经常会遇到这样的代码，它们只是形式不同，实质上是一样的。

Freebird

好累.看不懂.   

寂寞烈火

Post by Freebird
好累.看不懂.   

me2!

herberteuler

Post by Freebird
好累.看不懂.   

5555~~~~
您怎么老对我说这样的话呢？我还记得上一次，您说 “Shell 脚本写成这样真是不敢恭维”。

herberteuler

摘要

用 C 写程序，可以用 exit 随时结束程序的执行。用 Perl，可以用 die。用 Shell 的什么呢？exit？这是我最初的想法。可是当我准备应用它时，我发现有些微妙的错误，就像上面提到的那样，有时 exit 无法成功地完成我们寄予它的希望。当我解决了这个问题时，我就把心得写了出来。

kiron

我通读了一遍文章
herberteuler兄所以写这样的错误报告的文章是否为了调试?

若是调试,我在脚本某处echo就成了.另外也听说有特别的脚本的调试工具,不过我没用过.别人也许有更特别的方法,但专门写一个无通用性的函数来错误报告似乎不可取.
你能说明一个我无法拒绝的理由吗?

herberteuler

我现在要做一个程序，除非特别，只能用 POSIX Shell 来写；此外，它的行为要与完成同样功能的、用 C 或者 Perl 或者 Python 写的程序并无二致。你可以这样想像，就是 rpm 或者 apt 或者 emerge 的用 Shell 实现的版本。对于这种程序来说，某处的执行失败必须导致程序的结束并且打印出有用的提示信息。但是很快我就发现 exit 并不能保证在任何情况下退出 Shell 程序，这里的程序就是例子。无可奈何之下，只能用这个方法了。

btw，1. 为什么说这是一个无通用性的函数呢？
2. 调试的话，我觉得 set -vx 就很好了。

Freebird

Post by herberteuler
5555~~~~
您怎么老对我说这样的话呢？我还记得上一次，您说 “Shell 脚本写成这样真是不敢恭维”。

只怪偶水平有限   

herberteuler

也许是我的程序写得有问题。我把它放上来，欢迎提出建议。这样执行：首先，把文件解压：

1. $ tar xzf dipmt.tar.gz
   
2. $ cd dipmt/usr/lib/dipmt/lib/
   
3. $ make
   
4. $ PKGASSISTDIR=../../../../pkgassist ./pkgop xterm
   
5. $ PKGASSISTDIR=../../../../pkgassist ./pkgop aterm
   
6. $ PKGASSISTDIR=../../../../pkgassist ./pkgop dev-libs/aterm

复制代码

程序还没有开发完成，所以比较麻烦，请原谅。

kiron

Post by herberteuler
但是很快我就发现 exit 并不能保证在任何情况下退出 Shell 程序，这里的程序就是例子。无可奈何之下，只能用这个方法了。

上面的die函数的使用:
f 中避免了用子shell来确保exit能从shell脚本中退出
那....
我要是在f中避免了用子shell,那也能确保exit能使脚本退出.
另外,若是为了使用die函数而使你的bash脚本少用了子shell,那岂不是把shell的功能减了一些?我认为得不偿失

Post by herberteuler

btw，1. 为什么说这是一个无通用性的函数呢？

因为不能用它来开发里面用了子shell的函数

或许我的理解有误,还请herberteuler兄继续指正