Visualizza wikitesto di Creazione automatica di un file di log per inviare quesiti al forum

{{Versioni compatibili}}
== Introduzione ==
Questo [[script]] permette la creazione di un file contenente informazioni utili che è possibile portare a conoscenza del [http://forum.debianizzati.org forum] per tentare di risolvere insieme i problemi più comuni.<br/>
Lo script crea due file:
;log.txt:contiene le informazioni in formato testo
;log.{txt.bz2,zip,tgz}:il file precedente ma in formato compresso. Può essere allegato ad una discussione sul forum

Attraverso lo script è anche possibile inviare il file direttamente a [http://paste.debian.net paste.debian.net] per poterlo condividere pubblicamente.

In questo caso il file non potrà superare la grandezza complessiva di 320K circa (diviso in parti della dimensione massima di 80K circa) e le informazioni saranno disponibili a chiunque per una settimana.<br/>

Prima di effettuare l'invio, lo script chiede un esplicito consenso all'utente.<br/>
Per usufruire del servizio offerto da paste.debian.net è necessaria l'installazione del pacchetto <code>pastebinit</code>:
<pre># apt-get install pastebinit</pre>

{{Box|Nota|Lo script è liberamente modificabile.<br/>Per ogni segnalazione, informazione o suggerimento fare riferimento a [http://forum.debianizzati.org/viewtopic.php?f{{=}}13&t{{=}}45098 questa] discussione sul forum.}}

== Utilizzo ==
# Copiare il codice dello script in un file di testo. Il nome del file può essere scelto liberamente.
# Dare i permessi di esecuzione al file appena creato. Supponendo che si chiami ''nomefile'':<pre>$ chmod +x nomefile</pre>
# Eseguire lo script con i permessi di [[root]]:<pre># ./nomefile</pre>il comando precedente presuppone che sia eseguito nella stessa directory in cui risiede lo script.<br/>L'esecuzione con i permessi di root si rende necessaria poiché alcuni comandi devono essere eseguiti necessariamente come utente privilegiato.
# Leggere le informazioni a video.

== Script ==
<pre>
#!/bin/bash

# Nome del file di log
log="log.txt"

# --------------------------------------------------------------------------
# Funzioni iniziali
# --------------------------------------------------------------------------

# Funzione che stampa il messaggio introduttivo
function _intro {
 cat <<TESTO
*********************************************************************************
*  www.debianizzati.org                                                         *
*                                                                               * 
*  Script che crea un log utile alla risoluzione dei problemi più comuni        *
*  Versione 1.0.5                                                               * 
*                                                                               * 
*********************************************************************************
TESTO
}

# Funzione che stampa alcune avvertenze sullo script
function _avvertenze {
 local risp
 cat <<TESTO
-- Lo script richiede i permessi di root per essere eseguito
-- Per inviare il log su paste.debian.net è necessario il pacchetto 'pastebinit'
-- L'invio del log a paste.debian.net avverrà solo dopo esplicito consenso
-- Verrà creato un file (log.txt) contenente l'output di questo script
-- Verrà creato un file in formato compresso da inviare al forum
TESTO
 echo -n "Continuare [S/n]? "
 read risp
 case $risp in
  ""|[Ss])
       ;;
  *)
       echo -e "Uscita\n"
       exit 1
       ;;
 esac
}

# Funzione che esegue un check preliminare
function _check {
if [[ $EUID -ne 0 ]]; then # Lo script viene lanciato da root?
 echo "Lo script deve essere lanciato da root"
 exit 1
fi 

# Se esiste già un file di log con lo stesso nome oppure
# file compressi con lo stesso nome di quelli che verranno
# creati, lo script chiede se cancellarli o meno 
local risp
if [ -f ./log.txt -o -f ./log.zip -o -f ./log.txt.bz2 -o -f ./log.tgz ]; then
 echo -n "Esiste già un file log.txt, log.zip, log.txt.bz2 o log.tgz nella directory corrente. Sovrascivere [S/n]? "
 read risp
 case $risp in
   ""|[Ss])
       rm -f $log log.zip log.txt.bz2 log.tgz
       ;;
   *) 
       exit 1
       ;;
 esac
fi
}

# --------------------------------------------------------------------------
# Funzione per separare il log in parti per l'invio a paste.debian.net 
# --------------------------------------------------------------------------
function _split_and_send {
  local chunk_prefix='pastebin'
  local chunk_num=1

  # dimensione massima del singolo file da inviare a http://paste.debian.net
  local chunk_size='80k'

  # rinomina parti di log preesistenti (se ve ne sono) 
  # scarta i messaggi di errore (se presenti)
  rename "s/$chunk_prefix/old-$chunk_prefix-$(date +%s)/g" $chunk_prefix.* > /dev/null 2>&1 

  # dividi il file di log in parti di $chunk_size bytes senza spezzare le linee
  # scarta i messaggi di errore (se presenti) per log di dimensione superiore a 10 parti
  # (max 10 parti con l'opzione -a)
  split -a 1 -d -C $chunk_size $log $chunk_prefix. > /dev/null 2>&1
  
  # comunica il numero di parti inviate
  chunk_num=$( ls -1 $chunk_prefix.* | wc -l )
  if [ $chunk_num = 1 ]; 
    then
      echo -e "\nIl log sarà inviato in un singolo file."
    else
      echo -e "\nIl log sarà inviato in $chunk_num parti."
  fi
  
  # invia al massimo 4 parti a http://paste.debian.net
  echo -e "\nIl log è consultabile ai seguenti indirizzi:"
  for  chunkfile in $chunk_prefix.{0..3}; do
    if [ -f $chunkfile ]; then 
      pastelink="$(pastebinit -a "" -b http://paste.debian.net -i $chunkfile)"
      echo "   $pastelink"
    fi
  done

  # cancella i parti di log inviati
  # scarta i messaggi di errore (se presenti)
  rm $chunk_prefix.{0..9} > /dev/null 2>&1
  
  return 0
}

# --------------------------------------------------------------------------
# Funzione che invia il log a paste.debian.net
# --------------------------------------------------------------------------
function _upload {
 local pastelink
 local risp
 # Pastebinit è installato?
 if [ ! -f /usr/bin/pastebinit ]; then
  echo -e "\nNon è possibile inviare il log a paste.debian.net\nIl pacchetto 'pastebinit' non è installato."
  return 1
 fi
 # Invia il file log.txt a paste.debian.net
 echo -en "\nInviare il log a paste.debian.net [S/n]? "
 read risp
 case $risp in
  ""|[Ss])
      _split_and_send
       ;;
  *)
       echo "Il log non è stato inviato"
       ;;
 esac
}

# --------------------------------------------------------------------------
# Funzioni di creazione del file compresso e messaggi di successo/fallimento
# --------------------------------------------------------------------------

# Funzione richiamata in caso di corretta creazione del file compresso
function _compress_ok {
 echo "Il file compresso $1 è stato creato correttamente nella directory corrente."
 echo -e "Allegare questo file alla discussione sul forum.\n"
 # Imposta i permessi di lettura-scrittura sul file per tutti gli utenti
 chmod 666 $1
}

# Funzione richiamata in caso di errore nella creazione del file compresso
function _compress_err {
 echo -e "\nErrore nella creazione del file compresso $1."
}

# Funzione che crea il file compresso
# Prova a creare nell'ordine: un file .bz2, un file .zip o un file .tgz
function _compress {
 local risp
 echo -en "\nCreare un file compresso [S/n]? "
 read risp
 case $risp in
  ""|[Ss])
       echo -e "\nSta per essere creato un file compresso..."
       sleep 2
       if [ -f /bin/bzip2 ]; then
        bzip2 -k9 $log && _compress_ok log.txt.bz2 || _compress_err log.txt.bz2
       elif [ -f /usr/bin/zip ]; then
        zip log.zip $log && _compress_ok log.zip || _compress_err log.zip
       else
       tar czf log.tgz $log && _compress_ok log.tgz || _compress_err log.tgz
       fi
       ;;
  *)
       ;;
 esac
}


# --------------------------------------------------------------------------
# Funzioni varie
# --------------------------------------------------------------------------

# Funzione che stampa due righe vuote
function _spazi {
 echo >> $log
 echo >> $log
}

# Funzione che stampa un pallino di colore verde in caso di comando con output
function _ok {
 /bin/echo -e "  $1" "\033[35G\033[01;32m•\033[0m"
}

# Funzione che stampa una pallino rosso in caso di comando privo di output
function _error {
 /bin/echo -e "  $1" "\033[35G\033[01;31m•\033[0m"
}

# Funzione che invia nel file di log due righe tra le quali
# viene visualizzato il nome del comando ( passato come primo
# parametro della funzione -> $1 )
function nome_e_riga {
 cat <<FINE >> $log 
******************************************
$1
******************************************
FINE
}

# Funzione che stampa un messaggio di attesa e aspetta 2 secondi
function _wait {
 echo -e "\nCreazione del log in corso. Attendere pochi secondi...\n"
 sleep 2
}


# --------------------------------------------------------------------------
# Array che contiene la lista delle funzioni
# --------------------------------------------------------------------------

# Questo array contiene tutte le funzioni utilizzate per il log
# dei comandi. 
# Per aggiungere una nuova funzione, inserire qui il suo nome e 
# scriverne il codice in basso.

comandi=(
_unamea
_version
_dmesg
_lsmod
_lspci
_lsusb
_fdisk
_fstab
_mount
_df
_xorg_log
_sources
_interfaces
_hosts
_ifconfig
_ping
_ip
_iwconfig
_iwlist
_route
_resolvconf
_resolvconf2
_firmware
_dhcp
_dhclient
_nm
_wicd
_iptables
)


# --------------------------------------------------------------------------
# Funzioni contenute nell'array
# --------------------------------------------------------------------------

# comando 'uname -a'
function _unamea {
 local var="uname -a"
 nome_e_riga "$var"
 if [ -x /bin/uname ]; then
  /bin/uname -a &>> $log && _ok "$var" || _error "$var"
 else
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'cat /etc/debian/version'
function _version {
 local var="/etc/debian_version"
 nome_e_riga "$var"
 if [ -f /etc/debian_version ]; then
  cat /etc/debian_version &>> $log && _ok "$var" || _error "$var"
 else
  echo "Il file /etc/debian_version non trovato" >> $log && _error "$var"
 fi
}

# comando 'dmesg'
function _dmesg {
 local var="dmesg"
 nome_e_riga "$var"
 if [ -x /bin/dmesg ]; then
  /bin/dmesg &>> $log && _ok "$var" || _error "$var"
 else
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'lsmod'
function _lsmod {
 local var="lsmod"
 nome_e_riga "$var"
 if [ -x /bin/lsmod ]; then
  /bin/lsmod &>> $log && _ok "$var" || _error "$var"
 else
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'lspci'
function _lspci {
 local var="lspci"
 nome_e_riga "$var"
 if [ -x /usr/bin/lspci ]; then
  /usr/bin/lspci -knn &>> $log && _ok "$var" || _error "$var"
 else
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'lsusb'
function _lsusb {
 local var="lsusb"
 nome_e_riga "$var"
 if [ -x /usr/bin/lsusb ]; then
  /usr/bin/lsusb &>> $log && _ok "$var" || _error "$var"
 else
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'fdisk'
function _fdisk {
 local var="fdisk -l"
 nome_e_riga "$var"
 if [ -x /sbin/fdisk ]; then
  /sbin/fdisk -l &>> $log && _ok "$var" || _error "$var"
 else 
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# file /etc/fstab 
function _fstab {
 local var="/etc/fstab"
 nome_e_riga "$var"
 if [ -f /etc/fstab ]; then
  cat /etc/fstab &>> $log && _ok "$var" || _error "$var"
 else
  echo "Il file $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'mount'
function _mount {
 local var="mount"
 nome_e_riga "$var"
 if [ -x /bin/mount ]; then
  /bin/mount &>> $log && _ok "$var" || _error "$var"
 else 
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'df'
function _df {
 local var="df -h"
 nome_e_riga "$var"
 if [ -x /bin/df ]; then
  /bin/df -h &>> $log && _ok "$var" || _error "$var"
 else 
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# log del server X
function _xorg_log {
 local var="/var/log/Xorg.0.log"
 nome_e_riga "$var"
 if [ -f /var/log/Xorg.0.log ]; then
  cat /var/log/Xorg.0.log &>> $log && _ok "$var" || _error "$var"
 else
  echo "File $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'cat /etc/network/interfaces'
function _interfaces {
 local var="/etc/newtork/interfaces"
 nome_e_riga "$var"
 if [ -f /etc/network/interfaces ]; then
  ls -l  /etc/network/interfaces &>> $log || _error "$var"
  echo "" >> $log
  cat /etc/network/interfaces &>> $log && _ok "$var" || _error "$var"
 else
  echo "File $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'cat /etc/hosts'
function _hosts {
 local var="/etc/hosts"
 nome_e_riga "$var"
 if [ -f /etc/hosts ]; then
  cat /etc/hosts &>> $log && _ok "$var" || _error "$var"
 else
  echo "File /etc/hosts non trovato" >> $log && _error "$var"
 fi
}

# comandi 'ifconfig' e 'ifconfig -a'
function _ifconfig {
 local var="ifconfig"
 nome_e_riga "$var"
 if [ -x /sbin/ifconfig ]; then
  /sbin/ifconfig &>> $log && _ok "$var" || _error "$var"
  _spazi
  nome_e_riga "$var -a"
  ifconfig -a &>> $log && _ok "$var -a" || _error "$var -a"
 else 
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'ping -c3 8.8.8.8'
function _ping {
 local var="ping"
 #Ping verso l'IP del DNS di Google 8.8.8.8
 local host="8.8.8.8"
 nome_e_riga "$var"
 if [ -x /bin/ping ]; then
  /bin/ping -c3 $host &>> $log && _ok "$var" || _error "$var"
 else 
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'iwconfig'
function _iwconfig {
 local var="iwconfig"
 nome_e_riga "$var"
 if [ -x /sbin/iwconfig ]; then
  /sbin/iwconfig &>> $log && _ok "$var" || _error "$var"
 else
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'iwlist scan'
function _iwlist {
 local var="iwlist"
 local tmpfile=$(/bin/tempfile)
 nome_e_riga "$var"
 if [ -x /sbin/iwlist ]; then 
    /sbin/iwlist scan > $tmpfile 2>&1
    if [ $? = 0 ]; then
      _ok "$var scan" 
      /bin/sed -e 's/ESSID:.*/ESSID:"*script-removed*"/g' -e '/^[ ]*IE: Unknown:.*/d' $tmpfile &>> $log 
    else
      _error "$var scan"
    fi    
 else 
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
 rm $tmpfile
}

# comandi 'ip addrr list' e 'ip route list'
function _ip {
 if [ -x /bin/ip ]; then
  nome_e_riga "ip addr list"
  /bin/ip addr list &>> $log && _ok "ip addr list" || _error "ip addr list"
  _spazi
  nome_e_riga "ip route list"
  /bin/ip route list &>> $log && _ok "ip route list" || _error "ip route list"
 else 
  echo "Comando ip non trovato" >> $log && _error "ip"
 fi
}

# comando 'route -n'
function _route {
 local var="route"
 nome_e_riga "$var -n"
 if [ -x /sbin/route ]; then
  /sbin/route -n &>> $log && _ok "$var -n" || _error "$var -n"
 else 
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'iptables -L'
function _iptables {
 local var="iptables"
 nome_e_riga "$var"
 if [ -x /sbin/iptables ]; then
  /sbin/iptables -L &>> $log && _ok "$var -L" || _error "$var -L"
 else 
  echo "Comando $var non trovato" >> $log && _error "$var"
 fi
}

# comando 'cat /etc/resolv.conf'
function _resolvconf2 {
 local var="/etc/resolv.conf"
 nome_e_riga "$var"
 if [ -f /etc/resolv.conf ]; then
  ls -l /etc/resolv.conf &>> $log || _error "$var"
  echo "" >> $log
  cat /etc/resolv.conf &>> $log && _ok "$var" || _error "$var"
 else 
 echo "File $var non trovato" >> $log && _error "$var"
 fi
}

# esistenza del pacchetto 'resolvconf'
function _resolvconf {
 local var="resolvconf"
 nome_e_riga "$var"
 if [ $(dpkg -l | grep -ci resolvconf) -eq 0 ]; then
  echo "Il pacchetto resolvconf non è installato" >> $log && _error "$var"
 else
  dpkg -l | grep -i resolvconf >> $log && _ok "$var"
 fi
}

# esistenza di pacchetti contenenti firmware e firmware presente sulla macchina
function _firmware {
 local var="Firmware"
 local i
 nome_e_riga "$var"
 dpkg -l | grep -i firmware >> $log && _ok "$var"
 # Array contenente tre directory
 local firm_dir=(/usr/lib/firmware /usr/local/lib/firmware /lib/firmware)
  for ((i=0; i<${#firm_dir[@]}; i++)); do
   if [ -d ${firm_dir[$i]} ]; then
    echo "Contenuto di ${firm_dir[$i]}" >> $log 
    ls -al ${firm_dir[$i]} >> $log
   else
    echo "${firm_dir[$i]} non trovato" >> $log
   fi
  done
}

# esistenza di pacchetti riguardanti DHCP
function _dhcp {
 local var="DHCP"
 nome_e_riga "$var"
 if [ $(dpkg -l | grep -ci dhcp) -eq 0 ]; then
  echo "Nessun pacchetto DHCP installato" >> $log && _error "$var"
 else
  dpkg -l | grep -i dhcp >> $log && _ok "$var"
 fi
}

# comando 'cat /etc/dhclient.conf'
function _dhclient {
 local var="/etc/dhclient.conf"
 nome_e_riga "$var"
 if [ -f /etc/dhclient.conf ]; then
  cat /etc/dhclient.conf &>> $log && _ok "$var" || _error "$var"
 else
  echo "File /etc/dhclient.conf non trovato" >> $log && _error "$var"
 fi
}

# comando 'cat /etc/apt/sources.list'
function _sources {
 local var="/etc/apt/sources.list"
 nome_e_riga "$var"
 if [ -f /etc/apt/sources.list ]; then
  ls -l /etc/apt/sources.list &>> $log || _error "$var"
  echo "" >> $log
  cat /etc/apt/sources.list &>> $log && _ok "$var" || _error "$var"
 else 
  echo "File $var non trovato" >> $log && _error "$var"
 fi
}

# esistenza di Network Manager
function _nm {
 local var="Network Manager"
 nome_e_riga "$var"
 if [ -n "$(dpkg -l | cut -d ' ' -f3 | egrep -i '^network-manager$')" ]; then
  echo "Network Manager è installato (versione "$(NetworkManager --version)")" >> $log && _ok "$var"
  invoke-rc.d network-manager status &>/dev/null
  if [ $? -eq 0 ]; then
   echo "Network Manager è in esecuzione" >> $log
  else
   echo "Network Manager non è in esecuzione" >> $log  
  fi
 else
  echo "Network Manager non è installato" >> $log && _error "$var"
 fi
}

# esistenza di Wicd
function _wicd {
 local var="Wicd"
 nome_e_riga "$var"
 if [ -n "$(dpkg -l | grep -i 'wicd')" ]; then
  echo "Wicd è installato" >> $log && _ok "$var"
  if [ -n "$(invoke-rc.d wicd status | grep "is running")" ]; then
   echo "Wicd è in esecuzione" >> $log
  else
   echo "Wicd non è in esecuzione" >> $log  
  fi
 else
  echo "Wicd non è installato" >> $log && _error "$var"
 fi
}


# --------------------------------------------------------------------------
# Main
# --------------------------------------------------------------------------

clear

_intro
_avvertenze
_check
_wait

# Ciclo sull'array di funzioni
for ((i=0; i<${#comandi[@]}; i++)); do
 ${comandi[$i]}
 _spazi
 sleep 1
done
echo -e "\nIl file $log è stato creato correttamente nella directory corrente."

_upload
_compress

# Permessi di lettura e scrittura per tutti
# poiché il file di log viene creato da root
chmod 666 $log

exit 0
</pre>

== Changelog ==
<!-- Qui vanno inserite le spiegazioni di eventuali modifiche dello script (chi, cosa, quando). Ricordarsi di modificare la versione all'interno del codice (la versione iniziale è 1.0.0) -->
;1.0.5
:''Aggiunta funzionalità frammentazione log per invio ad http://paste.debian.net''
:[[Utente:Aki|Aki]] 13:30 25 apr 2013 (CEST)
;1.0.4
:''Tolto qualche echo e inserito un messaggio di mancato invio log a p.d.n''
:[[Utente:S3v|S3v]] 18:15, 20 apr 2013 (CEST)
;1.0.3
:''Aggiunta rimozione valore ESSID dalla scansione delle reti wireless''
:[[Utente:Aki|Aki]] 20:34 14 apr 2013 (CEST)
;1.0.2
:''Aggiunta avvertenza su esplicito consenso all'invio verso paste.debian.net''
:[[Utente:S3v|S3v]] 14:56, 14 apr 2013 (CEST)
;1.0.1
:''Corretta la funzione "dmesg" che svuotava il buffer e non produceva output''
:[[Utente:S3v|S3v]] 12:22, 14 apr 2013 (CEST)

{{Autori
|Autore=[[Utente:S3v|S3v]] 23:38, 13 apr 2013 (CEST)
}}

[[Categoria: Bash Scripting]][[Categoria: Configurazione ethernet]][[Categoria: Configurazione wireless]]