Come ripulire l'output del comando "script" di Linux

Sto usando il comando 'script' di Linux http://www.linuxcommand.org/man_pages/script1.html per tracciare alcune sessioni interattive. I file di output che contengono caratteri non stampabili, inclusi i tasti premuti sul backspace.

C'è un modo per riordinare questi file di output in modo che contengano solo ciò che è stato visualizzato sullo schermo?

Oppure c'è un altro modo per registrare una sessione di shell interattiva (input e output)?

Se si desidera visualizzare il file, è possibile inviare l'output tramite col -bp; questo interpreta i caratteri di controllo. Quindi puoi passare meno, se vuoi.

col -bp typescript | less -R

Su alcuni sistemi colnon accetterebbe un argomento nomefile, utilizzare invece questa sintassi:

col -bp <typescript | less -R

cat typescript | perl -pe 's/\e([^\[\]]|\[.*?[a-zA-Z]|\].*?\a)//g' | col -b > typescript-processed

ecco qualche interpretazione dell'input della stringa per perl:

• s/pattern//gsignifica fare una sostituzione sull'intero (l' gopzione significa fare l'intera cosa invece di fermarsi sul primo sostituto) stringa di input

ecco qualche interpretazione del modello regex:

• \e corrisponde allo speciale carattere di controllo "escape" (ASCII 0x1A)
• (e )sono l'inizio e la fine di un gruppo
• |significa che il gruppo può abbinare uno di N pattern. dove sono gli schemi N
  • [^\[\]] o
  • \[.*?[a-zA-Z] o
  • \].*?\a
• [^\[\]] si intende
  • abbina una serie di caratteri NOT in cui i caratteri non sono [e]
• \[.*?[a-zA-Z] si intende
  • abbinare una stringa che inizia con [quindi fare un non avido .*?fino al primo carattere alfa
• \].*?\a si intende
  • abbina una stringa che inizia con ]quindi fai un non avido .*?fino a quando non colpisci lo speciale carattere di controllo chiamato "il carattere di avviso (campana)"

Per una grande quantità di scriptoutput, hackererei uno script perl insieme in modo iterativo. Altrimenti modifica a mano con un buon editor.

È improbabile che esista un metodo automatizzato esistente per rimuovere i caratteri di controllo scriptdall'output in un modo che riproduca ciò che è stato visualizzato sullo schermo in determinati momenti importanti (come quando l'host stava aspettando il primo carattere di alcuni input dell'utente).

Ad esempio, lo schermo potrebbe essere vuoto tranne che Andrew $, se hai digitato rm /*e premuto backspace dodici volte (molto più del necessario), ciò che viene mostrato sullo schermo alla fine dipende da quale shell era in esecuzione, quali sono le tue sttyimpostazioni attuali ( che potresti cambiare nel corso di una sessione) e probabilmente anche altri fattori.

Quanto sopra si applica a qualsiasi metodo automatizzato di acquisizione continua di input e output. L'alternativa principale è scattare "schermate" o tagliare e incollare lo schermo nei momenti appropriati durante la sessione (che è quello che faccio per le guide per l'utente, le note per un diario giornaliero, ecc.).

Una risposta alla seconda parte della mia domanda è quella di utilizzare la funzione di registrazione nella schermata di GNU: ^A Hall'interno di una sessione di schermata in esecuzione. La documentazione è disponibile all'indirizzo http://www.gnu.org/software/screen/manual/screen.html#Logging

Ho usato cat filenameche rimuove i caratteri di controllo :-)

Se quello che stai cercando è registrare i tuoi comandi (ad es. Per trasformarli successivamente in uno script bash), allora deve essere eseguito un hack ragionevole script(1), quindi al suo interno esegui

bash -x

Successivamente grepil file di output (di solito "dattiloscritto") cerca le righe che iniziano con un "+". L'espressione regolare ^\+farà il trucco.

Se si desidera scrivere l'output in un file:

col -bp < typescript >>newfile

utilizzare il comando unix2dos per convertire il file in formato Windows, se lo si desidera

col -bp elabora i backspaces come desiderato (AFAIK). Ma altera le sequenze di escape del colore. Potrebbe essere utile rimuovere prima le sequenze di colori, quindi, se possibile, elaborare i backspaces.

Questa è un'esigenza molto comune e sono sorpreso che non ci siano più soluzioni. È estremamente comune scrivere una sessione, quindi qualcuno ha bisogno di rivedere la procedura. Volete eliminare tutti i piccoli errori di battitura e le sequenze di escape del colore per creare uno script "pulito" della procedura per riferimento futuro. Preferisce un semplice testo ASCII. Penso che questo sia ciò che si intende per "lettura umana", ed è una cosa molto ragionevole da fare.

Ho trovato la risposta che dewtall ha fornito a una domanda simile sulla scheda Unix per essere più efficace nel rimuovere i caratteri di controllo dall'output dello script se ci si trova in un ambiente in cui Perl è disponibile.

sceneggiatura di dewtall:

#!/usr/bin/perl
while (<>) {
    s/ \e[ #%()*+\-.\/]. |
       \r | # Remove extra carriage returns also
       (?:\e\[|\x9b) [ -?]* [@-~] | # CSI ... Cmd
       (?:\e\]|\x9d) .*? (?:\e\\|[\a\x9c]) | # OSC ... (ST|BEL)
       (?:\e[P^_]|[\x90\x9e\x9f]) .*? (?:\e\\|\x9c) | # (DCS|PM|APC) ... ST
       \e.|[\x80-\x9f] //xg;
       1 while s/[^\b][\b]//g;  # remove all non-backspace followed by backspace
    print;
}

Per rimuovere i caratteri di controllo:

./dewtalls-script.pl < output-from-script-that-needs-control-characters-removed

https://github.com/RadixSeven/typescript2txt è stato scritto per risolvere questo problema.

Sono passati 4 anni dall'ultimo aggiornamento / utilizzo, ma non ricordo di aver fatto nulla di fantasioso che non dovrebbe funzionare ancora oggi.

Ho trovato un buon modo per farlo. Sul mio sistema, le linee di uscita lunghe sono cosparse di "^ M" (spazio vuoto seguito da ritorno a capo). "^ M" può essere facilmente sostituito con il carattere null "^ @", che non viene visualizzato affatto quando si esegue il cat del file.

Catturo anche i tempi, quindi per poter riprodurre perfettamente il file, non posso semplicemente rimuovere completamente "^ M" usando i seguenti comandi (perché la sceneggiatura conta i byte):

tr '\r' '\0' | sed 's/ \x0//g'

Eseguo il mio comando di script in questo modo:

script -t -f session.log 2>timing

Quindi, quello che faccio dopo è:

cat session.log | tr '\r' '\0' > typescript 
scriptreplay -t timing | sed 's/ \x0//g'

La prima modifica (prima della riproduzione) mantiene il numero di byte nel file. La seconda modifica (dopo il replay) elimina lo spazio bianco in punti casuali. (Si noti che per impostazione predefinita lo scriptreplay cerca il file di input denominato "typescript", motivo per cui non l'ho fornito dopo "timing".)

dos2unix sull'output farà anche il trucco

Un'altra soluzione consiste nell'utilizzare stringsche stampa solo caratteri stampabili da un file (o dallo standard input):

strings -n 1 filename

L' -n 1opzione imposta la lunghezza minima delle sequenze da conservare su una e quindi assicura che vengano conservati anche i singoli caratteri stampabili circondati da caratteri non stampabili.

Un possibile aspetto negativo di questo approccio è che stringsaggiunge interruzioni di riga tra stringhe contigue di caratteri stampabili. Ad esempio un file con contenuto

Foo<SOMECONTROLCHAR>Bar

(dove <SOMECONTROLCHAR>è il carattere di controllo o qualsiasi altro carattere non stampabile) verrebbe restituito come

Foo
Bar

Un altro problema sollevato nei commenti è che alcune sequenze di caratteri di controllo consistono in una combinazione di caratteri sia stampabili che non stampabili e questo approccio rimuoverà solo parte di quelli.

Tuttavia, stringsfa un buon lavoro nel rimuovere i caratteri di controllo come il backspace menzionato nella domanda.