os/exec: can add WaitTimeout(timeout time.Duration) bool for exec.Cmd

[mei-rune]

exec: can add WaitTimeout(timeout time.Duration) error for exec.Cmd.

example is:

    cmd := exec.Command("ping", "127.0.0.1", `-t`)
    if err := cmd.Start(); err != nil {
        log.Fatal(err)
    }
    if err := cmd.WaitTimeout(10 * time.Second); err != nil {
        log.Fatal(err)
                if err == exec.ErrTimeout {
                    cmd.Kill()
                }
    }

[adg]

    cmd := exec.Command("ping", "127.0.0.1", `-t`)
    if err := cmd.Start(); err != nil {
        log.Fatal(err)
    }
    done := make(chan error)
    go func() { done <- cmd.Wait() }()
    select {
    case err := <-done:
        // exited
    case <-time.After(10*time.Second):
        // timed out
    }

[mattn]

Or how about to use timer.AfterFunc ?

var timer *time.Timer
timer = time.AfterFunc(3 * time.Second, func() {
    timer.Stop()
    cmd.Process.Kill()
})

[mei-rune]

@mattn it is very good.

[rogpeppe]

@mattn The approach is reasonable but I don't think you need to stop the timer when it fires (it
will stop then anyway)

cmd := exec.Command("ping", "127.0.0.1", `-t`)
if err := cmd.Start(); err != nil {
    log.Fatal(err)
}
timer := time.AfterFunc(3 * time.Second, func() {
    cmd.Process.Kill()
})
err := cmd.Wait()
timer.Stop()

You can tell if the cmd was killed by looking at err, or (with high probabilty
and no need for syscall) by checking whether timer.Stop returns false.

The disadvantage of this approach is that sometimes a process
isn't killable, so it may fail sometimes.

The advantage is that it's possible to read from StdoutPipe
(running Wait in a separate goroutine has issues with
StdoutPipe - see http://golang.org/pkg/os/exec/#Cmd.StdoutPipe )