Nel primo articolo di questa serie sono stati affrontati i comandi interni alla shell Bash che permettono di agevolare il proprio lavoro ed ottimizzarne le tempistiche di realizzazione.
In questa nuova puntata verranno trattati comandi di sistema, generalmente ignorati, richiamabili all’interno della shell Bash per la manipolazione degli stream di output e dei contenuti dei file.

Comandi per l’elaborazione degli stream di testo

Lo studio del contenuto dei file, dal filtro dei contenuti all’ordinamento di questi sono operazioni effettuate quotidianamente attraverso diffusissimi comandi come cat, grep e sort. Ma esiste un nutrito numero di comandi utilizzabili per l’elaborazione dei così detti “stream” di testo, eccone descritti alcuni.

tac

Il funzionamento di tac è quello dell’esatto opposto di cat. Esso infatti concatena e stampa il contenuto dei file in ordine inverso, partendo cioè dall’ultima riga. Supponendo di avere il seguente file di testo:

$ cat elenco
1
2
3
4
5
6

l’output generato da tac sarà il seguente:

$ tac elenco
6
5
4
3
2
1

tr

Il comando tr permette di modificare o cancellare caratteri da uno stream di input. Dato ad esempio il file contenente l’elenco precedente, sarà possibile ad esempio sostituire i caratteri newline (accapo) con il carattere “#”, utilizzando il comando in questa forma:

$ cat elenco_num | tr "\n" "#"
1#2#3#4#5#6#

L’opzione “-d” del comando consente di eliminare e non sostituire le occorrenze trovate, applicato al comando precedente, correggerebbe l’output come segue:

$ cat elenco | tr "\n" "#" | tr -d "#"
12345678910

tr permette di utilizzare anche specifici set di caratteri, senza che ne venga indicato uno specifico. Ad esempio dato il seguente file di testo:

$ cat elenco
A
B
C
D
E
F

è possibile convertire tutte le lettere maiuscole in minuscole attraverso l’utilizzo dei seguenti set:

$ cat elenco | tr "[:upper:]" "[:lower:]"
a
b
c
d
e
f

L’elenco completo dei set di caratteri utilizzabili si trova nella man page del comando.

nl

nl consente di numerare le righe proveniente da uno stream di input. La forma in cui la numerazione appare dipende dalle opzioni passate, senza alcuna opzione il comando numererà le righe con gli indici allineati a destra:

$ cat elenco | nl
     1	A
     2	B
     3	C
     4	D
     5	E
     6	F

è possibile specificare un formato diverso per l’indice di riga attraverso l’opzione “-n”, ad esempio per fare in modo che gli indici siano allineati a sinistra l’opzione da passare sarà “-n ln”, mentre per lasciare gli indici allineati a destra e fare in modo che gli spazi precedenti siano riempiti da zero l’opzione sarà “-n rz”.
E’ possibile specificare anche il carattere di separazione tra l’indice e la riga associata, che di default è tab, con un altro carattere attraverso l’opzione “-s”.
Ecco un esempio:

$ cat elenco | nl -n rz -s "#"
000001#A
000002#B
000003#C
000004#D
000005#E
000006#F

paste

Il comando paste permette di unire due file riga per riga. Nell’esempio più banale paste è utilizzato come segue:

$ paste elenco elenco_num 
A	1
B	2
C	3
D	4
E	5
F	6

ed anche per questo comando è possibile sostituire con l’opzione “-d” il carattere che separa le righe, di default sempre tab, con un carattere a scelta:

$ paste -d "#" elenco elenco_num
A#1
B#2
C#3
D#4
E#5
F#6

paste può essere utilizzato per operare anche su stream di input in modo da unire le righe prodotte ad un’elaborazione a quelle di un file:

$ tac elenco|paste - elenco
F	A
E	B
D	C
C	D
B	E
A	F

lo stream generato dal comando tac viene utilizzato da paste attraverso l’introduzione del carattere “-” per ottenere l’unione di tutte le righe del file con quelle dello stesso, ma contrapposte.

wc

wc effettua un conteggio e totalizza a seconda delle opzioni il numero di caratteri (“-m”), parole (“-w”), byte (“-c”) e linee (“-l”) di un file o di uno stream di input. Ad esempio per conoscere il numero di file nascosti presente in una directory, sarà sufficiente utilizzare il comando come segue:

$ ls .* | wc -l
681

Lanciato senza argomenti wc restituisce tre valori: il numero di linee, di parole e di byte. Ad esempio nel caso di un calcolo su due file il comportamento del comando sarà il seguente:

$ wc elenco elenco_num 
 6  6 12 elenco
 6  6 12 elenco_num
12 12 24 totale

tee

Il comando tee permette di redirigere l’output di un comando all’interno di un file e nel contempo stamparlo a video. Mentre la ridirezione classica effettuata attraverso il carattere “>” non permette di consultare istantaneamente l’output, attraverso tee è possibile osservare riproporre il flusso output del comando lanciato ed al contempo salvarlo in un file:

$ tac elenco | tee elenco_inv | wc -l
6

L’esempio dimostra la peculiarità del comando tee: lo stream di output viene registrato all’interno del file elenco_inv e passato al comando wc che ne calcola il numero di righe.

Conclusioni

Chiaramente ciascuno dei comandi illustrati possiede numerosi altri parametri che ne alterano il funzionamento, questi sono consultabili attraverso le man page sempre complete e prodighe di importanti informazioni. Scopo di questa serie di articoli rimane quello di fornire spunti dietro i quali approfondire.
Nel prossimo articolo verranno affrontati i comandi utilizzabili per la gestione delle code di stampa da linea di comando.

La linea di comando e più propriamente la console bash rappresentano lo strumento di cui ogni sistemista Linux non può fare a meno. Modificare file, elaborare contenuti ed operare sui processi sono parte del lavoro quotidiano di chiunque gestisca sistemi informatici più o meno ampi.
Interessante è capire come esistano moltissimi comandi a disposizione di un sistemista oltre a quelli comunemente usati che, per quanto ignorati, possono facilitare il lavoro quotidiano.
Questo primo articolo cerca di effettuare una panoramica ricca di esempi di come sia possibile utilizzare comandi incorporati della shell come set, declare, type e molti altri.

Comandi interni alla shell

La prima panoramica riguarda i comandi interni alla shell. Caratteristica di questi comandi è di non avere binari corrispondenti installati nel sistema (in directory come /bin, /sbin, /usr/bin e così via), infatti è l’ambiente erogato dall’eseguibile bash (a sua volta un binario installato nel sistema) a renderli disponibili.

set

Il comando set permette di modificare molti comportamenti e funzionalità della bash. Per abilitare una funzionalità si antepone all’opzione interessata un carattere “-”, viceversa per disabilitarla è sufficiente anteporre un carattere “+” all’opzione.
Lanciato senza parametri il programma restituisce le impostazioni generali della shell, comprensive di variabili e funzioni che si riferiscono all’ambiente.
Alcuni esempi di utilizzo di set:
Per fare in modo che le variabili create vengano automaticamente esportate è possibile attivare l’opzione “a”:

$ set -a
$ VARIABILE="VALORE"
$ bash
$ echo $VARIABILE
VALORE

Per fare in modo che i comandi lanciati all’interno del sistema siano stampati, sarà sufficiente attivare l’opzione “x”, prima dell’output di ogni comando successivo lanciato apparirà il comando effettivamente lanciato. Cosa questo significhi lo si capisce dal seguente listato:

rasca@anomalia:~$ set -x
++ echo -ne '\033]0;rasca@anomalia: ~\007'
rasca@anomalia:~$ ls
+ ls --color=auto
...
...

il comando lanciato è quindi in realtà un alias dello stesso con l’opzione “–color=auto”.

Le altre funzionalità relative al comando set si trovano nella voce omonima della man page del comando bash.

declare

Il comando declare è utilizzato per la dichiarazione delle variabili. Generalmente in bash una variabile viene dichiarata automaticamente con la sua definizione:

$ FOO=bar

dopodiché è utilizzabile con il nome $FOO. Il comando declare consente in fase di dichiarazione di specificare il tipo di variabile oltre che alcuni attributi inerenti al suo utilizzo.
Ad esempio, per dichiarare un array utilizzando il comando declare si utilizzerà l’opzione “-a”:

$ declare -a elementi=("primo" "secondo" "terzo")

mentre l’opzione “-i” dichiarerà una variabile di tipo integer:

$ declare -i numero=10

declare torna utile in fase di definizione anche per esportare automaticamente le variabili, attraverso l’opzione “-x”:

$ declare -x -i numero=10

questo comando ottiene lo stesso effetto di:

$ export numero=10

ma in più aggiunge anche la definizione del tipo. Infine, attraverso l’opzione “-r” è possibile rendere la variabile readonly, ossia non scrivibile all’interno della sessione.

NOTA: Le variabili di tipo array non sono esportabili a causa di un baco nella BASH (vedere la man page).

type

Il comando type può essere utilizzato per conoscere le caratteristiche relative agli argomenti passati. Attraverso l’opzione “-t” viene restituito il tipo di parametro passato:

$ type -t ls
alias
$ type -t /bin/ls
file
$ type -t echo
builtin
$ type -t set_prefix
function
$ type -t while  
keyword

E’ da notare la differenza tra “ls” e “/bin/ls”, rispettivamente un alias (relativo ad un file eseguibile) ed un file eseguibile. Ad un comando di tipo builtin non corrisponde necessariamente un file eseguibile, mentre le ultime due righe rappresentano rispettivamente una funzione disponibile nell’ambiente ed una parola chiave relativa al linguaggio bash.
Un’altra opzione supportata dal comando type è “-a” che indica tutte le corrispondenze al parametro passato. Ad esempio, relativamente ai comandi precedentemente esposti i risultati saranno i seguenti:

$ type -a echo
echo is a shell builtin
echo is /bin/echo
$ type -a ls  
ls is aliased to `ls --color=auto'
ls is /bin/ls
$ type -a set_prefix
set_prefix is a function
set_prefix () 
{ 
    [ -z ${prefix:-} ] || prefix=${cur%/*}/;
    [ -r ${prefix:-}CVS/Entries ] || prefix=""
}
$ type -a while     
while is a shell keyword

il comando echo viene indicato come interno e disponibile inoltre con l’eseguibile /bin/echo, lo stesso avviene per il comando ls per il quale viene indicata la definizione dell’alias oltre che il path del file effettivo. Infine la funzione set_prefix viene stampata nella sua interezza, mentre per while rimane l’indicazione di keyword.

exec

Il comando exec permette di lanciare un comando utilizzando il process ID (PID) della shell corrente. Questo significa che la shell verrà rimpiazzata dal comando, non generando un nuovo PID e comporta inoltre che il termine del comando corrisponderà con il termine della shell.
Ad esempio, se nell’ambiente grafico da una console viene lanciato il comando

$ exec xterm

alla chiusura della shell del programma xterm, anche la console verrà automaticamente chiusa.

jobs

Se il comando interno bg viene utilizzato per mandare un processo in background (cioè sullo sfondo del sistema e non in primo piano, mantenendone l’esecuzione) ed il comando interno fg viene utilizzato invece per mandare in foreground (quindi, in primo piano) un processo, il comando jobs permette di effettuare il listato dei processi e di conoscere informazioni relative a questi.
Supponendo di avere due script denominati script e script1 lanciati entrambi automaticamente in background attraverso il carattere speciale & alla fine dell’invocazione:

$ ./script &
[1] 28548
$ ./script1 &
[2] 29261

Sarà possibile conoscere lo stato dei processi in sospeso attraverso jobs:

$ jobs
[1]-  Running                 ./script &
[2]+  Running                 ./script1 &

Di questi attraverso l’opzione “-l” si potrà conoscere identificativo e PID:

$ jobs -l
[1]- 28548 Running                 ./script &
[2]+ 29261 Running                 ./script1 &

O solamente il PID:

$ jobs -p
28548
29261

Su tali processi sarà possibile effettuare operazioni di kill (considerando il PID):

$ kill 28548
$ 
[1]-  Terminated              ./script

Oppure operazioni di foregrounding/backgrounding, attraverso i già citati comandi interni fg e bg, considerando invece l’identificativo:

$ fg 2
./script1

Il tutto grazie ai dati resi disponibili dal comando interno jobs.

Conclusioni

I comandi interni alla bash illustrati e molti altri sono tutti ottimamente documentati all’interno della già citata man page della Bash ($ man bash), più propriamente nel capitolo “COMANDI INCORPORATI DELLA SHELL“.
Nella seconda parte di questo articolo verranno trattate utility di sistema come paste, tee, apropos e molte altre, generalmente poco utilizzate, ma di indubbio interesse.

Oggi mostriamo un utility che torna comoda quando si lavora in ambito aziendale, dove puo’ capitare di dover lavorare su una batteria di server che fanno tutti lo stesso lavoro, quindi un intervento su una macchina va replicato su tutte.
Ad esempio la modifica di un parametro di start di tomcat, piuttosto che dover deployare lo stesso war, o dover restartare a nastro gli apache.

Dopo aver usato konsole e cluster-ssh mi sono imbattuto in clusterm che a mio parere e’ superiore agli altri.

Features:
1 – Divide lo schermo in tante finestre quanti sono i server del “cluster” su cui lavorare (se si sceglie la visualizzazione “table”, altre configurazioni sono possibili).
2 – Per ogni finestra si puo’ decidere se e’ la finestra master (chiamata director) se e’ uno slave (actor) oppure se uscire dal “cluster” per lavorare in proprio.
3 – Crea i “launcher”: ovvero i file con le configurazioni dei vari cluster sono visti come icone cliccabili che lanciano gia’ l’applicativo che apre le n finestre del “cluster” in questione. Se usati frequentemente sono comodi da avere sul desktop.
4 – C’e’ l’opzione “highlight differences” che graficamente mostra le differenze tra la finestra director e gli actor. Molto comodo se si stanno editando files sulle macchine.
5 – Sotto gnome prende le impostazioni grafiche di default dello gnome-terminal.

L’installazione e’ non banalissima, soprattutto come sequenza: vediamo in dettaglio tutti i passi per una Ubuntu standard (testata su una 8.10 64bit), effettuata come utente non privilegiato.

1 – Scaricare lo zip che contiene i pacchetti e gli zip richiesti ai punti 3, 5 e 6
2 – Installazione dipendenze:

sudo apt-get install libgtk2-perl libextutils-depends-perl 
libextutils-pkgconfig-perl libglade2-dev libgnome2-perl 
libvte-dev libgtk2-gladexml-perl libsocket6-perl perl-doc

3 – Installazione libreria libnetpacket-perl_0.04-1_all che non e’ nei repository (ma nel nostro zip si):

sudo dpkg -i libnetpacket-perl_0.04-1_all.deb

4 – Installazione libreria libgnome2-gconf-perl:

sudo apt-get install libgnome2-gconf-perl

5 – Installazione pacchetto Gnome2-Vte-0.09.tar.gz (sempre nel nostro zip)
Scompattare Gnome2-Vte-0.09.tar.gz
Nella dir dove si e’ scompattato lanciare:

perl Makefile.PL
make
make test
sudo make install

6 – Installazione pacchetto dell’applicazione vero e proprio (finalmente!)
Scompattare clusterm-0.6.tar.bz2 (e’ sempre nello zip )
Nella dir dove si e’ scompattato dare:

make
sudo make install

Alla fine di tutto cio’ sotto il menu’ Application -> System Tools comparira’ l’icona di lancio del programma.

Una nota per i furbini che fanno tutto da root quando installano (io sono uno di quelli, solitamente): il make del punto 6 fallira’, perche’ non e’ l’utente con cui sta girando l’istanza di X attuale, quindi il make va lanciato per forza con l’utente corrente.

A questo punto l’interfaccia e’ molto intuitiva: una barra di menu’  dove si possono aggiungere gli host da: File -> New Host

Cio’ detto… il resto lo scoprirete usando il tool!

enjoy

Quante volte è capitato di eseguire un’operazione, magari per la prima volta, e dimenticarsi completamente di prendere appunti?

Lavorando in ambiente sistemistico, se questo avvenimento non è quotidiano, poco ci manca!

Ed in genere come risolviamo il problema? Le soluzioni sono due:

1. Scrolling del buffer del terminale: Alt+Pag.Up permettono di rileggere cosa si è fatto; il problema è che il buffer dei terminali è limitato (specialmente se si lavora in ambiente non grafico), e spesso alcune cose si perdono comunque;
2. Visione della history: I moderni terminali supportano la history, permettendo così di scorrere nei comandi lanciati e richiamarli velocemente; il problema è che anche visualizzando la history, non abbiamo l’output dei comandi che abbiamo lanciato.

Quello che servirebbe è un software che permetta di eseguire un logging completo (quindi sia dell’input che immettiamo che dell’output che viene generato).

Ci viene in aiuto script! Tanto semplice quanto funzionale.

Il modo più “pulito” per eseguire il comando è il seguente:

$ script
Script iniziato, il file è typescript
$

Come vedete pare che non sia successo nulla. Ed in effetti possiamo dimenticarci di aver lanciato il comando. Continuiamo pure con il nostro lavoro…

$ su -
Password:
# pwd
/root
# cd /etc/ssh/
# cat sshd_config | grep PermitRoot
PermitRootLogin yes
# sed -i -e "s/PermitRootLogin yes/PermitRootLogin no/" sshd_config
# cat sshd_config | grep PermitRoot
PermitRootLogin no
# /etc/init.d/ssh restart
* Restarting OpenBSD Secure Shell server sshd                           [ OK ]
# exit
logout
$

Semplicemente quando avremo finito la nostra sessione di lavoro, e lanceremo il consueto “exit“, avremo un output di questo tipo:

$ exit
exit
Script effettuato, il file è typescript

Ora, se dovessimo andare a rivedere la nostra sessione, magari per trasformarla in un howto od in un file da tenere sott’occhio quando tra 6 mesi ci verrà richiesto di fare la stessa cosa, possiamo vedere il contenuto del file “typescript” generato da script:

mcappadonna@laptop ~ $ cat typescript
Script iniziato su ven 16 gen 2009 12:08:38 CET
$ su -
Password:
# pwd
/root
# cd /etc/ssh/
# cat sshd_config | grep PermitRoot
PermitRootLogin yes
# sed -i -e "s/PermitRootLogin yes/PermitRootLogin no/" sshd_config
# cat sshd_config | grep PermitRoot
PermitRootLogin no
# /etc/init.d/ssh restart
* Restarting OpenBSD Secure Shell server sshd                          [ OK ]
# exit
logout
$ exit
exit
 
Script effettuato su ven 16 gen 2009 12:09:38 CET

Alcune opzioni comode di script sono le seguenti:

• -a : Appende l’output ad un file già presente;
• -q : Elimina dall’output i messaggi di script;
• -t : Aggiunge all’output l’indicazione dell’ora (utile per tenere un timestamp del lavoro)

Ovviamente, potete aggiungere a script l’indicazione del nome del file da salvare:

$ script sessioneDiProva.txt
Script iniziato, il file è sessioneDiProva.txt
$

Un’ultima cosa: se si dovesse avere la necessità di seguire in due utenti (remoti) la stessa sessione di shell ma non fosse possibile installare “screen” sulla macchina, una soluzione elegante può essere la seguente:

$ mkfifo temp; script -f temp

Il comando sembrerà appeso, ma nel momento in cui l’altro utente va ad eseguire un cat sul file, la sessione di script ha inizio e tutti vedono “live” la sessione di shell:

$ cat temp
Script iniziato su ven 16 gen 2009 12:16:28 CET
$

Comodo no?

Buon lavoro.