df -h > /var/log/etat-disque.txt

Effet :

• Premiere execution : cree le fichier avec le rapport du moment
• Executions suivantes : ecrase le contenu precedent
• Le fichier ne contient que le rapport le plus recent

Variantes :

ps aux > /var/log/processus.txt        # snapshot des process
free -h > /var/log/memoire.txt          # snapshot memoire
systemctl status ircd-hybrid > etat.txt # statut a un instant

echo "Sauvegarde OK le $(date)" >> /var/log/historique-sauvegardes.log

Difference avec Q1 :

• > : ecrase (un seul etat present)
• >> : ajoute (historique cumulatif)

Variante avec date formattee :

echo "[$(date '+%Y-%m-%d %H:%M:%S')] Sauvegarde OK" \
    >> /var/log/historique-sauvegardes.log

Methode 1 - Reagir a l'echec :

backup-ircd.sh || echo "Erreur de sauvegarde"

• Si backup-ircd.sh reussit (code 0) : rien
• Si backup-ircd.sh echoue (code non-nul) : on affiche "Erreur de sauvegarde"
• Les messages d'erreur que la commande emet sur stderr passent quand meme dans le terminal

Methode 2 - Capturer le stderr :

backup-ircd.sh 2> /var/log/erreurs.txt

• Tous les messages que la commande envoie sur stderr partent dans le fichier
• La commande s'execute, on ne reagit pas explicitement au code de sortie
• Le fichier est ecrase a chaque execution (pour append : 2>>)

Pour un programmeur habitue au try/catch :

// JS/Java
try { backup(); } catch (e) { console.log("Erreur"); }

// Bash methode 1
backup-ircd.sh || echo "Erreur"

// La methode 2 est differente : on n'essaie pas de "rattraper", on
// se contente de DETOURNER les messages d'erreur dans un fichier.

Dans la prochaine question (Q4), on combinera les deux pour avoir le meilleur des deux mondes.

backup-ircd.sh 2> /var/log/blabla-erreur.txt || echo "blabla erreur"

Decomposition :

• 2> : envoie stderr (descriptor 2) dans le fichier (en ecrasant a chaque execution)
• || : declenche la suite si la commande echoue (code de sortie non-nul)
• echo "..." : message visible dans le terminal

Pour garder l'historique des erreurs (append) :

backup-ircd.sh 2>> /var/log/blabla-erreur.txt || echo "blabla erreur"

Pour aussi stopper le script :

backup-ircd.sh 2> /var/log/blabla-erreur.txt || { echo "blabla erreur"; exit 1; }

a) Notre message seulement :

cp /etc/ircd-hybrid.conf /backup/ \
    || echo "Echec copie" >> /var/log/erreurs.log

b) Notre message + le stderr natif :

cp /etc/ircd-hybrid.conf /backup/ 2>> /var/log/erreurs.log \
    || echo "Echec copie le $(date)" >> /var/log/erreurs.log

Le 2>> capture le stderr de cp (avant le ||), et le echo apres le || n'est execute que si cp a echoue. Resultat : si cp reussit, rien dans le log ; si cp echoue, deux lignes (message natif + notre message date).

a) Message simple :

cp /var/lib/ircd-hybrid/data /var/backups/ || echo "Erreur de copie"

b) Message + exit :

cp /var/lib/ircd-hybrid/data /var/backups/ || { echo "Erreur de copie"; exit 1; }

Notez les accolades avec espace, le point-virgule apres chaque commande dans le groupe, et le ; final avant }.

# a) stderr en append dans un fichier de log
backup-ircd.sh 2>> /var/log/ircd-erreurs.log

# b) stderr jete au neant (cron silencieux)
backup-ircd.sh 2> /dev/null

# c) stdout + stderr fusionnes
backup-ircd.sh >> /var/log/ircd.log 2>&1
# Variante moderne : backup-ircd.sh &>> /var/log/ircd.log

# a) Avec $? (verbeux mais explicite)
systemctl is-active --quiet ircd-hybrid
if [ $? -ne 0 ]; then
    systemctl restart ircd-hybrid
fi

# b) Avec if ! (plus elegant)
if ! systemctl is-active --quiet ircd-hybrid; then
    systemctl restart ircd-hybrid
fi

• cmd1 && cmd2 : cmd2 si cmd1 reussit (ET logique court-circuit)
• cmd1 || cmd2 : cmd2 si cmd1 echoue (OU logique court-circuit)
• cmd1 ; cmd2 : cmd2 toujours (succes de cmd1 ignore)

Pattern frequent :

mkdir -p /tmp/work && cd /tmp/work || exit 1
# creer + y aller ; sinon arret

#!/bin/bash
set -e             # arret au premier echec
set -o pipefail    # arret meme dans les pipelines
set -u             # arret si variable non definie

# ou en une ligne :
set -euo pipefail

Pourquoi pipefail : par defaut, le code de sortie d'un pipeline est celui de la derniere commande. pipefail renvoie l'erreur de la premiere qui echoue dans le pipeline.

trap 'rm -f /tmp/backup-en-cours.lock' EXIT

Cles :

• Quotes simples autour de la commande (evaluation differee)
• EXIT = fin normale, exit, set -e, Ctrl+C...
• Combiner : trap 'cleanup' EXIT INT TERM