在运行第三个命令之前执行两个命令的保证

在执行第三个命令之前，本文提出了一种可靠的方法来确保前两个命令已成功运行。通过在协程中运行前两个命令，然后使用通道接收它们的名称（如果没有标准错误输出），主函数可以将接收到的名称推送到切片中。一旦切片包含所有模块的名称，它就会启动第三个命令。这种方法避免了对每个进程的 stdout 进行不必要的轮询，从而提高了代码的可靠性和可维护性。

我要运行三个命令，但我想确保在运行第三个命令之前先运行前两个命令。

目前，它运行 a 和 b，然后运行 ​​c。

1. 我在 goroutine 中运行 a 和 b
2. 如果没有 stderr，我会通过 chan 传达他们的名字
3. main 函数将通过 chan 接收到的名称推送到切片中
4. 一旦切片包含模块 a 和 b 的所有名称，它就会启动 c

一些背景

作为一名业余爱好者，我正在学习 goroutine 和 chan。我不清楚如何在运行时以可靠的方式输出 exec.command("foo", "bar").run() 。目前还不清楚如何处理每个进程通过 chan 收到的错误。

我需要 a 和 b 在 c 之前运行的原因是因为 a 和 b 是 graphql 微服务，c 需要运行它们才能通过 http 获取其架构并开始进行一些 graphql 联合（又称为 graphql 拼接） p>

不一致

• 按照我目前的方法，只有当 a 和 b 打印出我猜测的内容时，我才会知道它们是否正在运行。
• 我不喜欢每个后续的 stdout 都会命中 if 语句，只是为了知道进程是否正在运行。
• 我的错误处理并不像我希望的那样干净。

问题

如果 a 和 b 没有打印任何内容并且没有抛出错误，我怎样才能有更可靠的方法来确保它们正在运行？

package main

import (
    "bufio"
    "fmt"
    "log"
    "os/exec"
    "reflect"
    "sort"
    "strings"
    "sync"
)

var wg sync.WaitGroup
var modulesToRun = []string{"micro-post", "micro-hello"}

func main() {
    // Send multiple values to chan
    // https://stackoverflow.com/a/50857250/9077800
    c := make(chan func() (string, error))

    go runModule([]string{"go", "run", "micro-post"}, c)  // PROCESS A
    go runModule([]string{"go", "run", "micro-hello"}, c) // PROCESS B

    modulesRunning := []string{}
    for {
        msg, err := (<-c)()
        if err != nil {
            log.Fatalln(err)
        }

        if strings.HasPrefix(msg, "micro-") && err == nil {
            modulesRunning = append(modulesRunning, msg)
            if CompareUnorderedSlices(modulesToRun, modulesRunning) {
                go runModule([]string{"go", "run", "micro-federation"}, c) // PROCESS C
            }
        }
    }

}

func runModule(commandArgs []string, o chan func() (string, error)) {
    cmd := exec.Command(commandArgs[0], commandArgs[1], commandArgs[2]+"/main.go")

    // Less verbose solution to stream output with io?
    // var stdBuffer bytes.Buffer
    // mw := io.MultiWriter(os.Stdout, &stdBuffer)
    // cmd.Stdout = mw
    // cmd.Stderr = mw

    c := make(chan struct{})
    wg.Add(1)

    // Stream command output
    // https://stackoverflow.com/a/38870609/9077800
    go func(cmd *exec.Cmd, c chan struct{}) {
        defer wg.Done()
        stdout, err := cmd.StdoutPipe()
        if err != nil {
            close(o)
            panic(err)
        }

        stderr, err := cmd.StderrPipe()
        if err != nil {
            close(o)
            panic(err)
        }

        <-c
        outScanner := bufio.NewScanner(stdout)
        for outScanner.Scan() {
            m := outScanner.Text()
            fmt.Println(commandArgs[2]+":", m)
            o <- (func() (string, error) { return commandArgs[2], nil })
        }

        errScanner := bufio.NewScanner(stderr)
        for errScanner.Scan() {
            m := errScanner.Text()
            fmt.Println(commandArgs[2]+":", m)
            o <- (func() (string, error) { return "bad", nil })
        }
    }(cmd, c)

    c <- struct{}{}
    cmd.Start()

    wg.Wait()
    close(o)
}

// CompareUnorderedSlices orders slices before comparing them
func CompareUnorderedSlices(a, b []string) bool {
    if len(a) != len(b) {
        return false
    }

    sort.Strings(a)
    sort.Strings(b)

    return reflect.DeepEqual(a, b)
}

解决方案

关于流程管理

启动进程是使用其参数调用二进制路径的操作。 如果找不到 bin 路径，或者提供了一些格式错误的参数语法，它将失败。

因此，您可能会成功启动一个进程，但会收到退出错误，因为不知何故其执行失败。

这些详细信息对于确定您是否只需要启动流程即可认为操作成功或进一步挖掘其状态和/或输出非常重要。

在您的代码中，您似乎等待打印 stderr 的第一行以将其视为已启动，而不考虑正在打印的内容。

它更像是一种睡眠时间，以确保进程已初始化。

考虑到启动二进制文件比执行引导序列要快得多。

关于代码，你的退出规则不清楚。是什么阻止 main 退出？

在当前代码中，当a和b启动时，它将在c执行之前退出（不包括其他情况）

您在 main 中实现的作业并发性不标准。它缺少收集结果、退出和关闭（chan）的循环。

chan 签名很尴尬，我宁愿使用 struct {module string, err error}

runmodule 函数有错误。当另一个例程可能尝试写入它时，它可能会关闭（o）。如果启动失败，您不会返回任何错误信号。

某种解决方案可能看起来像这样，将其视为固定的，并且根据二进制运行，可以/应该实施其他策略来检测标准 fd 上的错误。

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
    "os/exec"
    "strings"
    "sync"
    "time"
)

type cmd struct {
    Module string
    Cmd    string
    Args   []string
    Err    error
}

func main() {

    torun := []cmd{
        cmd{
            Module: "A",
            Cmd:    "ping",
            Args:   []string{"8.8.8.8"},
        },
        cmd{
            Module: "B",
            Cmd:    "ping",
            // Args:   []string{"8.8.8.8.9"},
            Args: []string{"8.8.8.8"},
        },
    }

    var wg sync.WaitGroup // use a waitgroup to ensure all concurrent jobs are done
    wg.Add(len(torun))

    out := make(chan cmd) // a channel to output cmd status

    go func() {
        wg.Wait()  //wait for the group to finish
        close(out) //  then close the signal channel
    }()

    // start the commands
    for _, c := range torun {
        // go runCmd(c, out, &wg)
        go runCmdAndWaitForSomeOutput(c, out, &wg)
    }

    // loop over the chan to collect errors
    // it ends when wg.Wait unfreeze and closes out
    for c := range out {
        if c.Err != nil {
            log.Fatalf("%v %v has failed with %v", c.Cmd, c.Args, c.Err)
        }
    }

    // here all commands started you can proceed further to run the last command
    fmt.Println("all done")
    os.Exit(0)
}

func runCmd(o cmd, out chan cmd, wg *sync.WaitGroup) {
    defer wg.Done()

    cmd := exec.Command(o.Cmd, o.Args...)

    if err := cmd.Start(); err != nil {
        o.Err = err // save err
        out <- o    // signal completion error
        return      // return to unfreeze the waitgroup wg
    }
    go cmd.Wait() // dont wait for command completion,
    // consider its done once the program started with success.

    // out <- o // useless as main look ups only for error
}

func runCmdAndWaitForSomeOutput(o cmd, out chan cmd, wg *sync.WaitGroup) {
    defer wg.Done()

    cmd := exec.Command(o.Cmd, o.Args...)

    stdout, err := cmd.StdoutPipe()
    if err != nil {
        o.Err = err // save err
        out <- o    // signal completion
        return      // return to unfreeze the waitgroup wg
    }
    stderr, err := cmd.StderrPipe()
    if err != nil {
        o.Err = err
        out <- o
        return
    }

    if err := cmd.Start(); err != nil {
        o.Err = err
        out <- o
        return
    }

    go cmd.Wait() // dont wait for command completion

    // build a concurrent fd's scanner

    outScan := make(chan error) // to signal errors detected on the fd

    var wg2 sync.WaitGroup
    wg2.Add(2) // the number of fds being watched

    go func() {
        defer wg2.Done()
        sc := bufio.NewScanner(stdout)
        for sc.Scan() {
            line := sc.Text()
            if strings.Contains(line, "icmp_seq") { // the OK marker
                return // quit asap to unfreeze wg2
            } else if strings.Contains(line, "not known") { // the nOK marker, if any...
                outScan <- fmt.Errorf("%v", line)
                return // quit  to unfreeze wg2
            }
        }
    }()

    go func() {
        defer wg2.Done()
        sc := bufio.NewScanner(stderr)
        for sc.Scan() {
            line := sc.Text()
            if strings.Contains(line, "icmp_seq") { // the OK marker
                return // quit asap to unfreeze wg2
            } else if strings.Contains(line, "not known") { // the nOK marker, if any...
                outScan <- fmt.Errorf("%v", line) // signal error
                return                            // quit to unfreeze wg2
            }
        }
    }()

    go func() {
        wg2.Wait() // consider that if the program does not output anything,
        // or never prints ok/nok, this will block forever
        close(outScan) // close the chan so the next loop is finite
    }()

    // - simple timeout less loop
    // for err := range outScan {
    //  if err != nil {
    //      o.Err = err // save the execution error
    //      out <- o // signal the cmd
    //      return // qui to unfreeze the wait group wg
    //  }
    // }

    // - more complex version with timeout
    timeout := time.After(time.Second * 3)
    for {
        select {
        case err, ok := <-outScan:
            if !ok { // if !ok, outScan is closed and we should quit the loop
                return
            }
            if err != nil {
                o.Err = err // save the execution error
                out <- o    // signal the cmd
                return      // quit to unfreeze the wait group wg
            }
        case <-timeout:
            o.Err = fmt.Errorf("timed out...%v", timeout) // save the execution error
            out <- o                                      // signal the cmd
            return                                        // quit to unfreeze the wait group wg
        }
    }

    // exit and unfreeze the wait group wg
}

好了，本文到此结束，带大家了解了《在运行第三个命令之前执行两个命令的保证》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！