Ou plutôt les problèmes, car il peut y en avoir plusieurs; par exemple le système sur la carte ne boot plus. On a fait une bêtise, on la débranché car on a voulu la déplacer ou le fil s'est débranché par accident, et aller cette fois là c'est la galère. C'est généralement long et fastidieux de récupérer les données sur sa carte SD ou autre, j'ai donc fait un script qui fait une sauvegarde globale du système sur un disque ou une clé usb que l'on devra autoriser auparavant, histoire que dès que l'on branche une clé usb, ça n'envoie pas les données dessus. Il y a bien évidement des solutions de sauvegarde en ligne mais ayant une connexion avec peu de débit, ça peut prendre beaucoup de temps, la connexion peut couper et alors c'est des complications, pour moi ce n'était pas très adapté.
Le principe c'est que le script a deux fonctionnalitées
Pour l'utiliser on lancera la commande saveonmedia create
c'est la commande saveonmedia make qui fera ça.
Pour la liste, un bête fichier texte suffit pour ajouter les supports de stockage ligne par ligne, on se basera sur les UUID des partitions sur le disque qui sont normalement identifier de manière unique. Pour réaliser la sauvegarde le script lancera un script bash qui est généralement plus pratique si l'on veut ajouter des taches à effectuer ou personnaliser le truc un peu comme on veut.
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import pyudev
import subprocess
import sys
import os
import socket
from email.mime.text import MIMEText
from subprocess import Popen, PIPE
def print_help():
print ("""
##### saveonusb Sauvergarde sur support USB ####
! A executer avec l'utilisateur avec des droits root (sudo) ou en root !
Pour autoriser un disque (clé usb, disque usb)
Lancez la commande :
./saveonusb create
Pour effectuer l'ecoute puis la sauvegarde:
./saveonusb make
""")
def send_msg(subject, message):
# Permet d'envoyer des mail a root via sendmail.
msg = MIMEText(message)
msg["From"] = "sauvegarde@"+socket.gethostname()
msg["To"] = "root@"+socket.gethostname()
msg["Subject"] = subject
p = Popen(["/usr/sbin/sendmail", "-t", "-oi"], stdin=PIPE, universal_newlines=True)
p.communicate(msg.as_string())
def clean_df_out(df_out):
# Ici on tri les enleve les partitions de la sortir de df qui ne sont pas des supports
# de stockages
#
df_out = df_out.split('\n')
lines=[]
for line in df_out:
if line[0:4] == '/dev':
lines.append(line)
line_clean = list()
lines_clean = list()
# On crée la liste des champs de df
for line in lines:
line = line.split(' ')
for champ in line:
if champ != '':
line_clean.append(champ)
lines_clean.append(line_clean.copy())
line_clean.clear()
return lines_clean
def getMinSpaceRequirement():
# df -k A ce schema de sorti
# Filesystem | 1K-blocks | Used | Avail | Capacity | Mounted on
#
# Pour obtenir l'espace minimum on suppose que l'on veut sauvegarder toutes les
# données de tout les supports de stockages.
df = subprocess.check_output(['/bin/df', '-k']).decode('utf8')
df_list = clean_df_out(df)
print (df_list)
space_used = 0
for line in df_list:
space_used = space_used + int(line[2])
return space_used
def get_uuid(device):
cmd = subprocess.check_output(['sudo', 'blkid', device])
cmd = cmd.decode('utf-8')
for line in cmd.split(' '):
if 'UUID=' == line[0:5]:
return line[6:len(line)-1]
return ''
def make_save(save_directory, storages):
context = pyudev.Context()
monitor = pyudev.Monitor.from_netlink(context)
monitor.filter_by('block')
done = False
with open (storages, 'r') as f:
medias_save = f.read().splitlines()
while not(done):
device = monitor.poll()
if 'ID_FS_TYPE' in device and device.action == "add":
print ("device: {0} medias: {1}".format(device.get('ID_FS_UUID'), medias_save))
if "ynh_save" == device.get('ID_FS_LABEL') and device.get('ID_FS_UUID') in medias_save:
print ("La sauvegarde a commencé")
send_msg("Une sauvegarde a été lancé","Ne retirez pas votre disque ou clé usb. Merçi.")
retcode = subprocess.call("mount " + device.device_node + " "+ save_directory, shell=True)
if retcode != 0:
subject = "Bon ... ça s'est mal passé"
message = """Impossible de monter le disque ou la clé USB :( """
send_msg(subject, message)
retcode = subprocess.call( save_script + " " + save_directory, shell=True)
if retcode != 0:
subject = "Bon ... ça s'est mal passé"
message = """Le script de sauvegarde a remonté une erreur, comment dire ... je le ferai autrement moi """
send_msg(subject, message)
retcode = subprocess.call("umount " + device.device_node, shell=True)
if retcode != 0:
subject = "Bon ... ça s'est a peu près bien passé"
message = """Ça a monté le support et tout, le script pas de problèmes, mais ca ne démonte pas la partition correctement le script ne peut rien faire seul vous pouvez voir ce qu'il se passe en vous connectant en admin à votre machine"""
else:
subject = "Confirmation de sauvegarde"
message = """Votre sauvegarde est prête vous pouvez retirer votre support de stockage en toute sécurité. Rebranchez ce même support quand vous souhaitez effectuer une sauvergarde. Attention! Toutes modifications de la partiton rendra le support invalide"""
send_msg(subject, message)
def create_key_save(storages):
context = pyudev.Context()
monitor = pyudev.Monitor.from_netlink(context)
monitor.filter_by('block')
with open (storages, 'r') as f:
medias_save = f.read().splitlines()
done = False
while not(done):
device = monitor.poll()
if device.device_type == "partition" and device.action == "add":
if "ynh_save" == device.get('ID_FS_LABEL') and device.get('ID_FS_UUID') in medias_save:
subject = "Ce support de stockage est déjà initialisé"
message = "Il n'est pas nécéssaire d'initialisé ce périphérique"
send_msg(subject, message)
else:
size = subprocess.check_output("fdisk -s " +
device.device_node,
shell=True)
size = int(size)
size_requirement = getMinSpaceRequirement()
if size > size_requirement:
done = True
retcode = subprocess.call("mkfs.ext4" + " -F -L ynh_save" +
" "+ device.device_node, shell=True)
if retcode != 0:
subject = "Impossible de formatter la clé"
message = """ Il y a eu un problème durant le formatage du support usb"""
send_msg(subject, message)
# On récupere le nouvel uuid
with open (storages, 'a') as f:
f.write(get_uuid(device.device_node)+ '\n')
subject = "Autorisation d'un support de sauvegarde"
message = """ Vous venez de créer un support pour votre sauvegarde.
Cela s'est deroulé normalement. Pour effectuer une sauvegarde maintenant
rebrancher votre support de stockage; un mail vous signalera quand vous pourrez enlevez votre support en toute sécurité."""
send_msg(subject, message)
done = True
else:
subject = "Votre support de stockage est de taille insufisante !"
message = """Il n'y a pas assez d'espace disque sur le support que
vous venez de brancher; essayer avec une media de plus grande capacité (minimum """ +
str(size_requirement/1000000) + "Gb)"
send_msg(subject, message)
save_directory = "/media/save"
save_script = "/etc/saveonusb/scripts/save.sh"
conf_path = "/etc/saveonusb/"
storages = conf_path+"storages"
if os.geteuid() != 0:
raise OSError("Ce programme doit s'executer avec les droits root")
if not(os.path.exists(save_directory)):
raise OSError("Le repertoire "+ save_directory +" n'existe pas")
if not(os.path.exists(conf_path)):
raise OSError("Le repertoire "+ conf_path +" n'existe pas")
if not(os.path.isfile(save_script)):
raise OSError("Le fichier "+ save_script +" n'existe pas")
if not(os.path.isfile(storages)):
raise OSError("Le fichier "+ storages +" n'existe pas")
if len(sys.argv) > 1:
if sys.argv[1] == 'create':
create_key_save(storages)
if sys.argv[1] == 'make':
make_save(save_directory, storages)
if sys.argv[1] == '--help' or sys.argv[1] == '-h':
print_help()
else:
print_help()
On installe pyudev:
apt install python3-pyudev
On créé les répertoires et les fichiers nécessaires:
mkdir /media/save
mkdir -p /etc/saveonusb/scripts
touch /etc/saveonusb/storages && touch /etc/saveonusb/scripts/save.sh
chmod +x /etc/saveonusb/scripts/save.sh
Je me suis fait tout d'abord un petit script afin de générer une image prête a être flasher sur une carte SD
#!/bin/bash
set -e
#set -x
#Implementer un TRAC error avec exit qui clean quand ca foire
# Implementer des logs
#Fonction pour check les programmes nécéssaire.
#lance apt install quand les programmes manques
# modprobe loop
# Test les medias disponibles et passer en parametre le disk a monter pour mettre l'image
# Demande confirmation pour commencer tout les étapes ou a toutes les étapes
_apt_install_dep()
{
echo "on passe ici avec $1 comme argument"
case $1 in
truncate)
apt-get -y install --no-install-recommends coreutils
;;
mkfs.ext4)
apt-get -y install --no-install-recommends e2fsprogs
;;
*)
apt-get -y install --no-install-recommends $1
;;
esac
}
check_dep()
{
bins=(dd truncate rsync parted mkfs.ext4 )
for i in "${bins[@]}"; do
if ! which "${i}" &> /dev/null; then
echo "${i} command is required"
_apt_install_dep ${i}
fi
done
echo "check_dep ok"
}
create_img() {
local folder=$1
local image=$2
# Espace utilisé sur /
local usage=$(df -BM | grep ^/dev | head -1 | awk '{print $3}' | tr -cd '[0-9]. \n')
# Espace libre
local avaible=$(df -BM $folder | grep ^/dev | head -1 | awk '{print $4}' | tr -cd '[0-9]. \n')
if [[ $usage -gt $avaible ]]; then
echo "No space left"
echo "Required: $usage MB "
echo "Free space in $folder : $avaible MB "
exit 1
fi
#On laisse 1024M d'espace libre sur l'image
local image_size=$(($usage+1024))'M'
truncate -s $image_size $folder/$image
}
prepare_part() {
local loop=$1
local folder=$2
local image=$3
local mount_image=$4
losetup $loop $folder/$image
parted -s $loop -- mklabel msdos
parted -s $loop -- mkpart primary ext4 8192s -1s
#La carte ne boot pas avec la ligne en dessous
#parted -s $loop align-check optimal 1
partprobe $loop
mkfs.ext4 $loop"p1"
mkdir $mount_image
mount $loop"p1" $mount_image
}
copy_files() {
# Stopper les services avant de copie
# Vérifier que les partitions soient montées
# Afficher le point de montage de la partition
# On redirige la sortie du programme vers /dev/null et la sortie erreur (2) sur la sortie standard
# On ne verra que les erreurs des fichiers ou la copie a posé problème
local mount_image=$1
rsync -avrltD --delete --exclude={/dev/*,/proc/*,/sys/*,/media/*,/mnt/*,/run/*,/tmp/*} / $mount_image > /dev/null 2>&1
}
#Modify fstab
change_fstab() {
local mount_image=$1
local old_uuid=$(blkid -o export `mount | grep -w / | awk '{print $1}'` | grep ^UUID)
local new_uuid=$(blkid -o export `mount | grep -w /media/$IMAGE | awk '{print $1}'` | grep ^UUID)
echo "old_uuid: $old_uuid"
echo "new_uuid: $new_uuid"
sed -i s/$old_uuid/$new_uuid/ $MOUNT_IMAGE/etc/fstab
if [ -e $MOUNT_IMAGE/boot/armbianEnv.txt ]; then
sed -i s/$old_uuid/$new_uuid/ $MOUNT_IMAGE/boot/armbianEnv.txt
fi
}
write_mbr() {
# On cherche le uboot_sunxi_with_spl.bin selon si on est sur armbian ou non
local $uboot_mbr
local $loop
loop=$1
uboot_mbr=$2
if [ ! -f $uboot_mbr ]; then
exit 1;
fi
# on Efface la zone pour le mbr
dd if=/dev/zero of=$loop bs=1k count=1023 seek=1 status=noxfer > /dev/null 2>&1;
# on flash le mbr
dd if=$uboot_mbr of=$loop bs=1024 seek=8 status=noxfer > /dev/null 2>&1;
}
clean() {
local loop=$1
local mount_image=$2
sync
umount $mount_image
losetup -d $loop
rmdir $mount_image
}
## Début du script
show_usage() {
cat << EOF
Ce script génère une image qui peut être flasher sur une carte SD pour les cartes
Olimex LIME LIME2 et orange pi pc (plus)
$(basename $0)
-d Dossier où sera stocké l'image
-u uboot_sunxi_with_spl.bin
EOF
exit 1
}
if [ ! $(id -u) = 0 ]; then
echo "L'utilisateur doit être root"
exit 1
fi
## Possibilité d'aller chercher le uboot_sunxi_with_spl.bin sur une adresse http
#Check arguments
if [ $# -eq 0 ]; then
show_usage
fi
# Gérer les options https://www.tutorialspoint.com/unix_commands/getopt.htm
while getopts ":d:u:h" opt; do
case $opt in
d)
FOLDER=$OPTARG
;;
u)
UBOOT_MBR=$OPTARG
;;
h | *)
show_usage;
;;
esac
done
if [ -z $FOLDER ]; then
show_usage
fi
if [ ! -d $FOLDER ]; then
echo "$FOLDER isn't a directory";
#echo "Le dossier $FOLDER n'existe pas"
show_usage
fi
if [ -z $UBOOT_MBR ]; then
show_usage
fi
if [ ! -f $UBOOT_MBR ]; then
echo "This file $UBOOT_MBR doesn't exist";
show_usage
fi
IMAGE=snapshot_`date +%Y%m%d`.img
LOOP=$(losetup -f)
MOUNT_IMAGE="/media/"$IMAGE
check_dep
echo "check_dep : OK"
#On crée un image de la taille minimale avec 1024M de place disponible.
create_img $FOLDER $IMAGE
echo "create_img: OK"
#On crée l'interface Loop et les partitions qui vont bien
prepare_part $LOOP $FOLDER $IMAGE $MOUNT_IMAGE
echo "prepare_part: OK"
#On copie la /
copy_files $MOUNT_IMAGE
echo "copy_file: OK"
#
change_fstab $MOUNT_IMAGE
echo "change_fstab: OK"
#On écrit le MBR
write_mbr $LOOP $UBOOT_MBR
echo "write_uboot: OK"
#demonte l'image et detache l'interface loop
clean $LOOP $MOUNT_IMAGE
je copie ce script dans /usr/local/bin/make_img
chmod +x /usr/local/bin/make_img
Puis dans mon fichier /etc/saveonusb/script/save.sh
DIR_SAVE=$1
if [ ! -d "$DIR_SAVE" ]; then
echo "Le repertoire $DIR_SAVE n'existe pas" 1>&2;
exit 1;
fi
/usr/local/bin/make_img -f $DIR_SAVE -u /usr/lib/linux-u-boot-next-orangepipcplus_5.90_armhf/u-boot-sunxi-with-spl.bin
if [ $? -eq 1 ]; then
echo "Il y a eu une erreur durant la copie des fichiers" 1>&2;
exit 1;
fi
Version pour les personnes qui sont sous yunohost:
#!/bin/bash
DIR_SAVE=$1
if [ ! -d "$DIR_SAVE" ]; then
echo "Le repertoire $DIR_SAVE n'existe pas" 1>&2;
exit 1;
fi
/usr/bin/yunohost backup create -o $DIR_SAVE
if [ $? -eq 1 ]; then
echo "Il y a eu une erreur pendant l'exécution de yunohost backup" 1>&2;
exit 1;
fi
Il y a biensur des choses à améliorer, mais c'est fonctionnel. On pourrait par exemple avoir plusieurs scripts ou vérifier si le support de sauvergarde a encore la place suffisante. Mais pour mes besoins ça me suffit. Une fonction pour la restauration ça serait pas mal aussi :).