Fix goroutine leak in the nullio reader

pkg/nullio/nullio.go

@@ -1,16 +1,31 @@
 package nullio
 
 import (
+	"context"
 	"fmt"
 	"io"
 )
 
-// Reader is a struct that implements the io.Reader interface. Read does not return when called.
-type Reader struct{}
+// Reader is a struct that implements the io.Reader interface.
+// Read does not return when called until the context is done. It is used to avoid reading anything and returning io.EOF
+// before the context has finished.
+// For example the reader is used by the execution that fetches the stderr stream from Nomad. We do not have a stdin
+// that we want to send to Nomad. But we still have to pass Nomad a reader.
+// Normally readers send an io.EOF as soon as they have nothing more to read. But we want to avoid this, because in that
+// case Nomad will abort (not the execution but) the transmission.
+// Why should the reader not just always return 0, nil? Because Nomad reads in an endless loop and thus a busy waiting
+// is avoided.
+type Reader struct {
+	Ctx context.Context
+}
 
 func (r Reader) Read(_ []byte) (int, error) {
-	// An empty select blocks forever.
-	select {}
+	if r.Ctx.Err() != nil {
+		return 0, io.EOF
+	}
+
+	<-r.Ctx.Done()
+	return 0, io.EOF
 }
 
 // ReadWriter implements io.ReadWriter. It does not return from Read and discards everything on Write.

pkg/nullio/nullio_test.go

@@ -1,8 +1,9 @@
 package nullio
 
 import (
+	"context"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"io"
 	"testing"
 	"time"
 )
@@ -10,12 +11,15 @@ import (
 const shortTimeout = 100 * time.Millisecond
 
 func TestReaderDoesNotReturnImmediately(t *testing.T) {
-	reader := &Reader{}
+	readingContext, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	reader := &Reader{readingContext}
 	readerReturned := make(chan bool)
 	go func() {
 		p := make([]byte, 0, 5)
 		_, err := reader.Read(p)
-		require.NoError(t, err)
+		assert.ErrorIs(t, io.EOF, err)
 		close(readerReturned)
 	}()