IMPORTANT: Per accedir als fitxer de subversion: http://acacha.org/svn (sense password). Poc a poc s'aniran migrant els enllaços. Encara però funciona el subversion de la farga però no se sap fins quan... (usuari: prova i la paraula de pas 123456)

Linux Professional Institute Certificate. LPIC-1

Lpic1 large.gif
Certificat LPIC-1
Examen: 101 (torneu a la resta de temes)
Fitxers: LPI103.4_UtilitzarFluxosCanonadesIRedireccionaments.pdf (LPI103.4_UtilitzarFluxosCanonadesIRedireccionaments.odp)
Objectius: http://www.lpi.org/eng/certification/the_lpic_program/lpic_1/exam_101_detailed_objectives
Dipòsit SVN: https://svn.projectes.lafarga.cat/svn/lpi/Materials/Examen_101/103.4
Usuari: anonymous
Paraula de pas: qualsevol paraula de pas

Objectius del tema

103.4. Utilitzar fluxos, conductes i redireccions
Objective.jpg
  • Objectiu: Els candidats han de ser capaços de redirigir fluxos i connectar-los per tal de processar dades de text de forma eficient. Les tasques inclouen redirigir l'entrada, la sortida i l'error estàndard i l'ús de canonades (pipes) per tal d'enviar la sortida d'una ordre a l'entrada d'un altra ordre, utilitzant la sortida d'una ordre com a argument d'un altra ordre i enviar la sortida d'una ordre tant a un fitxer com a a la sortida estàndard.
  • Pes: 4
060317 Icon - Theory of Knowledge v01 pdc.jpg

Àrees Clau de Coneixement:

Icon list.jpg

La següent és una llista parcial de fitxers, termes i utilitats utilitzades:

Text-editor.svg

Apunts: LPI 103.4. Utilitzar fluxos, conductes i redireccions

Plantilla

Fluxos

El concepte de flux de dades (stream en anglès) és un concepte bàsic que cal dominar per tal de fer operacions complexes combinant ordres a la terminal.

La filosofia de Linux és disposar de petites eines que realitzen una sola tasca però molt bé. Per tal de realitzar tasques 
complexes cal combinar l'ús de petites utilitats. En aquest sentit els fluxs de dades seran bàsics per tal de poder combinar ordres.

L'entrada i sortida d'un programa o ordre són tractats a Linux com flux de dades. Aquest flux de dades es poden manipular per tal d'adaptar-los a les nostres necessitats. Habitualment l'entrada per defecte és el teclat i la sortida per defecte és la pantalla (cal tenir en compte que realment parlem de terminal, que pot ser un emulador de terminal o una terminal virtual).

La potència del sistema prové però de la possibilitat de poder modificar els fluxs de dades estàndard i per exemple poder utilitzar com a entrada estàndard un fitxer, o un dispositiu de maquinari, el resultat d'un altre comanda, etc.

Tipus de flux de dades:

Hi ha 3 tipus principals, 1 d'entrada i 2 de sortida:

  • Entrada estàndard: També conegut com stdin o pel valor 0. És el flux d'entrada de les ordres i aplicacions. Habitualment és el teclat.
  • Sortida estàndard: També conegut com stdout o pel valor 1. És el flux de sortida de les ordres i aplicacions. Normalment és la terminal.
  • Error Estàndard: També conegut com stderr o pel valor 2. Linux proporciona un segon tipus de flux de dades de sortida. La idea és tenir una sortida per aquelles dades amb alta prioritat, com per exemple els missatges d'error. Pot ser molt útil a l'hora de enviar els missatges d'error a un altre lloc que no sigui la terminal (per exemple, un fitxer)
NOTA: cal tenir present que les aplicacions gràfiques d'usuari (GUI) funcionen una mica diferent pel que fa a la sortida estàndard.

Internament (com gairebé tot en Linux), els fluxs de dades són tractats com a fitxers (vegeu Programació_amb_fitxers), és a dir, s'obren, es llegeixen o s'escriuen i es tanquen els fitxers un cop acabada l'operació. Els fitxers de dispositiu es troben a la carpeta /dev, els de les entrades i sortides estàndard els podeu consultar amb:

$ ls -la /dev/std*
lrwxrwxrwx 1 root root 15 2009-09-27 14:54 /dev/stderr -> /proc/self/fd/2
lrwxrwxrwx 1 root root 15 2009-09-27 14:54 /dev/stdin -> /proc/self/fd/0
lrwxrwxrwx 1 root root 15 2009-09-27 14:54 /dev/stdout -> /proc/self/fd/1

Vegeu també:

Redireccions

Amb les redireccions podem modificar l'entrada o la sortida estàndard que utilitza una ordre o aplicació.

Per exemple, per tal de redireccionar la sortida d'una ordre cap a un fitxer (en comptes de cap a la terminal), podem executar:

$ echo Hola! > hola.txt

El resultat és que el fitxer hola.txt (sempre que tinguéssiu permisos per tal de realitzar l'operació) ara conté el text Hola!. Ho podeu comprovar amb:

$ cat hola.txt

A part de l'operador de redirecció ">", existeixen altres operadors de redirecció amb bash:

Operador Descripció
> Crea un nou fitxer contenint la sortida estàndard (no la d'error!) de la comanda executada. Atenció, si el fitxer existeix es sobreescrit (i es perden les dades existents). És equivalent a 1>.
>> Afegeix (append) un fitxer la sortida estàndard (no la estandard !). Si el fitxer no existeix es crea. Les noves dades s'afegeixen al final del fitxer i no s'eliminen les dades existents. És equivalent 1>>
2> Crea un nou fitxer contenint la sortida d'error estàndard de la comanda executada. Atenció, si el fitxer existeix es sobreescrit (i es perden les dades existents)
2>> Afegeix (append) a un fitxer la sortida d'error estàndard (no la d'error!). Si el fitxer no existeix es crea. Les noves dades s'afegeixen al final del fitxer i no s'eliminen les dades existents.
&> o >& o > fitxer 2>&1 Crea un nou fitxer contenint la sortida estàndard i la sortida d'error estàndard de la comanda executada. Atenció, si el fitxer existeix es sobreescrit (i es perden les dades existents)
&>> El mateix que l'anterior però afegint (append)
< Envia les dades del fitxer especificat a la dreta com a entrada estàndard de la comanda de l'esquerre.
<< Accepta el text de les següents línies com a entrada estàndard. També conegut com here document (heredoc)
<> El fitxer especificat a la dreta es tant la entrada estàndard com la sortida estàndard de la comanda de l'esquerre.
&> El fitxer especificat a la dreta es tant la entrada estàndard com la sortida estàndard de la comanda de l'esquerre.
1>&2 Redirecciona la sortida estàndard a l'error estàndard. Permet mostrar missatges d'error.

NOTA: per a asch consulteu http://www.lamfa.u-picardie.fr/asch/f/MeCS/courseware/users/help/general/unix/redirection.html

Podeu obtenir més informació al manual de bash:

$ man bash

a la secció REDIRECTION.

NOTA: un truc habitual es redireccionar alguna de les sortides estàndard cap al dispositiu especial /dev/null. Aquest dispositiu actua com un "forat negre" i tot el 
que es enviat a aquest dispositiu desapareix o és ignorat. Per exemple, per ignorar els errors:

2> /dev/null

Possiblement l'operador més complex és <<. Aquest operador normalment s'utilitza en guions de l'intèrpret d'ordres. Al utilitzar aquest operador cal indicar en quin moment s'acaba l'entrada de text. Per exemple:

<< EOF

Indica que introduirem text fins a trobar un final de fitxer (EOF--> End Of File) (o la combinació de tecles Ctrl+D). Aquest operador és coneix com heredoc (here document). Algunes comandes com write o wall l'utilitzen.

Vegem un exemple:

$ cat <<EOF
> Això és un document
> de múltiples línies
> un altre línia
> EOF
Això és un document
de múltiples línies
un altre línia

Però també podem utilitzar:

$ cat <<PROVA
> dsadsasadsad
> sadddsadsa
> dsadsadsa
> sdadsadsa
> PROVA
dsadsasadsad
sadddsadsa
dsadsadsa
sdadsadsa

També es pot utilitzar l'ordre tee com a eina per a fer redireccions.

Vegem alguns exemples de redireccions:

Enviar tot a enlloc:

$ grep -n -r "linux" / Prova &> /dev/null

on /dev/null és un dispositiu especial que és una espècie de forat negre.

Redireccionar només els errors:

$ grep -n -r "linux" / 2>/home/sergi/grep-errors.txt

Append:

$ ls >> file_list.txt

Ordenar un fitxer:

$ sort < file_list.txt

Ordenar un fitxer i guardar el resultat en un altre fitxer:

$ sort < file_list.txt > sorted_file_list.txt

Conductes

Els conductes són un mecanisme que permet enllaçar la sortida estàndard d'una ordre amb l'entrada estàndard d'una altra ordre. Dit d'una manera més simple, els conductes us permetran concatenar l'execució de diverses comandes. Aquest tipus de conductes s'anomenen conductes de dades. La sintaxi és:

$ comanda1 | comanda2 | comanda3 | comanda4 | ...

La barra vertical és el símbol utilitzat per indicar un conducte. Un dels exemples més habituals és utilitzar la comanda grep, per buscar una línia en la sortida d'una comanda. Per exemple, per saber si tenim instal·lat el paquet manpages, podem executar:

$ dpkg -l | grep manpages
ii  manpages                                   3.15-1                                    Manual pages about using a GNU/Linux system
...

Amb "distribucions rpm", una ordre equivalent seria:

$ rpm -aq | grep man-pages
man-pages-2.78-2.fc9.noarch
...

Cal tenir en compte que els conductes es podrien implementar utilitzant un fitxer intermediari i redireccions:

$ dpkg -l > intermediari.txt ; grep manpages < intermediari.txt
NOTA: L'operador ; us permet executar múltiples comandes en una mateixa línia

Vegem algunes exemples:

$ ps aml | sort -r -k 7 | less

Mostra els processos ordenats al revés segons la setena columna i ho mostra amb el pàginador less


$ ps axl | grep zombie 

Buscar processos zombies

$ cat fitxer | head
$ cat fitxer | tail

Mostren les 10 primeres i últimes línies del fitxer fitxer respectivament.

Consulteu el següents articles si voleu saber els detalls de com s'implementen els conductes amb crides de sistema i llenguatge C:

Conductes amb nom (named pipes)

En informàtica, un conducte amb nom (també conegut com FIFO - First In First Out - pel seu mode de funcionament) és una extensió del concepte tradicional de conducte (pipe) i s'utilitza en sistemes Unix-like com un mecanisme més de comunicació entre processos (IPC Inter Proces Communication).

Un conducte tradicional és "sense nom" per que existeix anònimament i nomé existeix mentrestant els processos existeixen. Un conducte amb nom, es creat pel sistema operatiu i persisteix més enllà del temps de vida dels processos que l'utilitzen.

Els conductes amb nom són un tipus de fitxer i es reconeixen per que que la sortida de l'ordre ls -l els marca com a fitxers de tipus p:

$ mkfifo prova
$ ls -l prova
prw-r--r-- 1 sergi sergi 0 2009-10-11 17:29 prova

Com podeu veure els conductes amb nom es poden crear amb les ordres mkfifo o mknod

Vegem un exemple d'ús, on podem crear un conducte on tot el que enviem a aquest conducte serà comprimit:

$ mkfifo conducte_comprimidor
$ gzip -9 -c < conducte_comprimidor > sortida.gz

En una altra terminal podem executar:

$ cat fitxer > conducte_comprimidor

Els conductes amb nom es poden esborrar com els fitxers normals amb l'ordre rm:

$ rm conducte_comprimidor

Un altre exemple és utilitzar un conducte per tal per tal d'enviar informació d'una aplicació a un altre sense la necessitat de crear un fitxer temporal:

$ mkfifo /tmp/namedPipe
chmod 0666 /tmp/namedPipe
gzip -d file.gz > /tmp/namedPipe

I per exemple, carregar les dades sense comprimir a una taula de Mysql:

LOAD DATA INFILE '/tmp/namedPipe' INTO TABLE tableName;

Recursos:

Comandes

tee

L'ordre tee divideix la sortida estàndard per tal que sigui mostrada per pantalla i guardada en tants fitxers com s'indiquin. Normalment s'utilitza conjuntament amb conductes (pipes) de la següent forma:

$ ls -la | tee ls.txt

Us mostrarà el resultat de la comanda ls -la i guardarà aquest resultat al fitxer ls.txt.

Es poden indicar més fitxers amb:

$ ls -la | tee ls.txt ls1.txt

Per defecte tee sobreescriu els fitxers que indiquem (elimini els continguts previs si el fitxer ja existia). Per evitar aquest comportament podeu utilitzar el paràmetre -a.

xargs

Segons el manual:

$ man xargs

Aquesta comanda permet construir arguments complexes de comandes. La millor forma d'entendre com funciona xargs és veure un exemple. Per exemple quan volem esborrar de forma massiva fitxers que compleixen amb un patró. Per exemple si volem esborrar tots els directoris .svn (vegeu subversion) de tots els directoris i subdirectoris d'un camí del sistema:

$ find . -type d -name ".svn" -print | xargs rm -rf 

La comanda find trobarà totes les carpetes anomenades .svn i les llistarà. Un exemple de sortida podria ser:

./ICE/2007-2008/ProgramacioLinux/svn-ubuntu-sala/svn/prova/.svn
./ICE/2007-2008/ProgramacioLinux/svn-ubuntu-sala/svn/cursplinux2/.svn
./ICE/2007-2008/ProgramacioLinux/svn-ubuntu-sala/svn/cursplinux/.svn
...

aleshores els resultat és equivalent a executar:

$ rm -rf ./ICE/2007-2008/ProgramacioLinux/svn-ubuntu-sala/svn/prova/.svn
$ rm -rf ./ICE/2007-2008/ProgramacioLinux/svn-ubuntu-sala/svn/cursplinux2/.svn
$ rm -rf ./ICE/2007-2008/ProgramacioLinux/svn-ubuntu-sala/svn/cursplinux/.svn
$ rm -rf ...

La comanda xargs té moltes possibilitats i moltes opcions. Per exemple, permet convertir una llista en comes en una llista separada per salts de línia:

$ echo "foo,bar,baz" | xargs -d, -L 1 echo 
foo
bar
baz

Recursos:

Vegeu també