Inserisci Infobox

Ambiente shell e scripting

L'ambiente shell e lo scripting: variabili d'ambiente, cicli, strutture base.

Lo zen e l'arte dell'automazione del sistema
Autore: al - Ultimo Aggiornamento: 2003-11-28 00:04:51 - Data di creazione: 2003-11-28 00:04:51
Tipo Infobox: DESCRIPTION - Skill: 1- NOVICE

Unix è un sistema operativo nato nei primi anni 70, grazie all'opera di monumenti dell'informatica quali Ken Thompson, Dennis Ritchie (l'inventore del C, per intenderci) e vari altri.

Uno dei motivi che rende Unix un sistema operativo attuale e perfettamente adattabile a sistemi che ai tempi non si concepivano neppure è la sua filosofia di base: KISS (Keep It Simple, Stupid).
E' il principio dei tanti piccoli mattoni, ognuno necessario per fare bene un compito specifico, messi insieme per fare compiti più complessi. Questo approccio facilita il troubleshooting, riduce i tempi di sviluppo, non dovendo "reinventare la ruota" ogni volta, , aumenta la possibilità di sviluppare un sistema in modo collaborativo distribuito e, evidentemente, permette una scalabilità e una adattabilità ineguagliate.

La shell è un interprete di comandi che funge sia da layer fra il kernel del sistema operativo e l'utente sia come linguaggio di programmazzione avanzato.
Un programma in shell è chiamato script e presenta un metodo facile e veloce per automatizzare operazioni ripetitive.
Conoscere lo shell scripting language e saperlo applicare per risolvere problemi di ordinaria e straordinaria amministrazione è una delle funzioni basilari del system administrator.

Saper scrivere uno script shell non è complicato, poichè la sintassi è semplice e la filosofia su cui bisogna basarsi nella realizzazione è la stessa dalla quale nasce unix: spezzare un progetto laborioso in tanti e semplici task.

Un bravo e produttivo sistemista Unix, quindi, è colui in grado di mettere insieme i mattoni che gli servono, creando script di "collante" che inglobano altri script con funzioni specifiche, magari pure scritti in linguaggi diversi.
E' colui che è pienamente consapevole che la macchina è al suo servizio e non viceversa, che ne può vedere e cambiare gli elementi con un semplice vi, che riesce a non ripetere due volte la stessa operazione, perchè la prima volta che l'ha fatto ha già creato uno script che lo fa per lui.

L'arte dell'automazione dei processi è strettamente legata alla conoscenza dalla bash (o della shell che si utilizza) e delle sue capacità di scripting.
I principi di massima per impratichirsi sono semplici:
- Avere obiettivi chiari, facendosi un percorso logico dei processi da effettuare;
- Guardare gli script esistenti scritti da altri, notare come vengono affrontati i problemi, come si usano le variabili e i cicli logici;
- Impratichirsi costantemente;
- Approfondire lo studio delle opzioni dei programmi che servono. Spesso risolvono molti problemi e aprono nuove prospettive sui risultati che si possono raggiungere.

Una distribuzione Linux o un sistema Unix è di fatto un insieme di script e comandi che vengono eseguiti al boot dopo il caricamento del kernel, ed è un'ottima fonte di apprendimento di tecniche di scripting e automazione.

Introduzione allo shell scripting
Autore: ask - ( Revisione: al ) - Ultimo Aggiornamento: 2003-11-27 23:54:29 - Data di creazione: 2003-11-27 23:54:29
Tipo Infobox: DESCRIPTION - Skill: 2- JUNIOR

La Shell è il programma di interfacciamento tra l'utente e il sistema operativo in grado di interpretare ed eseguire le richieste dell'utente.

La shell dispone di frasi proprie, di controllo di flusso, variabili, metacaratteri che combinati a comandi del sistema fa della shell un vero e proprio linguaggio di programmazione a comandi.
Quando ci si trova ad eseguire in modo ripetitivo comandi o sequenze di comandi abbastanza complesse è consigliabile scrivere tali comandi in un file ed esegulirlo ogni volta che occorre.
I file contenenti comandi shell si chiamano SCRIPT (procedure), per poter esser eseguiti questi file devono avere l'attributo di esecuzione (chmod +x file).

La selezione di quale shell (bash, csh, ksh) eseguirà lo script è indicata nella prima riga del file:
- nel caso la prima riga contiene solo il carattere # sarà eseguita la shell da cui è stato lanciato lo script;
- se contiene #!pathname viene utilizzata la shell indicata  (es: #!/bin/ksh)
- se non viene indicato nulla verrà interpretato da una Bourne Shell.

Per creare uno script shell quindi basta:
- Creare un nuovo file di testo con un editor come vi: vi prova;
- Iniziare il file con una riga che identifica l'interpreta da usare: #!/bin/bash
- Scrivere nelle righe successive i comandi e le istruzioni che si intendono eseguire nello script
- Salvare il file e renderlo eseguibile: chmod 755 prova
- Eseguire il file: ./prova.
NOTA: Se si edita un file su Windows o DOS fare attenzione ai caratteri speciali di fine riga che Windows introduce e che rendono impossibile l'esecuzione di uno script shell su Linux. Usare il comando dos2unix prova per converire i caratteri ESC di fine riga Windows (LF,CR) nell'analogo Unix (CR).

Redirezionamenti e pipe
Autore: al - Ultimo Aggiornamento: 2004-05-23 16:01:22 - Data di creazione: 2004-05-23 16:01:22
Tipo Infobox: DESCRIPTION - Skill: 2- JUNIOR

Fin dalle prime (ma non le primissime) versioni di Unix è stata introdotta nella shell la possibilità di redirezionare l'output di programmi (i dati che generano) ad altri programmi e di compiere analoghe operazioni con l'input e i messaggi di errore.
Questa possibilità, essendo valida per tutti i programmi e applicabile a tutti i file e oggetti del file system, permette una flessibilità enorme ed è particolarmente utile in script shell.

La shell gestisce la comunicazione con ogni programma lanciato tramite 3 file descrittori:
- standard input (stdin - file descriptor 0)
E' il canale attraverso il quale il programma riceve i dati di ingresso, generalmente la tastiera.
- standard output (stdout - file descriptor 1)
E' il canale di uscita del risultato dell'elaborazione del programma, di solito il video.
- standard error (stderr - file descriptor 2)
E' dove il programma stampa eventuali errori durante l'esecuzione, di solito il video.
Molti comandi UNIX assumono che l'ingresso dei dati avvenga (o possa avvenire) da standard input e l'uscita avvenga su standard output. E' possibile concatenare più programmi fra loro e fare in modo che lo standard output di uno diventi lo standard input di un altro. Per farlo si utilizza il carattere | chiamato pipe.
E' inoltre possibile redirezionare stdin, stdout e stderr su un file tramite gli operatori di redirezionamento:
> redirige lo standard output di un comando su un file o dispositivo
>> redirige l'output di un comando su un file o dispositivo ma se il file esiste già i dati vengono aggiunti alla fine del file. Se il file non esiste viene creato
< redirige lo standard input da un file o dispositivo
2> redirige lo standard error di un comando su un file o dispositivo
| operatore pipe, concatena standard output e standard input di due programmi

Le variabili d'ambiente e di shell
Autore: al - Ultimo Aggiornamento: 2003-11-27 23:53:41 - Data di creazione: 2003-11-27 23:53:41
Tipo Infobox: DESCRIPTION - Skill: 2- JUNIOR

La shell permette di definire mediante l'uso di variabili alcuni parametri che influenzano il comportamento dei programmi che vengono eseguiti.

Si usa distinguere fra Variabili d'ambiente, generalmente indicate in MAIUSCOLO, che vengono passate ad ogni programma eseguito dalla shell e quindi costituiscono di fatto la definizione di un una serie di parametri globali, e variabili locali, che vengono create ed utilizzate  solo all'interno di un programma (che può essere anche uno script shell) e che generalmente si indicano in minuscolo.
Di solito basta esportare una variabile locale per farla diventare d'ambiente.
Si identifica una variabile con il simbolo $.

Le variabili d'ambiente più importanti sono:
HOME  il valore di questa variabile è quella della home-directory dell'utente
PATH  l'elenco delle directory dove la shell, dopo l'inserimento di un comando, cerca il programma da eseguire
DISPLAY  definisce lo schermo sul quale un programma X-Window aprirà le proprie finestre  
TERM  definisce le sequenze di comandi che saranno usate per comandare il terminale che si sta usando.
Con il comando printenv o env vengono visualizzate le variabili d'ambiente della propria shell.

Customizzare il proprio ambiente shell
Autore: al - Ultimo Aggiornamento: 2003-11-27 23:44:20 - Data di creazione: 2003-11-27 23:44:20
Tipo Infobox: TIPS - Skill: 3- INTERMEDIATE

Tramite gli script di inizializzazione è possibile customizzare l'ambiente shell in cui si lavora, modificando e impostando i valori di variabili d'ambiente (valide per ogni processo gestito dall'utente) o di variabili locali (valide solo la shell corrente).

Le variabili d'ambiente più comuni sono:
LOGNAME La login dell'utente. Viene impostata al login.
USER L'utente corrente. Può essere diverso da LOGNAME se l'utente ha fatto un 'su'.
HOME Il path dell'home directory dell'utente. Viene impostata al login.
SHELL Il path della shell di default. Viene impostata al login.
PATH I path di default in cui la shell cerca comandi da eseguire. Viene impostata al login.
MAIL Il path della casella postale dell'utente. Viene impostata al login.
TERM Il tipo di terminale corrente.
PWD La directory di lavoro corrente.
PS1 Il prompt della shell (per Bourne e Korn shell)
prompt Il prompt della shell (per la C shell)
EDITOR Il text editor di default (usato nella shell e in comandi quali crontab -e)
DISPLAY Dove viene visualizzato il Display di un X server

Per impostare o modificare una variabile d'ambiente ci sono diversi metodi a seconda della shell utilizzata:
Bourne, Bash e Korn Shell: VARIABILE=valore ; export VARIABILE. Per esempio: PS1='[email protected]$HOSTNAME ! $' ; export PS1. Oppure, in forma ridotta: export VARIABILE=valore
C Shell: setenv variabile valore. Per esempio: setenv prompt "\! 'uname -n' % "

Strutture di controllo nella shell
Autore: ask - ( Revisione: al ) - Ultimo Aggiornamento: 2003-11-28 00:00:09 - Data di creazione: 2003-11-28 00:00:09
Tipo Infobox: DESCRIPTION - Skill: 3- INTERMEDIATE

Come ogni linguaggio di programmazione anche la shell ha delle strutture di controllo, la cui logica e sintassi è simile a quelle comuni in altri linguaggi come il C.

IF THEN ELIF ELSE
if cmd1 -  Se l'ultimo comando in cmd1 è terminato con successo
    then
cmd2 - I comandi cmd2 vengono eseguiti
elif
    cmd3 - Altrimenti se l'ultimo comando in cmd3 è terminato con successo  
then
    cmd4 - Vengono eseguiti i cmd4
else
    cmd5 - Altrimenti, se ne cmd1 ne cmd3 sono soddisfatti, vengono eseguiti i cmd5
fi

FOR IN DO DONE
for cmds - Cmds viene eseguito tante volte quanti sono
[in  a b c...]    - i valori in a b c. Ad ogni ciclo il valore di vars cambia
do - a seconda del corrispettivo valore a b c....
    cmds
done

WHILE DO DONE
while cmds1 - Esegue cmd1 e se i comandi terminano con valore logico vero
do
    cmds2 - Esegue cmd2 fino a quando cmd1 termina con valore logico falso
done

UNTIL DO DONE
until cmd1 - Esegue cmd1 e se i comandi terminano con valore logico falso
do
    cmd2 - Esegue cmd2 fino a quando cmd1 termina con valore logico vero
done

CASE IN ESAC
case vars in - Viene effettuato un confronto tra vars
    match1) list1 ;; - e le match1.. finchè non trova il
    match2) list2 ;; - corrispettivo valore
    match3) list3 ;;
    ...
esac

Inizializzazione della bash
Autore: al - Ultimo Aggiornamento: 2003-11-27 23:50:56 - Data di creazione: 2003-11-27 23:50:56
Tipo Infobox: DESCRIPTION - Skill: 3- INTERMEDIATE

Una delle caratteristiche della filosofia di Unix è che l'impostazione del sistema non vuole prevedere tutte le necessità dell'utente, ma tenta di rendere semplice per ciascuno modificarsi l'ambiente a seconda delle proprie necessità.
Ogni shell prevede uno o più "file di configurazione" che viene processato ogni volta che viene invocata. Di fatto, gli script di inizializzazione di una shell, sono normali script che si eseguono all'avvio delle shell stessa.

Questi file di configurazione sono noti anche come "file init", "file rc"" (per "run control", controllo dell'esecuzione) o anche "file punto", perché il loro nome di solito inizia con ".".
La shell di default di Linux è la bash.
I file di configurazione della bash di default sono:
/etc/bashrc: Contiene gli alias e le funzioni valide per l'intero sistema;
/etc/profile: Contiene le variabili d'ambiente per l'intero sistema e i programmi di avvio;
$HOME/.bashrc: Contiene gli alias e le funzioni dell'utente;
$HOME/.bash_profile: Contiene le variabili d'ambiente e i programmi di avvio dell'utente;
$HOME/.inputrc: Contiene definizioni di tasti e altre funzioni.

Per personalizzare il proprio ambiente bash è necessario modificare il file $HOME/.bashrc.
E' possibile creare alias per comandi che vengono usati spesso (alias "alias"= "comando") o modificare il prompt utilizzando il linguaggio bash o eseguire determinati programmi all'avvio della shell ecc.

Oltre agli script eseguiti al login, la shell può eseguire uno script al momento del logout da parte dell'utente.
Per la bash, questo script, se esiste, è : $HOME/.bash_logout

Gli script di inizializzazione su shell diverse
Autore: al - Ultimo Aggiornamento: 2002-09-12 13:21:41 - Data di creazione: 2002-09-12 13:21:41
Tipo Infobox: ETCETERA - Skill: 3- INTERMEDIATE

I file di inizializzazione possono variare su Shell e sistemi operativi diversi.
Qui si analizzano quelli di tutte le shell disponibili su Solaris. In genere sono validi per tutti i dialetti Unix.

BOURNE SHELL
File di inizializzazione globali:/etc/profile
File eseguiti al login dell'utente: $HOME/.profile
File eseguiti all'apertura della shell dopo il login: --
PATH della shell: /bin/sh

KORN SHELL
File di inizializzazione globali:/etc/profile
File eseguiti al login dell'utente: $HOME/.profile - $HOME/.kshrc
File eseguiti all'apertura della shell dopo il login: $HOME/.kshrc
PATH della shell: /bin/ksh

C SHELL
File di inizializzazione globali:/etc/.login
File eseguiti al login dell'utente: $HOME/.cshrc
File eseguiti all'apertura della shell dopo il login: --
PATH della shell: /bin/csh

Z SHELL
File di inizializzazione globali:/etc/zshenv - /etc/zprofile - /etc/zshrc - /etc/zlogin
File eseguiti al login dell'utente: $HOME/.zshenv - $HOME/.zprofile - $HOME/.zlogin
File eseguiti all'apertura della shell dopo il login: $HOME/.zshrc
PATH della shell: /bin/zsh

BASH
File di inizializzazione globali:/etc/profile
File eseguiti al login dell'utente: $HOME/.bash_profile - $HOME/.bash_login - $HOME/.profile
File eseguiti all'apertura della shell dopo il login: $HOME/.bashrc
PATH della shell: /bin/bash

TC
File di inizializzazione globali:/etc/csh.cshrc - /etc/csh.login
File eseguiti al login dell'utente: $HOME/.tcshrc o $HOME/.cshrc
File eseguiti all'apertura della shell dopo il login: --
PATH della shell: /bin/tcsh

Exit & Exit Status
Autore: homer - Ultimo Aggiornamento: 2003-11-28 00:07:50 - Data di creazione: 2003-11-28 00:07:50
Tipo Infobox: DESCRIPTION - Skill: 4- ADVANCED

Il comando EXIT può essere utilizzato per terminare uno script Bash, ed in modo simile ad un linguaggio di programmazione può restituire un valore chiamato Exit Status.

EXIT, permette di terminare arbitrariamente uno script. In particolare, ogni comando ritorna un Exit Status con valore 0 quando termina con successo e un valore diverso da 0 quando si verifica un errore.

Anche le funzioni all'interno di uno script o lo script stesso possono ritornare un Exit Status il quale è determinato dall'ultimo comando eseguito dalla funzione o dallo script.

E' possibile controllare lo stato di uscita dell'ultimo comando eseguito tramite la variabile $?. Terminato uno script è possibile verificarne lo stato di uscita con echo $?.

Per far ritornare un valore personalizzato da restituire alla Shell è possibile utilizzare EXIT nnn, dove nnn è un numero compreso tra 0 e 255. Alcuni Exit Status hanno un valore riservato ed è quindi consigliato non utilizzarli per non confondersi in fase di troubleshooting:

- 1: Errore Generico
- 2: Errato utilizzo delle shell builtins
- 126: quando il comando non può essere eseguito
- 127: quando il comando non viene trovato
- 128: quando viene fornito un argomento errato a EXIT
- 128+n: quando il comando viene terminato da un segnale di interruzione. 128 +n sta a significare il valore 128 + il valore del segnale che lo ha interrotto.
- 130: quando lo script è terminato da Control-C
- 255: quando l'exit status è fuori dai limiti consentiti (0-255)

Se EXIT è chiamato senza parametri il suo valore è quello dell'ultimo comando eseguito.

Invio non interattivo di mail da shell
Autore: homer - ( Revisione: al ) - Ultimo Aggiornamento: 2004-11-12 17:48:12 - Data di creazione: 2004-11-12 17:48:12
Tipo Infobox: TIPS - Skill: 2- JUNIOR

Tramite il comando mail è possibile invare in modo non interattivo, tipicamente da uno script shell, una messaggio di posta elettronica.

Nel caso intervenga la necessità di inviare una email, in seguito ad un controllo eseguito per esempio da uno script, è possibile farlo utilizzando una particolare sintassi del comando mail: mail -s [oggetto] [destinatario] < file .
Esempio:
[email protected]:/script# cat /script/check.sh
#!/bin/bash
if [ ! -e /disco2/backup/joker/backup.tar.gz ]; then
        mail -s "Joker Backup Control" homer < "/script/testomail.txt"
fi

In questo caso lo script, che potrebbe essere per esempio lanciato a crontab, verifica l'esistenza del file backup.tar.gz, ed in caso contario, invia una mail all'utente homer con il testo contenunto in testomail.txt

Tramite le opzioni -c e -b è possibile rispettivamente inviare la mail in copia o in copia nascosta anche ad altri destinatari.
Ovviamente è possibile usare mail anche direttamente da shell in modalità interattiva, ad esempio con: df -k | mail -s "Spazio su Disco" [email protected] si invia un messaggio con l'output del comando df -k all'indirizzo specificato.

Usare Bash in modalità "vi"
Autore: Dave - Ultimo Aggiornamento: 2004-04-28 21:24:22 - Data di creazione: 2004-04-28 21:24:22
Tipo Infobox: TIPS - Skill: 3- INTERMEDIATE

Tutti gli utenti Linux/unix conoscono ( o dovrebbero conoscere ) l'editor di testo più usato nel mondo Unix, VI.
Quando si utilizza la shell Bash (ma anche altre come la Korn), si può modificare il tipo di interazione con la linea di comando facendo si che quest'ultima 'comprenda' i comandi classici di VI.
Questo è molto utile quando le frecce per lo spostamento non funzionano (ad esempio per terminali/server vecchi)  e occorre richiamare e modificare i comandi dall'history.

Per fare questo è necessario avviare la shell con l'opzione "-o vi"
#> bash -o vi
oppure una volta nella shell, digitare "set -o vi" :
#> set -o vi

Questo consente ad esempio di usare i comandi VI quali :
$ : vai alla fine della riga
0 : vai all'inizio della riga
r : sostituisci 1 carattere
cw : sostituisci 1 parola
c$ : sostituisci dal cursore al fine riga
. : ripeti ultimo comando

Suse 9: Shell initialization
Autore: al - Ultimo Aggiornamento: 2005-02-11 23:43:10 - Data di creazione: 2004-01-06 16:45:42
Tipo Infobox: DISTRO - Skill: 4- ADVANCED

The initialization scripts of the shells in SuSE Professional 9have functions and login similar to the ones of other Linux distros and Unix flavours.
Let's analyze them.

/etc/profile (every shell)
Is the common init script for every shell. It sets a number of environment variables system settings. It's generally not a good idea to modify it, since there are various other dedicated files for custom settings. It:
- Checks the shell by which is invoked (this file is common to every shell) and assigns the shell's name to the is variable.
- Sets $TERM=linux and other terminal parameters with stty and tset
- Sets umask = 022
- Sets and exports the environment variables: HOST CPU HOSTNAME HOSTTYPE OSTYEP MACHTYPE
- Sets some ulimits: disactivates core file dumps and provides (commented) some default settings for maximum data, stack and RSS sizes of processes.
- Sets and exports the default PATH (PATH=/usr/local/bin:/usr/bin:/usr/X11R6/bin:/bin, to which are added sbin directories only for UID 0 (root). It also checks the existence of various directories and adds them to the PATH f they exist: $HOME/bin $HOME/bin/$CPU /var/lib/dosemu /usr/games /opt/bin /opt/gnome/bin /opt/kde3/bin /opt/kde2/bin /opt/kde/bin /usr/openwin/bin /opt/cross/bin
- Sets and exports INPUTRC=$HOME/.inputrc OR, if doesn't exist a .inputrc file in the user's home, INPUTRC=/etc/inputrc.
- Sets and exports HISTSIZE=1000
- Sets and exports TEXINPUTS for Tex/Latex
- Sets and exports variables for the default pages (less): LESSOPEN LESSCLOSE LESS LESSKEY PAGER LESS_ADVANCED_PREPROCESSOR
- Sets and exports MINICOM="-c on"
- Sets and exports MANPATH
- Sets and exports INFOPATH INFODIR (they are equal: /usr/local/info:/usr/share/info:/usr/info
- Sets and exports XKEYSYMDB XNLSPATH (for old motif applications)
- If /etc/nntpserver exists sets and exports NNTPSERVER
- If /etc/organization exists sets and exports ORGANIZATION
- Sets and exports COLORTERM=1 (used by mc)
- Checks if there exist scripts in the /etc/profile.d directory and executes them if they end with .sh.
- Checks if /etc/SuSEconfig/profile exists and executes it (this script is generated by Yast and shouldn't be edited directly)
- (This option is commented by default) Checks if /etc/profile.dos exists and executes it (this script adds  an alias for various typical DOS commands giving an explanation of their alternatives in the Unix world). For Windows users it can be useful to uncomment this.
- Checks if /etc/profile.local exists and executes it (this file doesn't exist by default and can be used for customization)
- Checks if /etc/bash.bashrc and $HOME/.bashrc exist and executes them (only if the shell is bash).
- Checks if /etc/ksh.kshrc and $HOME/.kshrc exist and executes them (only if the shell is ksh).

/etc/inputrc (And $HOME/.inputrc for custom codes)
Sets the key bindings for various terminals (linux, xterm, gnome, kvt) for the readline library that handles user's inputs in an interactive shell.

/etc/profile.d/ (every shell)
In this directory SuSE places various scripts for different programs and adds different suffixes for different shells. Here you find scripts like alias.ash (simulates the alias function under ash), mc.csh mc.sh (used by mc under sh and csh), cvs.sh (sets up environment variables for cvs).
In this way every single package can easily install its own init scripts adapted to different shells (the ones with suffix .sh are always run, the others run only with the relevant shell).

/etc/SuSEconfig/profile
This file sets some important environment variables according to what is configured under /etc/sysconfig and should not be edited manually:
- Sets and exports LANG QTDIR WINDOWMANAGER

/etc/bash.bashrc (every shell)
Despite its name, this script is sourced by every shell in SuSE 9 and does various things:
- Sets the dircolors according to the master configuration file /etc/DIR_COLORS and exports LS_COLORS LS_OPTIONS. If you want to customize your listing colors you can override its settings with the file $HOME/.dir_colors
- Sets the prompt format (PS1) for various shells and some aliases.
- If it exists, executes /etc/bash.bashrc.local (by default is null and can be used by custom general settings)

$HOME/.bashrc (bash only)
This can be changed by every user and, in SuSE9, is always executed with the bash shell (other Unixes use this only in interactive shels). By default it:
- esecutes /etc/profile.dos with some aliases useful for DOS users;
- executes $HOME/.alias if it exists, for custom alias definitions.
It has also various (commented) settings, for exporting PILOTRATE PILOTPORT EDITOR

$HOME/.profile (every shell)
This is custom for every user and is executed in every login shell. The default file (stored in /etc/skel for replication in the home of every new user) is entirely commented and has already set few fuctions to uncomment: exporting for a custom, local LANG and activation of fortune at the login (by default is disabled).

Alias e .profile
Autore: Jediblack - Ultimo Aggiornamento: 2004-05-23 15:37:21 - Data di creazione: 2004-05-23 15:37:21
Tipo Infobox: TIPS - Skill: 2- JUNIOR

Bash mette a disposizione due comandi interni molto interessanti: alias e unalias. Il primo dà la possibilità all'utente di rinominare un comando od uno script, mentre il secondo cancella un alias creato in questo modo.

Proviamo a digitare il comando alias. Ciò che appare a schermo potrebbe assomigliare a quanto segue:
alias d='dir'
alias dir='/usr/bin/ls $LS_OPTIONS --format=vertical'
alias emacs='emacs-21.3-no-x11'
alias halt='su -c halt'
alias la='ls -la'
alias lh='ls -lh'
alias ll='ls -l'
alias ls='/usr/bin/ls $LS_OPTIONS'
alias mc='. /usr/share/mc/bin/mc-wrapper.sh'
alias reboot='su -c reboot'
alias v='vdir'
alias vdir='/usr/bin/ls $LS_OPTIONS --format=long'

Quello che viene mostrato è la lista degli alias attivi. Attenzione che questa lista potrebbe cambiare da utente ad utente e da distribuzione a distribuzione.

Vediamo come definire nostri alias. La sintassi del comando è particolarmente semplice ed assomiglia in tutto e per tutto alla definizione di variabili d'ambiente.
alias nomeAlias='comando + opzioni'

Tuttavia bisogna porre attenzione a due dettagli. Quando si digita un comando al prompt della Bash, quest'ultima come prima cosa scandisce la lista degli alias e, se trova una corrispondenza, la esegue. Significa che se ho intrapreso una decisione del tipo alias ls='clear', ogni volta che chiedo la lista delle directory mi ritrovo lo schermo pulito.
Un secondo dettaglio è che gli alias creati in questo modo vengono persi nel momento in cui eseguiamo il logout. Risulta quindi utile salvare gli alias che vengono usati più frequentemente nel file .profile nella propria home directory. In questo modo vengono ridefiniti tutte le volte che eseguiamo il login.

Modificare nomi dei file in una directory con sed
Autore: aenigma - Ultimo Aggiornamento: 2004-03-23 21:51:28 - Data di creazione: 2004-03-23 21:51:28
Tipo Infobox: TIPS - Skill: 2- JUNIOR

Dopo aver scaricato file con wget ho avuto la sorpresa di aver lasciato il carattere %20 all'interno dei nomi dei file...

Dopo aver scaricato una serie di file con WGET da un file indice, mi son ritrovato con circa 1500 file che all'interno del loro nome avevano la sequenza %20 (quella dello spazio).
Dovevo toglierla in modo semplice e veloce, e prendendo spunto da un tips & trick trovato su una rivista, con le oppurtune modifiche ho risolto la cosa in una sola riga di codice.

for i in * ; do [ -f $i ] && mv -i $i `echo $i | sed -r s/%20/_/g`; done

Con un unico ciclo e il comando sed ho rimosso la sequenza '%20' dai nomi di tutti i file nella direcotry sostituendola con il carattere '_' (undescore).

Ovviamente potete sbizzarrirvi nel modificare il comando per fare altri tipi di modifiche grazie a sed e alle regexp che potete scrivere.

Unicode UTF-8 e problemi di visualizzazione e uso di script Perl con RedHat
Autore: al - Ultimo Aggiornamento: 2003-11-28 00:12:40 - Data di creazione: 2003-11-28 00:12:40
Tipo Infobox: TIPS - Skill: 3- INTERMEDIATE

Da RedHat 8 in poi si possono incontrare vari problemi nella visualizzazione di certi caratteri (un esempio tipico è la sostituzione del trattino "-" con il carattere "â") nei momenti e nelle forme più disparate: quando si configura il kernel con make menuconfig, quando si usa man in un collegamento remoto ecc.
Altri problemi si possono avere nell'utilizzo di programmi e script generalmente in Perl.

Il motivo è la criticata ma lungimirante decisione di RedHat di utilizzare l'encoding UTF-8 per supportare caratteri Unicode e quindi per gestire diverse lingue e diversi caratteri (in pratica ogni idioma possibile, inclusi Klingoniano e Lingua Morta di Tolkien).
Questo viene fatto aggiungendo, nella variabile d'ambiente LANG, la scritta  UTF-8 dopo la lingua utilizzata sul sistema.
Per bypassare il problema si può rimuovere il supporto Unicode UTF-8. Su server o sistemi in lingua inglese questo non dovrebbe comportare alcun problema. Lo stesso non si può certo dire per sistemi in Giapponese, Cirillico e in genere con caratteri non latini.
Questo è quanto risulta su un RedHat 8 di default:
[[email protected] root]# printenv LANG
en_US.UTF-8


Per rimuovere il supporto UTF-8 scrivere:
export LANG=us_US

Oppure modificare direttamente il file di configurazione RedHat dove viene impostata questa variabile d'ambiente:
/etc/sysconfig/i18n

Attenzione però, l'uso dell'encoding UTF-8 è destinato ad essere sempre più diffuso nelle distribuzioni Linux, visto che facilita enormemente l'internazionalizzazione e la gestione di lingue diverse, per cui è solo questione di tempo prima che vi siano allineati i programmatori dei vari software GPL comunemente utilizzati su Linux.

Privacy Policy