Sommario:

1- Introduzione

2- Iniziamo

2.1 Un semplice programma commentato

2.2 Esecuzione dei sorgenti .sh

3- Redirezioni e Pipe

4- Conclusione

4.1 Programma per ricapitolare


# INTRODUZIONE #

Eccoci qua al primo numero delle lezioni su bash scripting.
Io sto imparando questo linguaggio smanettando, leggendo
script fatti da altri ecc.
Non staro' qui a dirvi cos'è e cosa non è il bash scripting,
poichè spero che lo sappiate =)
Posso in ogni caso scrivere cazzate, quindi attenti ;)
Ho deciso di iniziare questo viaggio nel bash scripting,
perchè se no ValK mi ammazza :P
-- Siccome la cosa più comoda del bash è sfruttare in modo
-- dinamico altri prog/comandi, sara' anche utile (spero!)
-- leggere i tute per i newbie che si avvicinano al mondo
-- del pinguino :)

# INIZIAMO #

Non so' proprio da dove cominciare.. =)
Facciamo subito un banalissimo esempio..
Che commento:
A proposito tanto per dirvi, i commenti in Bash Scripting
si fanno antecedendo un cancelletto "#"
es. #Questo è un commento

----- Inizio codice -----
!/bin/sh 	#Come in altri linguaggi, con questa riga
		#richiamiamo con quale prog vogliamo eseguire
		#il codice (in questo caso il prog è la shell)
		#Altri es. #!/bin/bash ; #!/bin/zsh ecc...

echo "Resinaro r0x, Mojodo Project rulez"
		#Ragioniamo.. il bash scripting è comodo prorio
		#perchè una volta che noi stabiliamo quale
		#interprete usare per i nostri comandi, viene
		#naturale. In questo caso noi stampiamo sul
		#terminale la scritta. La stessa cosa sarebbe
		#successa aprendo un terminale e scrivendoci
		#il comando echo "........"

echo -n "Caricamento programma.. " #ancora una istruzione echo
		#però in questo caso abbiamo
		#messo anteposto -n che fa
		#stampare sullo schermo il
		#prossimo output, nella stessa riga.
		#Cmq vi rimando sempre ai man dei vari comandi
		#che uso. (man )
echo "Programma caricato"
tar zxvf file.tar.gz
		#con questo estraiamo il contenuto di file.tar.gz
		#mostrandone il suo contenuto
----- Fine -------

Facile no? è come se per ogni riga ci fosse il nostro terminale
pronto ad eseguire i nostri comandi. Ovviamente per i primi esempi
sembra + comodo farlo direttamente da bash, ma col tempo scopriremo
quante cose si posso fare, soprattutto su come "automatizzare"
delle operazioni un pò ripetitive..

Cmq per provare, salviamo il codice in un file .sh (es: prog.sh)
e se vogliamo testarne l'esattezza mettiamo un file tar.gz di nome
file nella cartella del file .sh
Possiamo eseguirlo in due modi:
1) $ sh pro.sh
2) $ chmod +x prog.sh 	#usiamo chmod per stabilire che il sorgente
			#può essere eseguito (+x)
   $ ./prog.sh		#Lo eseguiamo come un qualsiasi programma

Ok ora bene o male sappiamo la struttuare di un "programma".
Ora veniamo al succo del primo tute.

# REDIREZIONI E PIPE #

Eccoci agli "strumenti" a mio parere + fighi (lo diro' per tutte le
cose che spieghero' =)
Le redirezioni, sono come dice la parola stessa delle redirezioni
dell'output di un qualcosa vero qualcos'altro.
Ci sono vari tipi di redirezioni, li divido per categorie:
Stdout (Standard Output), StdIn (Standard Input) e StdErr (standard
error.. credo!)

*- Standard OutPut

Comoda funzione, permette di "redirezionare" l'output di un
comando/programma verso qualcosa, per es. un file.
(per rendere la cosa + comoda facci esempi di una sola riga così
da poter essere provati direttamente da terminale)

$ cat file.sh > file1.sh

con il carattere ">" ridirigiamo l'output del comando "cat file.txt"
nel file "file1.txt"
Faccio altri esempio per chiarire la cosa..

$ ls /* > hd.txt
$ grep testo index.html > testo.txt
		#cerca la parola "testo" in ogni riga di index.html
		#e manda il risultato al file testo.txt
$ls /* >> hd.txt
		#no.. non ho sbagliato a scrivere :P mettendo 2 ">"
		#la redirezione non sovrascrive il file, bensi
		#"aggiunge". Facendo un esempio pratico, se facciamo
		#due volte `echo "ciau" > ciao.txt`
		#il file ciao.txt conterra' soltanto UNA volta
		#"ciau", perchè ogni volta che facciamo il comando
		#il file viene sovrascritto,invece facciamo 2 volte
		#echo "ciau" >> ciao.txt
		#il file ciao.txt conterra' due volte (in due righe
		#diverse) "ciau"

*- Standard InPut
Opposto di StdOut, in poche parole, con il simbolo < facciamo si'
che l'imput di un comando che viene prima del <, corrisponde a
quello che è posto dopo al <
Esempi:

$ cat < file.txt
		#stessa cosa di "cat file.txt" in questo caso però,
		#prima richiamiamo il prog (cat) poi gli diamo
		#un imput (file.txt). Questo è un trucchetto molto
		#famoso, xchè se siamo su una shell non proprio
		#"nostra", eseguendo un ps aux, vedremmo soltanto
		#cat, e non per es. "cat /etc/shadow".

$ sort < "`ls -d */`"	#ecco un esempio un pò + complesso,
		#in questo caso io uso un comando, come imput di sort
		#chiarendo che sort è un programma che mette in ordine
		#alfabetico un certo input, la spiegazione è:
		#richiamo il programma, metto un < per inserire l'imput
		#poi ci faccio il comando, che andrebbe da ` ` (almeno
		#quando si stabilisce una variabile, ma nn parleremo
		#+ avanti) però smanettando ho visto che ci vogliono
		#anche i doppi apici (""). =) il comando "ls -d */"
		#mi da' come output tutte le cartelle presenti nella
		#cartella dove lanciamo il comando.

*- Standard Error (spero si chiamino così)

Con questa funzione possiamo "cuttare" soltanto quello che riguarda
l'errore (se prensente) nel "nostro output".
La sintassi è indentica a StdOut, soltanto che come simbolo di
redirezione dobbiamo mettere "2>" (senza doppi apici ovviamente)
Esempi (visto che parlo meglio in bash che in italiano =)):

$ make 2> make-error.txt
		#se per es. un programma nn si compila, e vogliamo
		#analizzare solo gli errori, bastera' cattare
		# make-error.txt per vederli. (tanto per fare un es.)

*- Pipe

Il pipe come spero sappiate, è il "|" (+shift). A mio parere tra le
varie redirezioni, questo è il più utile. è + che altro un "conduttore"
di dati, infatti l'output del comando che precede il pipe, viene usato
come input del comando che viene dopo..
Come al solito esempiamo:

$ cat ip.txt | grep 62.211
		#es. abbiamo una lista di ip e vogliamo vedere tutti
		#quelli che contengono "62.211". Per prima cosa mostriamo
		#il file ip.txt che diventera' l'input di grep, quindi
		#il file da "scansionare" alla ricerca di ogni riga
		#contenente "62.211", e proprio queste righe vengono
		#mostrate sullo schermo

$ cat ip.txt | grep 62.211 >> 62.211.txt
		#questo nn ve lo spiego ma credo che oramai siete
		#degli "esperti" in fatto di redirezioni.. ihihih..
*- Virtuosismi
Faccio un paio di esempi carini, tanto per incentivarvi ad usare la
fantasia.

$ tar zxvf file.tgz &> tar.txt
		#Scompattiamo un file tar.gz, facendone mostrare
		#ogni singolo file estratto, però direzionando
		#TUTTO (stderr e stdout) verso il file tar.txt
		#N.B. Potresti mettere come file /dev/null così
		#l'operazione nn avrebbe output
$ ls -d */ | sort >> dirsort.txt
		#non vi spiego neanche questo. =)

# CONCLUSIONE #

Ok.. abbiamo terminato. Vi lascio con un semplice programma
Veramente per ora nn volevo far nulla, visto che per fare una cosa
quantomeno decente bisogna conoscere i vari cicli e le variabili,
ma la prossima volta vedremo di fare di più.

------- ip.sh Cut Here -------
#!/bin/sh

echo "http://www.mojodo.it - Resinaro"
echo "Il modo più malato per vedere il proprio ip"
echo "Coded by ******** (mi vergogno..)"
echo "-------------------------------------------"
echo -n "Scarichiamo la pagina contenente l'ip.. "
wget http://www.putrella.com/ip.asp &> wget.out

echo "fatto.."
echo "Una serie di cut e grep per beccare il nostro IP.. "
cat ip.asp | grep "Il tuo indirizzo IP in questo
momento" | cut -d '>' -f2 | cut -d '<' -f1 > /tmp/.resi-ip
echo "-----------------------------"
echo -n "Il tuo attuale ip è: "
echo `cat /tmp/.resi-ip`
echo "-----------------------------"
echo -n "Rimozione del file che contiene l'ip e del file dello script "
rm -rf ip.asp
rm -rf wget.out
echo "Fatto."
echo "in caso ti scordassi il tuo ip lo potrai rivedere facendo:"
echo "cat /tmp/.resi-ip"
echo "----- EOF ------"

------- cut here -------

Apriamo un editor, incolliamo il sorgente, e rinominiamolo per es.
con ip.sh
Poi salviamo e da shell: $ sh ip.sh
SONO PROPRIO MALATOOOOOOOOOOOOOOOOOO!!!
Mi sono divertito a scrivere questo tute. W il Bash