Question

given the following example:

// test.go
package main

import (
        "fmt"
        "os/exec"
)

func main() {
    cmd := exec.Command("login")
    in, _ := cmd.StdinPipe()
    in.Write([]byte("user"))
    out, err := cmd.CombinedOutput()
    if err != nil {
         fmt.Println("error:", err)
        }
    fmt.Printf("%s", out)
}

How can I detect that the process is not going to finish, because it is waiting for user input?

I’m trying to be able to run any script, but abort it if for some reason it tries to read from stdin.

Thanks!

Answer 1

Detecting that the process is not going to finish is a difficult problem. In fact, it is one of the classic “unsolvable” problems in Computer Science: the Halting Problem.

In general, when you are calling exec.Command and will not be passing it any input, it will cause the program to read from your OS’s null device (see documentation in the exec.Cmd fields). In your code (and mine below), you explicitly create a pipe (though you should check the error return of StdinPipe in case it is not created correctly), so you should subsequently call in.Close(). In either case, the subprocess will get an EOF and should clean up after itself and exit.

To help with processes that don’t handle input correctly or otherwise get themselves stuck, the general solution is to use a timeout. In Go, you can use goroutines for this:

// Set your timeout
const CommandTimeout = 5 * time.Second

func main() {
  cmd := exec.Command("login")

  // Set up the input
  in, err := cmd.StdinPipe()
  if err != nil {
    log.Fatalf("failed to create pipe for STDIN: %s", err)
  }

  // Write the input and close
  go func() {
    defer in.Close()
    fmt.Fprintln(in, "user")
  }()

  // Capture the output
  var b bytes.Buffer
  cmd.Stdout, cmd.Stderr = &b, &b

  // Start the process
  if err := cmd.Start(); err != nil {
    log.Fatalf("failed to start command: %s", err)
  }

  // Kill the process if it doesn't exit in time
  defer time.AfterFunc(CommandTimeout, func() {
    log.Printf("command timed out")
    cmd.Process.Kill()
  }).Stop()

  // Wait for the process to finish
  if err := cmd.Wait(); err != nil {
    log.Fatalf("command failed: %s", err)
  }

  // Print out the output
  fmt.Printf("Output:\n%s", b.String())
}

In the code above, there are actually three main goroutines of interest: the main goroutine spawns the subprocess and waits for it to exit; a timer goroutine is sent off in the background to kill the process if it’s not Stopped in time; and a goroutine that writes the output to the program when it’s ready to read it.