Please allow us to customize OutputStream and ExtendedOutputStream before executing an SSH command.

[ScionOfDesign]

I have a use case where I want real time output from the console command to be printed to the console. Unfortunately, the streams that are written to cannot be customized with the existing public interface, even though the PipeStream class is extensible. The best solution I found to do what I need to do unfortunately requires reflection.

A public interface (such as a callback) for this feature would be greatly appreciated.

public static class SshClientExtensions
{
    public static async Task<SshCommand> ConnectAndExecuteCommandAsync(this SshClient client, string command, CancellationToken cancellationToken = default)
    {
        SshCommand sshCommand;
        try
        {
            await client.ConnectAsync(cancellationToken);
            sshCommand = client.CreateCommand(command);
            using CancellationTokenSource linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);

            BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Instance;
            PropertyInfo stdOutProp = typeof(SshCommand).GetProperty(nameof(SshCommand.OutputStream), bindingFlags)!;
            PropertyInfo stdErrProp = typeof(SshCommand).GetProperty(nameof(SshCommand.ExtendedOutputStream), bindingFlags)!;

            PipeStream stdOutStream = (PipeStream)stdOutProp.GetValue(sshCommand)!;
            PipeStream stdErrStream = (PipeStream)stdErrProp.GetValue(sshCommand)!;

            await stdOutStream.DisposeAsync();
            await stdErrStream.DisposeAsync();

            TextWriterPipeStream stdOut = new(Console.Out);
            TextWriterPipeStream stdErr = new(Console.Error);

            stdOutProp.SetValue(sshCommand, stdOut);
            stdErrProp.SetValue(sshCommand, stdErr);

            await sshCommand.ExecuteAsync(cancellationToken);
        }
        catch (Exception e)
        {
            return await Task.FromException<SshCommand>(e);
        }
        finally
        {
            client.Disconnect();
        }
        return sshCommand;
    }

    private sealed class TextWriterPipeStream : PipeStream
    {
        private readonly TextWriter textWriter;

        public TextWriterPipeStream(TextWriter textWriter) : base()
        {
            this.textWriter = textWriter;
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            base.Write(buffer, offset, count);
            string output = Encoding.UTF8.GetString(buffer, offset, count);
            textWriter.Write(output);
        }
    }
}

[Rob-Hague]

This works for me:

using var command = client.CreateCommand("head -c 10000000 /dev/urandom | base64"); // 10MB of data please
await using Stream cout = Console.OpenStandardOutput();
await using Stream cerr = Console.OpenStandardError();

await Task.WhenAll(
    command.ExecuteAsync(),
    command.OutputStream.CopyToAsync(cout),
    command.ExtendedOutputStream.CopyToAsync(cerr));

[ScionOfDesign]

@Rob-Hague sorry I misunderstood your code before.

I already tried copying the stream at the same time, the problem with that is that it affects the Result and Error properties on the SshCommand. This is not acceptable for my use case, as I need to maintain all of the output.

Also, the PipeStreams are disposed of as soon as the command finishes, leading to a tiny risk that the code you have would try to read a now-disposed stream.

The copy could also complete during a pause in output, in which case it wouldn't record all the information.

The solution I came up with is the only way to ensure that all the output is displayed to the console in real time and not risk accessing a disposed stream.

[Rob-Hague]

PipeStream is safe to read from after disposal (it is documented as such). It also does not complete until the command is finished.

Result is just a StreamReader wrapped around command.OutputStream. You could use your own StreamReader:

string? line;
using StreamReader sr = new(command.OutputStream);
while ((line = sr.ReadLine()) != null)
{
    // Do what you want with `line`, or use sr.Read(char[], int, int) for more control

    // e.g. Console.Write or build up a StringBuilder
}

[ScionOfDesign]

That's good to know that it is safe to read from after it is disposed.
However, that still doesn't resolve this issue:

I already tried copying the stream at the same time, the problem with that is that it affects the Result and Error properties on the SshCommand. This is not acceptable for my use case, as I need to maintain all of the output.

Reading from OutputStream moves its position, which means that Result will be empty after it is read.
Its Position/_head cannot be reset after it is disposed, either, as it is designed that way:

Based on the code CopyToAsync, the output order is not deterministic. Whereas, with the solution I gave, the output is deterministic.
Example script:

#!/bin/bash
for i in {1..3}
do
  echo "Hello, World $i"          # Output to standard output
  echo "Hello, Error World $i" >&2 # Output to standard error
  sleep 1
done

Output (inconsistent) from CopyToAsync:

Hello, World 1
Hello, Error World 1
Hello, Error World 2
Hello, World 2
Hello, World 3
Hello, Error World 3

Output (consistent) from my code:

Hello, World 1
Hello, Error World 1
Hello, World 2
Hello, Error World 2
Hello, World 3
Hello, Error World 3

Furthermore, ReadLine() has this same issue, as it depends on the output ending in a single NewLine, which may not always be the case.

I think that being able to hook into a wrapper around the Channel events like channel.DataReceived and Channel_ExtendedDataReceived would be a good solution to this issue.