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

Da Guide@Debianizzati.Org.
Versione del 23 mag 2013 alle 13:25 di S3v (discussione | contributi) (1.0.12)
Vai alla navigazione Vai alla ricerca
Debian-swirl.png Versioni Compatibili

Tutte le versioni supportate di Debian

Introduzione

Questo script permette la creazione di un file contenente informazioni utili che è possibile portare a conoscenza del forum per tentare di risolvere insieme i problemi più comuni.

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 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.

Prima di effettuare l'invio, lo script chiede un esplicito consenso all'utente.
Per usufruire del servizio offerto da paste.debian.net è necessaria l'installazione del pacchetto pastebinit: 

# apt-get install pastebinit
Info.png Nota
Lo script è liberamente modificabile.
Per ogni segnalazione, informazione o suggerimento fare riferimento a questa discussione sul forum.


Utilizzo

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

Script

#!/bin/bash

# Path dei comandi dello script
PATH=/bin:/sbin:/usr/bin:/usr/sbin

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

# I file creati saranno leggibili e scrivibili da tutti
umask 0111

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

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

# Funzione che stampa alcune avvertenze sullo script
function _avvertenze {
  local risp
  echo "
-- 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) contenente l'output di questo script
-- Verrà creato un file in formato compresso da inviare al forum"
  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 -o -f log.zip -o -f log.txt.bz2 -o -f log.tgz ]; then
    echo -n "Esiste già un file $log, 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 paste_url='http://paste.debian.net'
  local chunk_prefix='pastebin'
  local chunk_num=1
  local paste_exit_status=0
  local chunkfile pastelink
  
  # dimensione massima del singolo file da inviare 
  local chunk_size='60k'
  
  # 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
  echo -e "\nIl log è consultabile ai seguenti indirizzi:"
  for chunkfile in $chunk_prefix.{0..3}; do
  
    # verifica l'esistenza del file da inviare
    if [ -f $chunkfile ]; then

    # invia dati tramite pastebinit
    pastelink="$(pastebinit -a '' -b $paste_url -i $chunkfile)"
        
    if [ $? = 0 ]; then
        # invio apparentemente riuscito (pastebinit exit status = 0)
        
        # controlla URL restituita da pastebinit
        case $pastelink in 
        # verifica in caso di url corretta
        "$paste_url"/[0-9]*) 
            echo ".. inviato $chunkfile all'indirizzo $pastelink" 
            ;; 
        # verifica in caso di url non corretta
        *)
            echo ".. $paste_url ha restituito una URL non valida ($pastelink) per $chunkfile!"
            paste_exit_status=1
            ;;
        esac
    
    else
        # Invio fallito (pastebinit exit status = 1)
        echo ".. non riuscito invio $chunkfile"
        paste_exit_status=1
        fi
    
    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 $paste_exit_status
}

# --------------------------------------------------------------------------
# Funzione che invia il log a paste.debian.net
# --------------------------------------------------------------------------
function _upload {
  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 http://paste.debian.net [S/n]? "
  read risp
  case $risp in
    ""|[Ss])
      _split_and_send 
      if [ $? == 0 ]; then
      echo -e "\nIl log è stato inviato" 
      else
      echo -e "\nSi sono verificati errori nell'invio del log!"
      fi
      ;;
    *)
      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"
}

# 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 1
      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
}

# --------------------------------------------------------------------------
# Funzione di stampa menù e selezione del problema
# --------------------------------------------------------------------------

function _scelta {
  local num
  
  echo "
Selezionare il tipo di problema per il quale verrà generato il file di log
[1] Tutti
[0] Uscita"
 
  while true; do
   echo -n "Scegliere il numero corrispondente: "
   read num
     case $num in
       1) 
         _wait
         _tutti
         break
         ;;
       0)
         exit 1
         ;;
       *)
         tput cuu1 # in alto di una riga
         tput ed # cancella fino alla fine dello schermo
         ;;
     esac 
  done
}

# --------------------------------------------------------------------------
# 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 {
  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 {
  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 {
 echo "
******************************************
$1
******************************************" >> $log
}

# 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
}


# --------------------------------------------------------------------------
# Funzioni reltive a ciascun problema selezionato
# --------------------------------------------------------------------------

function _tutti  {
  _dmi_decode
  _comando "/bin/uname -a"
  _file "/etc/debian_version"
  _file "/var/log/syslog.1"
  _file "/var/log/syslog"
  _comando "/bin/lsmod"
  _comando "/usr/bin/lspci -knn"
  _comando "/usr/bin/lsusb"
  _comando "/sbin/fdisk -l"
  _file "/etc/fstab"
  _comando "/bin/mount"
  _comando "/bin/df"
  _file "/var/log/Xorg.0.log"
  _file "/etc/apt/sources.list"
  _comando "/usr/bin/apt-cache policy"
  _comando "/usr/bin/apt-cache stats"
  _comando "/usr/bin/apt-get check"
  _file "/etc/network/interfaces"
  _file "/etc/hosts"
  _comando "/sbin/ifconfig"
  _comando "/sbin/ifconfig -a"
  _comando "/bin/ping -c3 8.8.8.8"
  _comando "/bin/ip addr"
  _comando "/bin/ip route list"
  _iwconfig
  _iwlist
  _comando "/sbin/route -n"
  _resolvconf
  _file "/etc/resolv.conf"
  _firmware
  _dhcp
  _file "/etc/dhclient.conf"
  _nm
  _wicd
}


# --------------------------------------------------------------------------
# Funzioni che si occupano di inviare l'output di un comando oppure il
# contenuto di un file al file di log
# --------------------------------------------------------------------------

# Funzione che invia un file al file di log
# La funzione va richiamata specificando il path completo del file che
# sarà assegnato a $1
function _file {
  nome_e_riga $1
    if [ -f $1 ]; then
      cat $1 &>> $log && _ok $1 || _error $1
    else
      echo "File $1 non trovato" >> $log && _error $1
    fi
}

# Invia l'output di un comando al file di log
# La funzione va richiamata specificando il path completo del comando
# (con eventuali opzioni) che sarà assegnato a $1
function _comando {
  local var=${1##*/} #var conterrà il comando con le opzioni ma privo del path
  local var2=${1%% *} #var2 conterrà il comando privo di eventuali opzioni ma con il path
  nome_e_riga "$var"
  if [ -f "$var2" ]; then
    $1 &>> $log && _ok "$var" || _error "$var"
  else
     echo "Comando $var2 non trovato" >> $log && _error "$var"
  fi
}

# comando 'cat /sys/class/dmi/id/{sys_vendor,product_name,product_version,bios_version}'
function _dmi_decode {
  local var="/sys/class/dmi/id/*"
  nome_e_riga "$var"
  if [ -f /sys/class/dmi/id/sys_vendor ]; then
    echo 'Produttore:' $(cat /sys/class/dmi/id/sys_vendor)      &>> $log
    echo 'Prodotto:  ' $(cat /sys/class/dmi/id/product_name)    &>> $log
    echo 'Versione:  ' $(cat /sys/class/dmi/id/product_version) &>> $log
    echo 'BIOS vers.:' $(cat /sys/class/dmi/id/bios_version)    &>> $log && _ok "$var" || _error "$var"
  else
    echo "File /sys/class/dmi/id/sys_vendor non trovato" >> $log && _error "$var"
  fi
}

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

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

# 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
}

# 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 del demone wicd
function _wicd {
  local var="Wicd"
  nome_e_riga "$var"
  if [ -f /usr/sbin/wicd ]; then
    echo "$var è installato (versione "$(wicd -h | head -2 | tail -1)")" >> $log && _ok "$var"
    invoke-rc.d wicd status &>/dev/null
    if [ $? -eq 0 ]; then
      echo "$var è in esecuzione" >> $log
    else
      echo "$var non è in esecuzione" >> $log
    fi
  else
    echo "$var non è installato" >> $log && _error "$var"
  fi
}


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

clear

_intro
_avvertenze
_check
_scelta
_upload
_compress

exit 0

Changelog

1.0.12
Inserito il path di default
Sostituito il comando cat con echo nei messaggi a video
Inserito un menù di scelta e rimosso l'array delle funzioni
Inserite due funzioni per inviare al log un file o un output generico
lspci -knn
Rimossa _dmesg (l'ouput è fornito da syslog)
S3v 15:25, 23 mag 2013 (CEST)
1.0.11
Modificata la funzione _wicd
S3v 00:57, 15 mag 2013 (CEST)
1.0.10
Tolta la funzione iptables per motivi di sicurezza
Impostata una maschera di default per i file creati dallo script
Modifiche minori
S3v 11:19, 14 mag 2013 (CEST)
1.0.9
Aggiunta funzionalità per aggiungere i log di sistema (/var/log/syslog e /var/log/syslog.1)
Aki 14:20 3 mag 2013 (CEST);
1.0.8
Integrazione funzionalità upload per supportare la verifica della ricezione da parte di http://paste.debian.net
Revisione messaggistica in caso di fallito invio a http://paste.debian.net
Aki 12:40 2 mag 2013 (CEST);
1.0.7
Aggiunta funzionalità per identificazione produttore e modello del computer secondo lo standard SMBIOS/DMI
Aggiunta rimozione valore ESSID dall'output del comando iwconfig
Aggiunto controllo esito invio log verso http://paste.debian.net (in caso di falito invio)
Anticipazione ed unificazione nell'ordine del codice sorgente delle sezioni relative al controllo del sistema apt
Aki 13:40 27 apr 2013 (CEST);
1.0.6
Aggiunta funzionalità per verifiche sullo stato del gestiore dei pacchetti (comandi apt-cache policy, apt-cache status)
Aki 10:39 26 apr 2013 (CEST)
1.0.5
Aggiunta funzionalità frammentazione log per invio a http://paste.debian.net
Aggiunta funzionalità per verifiche sullo stato dei dischi (comandi fdisk -l , mount, df -h)
Aggiunta funzionalità per verifica del file /etc/fstab
Apportate alcune variazioni ai messaggi diagnostici
Collegamento con la guida su Come formulare quesiti tecnici al forum
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
S3v 18:15, 20 apr 2013 (CEST)
1.0.3
Aggiunta rimozione valore ESSID dalla scansione delle reti wireless
Aki 20:34 14 apr 2013 (CEST)
1.0.2
Aggiunta avvertenza su esplicito consenso all'invio verso paste.debian.net
S3v 14:56, 14 apr 2013 (CEST)
1.0.1
Corretta la funzione "dmesg" che svuotava il buffer e non produceva output
S3v 12:22, 14 apr 2013 (CEST)



Guida scritta da: S3v 23:38, 13 apr 2013 (CEST) Swirl-auth20.png Debianized 20%
Estesa da:
Verificata da:

Verificare ed estendere la guida | Cos'è una guida Debianized

Estratto da "https://guide.debianizzati.org/index.php?title=Creazione_automatica_di_un_file_di_log_per_inviare_quesiti_al_forum&oldid=32563"