Lavorare con i flussi di dati sulla riga di comando di Linux

“Questa è la filosofia Unix:scrivere programmi che facciano una cosa e la facciano bene. Scrivi programmi per lavorare insieme. Scrivi programmi per gestire i flussi di testo, perché è un'interfaccia universale."

— Doug McIlroy, Nozioni di base sulla filosofia Unix

STDIO

STDIO è stato sviluppato da Ken Thompson come parte dell'infrastruttura richiesta per implementare le pipe nelle prime versioni di Unix. I programmi che implementano STDIO utilizzano handle di file standardizzati per l'input e l'output anziché i file archiviati su un disco o un altro supporto di registrazione. STDIO è meglio descritto come un flusso di dati con buffer e la sua funzione principale è trasmettere i dati dall'output di un programma, file o dispositivo all'input di un altro programma, file o dispositivo.

Esistono tre flussi di dati STDIO, ognuno dei quali viene aperto automaticamente come file all'avvio di un programma, ovvero quei programmi che utilizzano STDIO. Ogni flusso di dati STDIO è associato a un handle di file, che è solo un insieme di metadati che descrive gli attributi del file. Gli handle di file 0, 1 e 2 sono definiti in modo esplicito per convenzione e pratica lunga rispettivamente come STDIN, STDOUT e STDERR.

STDIN, handle di file 0 , è l'input standard che di solito viene immesso dalla tastiera. STDIN può essere reindirizzato da qualsiasi file, inclusi i file del dispositivo, anziché dalla tastiera. Non è comune dover reindirizzare STDIN, ma è possibile.

STDOUT, handle di file 1 , è l'output standard che invia il flusso di dati al display per impostazione predefinita. È comune reindirizzare STDOUT a un file o inviarlo tramite pipe a un altro programma per un'ulteriore elaborazione.

STDERR, File handle 2 . Anche il flusso di dati per STDERR viene solitamente inviato al display.

Se STDOUT viene reindirizzato a un file, STDERR continua a essere visualizzato sullo schermo. Ciò garantisce che quando il flusso di dati stesso non è visualizzato sul terminale, quello STDERR lo è, assicurando così che l'utente vedrà eventuali errori derivanti dall'esecuzione del programma. STDERR può anche essere reindirizzato allo stesso o passato al prossimo programma di trasformazione in una pipeline.

STDIO è implementato come libreria C, stdio.h , che può essere incluso nel codice sorgente dei programmi in modo che possa essere compilato nell'eseguibile risultante.

Stream semplici

Puoi eseguire i seguenti esperimenti in sicurezza in /tmp directory del tuo host Linux. Come utente root, crea /tmp la PWD, creare una directory di prova, quindi rendere la nuova directory la PWD.

# cd /tmp ; mkdir test ; cd test

Immettere ed eseguire il seguente programma da riga di comando per creare alcuni file con contenuto sull'unità. Usiamo il dmesg comando semplicemente per fornire i dati che i file devono contenere. I contenuti non contano tanto quanto il fatto che ogni file abbia dei contenuti.

# for I in 0 1 2 3 4 5 6 7 8 9 ; do dmesg > file$I.txt ; done 

Verifica che ora ci siano almeno 10 file in /tmp/ con i nomi file0.txt tramite file9.txt .

# ll

total 1320

-rw-r--r-- 1 root root 131402 Oct 17 15:50 file0.txt

-rw-r--r-- 1 root root 131402 Oct 17 15:50 file1.txt

-rw-r--r-- 1 root root 131402 Oct 17 15:50 file2.txt

-rw-r--r-- 1 root root 131402 Oct 17 15:50 file3.txt

-rw-r--r-- 1 root root 131402 Oct 17 15:50 file4.txt

-rw-r--r-- 1 root root 131402 Oct 17 15:50 file5.txt

-rw-r--r-- 1 root root 131402 Oct 17 15:50 file6.txt

-rw-r--r-- 1 root root 131402 Oct 17 15:50 file7.txt

-rw-r--r-- 1 root root 131402 Oct 17 15:50 file8.txt

-rw-r--r-- 1 root root 131402 Oct 17 15:50 file9.txt

Abbiamo generato flussi di dati utilizzando dmesg comando, che è stato reindirizzato a una serie di file. La maggior parte delle utilità di base utilizza STDIO come flusso di output e quelli che generano flussi di dati, anziché agire per trasformare il flusso di dati in qualche modo, possono essere utilizzati per creare i flussi di dati che utilizzeremo per i nostri esperimenti. I flussi di dati possono essere brevi come una riga o anche un singolo carattere e lunghi quanto necessario.

Esplorazione del disco rigido

È giunto il momento di fare un po' di esplorazione. In questo esperimento, esamineremo alcune delle strutture del filesystem.

Iniziamo con qualcosa di semplice. Dovresti avere almeno una certa familiarità con dd comando. Ufficialmente noto come "dump del disco", molti amministratori di sistema lo chiamano "distruttore di dischi" per una buona ragione. Molti di noi hanno inavvertitamente distrutto il contenuto di un intero disco rigido o partizione utilizzando il dd comando. Ecco perché ci fermeremo nel /tmp/test directory per eseguire alcuni di questi esperimenti.

Nonostante la sua reputazione, dd può essere molto utile per esplorare vari tipi di supporti di memorizzazione, dischi rigidi e partizioni. Lo useremo anche come strumento per esplorare altri aspetti di Linux.

Accedi a una sessione di terminale come root se non lo sei già. Per prima cosa dobbiamo determinare il file speciale del dispositivo per il tuo disco rigido usando lsblk comando.

[root@studentvm1 test]# lsblk -i

NAME                                 MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT

sda                                    8:0    0   60G  0 disk 

|-sda1                                 8:1    0    1G  0 part /boot

`-sda2                                 8:2    0   59G  0 part 

  |-fedora_studentvm1-pool00_tmeta   253:0    0    4M  0 lvm  

  | `-fedora_studentvm1-pool00-tpool 253:2    0    2G  0 lvm  

  |   |-fedora_studentvm1-root       253:3    0    2G  0 lvm  /

  |   `-fedora_studentvm1-pool00     253:6    0    2G  0 lvm  

  |-fedora_studentvm1-pool00_tdata   253:1    0    2G  0 lvm  

  | `-fedora_studentvm1-pool00-tpool 253:2    0    2G  0 lvm  

  |   |-fedora_studentvm1-root       253:3    0    2G  0 lvm  /

  |   `-fedora_studentvm1-pool00     253:6    0    2G  0 lvm  

  |-fedora_studentvm1-swap           253:4    0   10G  0 lvm  [SWAP]

  |-fedora_studentvm1-usr            253:5    0   15G  0 lvm  /usr

  |-fedora_studentvm1-home           253:7    0    2G  0 lvm  /home

  |-fedora_studentvm1-var            253:8    0   10G  0 lvm  /var

  `-fedora_studentvm1-tmp            253:9    0    5G  0 lvm  /tmp

sr0                                   11:0    1 1024M  0 rom 

Possiamo vedere da ciò che c'è un solo disco rigido su questo host, che il file speciale del dispositivo ad esso associato è /dev/sda , e che ha due partizioni. Il /dev/sda1 partizione è la partizione di avvio e /dev/sda2 partizione contiene un gruppo di volumi su cui è stato creato il resto dei volumi logici dell'host.

Come root nella sessione del terminale, usa dd comando per visualizzare il record di avvio del disco rigido, supponendo che sia assegnato a /dev/sda dispositivo. Il bs= l'argomento non è quello che potresti pensare; specifica semplicemente la dimensione del blocco e il count= argomento specifica il numero di blocchi di cui eseguire il dump su STDIO. Il if= argomento specifica l'origine del flusso di dati, in questo caso, /dev/sda dispositivo. Si noti che non stiamo guardando il primo blocco della partizione, stiamo guardando il primo blocco del disco rigido.

[root@studentvm1 test]# dd if=/dev/sda bs=512 count=1

�c�#�м���؎���|�#�#���!#��8#u

                            ��#���u��#�#�#�|���t#�L#�#�|���#�����€t��pt#���y|1��؎м ��d|<�t#��R�|1��D#@�D��D#�##f�#\|f�f�#`|f�\

                                      �D#p�B�#r�p�#�K`#�#��1��������#a`���#f��u#����f1�f�TCPAf�#f�#a�&Z|�#}�#�.}�4�3}�.�#��GRUB GeomHard DiskRead Error

�#��#�<u��ܻޮ�###��� ������ �_U�1+0 records in

1+0 records out

512 bytes copied, 4.3856e-05 s, 11.7 MB/s

Questo stampa il testo del record di avvio, che è il primo blocco sul disco, qualsiasi disco. In questo caso, ci sono informazioni sul filesystem e, sebbene sia illeggibile perché memorizzato in formato binario, la tabella delle partizioni. Se questo fosse un dispositivo avviabile, lo stadio 1 di GRUB o qualche altro boot loader si troverebbe in questo settore. Le ultime tre righe contengono dati sul numero di record e byte elaborati.

A partire dall'inizio di /dev/sda1 , diamo un'occhiata a pochi blocchi di dati alla volta per trovare ciò che vogliamo. Il comando è simile al precedente, tranne per il fatto che abbiamo specificato alcuni blocchi di dati in più da visualizzare. Potrebbe essere necessario specificare meno blocchi se il terminale non è abbastanza grande da visualizzare tutti i dati contemporaneamente, oppure è possibile reindirizzare i dati tramite l'utilità less e utilizzarla per sfogliare i dati, in entrambi i casi funziona. Ricorda, stiamo facendo tutto questo come utente root perché gli utenti non root non hanno i permessi richiesti.

Immettere lo stesso comando dell'esperimento precedente, ma aumentare il conteggio dei blocchi da visualizzare a 100, come mostrato di seguito, per mostrare più dati.

[root@studentvm1 test]# dd if=/dev/sda1 bs=512 count=100

##33��#:�##�� :o�[:o�[#��S�###�q[#

                                  #<�#{5OZh�GJ͞#t�Ұ##boot/bootysimage/booC�dp��G'�*)�#A�##@

     #�q[

�## ##  ###�#���To=###<#8���#'#�###�#�����#�'  �����#Xi  �#��`  qT���

  <���

      �  r����  ]�#�#�##�##�##�#�##�##�##�#�##�##�#��#�#�##�#�##�##�#��#�#����#       �     �#    �#    �#

�

�#

�#

�#

  �

   �#

     �#

       �#

         �

          �#

            �#

              �#100+0 records in

100+0 records out

51200 bytes (51 kB, 50 KiB) copied, 0.00117615 s, 43.5 MB/s

Ora prova questo comando. Non riprodurrò l'intero flusso di dati qui perché occuperebbe enormi quantità di spazio. Usa Ctrl-C per interrompere e interrompere il flusso di dati.

[root@studentvm1 test]# dd if=/dev/sda

Questo comando produce un flusso di dati che è il contenuto completo del disco rigido, /dev/sda , incluso il record di avvio, la tabella delle partizioni e tutte le partizioni e il relativo contenuto. Questi dati possono essere reindirizzati a un file da utilizzare come backup completo da cui è possibile eseguire un ripristino bare metal. Potrebbe anche essere inviato direttamente a un altro disco rigido per clonare il primo. Ma non eseguire questo particolare esperimento.

[root@studentvm1 test]# dd if=/dev/sda of=/dev/sdx

Puoi vedere che il dd Il comando può essere molto utile per esplorare le strutture di vari tipi di filesystem, localizzare i dati su un dispositivo di archiviazione difettoso e molto altro. Produce anche un flusso di dati su cui possiamo utilizzare le utilità del trasformatore per modificare o visualizzare.

Il vero punto qui è che dd , come molti comandi Linux, produce un flusso di dati come output. Quel flusso di dati può essere ricercato e manipolato in molti modi utilizzando altri strumenti. Può anche essere utilizzato per backup di tipo fantasma o duplicazione del disco.

Casualità

Si scopre che la casualità è una cosa desiderabile nei computer, chi lo sapeva? Esistono diversi motivi per cui gli amministratori di sistema potrebbero voler generare un flusso di dati casuali. Un flusso di dati casuali a volte è utile per sovrascrivere il contenuto di una partizione completa, come /dev/sda1 o anche l'intero disco rigido, come in /dev/sda .

Esegui questo esperimento come utente non root. Immettere questo comando per stampare un flusso infinito di dati casuali su STDIO.

[student@studentvm1 ~]$ cat /dev/urandom

Usa Ctrl-C per interrompere e interrompere il flusso di dati. Potrebbe essere necessario utilizzare Ctrl-C più volte.

I dati casuali vengono utilizzati anche come seme di input per i programmi che generano password casuali e dati e numeri casuali da utilizzare nei calcoli scientifici e statistici. Tratterò la casualità e altre fonti di dati interessanti in modo un po' più dettagliato nel Capitolo 24:Tutto è un file.

Sogni di tubo

Le pipe sono fondamentali per la nostra capacità di fare cose incredibili sulla linea di comando, tanto che penso sia importante riconoscere che sono state inventate da Douglas McIlroy durante i primi giorni di Unix (grazie, Doug!). Il sito web della Princeton University ha un frammento di un'intervista con McIlroy in cui discute la creazione della pipa e gli inizi della filosofia Unix.

Si noti l'uso di pipe nel semplice programma a riga di comando mostrato di seguito, che elenca ogni utente connesso una sola volta, indipendentemente dal numero di accessi attivi. Esegui questo esperimento come utente studente. Immettere il comando mostrato di seguito:

[student@studentvm1 ~]$ w | tail -n +3 | awk '{print $1}' | sort | uniq

root

student

[student@studentvm1 ~]$

I risultati di questo comando producono due righe di dati che mostrano che l'utente root e lo studente hanno entrambi effettuato l'accesso. Non mostra quante volte ogni utente ha effettuato l'accesso. I tuoi risultati saranno quasi sicuramente diversi dai miei.

I tubi, rappresentati dalla barra verticale ( | ), sono il collante sintattico, l'operatore, che collega insieme queste utilità della riga di comando. Le pipe consentono di "convogliare" l'output standard di un comando, ovvero di trasmetterlo in streaming dall'output standard di un comando all'input standard del comando successivo.

L'operatore |&può essere utilizzato per reindirizzare STDERR insieme a STDOUT a STDIN del comando successivo. Questo non è sempre auspicabile, ma offre flessibilità nella possibilità di registrare il flusso di dati STDERR ai fini della determinazione del problema.

Una serie di programmi collegati a pipe è chiamata pipeline e i programmi che utilizzano STDIO sono ufficialmente chiamati filtri, ma io preferisco il termine "trasformatori".

Pensa a come dovrebbe funzionare questo programma se non potessimo convogliare il flusso di dati da un comando all'altro. Il primo comando eseguirà il suo compito sui dati e quindi l'output di quel comando dovrebbe essere salvato in un file. Il comando successivo dovrebbe leggere il flusso di dati dal file intermedio ed eseguire la sua modifica del flusso di dati, inviando il proprio output a un nuovo file di dati temporaneo. Il terzo comando dovrebbe prendere i suoi dati dal secondo file di dati temporaneo ed eseguire la propria manipolazione del flusso di dati e quindi archiviare il flusso di dati risultante in un altro file temporaneo. Ad ogni passaggio, i nomi dei file di dati dovrebbero essere trasferiti da un comando all'altro in qualche modo.

Non riesco nemmeno a pensarci perché è così complesso. Ricorda:la semplicità spacca!

Costruzione di condotte

Quando sto facendo qualcosa di nuovo, risolvendo un nuovo problema, di solito non mi limito a digitare una pipeline di comandi Bash completa da zero dalla parte superiore della mia testa. Di solito inizio con solo uno o due comandi nella pipeline e costruisco da lì aggiungendo più comandi per elaborare ulteriormente il flusso di dati. Ciò mi consente di visualizzare lo stato del flusso di dati dopo ciascuno dei comandi nella pipeline e di apportare le correzioni necessarie.

È possibile creare pipeline molto complesse in grado di trasformare il flusso di dati utilizzando molte utilità diverse che funzionano con STDIO.

Reindirizzamento

Il reindirizzamento è la capacità di reindirizzare il flusso di dati STDOUT di un programma a un file anziché alla destinazione predefinita del display. Il carattere "maggiore di" (> ), noto anche come "gt", è il simbolo sintattico per il reindirizzamento di STDOUT.

Il reindirizzamento dello STDOUT di un comando può essere utilizzato per creare un file contenente i risultati di quel comando.

[student@studentvm1 ~]$ df -h > diskusage.txt

Non c'è output sul terminale da questo comando a meno che non si sia verificato un errore. Questo perché il flusso di dati STDOUT viene reindirizzato al file e STDERR viene comunque indirizzato al dispositivo STDOUT, che è il display. Puoi visualizzare il contenuto del file che hai appena creato usando questo comando successivo:

[student@studentvm1 test]# cat diskusage.txt 

Filesystem                          Size  Used Avail Use% Mounted on

devtmpfs                            2.0G     0  2.0G   0% /dev

tmpfs                               2.0G     0  2.0G   0% /dev/shm

tmpfs                               2.0G  1.2M  2.0G   1% /run

tmpfs                               2.0G     0  2.0G   0% /sys/fs/cgroup

/dev/mapper/fedora_studentvm1-root  2.0G   50M  1.8G   3% /

/dev/mapper/fedora_studentvm1-usr    15G  4.5G  9.5G  33% /usr

/dev/mapper/fedora_studentvm1-var   9.8G  1.1G  8.2G  12% /var

/dev/mapper/fedora_studentvm1-tmp   4.9G   21M  4.6G   1% /tmp

/dev/mapper/fedora_studentvm1-home  2.0G  7.2M  1.8G   1% /home

/dev/sda1                           976M  221M  689M  25% /boot

tmpfs                               395M     0  395M   0% /run/user/0

tmpfs                               395M   12K  395M   1% /run/user/1000

Quando si utilizza il simbolo> per reindirizzare il flusso di dati, il file specificato viene creato se non esiste già. Se esiste, il contenuto viene sovrascritto dal flusso di dati del comando. Puoi utilizzare il doppio dei simboli maggiore di>>, per aggiungere il nuovo flusso di dati a qualsiasi contenuto esistente nel file.

[student@studentvm1 ~]$ df -h >> diskusage.txt

Puoi usare cat e/o less per visualizzare il diskusage.txt file per verificare che i nuovi dati siano stati aggiunti alla fine del file.

Il simbolo <(minore di) reindirizza i dati allo STDIN del programma. Potresti voler utilizzare questo metodo per inserire i dati da un file in STDIN di un comando che non accetta un nome file come argomento ma che utilizza STDIN. Sebbene le origini di input possano essere reindirizzate a STDIN, ad esempio un file utilizzato come input per grep, generalmente non è necessario poiché grep accetta anche un nome file come argomento per specificare l'origine di input. La maggior parte degli altri comandi accetta anche un nome di file come argomento per la sorgente di input.

Solo in giro

Il grep Il comando viene utilizzato per selezionare le righe che corrispondono a un modello specificato da un flusso di dati. grep è una delle utility per trasformatori più comunemente utilizzate e può essere utilizzata in modi molto creativi e interessanti. Il grep il comando è uno dei pochi che può essere correttamente chiamato filtro perché filtra tutte le righe del flusso di dati che non desideri; lascia solo le righe che desideri nel flusso di dati rimanente.

Se il PWD non è il /tmp/test directory, fallo così. Per prima cosa creiamo un flusso di dati casuali da archiviare in un file. In questo caso, vogliamo dati un po' meno casuali che sarebbero limitati ai caratteri stampabili. Un buon programma di generazione di password può farlo. Il seguente programma (potrebbe essere necessario installare pwgen se non lo è già) crea un file che contiene 50.000 password lunghe 80 caratteri utilizzando ogni carattere stampabile. Provalo senza reindirizzare al random.txt prima file per vedere che aspetto ha, quindi fallo una volta reindirizzando il flusso di dati di output al file.

$ pwgen -sy 80 50000 > random.txt

Considerando che ci sono così tante password, è molto probabile che alcune stringhe di caratteri in esse siano le stesse. Innanzitutto, cat il random.txt file, quindi usa il grep comando per individuare sullo schermo alcune brevi stringhe selezionate casualmente dalle ultime dieci password. Ho visto la parola "vedi" in una di quelle dieci password, quindi il mio comando era simile a questo:grep see random.txt , e puoi provarlo, ma dovresti anche scegliere alcune tue stringhe da controllare. Le stringhe brevi da due a quattro caratteri funzionano meglio.

$ grep see random.txt 

        R=p)'s/~0}wr~2(OqaL.S7DNyxlmO69`"12u]h@rp[D2%3}1b87+>Vk,;4a0hX]d7see;1%9|wMp6Yl.

        bSM_mt_hPy|YZ1<TY/Hu5{g#mQ<u_(@8B5Vt?w%i-&C>NU@[;zV2-see)>(BSK~n5mmb9~h)yx{a&$_e

        cjR1QWZwEgl48[3i-(^x9D=v)seeYT2R#M:>wDh?Tn$]HZU7}j!7bIiIr^cI.DI)W0D"'[email protected]

        z=tXcjVv^G\nW`,y=bED]d|7%s6iYT^a^Bvsee:v\UmWT02|P|nq%A*;+Ng[$S%*s)-ls"dUfo|0P5+n

Riepilogo

È l'uso di pipe e reindirizzamento che consente molte delle attività straordinarie e potenti che possono essere eseguite con flussi di dati sulla riga di comando di Linux. Sono le pipe che trasportano i flussi di dati STDIO da un programma o file a un altro. La possibilità di convogliare flussi di dati attraverso uno o più programmi di trasformazione supporta la manipolazione potente e flessibile dei dati in tali flussi.

Ciascuno dei programmi in cantiere dimostrati negli esperimenti è piccolo e ognuno fa bene una cosa. Sono anche trasformatori; ovvero, prendono l'input standard, lo elaborano in qualche modo e quindi inviano il risultato allo standard output. L'implementazione di questi programmi come trasformatori per inviare flussi di dati elaborati dal proprio Standard Output allo Standard Input degli altri programmi è complementare e necessaria per l'implementazione di pipe come strumento Linux.

STDIO non è altro che flussi di dati. Questi dati possono essere quasi qualsiasi cosa dall'output di un comando per elencare i file in una directory o un flusso infinito di dati da un dispositivo speciale come /dev/urandom o anche un flusso che contiene tutti i dati grezzi da un disco rigido o una partizione.

Qualsiasi dispositivo su un computer Linux può essere trattato come un flusso di dati. Puoi usare strumenti ordinari come dd e cat per eseguire il dump dei dati da un dispositivo in un flusso di dati STDIO che può essere elaborato utilizzando altri normali strumenti Linux.