Dopo aver affrontato i comandi interni alla shell Bash ed i comandi di sistema richiamabili all’interno dalla stessa per la manipolazione degli stream di output e dei contenuti dei file in questo articolo verranno trattati i comandi per la gestione delle code di stampa.
Verranno illustrati i comandi per inviare un file direttamente alla stampante, analizzare la coda di stampa e rimuovere lavori in coda.

I comandi per operare sulle code di stampa nei sistemi Linux moderni sono forniti dal pacchetto del server di posta CUPS. CUPS fornisce un set di comandi retro compatibili al precedente gestore della posta Linux, LPD: questo significa che il nome degli stessi è stato mantenuto identico in modo da favorire l’integrazione di CUPS con i programmi che fanno riferimento a comandi di sistema come lpstat, lpq e così via.
Sebbene CUPS di default renda disponibile un’interfaccia web alla porta 631, alla quale si può accedere con il proprio browser, molte volte potrebbe essere necessario utilizzare la linea di comando per operare sulle code di stampa. I comandi che consentono tali operazioni si dividono in comandi che richiedono i permessi dell’utente root ed in comandi utilizzabili da utenti non privilegiati.

Informazioni sulle stampanti (utente root)

lpstat

Capire quali sono le code configurate all’interno del sistema è il primo passo per iniziare ad operare all’interno delle stesse.
Il comando lpstat consente di visualizzare diverse informazioni sulle stampanti installate all’interno del sistema, ad esempio attraverso l’opzione “-p” il comando restituisce l’elenco delle stampanti:

# lpstat -p
la stampante Brother-HL-4040CN è in attesa.  Abilitata da gio 19 nov 2009 18:23:32 CET
la stampante HPDeskJet9300 è in attesa. Abilitata da sab 21 nov 2009 18:15:58 CET
la stampante PDF è in attesa.  Abilitata da gio 19 nov 2009 17:29:14 CET

Un diverso elenco, contenente i riferimenti delle stampanti (socket, path remoti, etc.) è ottenibile attraverso l’opzione “-v”:

# lpstat -v
dispositivo per Brother-HL-4040CN: socket://192.168.1.13
dispositivo per HPDeskJet9300: smb://RASCA/RASCABOX/HPDeskjet9300
dispositivo per PDF: cups-pdf:/

E’ possibile inoltre identificare la coda di default verso cui vengono diretti i lavori in stampa (opzione “-d”):

# lpstat -d
destinazione predefinita di sistema: PDF

Tutte le informazioni illustrate sono ottenibili in un unico contatto attraverso l’opzione “-t”, mentre, lanciato senza argomenti, il comando restituisce l’elenco dei lavori in coda, ottenibile anche con i comandi illustrati di seguito.

Gestire la coda (utente root)

lpq

E’ possibile ottenere l’elenco dei lavori accodati nella stampante di default o di una specifica attraverso il comando lpq:

# lpq
PDF è pronta
Posiz.   Proprietario    Stampa   Doc.             Dim. totali
1st     rasca   298     Command-Line Printing and Optio 396288 byte

Nel caso si volessero conoscere i dettagli della coda relativa ad una stampante specifica, questa va specificata con l’opzione “-P”:

# lpq -P HPDeskJet9300
HPDeskJet9300 è pronta
nessuna voce

lprm

Per operare sulle code, rimuovendo lavori di cui si conosce l’identificativo (ottenuto attraverso lpq), è possibile utilizzare il comando lprm, indicando con l’opzione “-P” l’accoppiata coda/identificativo:

# lprm -P PDF/298

Inviare stampe (utente non privilegiato)

lpr

Se un utente comune volesse lanciare delle stampe da linea di comando, cosa molto utile in caso di lavori di sistema notturni, notifiche di problemi (o qualsiasi altro motivo per cui sia sensato utilizzare della carta!), il comando da utilizzare è lpr che stampa il contenuto di un file di testo passato come parametro:

$ lpr testfile

pr e fmt

lpr può essere utilizzato anche per dirigere l’output di un comando alla stampante. Ad esempio, utilizzando i comandi pr o fmt che formattano un file di testo per la stampa è possibile passare attraverso una pipe ad lpr la stampa da effettuare:

$ pr -a testfile | lpr

oppure

$ pr -a testfile | lpr

mpage

Lo stesso discorso si applica al comando mpage che consente di operare con maggior dettaglio sul formato di stampa. Lanciato senza argomenti, mpage produrrà una pagina divisa in quattro contenente il testo all’interno del file passato come parametro. Attraverso l’opzione “-b” è poi possibile specificare il formato della carta che verrà utilizzato dalla stampante (di default A4). Per conoscere i formati supportati è possibile utilizzare il parametro “-b” con l’aggiunta di un punto interrogativo:

$ mpage -b?
Mpage knows about the following paper types:
Type           Points Wide Points High
-------------- ----------- -----------
Letter                 612         792
LetterSmall            612         792
Tabloid                792        1224
Ledger                1224         792
Legal                  612        1008
Statement              396         612
Executive              540         720
A0                    2384        3368
A1                    1684        2384
A2                    1192        1684
A3                     842        1192
A4                     596         842
A4Small                595         842
A5                     420         595
B4                     729        1032
B5                     516         729
Folio                  612         936
Quarto                 610         780
10x14                  720        1008

Oltre all’utilizzo attraverso una pipe, mpage supporta anche la stampa diretta di file (anche in formato postscript), così come funziona lpr:

$ mpage -PPDF testfile

Numerose sono le opzioni disponibili per il comando mpage e sono tutte documentate nella man page del programma.

Conclusioni

Questa breve carrellata di comandi presenta alcune utili informazioni che potrebbero risultare vitali in situazioni (volute o meno) in cui non sia disponibile altro accesso al sistema che quello della linea di comando.
Approfondendo presso i link presentati qui sotto sarà possibile acquisire la padronanza totale del sistema di stampa da linea di comando.

Fonti di informazioni utili:

Pagina ufficiale del progetto CUPS: http://www.cups.org/documentation.php/options.html
The Linux Printing Usage HOWTO: http://tldp.org/HOWTO/Printing-Usage-HOWTO.html

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.