Versione delle 11:18, 12 mag 2010

Introduzione

Questo script visualizza alcune informazioni interessanti riguardanti i pacchetti Slackware installati e può essere usato per mantenere aggiornata una current. Lo script deve essere eseguito in una directory contenente il file FILE_LIST fornito dal CD/DVD.

Cosa fa e come si usa

Senza opzioni

Lo script, per ogni pacchetti installato va a controllare se è nominato nel file FILE_LIST controllandone la versione, dove per versione si intende sia la versione del software che la marca di compilazione. Se le due versioni differiscono allora lo script stampa a video il percorso dove poter trovare il pacchetto con la versione differente. Ad esempio sulla mia macchina:

$> analyze_SlackPkg.sh
./a/aaa_elflibs-13.013-x86_64-5.txz
./l/cairo-1.8.8-x86_64-3.txz
./n/stunnel-4.33-x86_64-1.txz

questo vuol dire che nella mia Slackware sono installati i tre pacchetti elencati ma con versioni differenti, infatti ad esempio:

$> ls /var/log/packages/stunnel-*
/var/log/packages/stunnel-4.17-x86_64-1

Quindi se si ha a disposizione un repository locale della current si può aggiornare il PC semplicemente eseguendo:

for package in $(analyze_SlackPkg.sh)
  do
    upgradepkg $package
  done

Le opzioni

-h

Mostra l'help dello script.

-n

Stampa l'elenco dei pacchetti nominati nel FILE_LIST, ma che non sono stati installati.

-m

Stampa l'elenco dei pacchetti che non sono stati trovati nel file FILE_LIST o che sono stati filtrati dal file di filtro. Questi pacchetti generalmente sono i pacchetti di terze parti (ad esempio quelli di Slacky.eu) ed i pacchetti che sono stati rimossi dalla Slackware.

-s

Stampa l'elenco dei pacchetti che hanno la stessa versione di quelli trovati nel file FILE_LIST.

-v

A volte è utile sapere la versione attuale dei pacchetti installati, questa opzione oltre a visualizzare il percorso del pacchetto con la versione diversa, stampa anche la versione attualmente installata.

$>analyze_SlackPkg.sh -v
./a/aaa_elflibs-13.013-x86_64-5.txz the current version is aaa_elflibs-13.013-x86_64-4
./l/cairo-1.8.8-x86_64-3.txz the current version is cairo-1.8.10-x86_64-1
./n/stunnel-4.33-x86_64-1.txz the current version is stunnel-4.17-x86_64-1

Il file di filtraggio

Può capitare che di alcuni software si voglia seguire una versione current e non quella fornita dalla Slackware, usando il ciclo for descritto precedentemente per aggiornare il PC evidentemente questi pacchetti risulteranno con una versione differente e saranno quindi aggiornati. Per evitare questo comportamento basta creare un file nella propria home chiamato .analyze_SlackPkg e inserirci al proprio interno il nome del software da saltare e quest'ultimo non sarà stampato in output. Ad esempio se inserisco nel mio file il software cairo e poi rieseguo lo script:

$> echo 'cairo' >> ~/.analyze_SlackPkg

$> analyze_SlackPkg.sh
./a/aaa_elflibs-13.013-x86_64-5.txz
./n/stunnel-4.33-x86_64-1.txz

si nota che rispetto a prima, cairo non viene visualizzato.

Lo script

Dulcis in fundo ecco lo script:

#!/bin/bash
#
# Ultimo aggiornamento: 12/05/2010
#
# Esegue un'analisi dei pacchetti installati sul PC a partire dal file FILE_LIST di un repository Slackware
#
# by Spina <spina80@gmail.com>

# -h per l'help

SCRIPT_NAME=${0##*/} # Nome dello script
SCRIPT_AUTHOR="Spina <spina80@gmail.com>" # Nome autore <email>

# Esce eliminando la directory temporanea
function _exit
{
    rm -r $TMP_DIR

    exit $1
}

# Stampa l'help dello script
function _help
{
    echo -e "Use: ${SCRIPT_NAME} [-h|-n|-m|-s|-v] [root_directory]\n\
For every package in ROOT_DIRECTORY/var/log/packages this script\n\
searches a corresponding package in the file ./FILE_LIST and\n\
prints out the name of the package on the standard output if it needs\n\
an upgrade (they have different version).\n\n\
OPTIONS:
   -h\tprint this help and exits\n\
   -n\tprint the name of packages not installed\n\
   -m\tprint the name of packages which are missing in ./FILE_LIST or\n\
     \tfiltered by ~/.analyze_SlackPkg file\n\
   -s\tprint the name of packages with same version\n\
   -v\tshow also current version of package\n\n\
ROOT_DIRECTORY is / by default, or the value of ROOT enviroment variable,\n\
or the value of root_directory passed in command line. If both variable ROOT\n\
and root_directory are set, root_directory is used.\n\n\
by ${SCRIPT_AUTHOR}"
}

# Controlla l'esistenza di tutti i programmi dati i loro nomi come argomento.
# Se un programma non viene trovato, allora, stampa il nome del o dei programmi mancanti ed esce.
# Si usa il programma which per controllare che esistono i programmi passati. Si assume che
# which sia in /bin/.
function _check_extern_program
{
    local error=0
    local string_error

    if [ ! -x /bin/which ]
    then
	error=1
	string_error="which : programma mancante.\n";
    else
	for progr in $@
	do
	    if [[ $(which $progr 2>/dev/null) == "" ]]
	    then
		let ++error
		string_error=${string_error}"${progr} : programma mancante.\n"
	    fi
	done
    fi

    if (( $error ))
    then
	if (( $error == 1 ))
	then
	    string_error=${string_error}"\nIl programma mancante è necessario "
	else
	    string_error=${string_error}"\nI programmi mancanti sono necessari "
	fi
	string_error=${string_error}"per la corretta esecuzione dello script."
	_exit "$string_error" 1
    fi
}

# Restituisce il nome del software di un pacchetto Slackware
#
# $1: il nome di un pacchetto Slackware
function _get_software_name
{
    echo $1 | sed 's/-[^-]\+-[^-]\+-[^-]\+$//'
}

# Controllo degli argomenti dello script in cerca di opzioni
enable getopts echo exit

# Impostazione del separatore di campi al valore di default
IFS=$'\n\t '

# Controllo dell'esistenza di tutti i programmi esterni ( quindi non comandi interni alla bash) usati
_check_extern_program bunzip2 grep mktemp rm sed tr

# Valori di default per le opzioni
FLAG_N=0   # Se = 1, stampa i pacchetti non installati
FLAG_M=0   # Se = 1, stampa i pacchetti che non sono trovati nel file FILE_LIST (es: pacchetti di terze parti)
FLAG_S=0   # Se = 1, stampa i pacchetti che non necessitano un aggiornamento
FLAG_V=0   # Se = 1, stampa la versione dei pacchetti installati

while getopts hnmsv OPT; do
    case $OPT in
	h)
	    _help
	    exit 0
	    ;;
	n)
	    FLAG_N=1
	    ;;
	m)
	    FLAG_M=1
	    ;;
	s)
	    FLAG_S=1
	    ;;
	v)
	    FLAG_V=1
	    ;;
	?)
	    exit 3
	    ;;
    esac
done

# Controllo sulle opzioni
if (( $FLAG_N + $FLAG_M + $FLAG_S + $FLAG_V > 1 )) ; then
    echo "Only one option between -n, -m, -s and -v must be set"
    exit 4
fi

while (( $OPTIND != 1 )); do
    shift
    let OPTIND--
done

# Controllo l'esistenza del file FILE_LIST
if [ ! -f "FILE_LIST" ]; then
    echo "FILE_LIST not found in current directory,"\
         "please enter in the directory where is located FILE_LIST"
    exit 2
fi

# Setto e controllo la root directory
root=$1
root=${root:-$ROOT}
root=${root%/}
root=${root}/var/log/packages/
if [ ! -d $root ]; then
    echo "$root not found, $1 is not the root directory"
    exit 5
fi

# Creo i file temporanei
TMP_DIR=$(mktemp -dt packages.XXXXXX)
PACKAGE_FROM_FILE_LIST=${TMP_DIR}/packages_from_file_list
PACKAGE_FROM_ROOT_DIR=${TMP_DIR}/packages_from_root_dir
sed -n '/t.z$/{s/.*\(\.\/.*\)/\1/;p;}' FILE_LIST > $PACKAGE_FROM_FILE_LIST # Elenco dei pacchetti in FILE_LIST
ls ${root} > $PACKAGE_FROM_ROOT_DIR                                        # Elenco dei pacchetti installati

# Catturo il segnal SIGINT inviato dal ctrl-c
trap "_exit 3" SIGINT

# File per il filtraggio dei pacchetti
FILTER_FILE=~/.analyze_SlackPkg # File di filtro
FLAG_FILTER=0  # Indica se il file di filtro esiste
[ -f $FILTER_FILE ] && FLAG_FILTER=1

# Modalità -n
if (( $FLAG_N == 1 )); then
    for file in $(< $PACKAGE_FROM_FILE_LIST); do
	software_name=$(_get_software_name ${file##*/})
	if ! grep -q "^${software_name}-[^-]\+-[^-]\+-[^-]\+$" $PACKAGE_FROM_ROOT_DIR; then
	    echo $file;
	fi
    done

    _exit 0;
fi

# Altre modalità
for file in $(< $PACKAGE_FROM_ROOT_DIR); do
    software_name=$(_get_software_name ${file})
    pack=$(grep "/${software_name}-[^-]\+-[^-]\+-[^-]\+$" $PACKAGE_FROM_FILE_LIST)

    # Controllo se il pacchetto deve essere filtrato
    FILTERED=0
    if [[ $pack != "" ]] && (( $FLAG_FILTER )) && grep -q "${software_name}$" $FILTER_FILE; then
        FILTERED=1 # E' stato filtrato
	pack=""    # Azzerando la variabile il pacchetto è filtrato
    fi

    if (( $FLAG_S == 1 )); then
	if [[ $pack != "" ]] && [[ ${pack##*/} == ${file}.t?z ]]; then
	    echo ${pack}
	fi
    elif (( $FLAG_M == 1 )); then
	if [[ $pack == "" ]] && (( $FILTERED == 0 )); then
	    echo ${file}
        elif [[ $pack == "" ]] && (( $FILTERED == 1 )); then
            echo -e "${file##*/} \033[32;1mfiltered by \033[33;1m${FILTER_FILE}\033[0m"
        fi
    else
	if [[ $pack != "" ]] && [[ ${pack##*/} != ${file}.t?z ]]; then
            if (( $FLAG_V == 1 )); then
		echo -e "$pack \033[32;1mthe current version is \033[33;1m${file##*/}\033[0m"
            else
                echo "$pack"
	    fi
	fi
    fi
done

_exit 0

Autore (data dell'ultimo aggiornamento): spina 16:09, 4 Mag 2010 (UTC)