golang: `os.Stdin.Read` doesn't handle input consisting of a sole EOF?

Question

I am writing a cat with a timeout on receiving the first byte. I have it working except that it can't handle echo -n:

❯ echo -n | time possiblycat 1000  # 1000 is the timeout in milliseconds                                                                                        
possiblycat 1000  0.00s user 0.00s system 0% cpu 1.008 total; max RSS 1864

cat itself has no issues with this; It notices the EOF and exits immediately:

❯ echo -n | time cat                                                                                                      
cat  0.00s user 0.00s system 71% cpu 0.003 total; max RSS 664

This is the whole source of possiblycat:

package main

import (
    "io"
    "io/ioutil"
    "os"
    "strconv"
    "time"
)

func main() {
    wait := 10
    if len(os.Args) >= 2 {
        waitDummy, err := strconv.Atoi(os.Args[1])
        if err != nil {
            panic(err)
        }
        wait = waitDummy
    }

    b := make(chan byte, 1)
    go scan(b)

    select {
    case res := <-b:
        inBytes, err := ioutil.ReadAll(os.Stdin)
        if err != nil {
            panic(err)
        }
        stdin := append([]byte{res}, inBytes...)
        _, err2 := os.Stdout.Write(stdin)
        if err2 != nil {
            panic(err2)
        }
    case <-time.After(time.Duration(wait) * time.Millisecond):
        os.Exit(1)
    }
}

func scan(out chan byte) {
    var b []byte = make([]byte, 1)
    _, err := os.Stdin.Read(b)
    if err == io.EOF {
        return
    } else if err != nil {
        panic(err)
    }
    out <- b[0]
}

Related:

• Does echo -n | … send an EOF to the pipe?

Answer 1

When os.Stdin.Read returns EOF, you exit the scan function which is running in its own goroutine.

However, nothing is being done to tell the main goroutine that all input has been processed. It is waiting for data on channel b, or for the timeout. Since there is no data coming on b, the timeout gets reached.

To properly handle this, the err == io.EOF case should signal the main goroutine that there is no more work to be done. A common pattern (but certainly not the only one) is to have a done channel indicating that all work is finished.

  done := make(chan bool, 1)
  go scan(b, done)

  select {
  case res := <-b:
    ...
  case <-done:
    os.Exit(1)
  case <-time.After(time.Duration(wait) * time.Millisecond):
    os.Exit(1)
  }
}

func scan(out chan byte, done chan bool) {
  var b []byte = make([]byte, 1)
  _, err := os.Stdin.Read(b)
  if err == io.EOF {
    fmt.Println("got EOF, exiting")
    done <- true
    return
  } else if err != nil {
  ...
}

Another (even simpler) alternative is to simply close the data channel when you're done:

func scan(out chan byte) {
  var b []byte = make([]byte, 1)
  _, err := os.Stdin.Read(b)
  if err == io.EOF {
    fmt.Println("got EOF, exiting")
    close(out)
    return
  } else if err != nil {
    panic(err)
  }
  out <- b[0]
}