Can I tee unbuffered program output in Powershell?

Question

I'm trying to use Putty's plink.exe as part of a Powershell script, and am having trouble teeing the output.

Some of the commands invoke an interactive response (eg: entering password). Specifically, I'm testing against an Isilon.

Example code:

$command = '&"C:\Program Files\Putty\plink.exe" root@10.0.0.141 -pw "password" -t -batch "isi auth users create testuser --set-password"'  
iex $command

Expected result:

• I get a prompt password:
• I enter the password
• I get a prompt confirm:
• I enter the password again
• Command ends

If I try to tee the output, using iex $command | tee-object -variable result or even just redirect with iex $command *>test.log, the prompt text doesn't show up until after I've responded to it. While still technically functional, if you don't know exactly what prompt to expect, it's useless.

I've tried using Start-Transcript, but that doesn't capture the output at all. I've also tried using plink's -sshlog argument, but that logs way too much, in a less than readable format.

Is there any way to have stdout be unbuffered in the console, and also have it stored in a variable?

To answer some potential questions:

-This is to be run in an environment that doesn't allow modules, so can't use Posh-SSH.

-The Powershell version available isn't new enough to use the built-in openssh functionality.

Answer 1

This is all about redirecting streams.

When you use redirection, all outputs are redirected from the streams, and passed to be written to file. When you execute:

Write-Host "Some Text" *>out.txt

You don't see any output and it is all redirected to the file.

Key Note: Redirection works on a (simplification) line by line basis, as the redirection works by writing to the file one line at a time.

Similarly, when you use Tee-Object, all outputs are redirected from the stream and down the pipeline. This is passed to the cmdlet Tee-Object. Tee-Object takes the input, and then writes that input to both the variable/file you want and to the screen. This happens After the input has been gathered and processed.

This means that both redirection and the Tee-Object commands work on a line by line basis. This makes sense both redirection and the Tee-Object commands work this way because it is hard to deal with things like deleting characters, moving around and editing text dynamically while trying to edit and maintain an open file at the same time. It is only designed for a one-way once the statement is complete, output.

In this case, when running it interactively, the password: prompt is written to the screen and you can respond.

When redirecting/Teeing the output, the password: text prompt is redirected, and buffered, awaiting your response. This makes sense because the statement has not completed yet. You don't want to send half a statement that could change, or half an object down the pipeline. It is only after you complete the statement (e.g. entering in the password + enter) that the whole statement is passed down the stream/pipeline. Once the whole statement is sent, then it is redirected/output Tee'd and can be displayed.

@Bill_Stewart is correct, in the sense that you should pick either an interactive prompt, or a fully automated solution.

---

Edit: To add some more information from comments.

If we use Tee-Object it relies on the Pipeline. Pipelines can only pass complete objects down the pipeline (e.g. complete strings inc. New Line). Pipelines have to interact with other commands like ForEach-Object or Select-Object, and they can't handle passing incomplete data to them. That's how the PowerShell console works, and you can't change it.

Similarly, redirection works line by line. The underlying reason why, I will explain why in a moment.

So, if you want to interact with it character by character, then you are dealing with streams. And if you want to deal with streams directly, it's 100 times more complicated because you can't use the convenience of the PowerShell console, you have to directly run of the process manually and handle all the input and output yourself.

To start, you have to manually launch the process. To do this we use the System.Diagnostics.Process class. The Pseudocode looks something like this:

$p = [System.Diagnostics.Process]::New()
$p.StartInfo.RedirectStandardOutput = $true
$p.StartInfo.RedirectStandardError = $true
$p.StartInfo.RedirectStandardInput = $true
$p.StartInfo.UseShellExecute = $false
#$p.StartInfo.CreateNoWindow = $true
$p.StartInfo.FileName = "plink.exe"
$p.StartInfo.Arguments = 'root@10.0.0.141 -pw "password" -t -batch "isi auth users create testuser --set-password"'
$p.EnableRaisingEvents = $true
....

We essentially create the process, specify that we are going to redirect the stdout (StartInfo.RedirectStandardOutput = $true), as well as the stdin to something else for us to handle. How do we know when to read the data? Well, the class has the Process.OutputDataReceived Event. You bind to this event to read in the additional data. But:

The OutputDataReceived event indicates that the associated Process has written a line, terminating with a newline character, to its redirected StandardOutput stream.

Remarks

So even the process class revolves around newlines for streaming data. This is why even redirects *> work on a line by line basis. PowerShell, and cmd, etc. all use the Process class as a basis to run processes. They all bind to this same event and methods to do their processing. Hence, why everything revolves around newlines and statement completions.

(big breath) So. You still want to interactively work with things one character at a time? well then you can't use the convenience of events. You will have to fall back to using a Stream Reader and directly binding to the Process.StandardOutput Property. Unfortunately this is where I stop, and say that to accomplish this is beyond the scope of SO, and will require much more research to accomplish.