Cannot get shell welcome message and prompt after creating session

[netes040]

I'm trying to establish an interactive SSH shell using the following code:

import asyncio, asyncssh, sys

async def run_client():
    async with asyncssh.connect(
        HOST, port=PORT, username=USER, password=PASSWORD,
        known_hosts=None) as conn:
        
        stdin, stdout, stderr = await conn.open_session()
        # Try to get the welcoming message and shell prompt
        welcome = await stdout.read(1024)
        print(welcome)

loop = asyncio.get_event_loop()
try:
    loop.run_until_complete(run_client())
except (OSError, asyncssh.Error) as exc:
    sys.exit('SSH connection failed: ' + str(exc))

However, when running this program, the stdout.read(1024) never returns. I can obtain the desired behavior using paramiko with the following code:

from paramiko import SSHClient, AutoAddPolicy

with SSHClient() as client:
    client.set_missing_host_key_policy(AutoAddPolicy())
    client.connect(hostname, port, username, password)
    
    with client.invoke_shell() as chan:
        chan.settimeout(2)
        ## wait until some data is available
        while not channel.recv_ready():
            time.sleep(0.3)
        ## get the data
        welcome = b""
        while channel.recv_ready():
            welcome += channel.recv(2**13)
            time.sleep(delay)
        print(welcome.decode("utf-8"))

[ronf]

By default, read() with a max length will return as soon as any bytes are available. However, if you want to collect up all the output until you don't get any more for a certain period of time, it's easiest to write a helper function such as:

async def read_timed(stream, timeout):
    """Read data from a stream with a timeout"""

    result = ''

    while True:
        try:
            result += await asyncio.wait_for(stream.read(1024), timeout=timeout)
        except asyncio.TimeoutError:
            return result

You could then use this in code such as:

async def main():
    async with asyncssh.connect('localhost') as conn:
        async with conn.create_process(term_type='ansi') as proc:
            welcome = await read_timed(proc.stdout, 2)
            print('Welcome banner:', welcome)

            proc.stdin.write('ls\n')
            response = await read_timed(proc.stdout, 2)
            print('Response:', response)

asyncio.run(main())

Note the term_type='ansi' there -- you'll want that if you want to actually get the shell prompts and echoed output of the commands you are sending. However, it works without that as well, and in that case you only get the banner and command output without the extra output for the shell prompts and command echo.

By default, all input and output is UTF-8, so you don't need to encode/decode the data yourself. If you want binary data, you just need to add encoding=None when opening up a session and all the read and write functions will take bytes instead of str values.

I used create_process() in this example because it is a context handler which will automatically clean up the session when exiting the block. However, you can use open_session() here if you like. You'd just want to do a stdin.close() followed by await stdin.wait_closed() when you're done with the session.

[netes040]

It works, thanks! I think what I needed is the term_type='ansi'.

Is there any documentation about the available term_types?

[ronf]

It would depend on the remote system. From an SSH perspective, this is just an opaque string passed from the SSH client to the SSH server, and from the SSH server to becoming a TERM environment variable in the shell which is started up. The term(5) man page describes some of the directories you might find terminal definitions in.

From an SSH perspective, the key difference when you set term_type is that it requests a pseudo-TTY on the remote system. This is why you'll see differences around things like the shell printing prompts and echoing command input. When running without a TTY, the shell just reads input without echoing it (or printing prompts).

Another difference worth mentioning is that when you request a TTY the SSH server will combine stdout and stderr, since a pseudo-TTY only has a single input stream and single output stream. So, even though SSH will have a stderr stream, you won't see any data on it when running with a TTY. Everything on stderr will be mixed into the output you read from stdout. This is true even when using pseudo-TTYs without SSH being involved.

[netes040]

Ok, thanks for the complement of information! I close the issue