io.Pipe() not working as desired. What am I doing wrong here?

I have been testing exec functionality to a kubernetes pod with client-go. This is the code that works perfectly with os.Stdin

{
// Prepare the API URL used to execute another process within the Pod.  In
// this case, we'll run a remote shell.
req := coreclient.RESTClient().
Post().
Namespace(pod.Namespace).
Resource("pods").
Name(pod.Name).
SubResource("exec").
VersionedParams(&corev1.PodExecOptions{
Container: pod.Spec.Containers[0].Name,
Command:   []string{"/bin/sh"},
Stdin:     true,
Stdout:    true,
Stderr:    true,
TTY:       true,
}, scheme.ParameterCodec)
exec, err := remotecommand.NewSPDYExecutor(restconfig, "POST", req.URL())
if err != nil {
panic(err)
}
// Put the terminal into raw mode to prevent it echoing characters twice.
oldState, err := terminal.MakeRaw(0)
if err != nil {
panic(err)
}
defer terminal.Restore(0, oldState)
// Connect this process' std{in,out,err} to the remote shell process.
err = exec.Stream(remotecommand.StreamOptions{
Stdin:  os.Stdin,
Stdout: os.Stdout,
Stderr: os.Stderr,
Tty:    true,
})
if err != nil {
panic(err)
}
fmt.Println()
}

I then started to test with a io.Pipe() so that I can give it input apart from the os.Stdin, basically from a variable or any other source. The modified code can be found here

{
// Prepare the API URL used to execute another process within the Pod.  In
// this case, we'll run a remote shell.
req := coreclient.RESTClient().
Post().
Namespace(pod.Namespace).
Resource("pods").
Name(pod.Name).
SubResource("exec").
VersionedParams(&corev1.PodExecOptions{
Container: pod.Spec.Containers[0].Name,
Command:   []string{"/bin/sh"},
Stdin:     true,
Stdout:    true,
Stderr:    true,
TTY:       true,
}, scheme.ParameterCodec)
exec, err := remotecommand.NewSPDYExecutor(restconfig, "POST", req.URL())
if err != nil {
panic(err)
}
// Put the terminal into raw mode to prevent it echoing characters twice.
oldState, err := terminal.MakeRaw(0)
if err != nil {
panic(err)
}
defer terminal.Restore(0, oldState)
// Scanning for inputs from os.stdin
stdin, putStdin := io.Pipe()
go func() {
consolescanner := bufio.NewScanner(os.Stdin)
for consolescanner.Scan() {
input := consolescanner.Text()
fmt.Println("input:", input)
putStdin.Write([]byte(input))
}
if err := consolescanner.Err(); err != nil {
fmt.Println(err)
os.Exit(1)
}
}()
// Connect this process' std{in,out,err} to the remote shell process.
err = exec.Stream(remotecommand.StreamOptions{
Stdin:  stdin,
Stdout: os.Stdout,
Stderr: os.Stdout,
Tty:    true,
})
if err != nil {
panic(err)
}
fmt.Println()
}

This oddly seems to be hanging the terminal, can someone point me out on what am I doing wrong?

I didn't try to understand all of your code, but: when executing a separate process, you pretty much always want to use os.Pipe, not io.Pipe.

os.Pipe is a pipe created by the operating system. io.Pipe is a software construct that lives entirely in Go that copies from an io.Writer to an io.Reader. Using an io.Pipe when executing a separate process will generally be implemented by creating an os.Pipe and starting up goroutines to copy between the io.Pipe and the os.Pipe. Just use an os.Pipe.

I was able to resolve my issue. Unfortunately, none of the above methods helped me but rather I did the below work.
I created a separate io.Reader for the string I wanted to input, then did a io.Copy from the reader to putStdin from the above code snipper. Earlier I used putStdin.Write(<string>) which did not do the trick.

I hope this solves issues for some folks.

UPDATE:
Thanks @bcmills for reminding me that the buffer of os.Pipe is system dependent.

Let's re-look at os.Pipe() return values

reader, writer, err := os.Pipe()

To resolve that, we should have a MAX_WRITE_SIZE constant for the length of the byte array written to the writer.

The value of MAX_WRITE_SIZE should be system-dependent also. For example, in linux, the buffer size is 64k. So we can configure MAX_WRITE_SIZE to a value < 64k.

If length of the data to send is greater than MAX_WRITE_SIZE, it can be broken in chunks to send sequentially.

The reason the terminal hang is because of deadlock when you use io.Pipe().

Document on the io.Pipe() method

> Pipe creates a synchronous in-memory pipe.

> The data is copied directly from the Write to the corresponding Read (or Reads); there is no internal buffering.

So writing to Pipe when there is no pipe read call blocking will cause deadlock (similar to reading from Pipe when there is no pipe write call blocking)

To solve the issue, you should use os.Pipe, which is similar to linux pipe command.

Because the data will be buffered, so no read/write blocking is required.

> Data written to the write end of
the pipe is buffered by the kernel until it is read from the read
end of the pipe