Captura a entrada do usuário enquanto faz outras coisas

Question

Existe uma maneira de fazer com que a saída de um subprocesso (algo diferente de 'sleep' abaixo) seja combinada com a saída de um loop de comando em primeiro plano? Por exemplo:

while true
do
    echo "updating screen..."
    sleep 3 & # Replace with command which takes some time and updates the screen
    read -s -n 1 -p "Input: " input
    case "$input" in
    q)
        exit
    ;;
    f)
        echo 'foo'
    ;;
    esac
done

    

Answer 1

O shell faz suposições sobre multiprocessamento; o primeiro e mais importante é: um programa deve controlar o terminal por vez, caso contrário, a entrada (e a saída) ficará confusa. E se o programa que você colocar no lugar de 'dormir' quiser receber informações do terminal? Para onde a entrada do teclado é enviada? Para o subprocesso ('sleep') ou para a instrução read ?

A partir disso, você precisa assumir que o subprocesso ('sleep') não receberá entrada. Você também tem que esperar até que o loop de comando (processamento 'q' ou 'f') e o subprocesso tenha terminado. Eu sugiro escrever isso é algo diferente de um script de shell, por exemplo python, para contornar as suposições da shell; mas como eu mostro, isso pode ser feito em shell Bourne (ou ksh ou bash ou zsh) também.

#!/usr/bin/python
import os, select, subprocess, sys
devnull = open('/dev/null', 'a')
# this is the same as "sleep 3 </dev/null > pipefile &" but will handle
# processing output at the same time
p = subprocess.Popen(
    ['/bin/sh', '-c',
 'i=0; while [ $i -lt 30 ]; do echo $i; sleep 2; i='expr $i + 1'; done' ],
    stdin=devnull, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
)
command_done = False
try:
    # endless loop until both input and output are done
    while True:
        inputs = []
        # only send input to our command loop
        if not command_done:
            sys.stdout.write('Input: ')
            sys.stdout.flush()
            inputs.append(sys.stdin)
        if p.returncode is None: # still not finished
            p.poll()
            inputs.append(p.stdout)
        outputs = []
        if not inputs and not outputs: # both are done
            break # exit while loop
        #print inputs, outputs
        r, w, x = select.select(inputs, outputs, [])
        #print 'r=', r, 'w=', w, 'x=', x
        # input from the user is ready
        for file in r:
            if file is sys.stdin:
                input = file.read(1)
                if input == 'q':
                    command_done = True
                    if p.returncode is None:
                        os.kill(p.pid, 15)
                elif input == 'f':
                    sys.stdout.write('foo\n')
            # the subprocess wants to write to the terminal too
            else:
                input = file.readline()
                sys.stdout.write(input)
finally:
    if p.poll():
        try:
            print
            os.kill(p.pid, 15)
        except OSError:
            pass

Você poderia fazer isso em um script de shell, mas a entrada / saída não seria tão bem integrada.

#!/bin/bash
mkfifo /tmp/mergedout.p
( i=0; while [ $i -lt 30 ]; do echo $i; sleep 'expr 30 - $i'; i='expr $i + 1'; done ) </dev/null >/tmp/mergedout.p 2>&1 &
pid=$!
exec 3</tmp/mergedout.p
done=false
trap 'rm /tmp/mergedout.p' 0
while [ -n "$pid" -a $done = false ]; do
    if [ $done = false ]; then
        echo -n "Input: "
        read -t 0.1 -s -r -n 1
        case $REPLY in
            q) done=true; if [ -n "$pid" ]; then kill $pid; fi;;
            f) echo foo;;
        esac
    fi
    if [ -n "$pid" ]; then
        kill -0 $pid 2>&-
        if [ $? -ne 0 ]; then
            echo "$pid terminated"
            wait $pid
            pid=""
            exec 3<&-
        else
            read -t 0.1 -u 3 -r
            echo "reading from fd3: X${REPLY}X $?"
            if [ -n "$REPLY" ]; then
                echo "$REPLY"
            fi
        fi
    fi
    sleep 0.5
done

Eu mesmo, o python é um pouco mais claro e mais "encaixado", mas na maior parte, isso pode ser feito de qualquer maneira.