Come indurre un'applicazione a pensare che il suo stdout sia un terminale, non una pipe

Sto cercando di fare il contrario di " Rileva se lo stdin è un terminale o una pipe? ".

Sto eseguendo un'applicazione che sta cambiando il suo formato di output perché rileva una pipe su STDOUT e voglio che pensi che sia un terminale interattivo in modo da ottenere lo stesso output durante il reindirizzamento.

Stavo pensando che avvolgerlo in uno expectscript o usare un proc_open()in PHP lo avrebbe fatto, ma non è così.

Qualche idea là fuori?

Aha!

Il scriptcomando fa quello che vogliamo ...

script --return --quiet -c "[executable string]" /dev/null

Fa il trucco!

Usage:
 script [options] [file]

Make a typescript of a terminal session.

Options:
 -a, --append                  append the output
 -c, --command <command>       run command rather than interactive shell
 -e, --return                  return exit code of the child process
 -f, --flush                   run flush after each write
     --force                   use output file even when it is a link
 -q, --quiet                   be quiet
 -t[<file>], --timing[=<file>] output timing data to stderr or to FILE
 -h, --help                    display this help
 -V, --version                 display version

Sulla base della soluzione di Chris , ho pensato alla seguente piccola funzione di supporto:

faketty() {
    script -qfc "$(printf "%q " "$@")" /dev/null
}

L'aspetto eccentrico printfè necessario per espandere correttamente gli argomenti dello script $@proteggendo al contempo eventuali parti del comando tra virgolette (vedere l'esempio seguente).

Uso:

faketty <command> <args>

Esempio:

$ python -c "import sys; print sys.stdout.isatty()"
True
$ python -c "import sys; print sys.stdout.isatty()" | cat
False
$ faketty python -c "import sys; print sys.stdout.isatty()" | cat
True

Lo script non buffer che viene fornito con Expect dovrebbe gestire questo ok. In caso contrario, l'applicazione potrebbe guardare qualcosa di diverso da quello a cui è collegata la sua uscita, ad es. su cosa è impostata la variabile d'ambiente TERM.

Non so se sia fattibile da PHP, ma se hai davvero bisogno del processo figlio per vedere un TTY, puoi creare un PTY .

In C:

#include <stdio.h>
#include <stdlib.h>
#include <sysexits.h>
#include <unistd.h>
#include <pty.h>

int main(int argc, char **argv) {
    int master;
    struct winsize win = {
        .ws_col = 80, .ws_row = 24,
        .ws_xpixel = 480, .ws_ypixel = 192,
    };
    pid_t child;

    if (argc < 2) {
        printf("Usage: %s cmd [args...]\n", argv[0]);
        exit(EX_USAGE);
    }

    child = forkpty(&master, NULL, NULL, &win);
    if (child == -1) {
        perror("forkpty failed");
        exit(EX_OSERR);
    }
    if (child == 0) {
        execvp(argv[1], argv + 1);
        perror("exec failed");
        exit(EX_OSERR);
    }

    /* now the child is attached to a real pseudo-TTY instead of a pipe,
     * while the parent can use "master" much like a normal pipe */
}

In realtà, avevo l'impressione che expectcreasse un PTY.

Facendo riferimento alla risposta precedente, su Mac OS X, "script" può essere utilizzato come di seguito ...

script -q /dev/null commands...

Ma poiché potrebbe sostituire "\ n" con "\ r \ n" sullo stdout, potresti anche aver bisogno di uno script come questo:

script -q /dev/null commands... | perl -pe 's/\r\n/\n/g'

Se tra questi comandi è presente una pipe, è necessario svuotare lo stdout. per esempio:

script -q /dev/null commands... | ruby -ne 'print "....\n";STDOUT.flush' |  perl -pe 's/\r\n/\n/g'

Troppo nuovo per commentare la risposta specifica, ma ho pensato di dare seguito alla fakettyfunzione pubblicata da ingomueller-net sopra poiché mi ha aiutato di recente.

Ho scoperto che questo stava creando un typescriptfile che non volevo / non avevo bisogno, quindi ho aggiunto / dev / null come file di destinazione dello script:

function faketty { script -qfc "$(printf "%q " "$@")" /dev/null ; }

Aggiornamento della risposta di @A-Ron a) lavoro su Linux e MacO b) propagazione indiretta del codice di stato (poiché i MacO scriptnon lo supportano)

faketty () {
  # Create a temporary file for storing the status code
  tmp=$(mktemp)

  # Ensure it worked or fail with status 99
  [ "$tmp" ] || return 99

  # Produce a script that runs the command provided to faketty as
  # arguments and stores the status code in the temporary file
  cmd="$(printf '%q ' "$@")"'; echo $? > '$tmp

  # Run the script through /bin/sh with fake tty
  if [ "$(uname)" = "Darwin" ]; then
    # MacOS
    script -Fq /dev/null /bin/sh -c "$cmd"
  else
    script -qfc "/bin/sh -c $(printf "%q " "$cmd")" /dev/null
  fi

  # Ensure that the status code was written to the temporary file or
  # fail with status 99
  [ -s $tmp ] || return 99

  # Collect the status code from the temporary file
  err=$(cat $tmp)

  # Remove the temporary file
  rm -f $tmp

  # Return the status code
  return $err
}

Esempi:

$ faketty false ; echo $?
1

$ faketty echo '$HOME' ; echo $?
$HOME
0

embedded_example () {
  faketty perl -e 'sleep(5); print "Hello  world\n"; exit(3);' > LOGFILE 2>&1 </dev/null &
  pid=$!

  # do something else
  echo 0..
  sleep 2
  echo 2..

  echo wait
  wait $pid
  status=$?
  cat LOGFILE
  echo Exit status: $status
}

$ embedded_example
0..
2..
wait
Hello  world
Exit status: 3

Stavo cercando di ottenere colori durante l'esecuzione shellcheck <file> | less, quindi ho provato le risposte sopra, ma producono questo bizzarro effetto in cui il testo è sfalsato orizzontalmente da dove dovrebbe essere:

In ./all/update.sh line 6:
                          for repo in $(cat repos); do
                                                                  ^-- SC2013: To read lines rather than words, pipe/redirect to a 'while read' loop.

(Per coloro che non hanno familiarità con il shellcheck, la riga con l'avvertimento dovrebbe allinearsi al punto in cui si trova il problema.)

Al fine di rispondere alle risposte sopra per lavorare con shellcheck, ho provato una delle opzioni dai commenti:

faketty() {                       
    0</dev/null script -qfc "$(printf "%q " "$@")" /dev/null
}

Questo funziona Ho anche aggiunto --returne usato lunghe opzioni, per rendere questo comando un po 'meno imperscrutabile:

faketty() {                       
    0</dev/null script --quiet --flush --return --command "$(printf "%q " "$@")" /dev/null
}

Funziona in Bash e Zsh.

C'è anche un programma pty incluso nel codice di esempio del libro "Advanced Programming in UNIX Environment, Second Edition"!

Ecco come compilare pty su Mac OS X:

man 4 pty  #  pty -- pseudo terminal driver

open http://en.wikipedia.org/wiki/Pseudo_terminal

# Advanced Programming in the UNIX Environment, Second Edition
open http://www.apuebook.com

cd ~/Desktop

curl -L -O http://www.apuebook.com/src.tar.gz

tar -xzf src.tar.gz

cd apue.2e

wkdir="${HOME}/Desktop/apue.2e"

sed -E -i "" "s|^WKDIR=.*|WKDIR=${wkdir}|" ~/Desktop/apue.2e/Make.defines.macos

echo '#undef _POSIX_C_SOURCE' >> ~/Desktop/apue.2e/include/apue.h

str='#include   <sys/select.h>'
printf '%s\n' H 1i "$str" . wq | ed -s calld/loop.c

str='
#undef _POSIX_C_SOURCE
#include <sys/types.h>
'
printf '%s\n' H 1i "$str" . wq | ed -s file/devrdev.c

str='
#include <sys/signal.h>
#include <sys/ioctl.h>
'
printf '%s\n' H 1i "$str" . wq | ed -s termios/winch.c

make

~/Desktop/apue.2e/pty/pty ls -ld *