go - 命令需要换行才能完成

Question

我正在尝试使用 Go 将 sqlite3 作为进程运行。我想合并cmd.Stdin与 bytes.Buffer和os.Stdin 。尽管如此，当我写.quit时命令在 stdin 字节缓冲区上运行，程序不会直接退出，而是等待 os.stdin 的换行符。当它收到来自 os.stdin 的换行符时，从而退出。

我尝试调用os.Stdin.Write([]byte("\n"))但没有成功。如何在.quit后直接退出命令，无需与 os.Stdin 进行任何交互？

func main() {
    cmd := exec.Command("/usr/bin/sqlite3")

    bufOut, bufErr, bufIn := &bytes.Buffer{}, &bytes.Buffer{}, &bytes.Buffer{}

    cmd.Stdout = io.MultiWriter(bufOut, os.Stdout)
    cmd.Stderr = io.MultiWriter(bufErr, os.Stderr)
    cmd.Stdin = io.MultiReader(bufIn, os.Stdin)

    if err := cmd.Start(); err != nil {
        log.Fatal(err)
    }

    // Execute .help command on sqlite3
    if _, err := bufIn.Write([]byte(".help\n")); err != nil {
        log.Fatal(err)
    }

    // Execute .quit command on sqlite3 (should exit here)
    if _, err := bufIn.Write([]byte(".quit\n")); err != nil {
        log.Fatal(err)
    }
    // Nevertheless, it requires a '\n' from os.Stdin before exiting

    if err := cmd.Wait(); err != nil {
        log.Fatal(err)
    }

    fmt.Println("out:", bufOut.String(), "err:", bufErr.String())
}

Answer 1

这里有一个问题是您使用 MultiReader 时遇到的问题:

cmd.Stdin = io.MultiReader(bufIn, os.Stdin)

来自docs for MultiReader (强调):

MultiReader returns a Reader that's the logical concatenation of the provided input readers. They're read sequentially.

其他相关信息来自the documentation for Cmd.Stdin 。它表示如果 Stdin 不是 nil 或 *os.File，则

during the execution of the command a separate goroutine reads from Stdin and delivers that data to the command over a pipe. In this case, Wait does not complete until the goroutine stops copying, either because it has reached the end of Stdin (EOF or a read error) or because writing to the pipe returned an error.

所以你的程序中发生的事情是这样的:cmd 的 Stdin 读取 goroutine 从 MultiReader bufIn 中读取。首先，它读取您写入到 bufIn 的数据，然后尝试读取更多数据。 MultiReader 发现 bufIn 已耗尽，并转至 Read 其下一个参数 os.Stdin。当您调用 cmd.Wait 时，它会阻止等待 MultiReader 发送 EOF，但 MultiReader 本身会阻止尝试从 os.Stdin 读取。在您发送 EOF(例如按 ctrl-D)或按 Enter 之前不会发生任何事情。 (我不太确定为什么按 Enter 有效，因为这通常不会导致 EOF，但如果我弄清楚详细信息，我会更新。)

另一个问题是竞争条件，如 Cerise Limón notes - 在写入之前，goroutine 完全有可能从 bufIn 中读取数据，在这种情况下，您随后写入 bufIn 的任何内容都将被忽略。

您最好使用 cmd.StdoutPipe 和 cmd.StdinPipe，而不是使用缓冲区与进程通信。但这并不能解决整个问题 - 您不能使用阻塞 IO 以交互方式与子进程通信，因为您最终将等待从正在等待您写入命令的进程中读取数据。也许你最好的选择是使用 goroutine 从命令中读取数据，并使用带超时的 select 来读取输出，直到相当确定不再有任何输出为止。

这是一个实现。它至少需要一些充实和错误处理，但它确实有效。 startScanner 设置 goroutine 从命令的输出中读取行并将其写入 channel 。 readLinesFromChannelWithTimeout 从给定 channel 读取数据，直到给定超时时间过去且没有数据。请注意，您必须在调用cmd.Wait()之前调用cmdIn.Close()，否则后者将无限期挂起。

package main

import (
    "bufio"
    "fmt"
    "io"
    "log"
    "os/exec"
    "time"
)

func readLinesFromChannelWithTimeout(ch chan string, timeout time.Duration) []string {
    var lines []string
    for {
        select {
        case line, ok := <-ch:
            if !ok {
                return lines
            } else {
                lines = append(lines, line)
            }
        case <-time.After(timeout):
            return lines
        }
    }
}

func startScanner(cmdOut io.ReadCloser) chan string {
    ch := make(chan string)
    go func(ch chan string) {
        defer close(ch)
        scanner := bufio.NewScanner(cmdOut)
        for scanner.Scan() {
            ch <- scanner.Text()
        }
    }(ch)
    return ch
}

func main() {
    cmd := exec.Command("/usr/bin/sqlite3")
    cmdIn, _ := cmd.StdinPipe()
    cmdOut, _ := cmd.StdoutPipe()
    cmd.Start()

    ch := startScanner(cmdOut)

    var lines []string

    io.WriteString(cmdIn, ".help\n")
    lines = readLinesFromChannelWithTimeout(ch, time.Millisecond*100)
    fmt.Printf("Got %d lines from .help\n", len(lines))

    io.WriteString(cmdIn, ".show\n")
    lines = readLinesFromChannelWithTimeout(ch, time.Millisecond*100)
    fmt.Printf("Got %d lines from .show\n", len(lines))

    cmdIn.Close() // vital! Wait() will hang otherwise
    if err := cmd.Wait(); err != nil {
        log.Fatal(err)
    }
}