Go学习笔记(八) | 使用 os/exec 执行命令

本文最后更新于：4 年前

用Go去调用一些外部的命令其实很愉快的，这遍文章就总结一下我自己日常用的比较多的几种方法。

关于Unix标准输入输出

在具体聊os/exec的使用前，了解一下shell的标准输出是很有必要的。

我们平常会用到或看到这样的命令：

1
2
$ ls xxx 1>out.txt 2>&1
$ nohup xxx 2>&1 &

你知道这里1,2含义么？

其实这里的1,2指的就是Unix文件描述符。文件描述符其实就一数字，每一个文件描述符代表的都是一个文件。如果你打开100个文件，你就会获取到100个文件描述符。

这里需要注意的一点就是，在Unix中一切皆文件。当然，这里我们不必去深究，我们需要知道的是1，2代表的是标准输出stdout与标准错误输出stderr。还有0代表标准输入stdin。

在os/exec中就用到了Stdin,Stdout,Stderr，这些基本Unix知识或能帮助我们更好理解这些参数。

os/exec

os/exec包内容并不多，我们大概过一下。

  1. LookPath(file string) (string, error)

    寻找可执行文件路径，如果你指定的可执行文件在$PATH中，就会返回这个可执行文件的相对/绝对路径；如果你指定的是一个文件路径，他就是去判断文件是否可读取/执行，返回的是一样的路径。

    在我们需要使用一些外部命令/可执行文件的时候，我们可以先使用该函数判断一下该命令/可执行文件是否有效。

  2. Command(name string, arg …string) *Cmd

    使用你输入的参数，返回Cmd指针，可用于执行Cmd的方法。

    这里name就是我们的命令/可执行文件，后面的参数可以一个一个输入。

  3. CommandContext(ctx context.Context, name string, arg …string) *Cmd

    和上面功能一样，不过我们可以用上下文做一些超时等控制。

  4. 之后几个就是Cmd的一些方法。

其实读完，结合官方的一些example，使用很简单，下面具体写几个场景。

注

  1. 本文全部的Demo在这里。

  2. ./testcmd/testcmd是我用Go写的一个简单的可执行文件，可以根据指定的参数 输出/延时输出/输出错误，方便我们演示。如下

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
func main() {

	var (
		start bool
		e     bool
	)

	flag.BoolVar(&start, "s", false, "start output")
	flag.BoolVar(&e, "e", false, "output err")
	flag.Parse()

	if start {
		for i := 5; i > 0; i-- {
			fmt.Fprintln(os.Stdout, "test cmd output", i)
			time.Sleep(1 * time.Second)
		}
	}

	if e {
		fmt.Fprintln(os.Stderr, "a err occur")
		os.Exit(1)
	}

	fmt.Fprintln(os.Stdout, "test cmd stdout")
}

简单执行

1
2
3
4
5
6
7
8
9
10
11
// 简单执行
func test1() {
	cmd := exec.Command("./testcmd/testcmd", "-s")

	// 使用CombinedOutput 将stdout stderr合并输出
	out, err := cmd.CombinedOutput()
	if err != nil {
		log.Printf("test1 failed %s\n", err)
	}
	log.Println("test1 output ", string(out))
}

输出：

1
2
3
4
5
6
7
Run Test 1
2019/06/06 18:02:39 test1 output  test cmd output 5
test cmd output 4
test cmd output 3
test cmd output 2
test cmd output 1
done

整个过程等待5秒，所有结果一次输出。

分离标准输出与错误输出

将错误分开输出，同时开了两个协成，同步的接收命令的输出内容。

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
// 	stdout & stderr 分开输出
func test2() {
	cmd := exec.Command("./testcmd/testcmd", "-s", "-e")
	stdout, _ := cmd.StdoutPipe()
	stderr, _ := cmd.StderrPipe()
	cmd.Start()

	go func() {
		for {
			buf := make([]byte, 1024)
			n, err := stderr.Read(buf)

			if n > 0 {
				log.Printf("read err %s", string(buf[:n]))
			}

			if n == 0 {
				break
			}

			if err != nil {
				log.Printf("read err %v", err)
				return
			}
		}
	}()

	go func() {
		for {
			buf := make([]byte, 1024)
			n, err := stdout.Read(buf)

			if n == 0 {
				break
			}

			if n > 0 {
				log.Printf("read out %s", string(buf[:n]))

			}

			if n == 0 {
				break
			}

			if err != nil {
				log.Printf("read out %v", err)
				return
			}

		}
	}()

	err := cmd.Wait()
	if err != nil {
		log.Printf("cmd wait %v", err)
		return
	}
}

输出：

1
2
3
4
5
6
7
8
Run Test 2
2019/06/06 18:02:39 read out test cmd output 5
2019/06/06 18:02:40 read out test cmd output 4
2019/06/06 18:02:41 read out test cmd output 3
2019/06/06 18:02:42 read out test cmd output 2
2019/06/06 18:02:43 read out test cmd output 1
2019/06/06 18:02:44 read err a err occur
2019/06/06 18:02:44 cmd wait exit status 1

按行读取输出内容

使用bufio按行读取输出内容。

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// 按行读输出的内容
func test3() {
	cmd := exec.Command("./testcmd/testcmd", "-s", "-e")
	stdout, _ := cmd.StdoutPipe()
	stderr, _ := cmd.StderrPipe()
	oReader := bufio.NewReader(stdout)
	eReader := bufio.NewReader(stderr)

	cmd.Start()

	go func() {
		for {
			line, err := oReader.ReadString('\n')

			if line != "" {
				log.Printf("read line %s", line)
			}

			if err != nil || line == "" {
				log.Printf("read line err %v", err)
				return
			}

		}
	}()

	go func() {
		for {
			line, err := eReader.ReadString('\n')

			if line != "" {
				log.Printf("read err %s", line)
			}

			if err != nil || line == "" {
				log.Printf("read err %v", err)
				return
			}

		}
	}()

	err := cmd.Wait()
	if err != nil {
		log.Printf("cmd wait %v", err)
		return
	}
}

输出：

1
2
3
4
5
6
7
8
Run Test 3
2019/06/06 18:06:44 read line test cmd output 5
2019/06/06 18:06:45 read line test cmd output 4
2019/06/06 18:06:46 read line test cmd output 3
2019/06/06 18:06:47 read line test cmd output 2
2019/06/06 18:06:48 read line test cmd output 1
2019/06/06 18:06:49 read err a err occur
2019/06/06 18:06:49 cmd wait exit status 1

设置执行超时时间

有时候我们要控制命令的执行时间，这是就可以使用上下文去控制了。

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// 通过上下文控制超时
func test4() {

	ctx, calcel := context.WithTimeout(context.Background(), 2*time.Second)
	defer calcel()

	cmd := exec.CommandContext(ctx, "./testcmd/testcmd", "-s", "-e")

	stdout, _ := cmd.StdoutPipe()
	stderr, _ := cmd.StderrPipe()
	oReader := bufio.NewReader(stdout)
	eReader := bufio.NewReader(stderr)

	cmd.Start()

	go func() {
		for {
			line, err := oReader.ReadString('\n')

			if line != "" {
				log.Printf("read line %s", line)
			}

			if err != nil || line == "" {
				log.Printf("read line err %v", err)
				return
			}

		}
	}()

	go func() {
		for {
			line, err := eReader.ReadString('\n')

			if line != "" {
				log.Printf("read err %s", line)
			}

			if err != nil || line == "" {
				log.Printf("read err %v", err)
				return
			}

		}
	}()

	err := cmd.Wait()
	if err != nil {
		log.Printf("cmd wait %v", err)
		return
	}
}

输出：

1
2
3
4
5
6
7
8
Run Test 4
2019/06/06 18:06:49 read line err EOF
2019/06/06 18:06:49 read err EOF
2019/06/06 18:06:49 read line test cmd output 5
2019/06/06 18:06:50 read line test cmd output 4
2019/06/06 18:06:51 read line err EOF
2019/06/06 18:06:51 read err EOF
2019/06/06 18:06:51 cmd wait signal: killed

持续输入指令，交互模式

有很多命令支持交互模式，我们进入之后就可以持续的输入一些命令，同时获取输出。如openssl命令。

下面我们需要进入交换模式，执行输入三个命令，并获取输出。

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
// 持续输入
func test5() {
	cmd := exec.Command("openssl")

	stdout, _ := cmd.StdoutPipe()
	stderr, _ := cmd.StderrPipe()

	stdin, _ := cmd.StdinPipe()

	cmd.Start()

	// 读
	var wg sync.WaitGroup
	wg.Add(3)
	go func() {
		defer wg.Done()
		for {
			buf := make([]byte, 1024)
			n, err := stderr.Read(buf)

			if n > 0 {
				fmt.Println(string(buf[:n]))
			}

			if n == 0 {
				break
			}

			if err != nil {
				log.Printf("read err %v", err)
				return
			}
		}
	}()

	go func() {
		defer wg.Done()
		for {
			buf := make([]byte, 1024)
			n, err := stdout.Read(buf)

			if n == 0 {
				break
			}

			if n > 0 {
				fmt.Println(string(buf[:n]))
			}

			if n == 0 {
				break
			}

			if err != nil {
				log.Printf("read out %v", err)
				return
			}

		}
	}()

	// 写
	go func() {
		stdin.Write([]byte("version\n\n"))
		stdin.Write([]byte("ciphers -v\n\n"))
		stdin.Write([]byte("s_client -connect razeencheng.com:443"))
		stdin.Close()
		wg.Done()
	}()

	wg.Wait()
	err := cmd.Wait()
	if err != nil {
		log.Printf("cmd wait %v", err)
		return
	}

}

这里，我们就用到了stdin标准输入了。输出如下：

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
Run Test 5
OpenSSL> LibreSSL 2.6.5
OpenSSL> OpenSSL>
ECDHE-RSA-AES256-GCM-SHA384 TLSv1.2 Kx=ECDH     Au=RSA  Enc=AESGCM(256) Mac=AEAD
ECDHE-ECDSA-AES256-GCM-SHA384 TLSv1.2 Kx=ECDH     Au=ECDSA Enc=AESGCM(256) Mac=AEAD
ECDHE-RSA-AES256-SHA384 TLSv1.2 Kx=ECDH     Au=RSA  Enc=AES(256)  Mac=SHA384
ECDHE-ECDSA-AES256-SHA384 TLSv1.2 Kx=ECDH     Au=ECDSA Enc=AES(256)  Mac=SHA384
ECDHE-RSA-AES256-SHA    SSLv3 Kx=ECDH     Au=RSA  Enc=AES(256)  Mac=SHA1
ECDHE-ECDSA-AES256-SHA  SSLv3 Kx=ECDH     Au=ECDSA Enc=AES(256)  Mac=SHA1
DHE-RSA-AES256-GCM-SHA384 TLSv1.2 Kx=DH       Au=RSA  Enc=AESGCM(256) Mac=AEAD
DHE-RSA-AES256-SHA256   TLSv1.2 Kx=DH       Au=RSA  Enc=AES(256)  Mac=SHA256
DES-CBC-SHA             SSLv3 Kx=RSA      Au=RSA  Enc=DES(56)   Mac=SHA1
...
OpenSSL> OpenSSL>
4466583148:error:14004410:SSL routines:CONNECT_CR_SRVR_HELLO:sslv3 alert handshake failure:/BuildRoot/Library/Caches/com.apple.xbs/Sources/libressl/libressl-22.260.1/libressl-2.6/ssl/ssl_pkt.c:1205:SSL alert number 40
4466583148:error:140040E5:SSL routines:CONNECT_CR_SRVR_HELLO:ssl handshake failure:/BuildRoot/Library/Caches/com.apple.xbs/Sources/libressl/libressl-22.260.1/libressl-2.6/ssl/ssl_pkt.c:585:

CONNECTED(00000005)
---
no peer certificate available
---
No client certificate CA names sent
---
SSL handshake has read 7 bytes and written 0 bytes
---
New, (NONE), Cipher is (NONE)
Secure Renegotiation IS NOT supported
Compression: NONE
Expansion: NONE
No ALPN negotiated
SSL-Session:
    Protocol  : TLSv1.2
    Cipher    : 0000
    Session-ID:
    Session-ID-ctx:
    Master-Key:
    Start Time: 1559815613
    Timeout   : 7200 (sec)
    Verify return code: 0 (ok)
---

—END—