feat : script de reconstruction de bdd

RecetteScripts/backup-bdd-recette.sh

@@ -92,8 +92,23 @@ exec > >(tee -a "$LOG_FILE") 2>&1
 
 log() { echo "---- $(date +'%Y-%m-%d %H:%M:%S') ---- $*"; }
 
+require_cmd() {
+  command -v "$1" >/dev/null 2>&1
+}
+
 export PGPASSWORD
 
+#######################################
+# Vérification dépendances minimales
+#######################################
+
+for cmd in ssh scp curl jq pg_dump pg_dumpall; do
+  require_cmd "$cmd" || {
+    echo "ERROR: commande manquante : $cmd" >&2
+    exit 1
+  }
+done
+
 #######################################
 # Configuration Discord
 #######################################
@@ -122,11 +137,14 @@ discord_send() {
 #######################################
 
 discord_msg_global_ok() {
-  local msg="**BACKUP BDD ${ENV_NAME} 🟢**\n"
+  local msg
-  msg+="Name: ${BACKUP_DIR_NAME}\n"
+  msg="$(cat <<EOF
-  msg+="Dumps transfer: ✅\n"
+**BACKUP BDD ${ENV_NAME} 🟢**
-  msg+="Users transfer: ✅"
+Name: ${BACKUP_DIR_NAME}
-
+Dumps transfer: ✅
+Users transfer: ✅
+EOF
+)"
   discord_send "$msg"
 }
 
@@ -135,9 +153,12 @@ discord_msg_global_ok() {
 #######################################
 
 discord_msg_users_ok_simple() {
-  local msg="**BACKUP BDD ${ENV_NAME} 🟢**\n"
+  local msg
-  msg+="Users backup validé"
+  msg="$(cat <<EOF
-
+**BACKUP BDD ${ENV_NAME} 🟢**
+Users backup validé
+EOF
+)"
   discord_send "$msg"
 }
 
@@ -150,12 +171,25 @@ discord_msg_users_error() {
   export_disp=$([[ -n "$export_ok" ]] && echo "✅" || echo "❌")
   transfer_disp=$([[ -n "$transfer_ok" ]] && echo "✅" || echo "❌")
 
-  local msg="**${DISCORD_PING} BACKUP BDD ${ENV_NAME} 🔴**\n"
+  local msg
-  msg+="Name: ${BACKUP_DIR_NAME}\n"
+  if [[ -n "$details" ]]; then
-  msg+="Users export: ${export_disp}\n"
+    msg="$(cat <<EOF
-  msg+="Users transfer: ${transfer_disp}"
+**${DISCORD_PING} BACKUP BDD ${ENV_NAME} 🔴**
-
+Name: ${BACKUP_DIR_NAME}
-  [[ -n "$details" ]] && msg+="\nDetails: ${details}"
+Users export: ${export_disp}
+Users transfer: ${transfer_disp}
+Details: ${details}
+EOF
+)"
+  else
+    msg="$(cat <<EOF
+**${DISCORD_PING} BACKUP BDD ${ENV_NAME} 🔴**
+Name: ${BACKUP_DIR_NAME}
+Users export: ${export_disp}
+Users transfer: ${transfer_disp}
+EOF
+)"
+  fi
 
   discord_send "$msg"
 }
@@ -166,9 +200,12 @@ discord_msg_users_error() {
 
 discord_msg_db_ok_simple() {
   local db="$1"
-  local msg="**BACKUP BDD ${ENV_NAME} 🟢**\n"
+  local msg
-  msg+="Backup validé : ${db}"
+  msg="$(cat <<EOF
-
+**BACKUP BDD ${ENV_NAME} 🟢**
+Backup validé : ${db}
+EOF
+)"
   discord_send "$msg"
 }
 
@@ -182,13 +219,27 @@ discord_msg_db_error() {
   dump_disp=$([[ -n "$dump_ok" ]] && echo "✅" || echo "❌")
   transfer_disp=$([[ -n "$transfer_ok" ]] && echo "✅" || echo "❌")
 
-  local msg="**${DISCORD_PING} BACKUP BDD ${ENV_NAME} 🔴**\n"
+  local msg
-  msg+="Name: ${BACKUP_DIR_NAME}\n"
+  if [[ -n "$details" ]]; then
-  msg+="Database: ${db}\n"
+    msg="$(cat <<EOF
-  msg+="Dump: ${dump_disp}\n"
+**${DISCORD_PING} BACKUP BDD ${ENV_NAME} 🔴**
-  msg+="Transfer: ${transfer_disp}"
+Name: ${BACKUP_DIR_NAME}
-
+Database: ${db}
-  [[ -n "$details" ]] && msg+="\nDetails: ${details}"
+Dump: ${dump_disp}
+Transfer: ${transfer_disp}
+Details: ${details}
+EOF
+)"
+  else
+    msg="$(cat <<EOF
+**${DISCORD_PING} BACKUP BDD ${ENV_NAME} 🔴**
+Name: ${BACKUP_DIR_NAME}
+Database: ${db}
+Dump: ${dump_disp}
+Transfer: ${transfer_disp}
+EOF
+)"
+  fi
 
   discord_send "$msg"
 }
@@ -220,7 +271,7 @@ if ! mkdir "$LOCK_DIR" 2>/dev/null; then
   exit 1
 fi
 
-trap 'rm -rf "$LOCK_DIR"' EXIT
+trap 'rm -rf "$LOCK_DIR" "$TMP_DIR"' EXIT
 
 #######################################
 # Préparation du dossier distant
@@ -240,13 +291,18 @@ fi
 # Export des rôles PostgreSQL
 #######################################
 
-ROLES_FILE="${TMP_DIR}/user_${TS}.dump"
+ROLES_FILE="${TMP_DIR}/user_${TS}.sql"
 
 set +e
 
-psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -Atq <<'SQL' > "$ROLES_FILE"
+log "Export des rôles PostgreSQL"
-SELECT rolname FROM pg_roles WHERE rolname !~ '^pg_';
+
-SQL
+pg_dumpall \
+  -h "$PGHOST" \
+  -p "$PGPORT" \
+  -U "$PGUSER" \
+  --globals-only \
+  > "$ROLES_FILE"
 
 RET=$?
 
@@ -254,18 +310,24 @@ if [[ $RET -ne 0 ]]; then
   USERS_OK=
   USERS_EXPORT_OK=
   USERS_DETAILS="roles export failed"
+else
+  log "Export des rôles OK : $ROLES_FILE"
 fi
 
-scp "${SSH_OPTS[@]}" "$ROLES_FILE" "$IA_SSH:${REMOTE_DIR}/user/"
+if [[ -n "${USERS_EXPORT_OK:-}" ]]; then
-RET=$?
+  scp "${SSH_OPTS[@]}" "$ROLES_FILE" "$IA_SSH:${REMOTE_DIR}/user/"
+  RET=$?
 
-if [[ $RET -ne 0 ]]; then
+  if [[ $RET -ne 0 ]]; then
-  USERS_OK=
+    USERS_OK=
-  USERS_TRANSFER_OK=
+    USERS_TRANSFER_OK=
-  if [[ -n "$USERS_DETAILS" ]]; then
+    if [[ -n "$USERS_DETAILS" ]]; then
-    USERS_DETAILS+=" | roles transfer failed"
+      USERS_DETAILS+=" | roles transfer failed"
+    else
+      USERS_DETAILS="roles transfer failed"
+    fi
   else
-    USERS_DETAILS="roles transfer failed"
+    log "Transfert des rôles OK"
   fi
 fi
 
@@ -317,11 +379,13 @@ log "Starting remote rotation: delete backups older than ${RETENTION_DAYS} days"
 
 set +e
 
-ssh "${SSH_OPTS[@]}" "$IA_SSH" "find '${REMOTE_DIR}/user' -type f -name 'user_*.dump' -mtime +${RETENTION_DAYS} -delete"
+ssh "${SSH_OPTS[@]}" "$IA_SSH" "find '${REMOTE_DIR}/user' -type f -name 'user_*.sql' -mtime +${RETENTION_DAYS} -delete"
 RET=$?
 
 if [[ $RET -ne 0 ]]; then
   log "ERROR: remote rotation failed for users"
+else
+  log "Remote rotation OK for users"
 fi
 
 for DB in "${DBS_ARRAY[@]}"; do

RecetteScripts/check-statut-recette.sh

@@ -127,11 +127,10 @@ send_discord_summary() {
   fi
 
   local msg="**${ping_prefix}CHECK APP ${ENV_NAME} ${header_icon}**"
-  msg+="\n"
 
   local line
   for line in "${SUMMARY_LINES[@]}"; do
-    msg+="\n${line}"
+    msg+=$'\n'"${line}"
   done
 
   local payload

RecetteScripts/rebuild-bdd-recette.sh

@@ -2,498 +2,424 @@
 set -euo pipefail
 
 ###############################################################################
-# restore-postgres-db.sh
+# rebuild-bdd-recette.sh
 #
-# Finalité :
+# Script de reconstruction d'une base PostgreSQL à partir d'un dump distant.
-#   Restaurer une base PostgreSQL à partir du dernier dump disponible sur un
-#   serveur distant.
 #
 # Fonctionnement global :
-#   1. charge les variables depuis un fichier .env placé à côté du script ;
+#   1. charge la configuration depuis le fichier .env ;
-#   2. vérifie les dépendances locales nécessaires ;
+#   2. prépare les chemins, logs et options SSH ;
-#   3. détermine la base à restaurer ;
+#   3. installe PostgreSQL si absent ;
-#   4. teste la connexion SSH au serveur distant ;
+#   4. démarre PostgreSQL si nécessaire ;
-#   5. recherche automatiquement le dump .dump le plus récent ;
+#   5. crée le rôle PGUSER uniquement si PostgreSQL vient d'être installé ;
-#   6. recherche automatiquement le fichier .sql des rôles le plus récent ;
+#   6. propose à l'utilisateur de choisir une base à reconstruire ;
-#   7. télécharge les fichiers dans un dossier temporaire local ;
+#   7. teste la connexion SSH au serveur distant ;
-#   8. vérifie que le dump téléchargé est valide ;
+#   8. recherche le dernier dump distant de la base choisie ;
-#   9. demande confirmation si la base existe déjà ;
+#   9. recherche le dernier fichier SQL des rôles dans le dossier "user" ;
-#  10. recrée la base si nécessaire ;
+#  10. télécharge les fichiers nécessaires ;
-#  11. restaure éventuellement les rôles PostgreSQL ;
+#  11. restaure les rôles via psql (avec filtrage des rôles sensibles) ;
-#  12. restaure le contenu de la base ;
+#  12. supprime puis recrée la base cible ;
-#  13. supprime les fichiers temporaires.
+#  13. restaure la base choisie via pg_restore ;
-#
+#  14. envoie une notification Discord si tout s'est bien passé.
-# Hypothèses :
-#   - machine locale de restauration sous Linux Debian/Ubuntu ou macOS ;
-#   - serveur distant compatible GNU find si l'on utilise -printf ;
-#   - dumps PostgreSQL au format custom (.dump) ;
-#   - rôles exportés dans un fichier .sql rejouable.
 ###############################################################################
 
 ###############################################################################
-# Chargement du .env
+# Chemins fixes du script
-#
-# Le script cherche automatiquement un fichier .env dans le même dossier
-# que lui. Cela évite d'avoir des chemins absolus codés en dur.
 ###############################################################################
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 ENV_FILE="${SCRIPT_DIR}/.env"
 
+###############################################################################
+# Vérification du fichier .env
+###############################################################################
 if [[ ! -f "$ENV_FILE" ]]; then
   echo "ERROR: fichier .env introuvable : $ENV_FILE" >&2
   exit 1
 fi
 
+###############################################################################
+# Chargement du .env
+###############################################################################
 set -a
 # shellcheck disable=SC1090
 source "$ENV_FILE"
 set +a
 
 ###############################################################################
-# Vérification des variables obligatoires
+# Variables obligatoires
-#
-# Ces variables doivent exister dans le .env. Sans elles, le script ne peut
-# pas fonctionner correctement.
 ###############################################################################
+: "${ENV_NAME:?Variable ENV_NAME manquante}"
 : "${PGHOST:?Variable PGHOST manquante}"
 : "${PGPORT:?Variable PGPORT manquante}"
 : "${PGUSER:?Variable PGUSER manquante}"
 : "${PGPASSWORD:?Variable PGPASSWORD manquante}"
-: "${BACKUP_LOG_DIR:?Variable BACKUP_LOG_DIR manquante}"
+: "${DBS:?Variable DBS manquante}"
+: "${BACKUP_REMOTE_USER:?Variable BACKUP_REMOTE_USER manquante}"
+: "${BACKUP_REMOTE_HOST:?Variable BACKUP_REMOTE_HOST manquante}"
+: "${BACKUP_REMOTE_DIR:?Variable BACKUP_REMOTE_DIR manquante}"
 : "${SSH_KEY:?Variable SSH_KEY manquante}"
-: "${IA_SSH:?Variable IA_SSH manquante}"
+: "${BACKUP_LOG_DIR:?Variable BACKUP_LOG_DIR manquante}"
-: "${IA_BASE_DIR:?Variable IA_BASE_DIR manquante}"
 
 ###############################################################################
 # Variables optionnelles
-#
-# Valeurs par défaut appliquées si elles ne sont pas définies dans le .env.
 ###############################################################################
-SSH_TIMEOUT="${SSH_TIMEOUT:-10}"
+LOCAL_RESTORE_DIR="${LOCAL_RESTORE_DIR:-${SCRIPT_DIR}/restore_tmp}"
-
-# Nom du dossier distant contenant les exports SQL des rôles PostgreSQL.
-# Exemple distant :
-#   /home/backup/backups/user
 REMOTE_ROLES_DIR_NAME="${REMOTE_ROLES_DIR_NAME:-user}"
+SSH_CONNECT_TIMEOUT="${SSH_CONNECT_TIMEOUT:-8}"
+DISCORD_WEBHOOK_URL="${DISCORD_WEBHOOK_URL:-}"
 
 ###############################################################################
-# Mise en place des logs
+# Préparation des dossiers locaux
-#
-# Tous les messages stdout/stderr sont redirigés vers la console ET vers
-# un fichier de log horodaté.
 ###############################################################################
-mkdir -p "$BACKUP_LOG_DIR"
+mkdir -p "$BACKUP_LOG_DIR" || {
-LOG_FILE="${BACKUP_LOG_DIR}/restore_$(date +'%Y-%m-%d_%H-%M-%S').log"
+  echo "ERROR: impossible de créer le dossier de logs : $BACKUP_LOG_DIR" >&2
-touch "$LOG_FILE"
+  exit 1
+}
 
-exec > >(tee -a "$LOG_FILE") 2>&1
+mkdir -p "$LOCAL_RESTORE_DIR" || {
+  echo "ERROR: impossible de créer le dossier local de restauration : $LOCAL_RESTORE_DIR" >&2
+  exit 1
+}
+
+TIMESTAMP="$(date '+%Y-%m-%d_%H-%M-%S')"
+LOG_FILE="${BACKUP_LOG_DIR}/restore_${ENV_NAME,,}_${TIMESTAMP}.log"
+
+touch "$LOG_FILE" || {
+  echo "ERROR: impossible d'écrire dans le fichier de log : $LOG_FILE" >&2
+  exit 1
+}
 
 ###############################################################################
 # Fonctions utilitaires
 ###############################################################################
-
-# Écrit un message daté dans les logs.
 log() {
-  echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*"
+  echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
 }
 
-# Affiche une erreur puis quitte le script.
 fail() {
-  echo "ERROR: $*" >&2
+  log "ERROR: $*"
   exit 1
 }
 
-# Vérifie que le nom de base est acceptable.
+cleanup() {
-#
+  rm -f \
-# Règle choisie ici :
+    "${LOCAL_DB_DUMP_FILE:-}" \
-#   - lettres
+    "${LOCAL_ROLES_FILE:-}" \
-#   - chiffres
+    "${FILTERED_ROLES_FILE:-}" \
-#   - underscore
+    "${ROLES_CREATE_LIST:-}" \
-#
+    "${ROLES_APPLY_FILE:-}"
-# Cela évite beaucoup de problèmes d'injection ou de nom invalide.
-validate_db_name() {
-  local db_name="$1"
-
-  [[ -n "$db_name" ]] || return 1
-  [[ "$db_name" =~ ^[a-zA-Z0-9_]+$ ]] || return 1
-
-  return 0
 }
+trap cleanup EXIT
 
-# Vérifie qu'une commande existe.
+require_cmd() {
-require_command() {
+  command -v "$1" >/dev/null 2>&1
-  local cmd="$1"
-  command -v "$cmd" >/dev/null 2>&1
-}
-
-# Petite fonction de confirmation utilisateur.
-# Retourne 0 si oui, 1 sinon.
-confirm_yes_no() {
-  local prompt="$1"
-  local answer=""
-
-  read -r -p "$prompt" answer
-  case "${answer,,}" in
-    oui|o|yes|y) return 0 ;;
-    *) return 1 ;;
-  esac
 }
 
 ###############################################################################
-# Installation des dépendances manquantes
+# Envoi Discord
 #
-# On privilégie ici les clients PostgreSQL plutôt que l'installation complète
+# Envoi simple d'un message texte via webhook Discord.
-# du serveur si ce n'est pas nécessaire.
+# Si WEBHOOK_URL n'est pas défini, on ignore silencieusement l'envoi.
 ###############################################################################
-install_postgres_client() {
+send_discord_message() {
-  log "Installation des outils PostgreSQL..."
+  local message="$1"
+  local payload=""
 
-  if require_command apt-get; then
+  [[ -n "$DISCORD_WEBHOOK_URL" ]] || {
-    sudo apt-get update
+    log "WEBHOOK_URL non défini : notification Discord ignorée."
-    sudo apt-get install -y postgresql-client
+    return 0
-  elif require_command brew; then
+  }
-    brew install postgresql
-  else
-    fail "impossible d'installer automatiquement les outils PostgreSQL : gestionnaire non supporté"
-  fi
-}
 
-install_scp_client() {
+  if ! require_cmd curl; then
-  log "Installation de OpenSSH client..."
+    log "curl absent : notification Discord ignorée."
-
-  if require_command apt-get; then
-    sudo apt-get update
-    sudo apt-get install -y openssh-client
-  elif require_command brew; then
-    fail "scp / ssh introuvable sur macOS. Installe OpenSSH manuellement."
-  else
-    fail "impossible d'installer automatiquement openssh-client : gestionnaire non supporté"
-  fi
-}
-
-###############################################################################
-# Résolution du nom de la base à restaurer
-#
-# Priorité :
-#   1. variable DB si elle existe déjà
-#   2. sélection depuis DBS si défini dans le .env
-#   3. saisie manuelle
-#
-# IMPORTANT :
-#   - les messages d'interface sont envoyés sur stderr ;
-#   - seul le résultat final (nom de base) est envoyé sur stdout.
-#
-# Cela évite de polluer la variable récupérée via :
-#   DB="$(resolve_db_name)"
-###############################################################################
-resolve_db_name() {
-  local selected_db=""
-  local choice=""
-  local custom_db=""
-  local -a dbs_array=()
-
-  if [[ -n "${DB:-}" ]]; then
-    printf '%s\n' "$DB"
     return 0
   fi
 
-  if [[ -n "${DBS:-}" ]]; then
+  payload="$(python3 -c 'import json,sys; print(json.dumps({"content": sys.argv[1]}))' "$message")" || {
-    read -r -a dbs_array <<< "$DBS"
+    log "Impossible de construire le payload JSON Discord."
+    return 0
+  }
 
-    if [[ "${#dbs_array[@]}" -gt 0 ]]; then
+  curl -sS -X POST "$DISCORD_WEBHOOK_URL" \
-      echo "Bases disponibles dans le .env :" >&2
+    -H "Content-Type: application/json" \
-      for i in "${!dbs_array[@]}"; do
+    -d "$payload" \
-        printf '  %d) %s\n' "$((i + 1))" "${dbs_array[$i]}" >&2
+    >/dev/null || log "Échec d'envoi de la notification Discord."
-      done
-      echo >&2
-
-      read -r -p "Voulez-vous utiliser une base de cette liste ? (oui/non) : " choice
-
-      case "${choice,,}" in
-        oui|o|yes|y)
-          while true; do
-            read -r -p "Sélectionnez le numéro de la base à restaurer : " selected_db
-
-            if [[ "$selected_db" =~ ^[0-9]+$ ]] && (( selected_db >= 1 && selected_db <= ${#dbs_array[@]} )); then
-              printf '%s\n' "${dbs_array[$((selected_db - 1))]}"
-              return 0
-            fi
-
-            echo "Choix invalide. Veuillez entrer un numéro entre 1 et ${#dbs_array[@]}." >&2
-          done
-          ;;
-        non|n|no)
-          read -r -p "Entrez le nom de la base à restaurer hors liste : " custom_db
-          printf '%s\n' "$custom_db"
-          return 0
-          ;;
-        *)
-          echo "Réponse invalide. Saisie manuelle de la base." >&2
-          read -r -p "Entrez le nom de la base à restaurer : " custom_db
-          printf '%s\n' "$custom_db"
-          return 0
-          ;;
-      esac
-    fi
-  fi
-
-  read -r -p "Aucune base définie via DB ou DBS. Entrez le nom de la base à restaurer : " custom_db
-  printf '%s\n' "$custom_db"
 }
 
 ###############################################################################
-# Détermination de la base cible
+# Vérifications de base
-###############################################################################
-DB="$(resolve_db_name)"
-
-if ! validate_db_name "$DB"; then
-  fail "nom de base invalide : '$DB'. Caractères autorisés : lettres, chiffres, underscore."
-fi
-
-log "Base cible sélectionnée : $DB"
-
-###############################################################################
-# Vérification des dépendances locales
-###############################################################################
-if ! require_command psql; then
-  log "psql introuvable."
-  install_postgres_client
-fi
-
-if ! require_command pg_restore; then
-  log "pg_restore introuvable."
-  install_postgres_client
-fi
-
-if ! require_command createdb; then
-  log "createdb introuvable."
-  install_postgres_client
-fi
-
-if ! require_command dropdb; then
-  log "dropdb introuvable."
-  install_postgres_client
-fi
-
-if ! require_command ssh; then
-  log "ssh introuvable."
-  install_scp_client
-fi
-
-if ! require_command scp; then
-  log "scp introuvable."
-  install_scp_client
-fi
-
-###############################################################################
-# Vérification de la clé SSH
 ###############################################################################
 [[ -f "$SSH_KEY" ]] || fail "clé SSH introuvable : $SSH_KEY"
+[[ -r "$SSH_KEY" ]] || fail "clé SSH non lisible : $SSH_KEY"
+
+export PGPASSWORD
 
-###############################################################################
-# Configuration SSH
-#
-# BatchMode=yes :
-#   empêche les demandes interactives de mot de passe.
-#
-# IdentitiesOnly=yes :
-#   force l'usage de la clé fournie.
-###############################################################################
 SSH_OPTS=(
   -i "$SSH_KEY"
   -o IdentitiesOnly=yes
   -o BatchMode=yes
-  -o ConnectTimeout="$SSH_TIMEOUT"
+  -o ConnectTimeout="$SSH_CONNECT_TIMEOUT"
+  -o StrictHostKeyChecking=accept-new
 )
 
+REMOTE_SSH="${BACKUP_REMOTE_USER}@${BACKUP_REMOTE_HOST}"
+
+###############################################################################
+# Installation PostgreSQL si absent
+#
+# Le rôle PGUSER est créé uniquement si PostgreSQL vient d'être installé.
+###############################################################################
+POSTGRES_INSTALLED=false
+
+if ! require_cmd psql || ! require_cmd pg_restore || ! require_cmd createdb || ! require_cmd dropdb; then
+  log "PostgreSQL absent : installation en cours..."
+
+  sudo apt update >>"$LOG_FILE" 2>&1 || fail "échec de apt update"
+  sudo apt install -y postgresql postgresql-client postgresql-contrib \
+    >>"$LOG_FILE" 2>&1 || fail "échec de l'installation de PostgreSQL"
+
+  POSTGRES_INSTALLED=true
+  log "Installation PostgreSQL terminée."
+else
+  log "PostgreSQL déjà installé."
+fi
+
+###############################################################################
+# Démarrage PostgreSQL
+###############################################################################
+if ! sudo systemctl is-active --quiet postgresql; then
+  log "Démarrage du service PostgreSQL..."
+  sudo systemctl start postgresql >>"$LOG_FILE" 2>&1 || fail "impossible de démarrer PostgreSQL"
+else
+  log "Service PostgreSQL déjà actif."
+fi
+
+###############################################################################
+# Attente disponibilité PostgreSQL
+###############################################################################
+log "Vérification de la disponibilité de PostgreSQL..."
+for _ in {1..20}; do
+  if sudo -u postgres psql -d postgres -c "SELECT 1;" >/dev/null 2>&1; then
+    log "PostgreSQL répond correctement."
+    break
+  fi
+  sleep 1
+done
+
+if ! sudo -u postgres psql -d postgres -c "SELECT 1;" >/dev/null 2>&1; then
+  fail "PostgreSQL ne répond pas correctement"
+fi
+
+###############################################################################
+# Création du rôle PGUSER uniquement si PostgreSQL vient d'être installé
+###############################################################################
+if [[ "$POSTGRES_INSTALLED" == "true" ]]; then
+  log "Création du rôle PostgreSQL ${PGUSER} suite à une installation neuve..."
+
+  sudo -u postgres psql -d postgres -c \
+    "CREATE ROLE \"${PGUSER}\" WITH LOGIN SUPERUSER CREATEDB CREATEROLE PASSWORD '${PGPASSWORD}';" \
+    >>"$LOG_FILE" 2>&1 || fail "échec de création du rôle ${PGUSER}"
+
+  log "Rôle PostgreSQL ${PGUSER} créé."
+fi
+
+###############################################################################
+# Affichage des bases disponibles
+###############################################################################
+read -r -a DBS_ARRAY <<< "$DBS"
+
+if [[ "${#DBS_ARRAY[@]}" -eq 0 ]]; then
+  fail "aucune base définie dans DBS"
+fi
+
+echo "Bases disponibles dans le .env :"
+for i in "${!DBS_ARRAY[@]}"; do
+  printf '  %d) %s\n' "$((i + 1))" "${DBS_ARRAY[$i]}"
+done
+
+echo
+read -r -p "Voulez-vous utiliser une base de cette liste ? (oui/non) : " USE_LIST
+
+DB=""
+
+if [[ "${USE_LIST,,}" == "oui" || "${USE_LIST,,}" == "o" ]]; then
+  read -r -p "Sélectionnez le numéro de la base à restaurer : " DB_INDEX
+
+  [[ "$DB_INDEX" =~ ^[0-9]+$ ]] || fail "numéro invalide"
+  (( DB_INDEX >= 1 && DB_INDEX <= ${#DBS_ARRAY[@]} )) || fail "numéro hors plage"
+
+  DB="${DBS_ARRAY[$((DB_INDEX - 1))]}"
+else
+  read -r -p "Nom exact de la base à restaurer : " DB
+  [[ -n "$DB" ]] || fail "nom de base vide"
+fi
+
+log "Environnement : $ENV_NAME"
+log "Base cible sélectionnée : $DB"
+
 ###############################################################################
 # Test de connexion SSH
-#
-# On teste la connexion immédiatement pour échouer tôt si le serveur distant
-# n'est pas joignable ou si la clé n'est pas acceptée.
 ###############################################################################
-log "Test de connexion SSH vers ${IA_SSH}..."
+log "Test de connexion SSH vers ${REMOTE_SSH}..."
-ssh "${SSH_OPTS[@]}" "$IA_SSH" "echo OK" >/dev/null 2>&1 \
+
-  || fail "connexion SSH impossible vers ${IA_SSH}"
+SSH_TEST_OUTPUT=""
+if ! SSH_TEST_OUTPUT="$(ssh "${SSH_OPTS[@]}" "$REMOTE_SSH" "exit 0" 2>&1)"; then
+  echo "$SSH_TEST_OUTPUT" | tee -a "$LOG_FILE" >&2
+  fail "connexion SSH impossible vers ${REMOTE_SSH}"
+fi
 
 ###############################################################################
 # Définition des chemins distants
-#
-# Structure attendue :
-#   $IA_BASE_DIR/$DB/               -> contient les dumps .dump de la base
-#   $IA_BASE_DIR/$REMOTE_ROLES_DIR_NAME/ -> contient les exports .sql des rôles
 ###############################################################################
-REMOTE_DUMP_DIR="${IA_BASE_DIR}/${DB}"
+REMOTE_DB_DIR="${BACKUP_REMOTE_DIR}/${DB}"
-REMOTE_ROLES_DIR="${IA_BASE_DIR}/${REMOTE_ROLES_DIR_NAME}"
+REMOTE_ROLES_DIR="${BACKUP_REMOTE_DIR}/${REMOTE_ROLES_DIR_NAME}"
 
-log "Recherche du dernier dump distant pour ${DB} dans : $REMOTE_DUMP_DIR"
+log "Recherche du dernier dump distant pour ${DB} dans : ${REMOTE_DB_DIR}"
-log "Recherche du dernier fichier de rôles dans : $REMOTE_ROLES_DIR"
+log "Recherche du dernier fichier de rôles dans : ${REMOTE_ROLES_DIR}"
 
 ###############################################################################
-# Recherche automatique du dump le plus récent
+# Recherche du dernier dump de base
-#
-# On cherche tous les fichiers .dump dans le dossier distant de la base,
-# puis on les trie par date de modification décroissante.
-#
-# Le premier résultat est donc le plus récent.
 ###############################################################################
-REMOTE_DUMP_PATH="$(
+LAST_REMOTE_DB_DUMP="$(
-  ssh "${SSH_OPTS[@]}" "$IA_SSH" "
+  ssh "${SSH_OPTS[@]}" "$REMOTE_SSH" \
-    if [ -d '$REMOTE_DUMP_DIR' ]; then
+    "find '${REMOTE_DB_DIR}' -maxdepth 1 -type f -name '${DB}_*.dump' | LC_ALL=C sort | tail -n 1"
-      find '$REMOTE_DUMP_DIR' -maxdepth 1 -type f -name '*.dump' -printf '%T@ %p\n' 2>/dev/null \
-        | sort -nr \
-        | head -n 1 \
-        | cut -d' ' -f2-
-    fi
-  "
 )"
 
-if [[ -z "$REMOTE_DUMP_PATH" ]]; then
+if [[ -z "$LAST_REMOTE_DB_DUMP" ]]; then
-  fail "aucun dump distant trouvé dans : $REMOTE_DUMP_DIR"
+  fail "aucun dump trouvé pour la base ${DB} dans ${REMOTE_DB_DIR}"
 fi
 
-REMOTE_DUMP_FILE="$(basename "$REMOTE_DUMP_PATH")"
+log "Dernier dump distant sélectionné : ${LAST_REMOTE_DB_DUMP}"
 
 ###############################################################################
-# Recherche automatique du dernier fichier des rôles
+# Recherche du dernier fichier SQL des rôles
-#
-# Ce fichier n'est pas obligatoire pour restaurer la base elle-même.
-# Si aucun fichier de rôles n'est trouvé, le script continue quand même.
 ###############################################################################
-REMOTE_ROLES_PATH="$(
+LAST_REMOTE_ROLES_FILE="$(
-  ssh "${SSH_OPTS[@]}" "$IA_SSH" "
+  ssh "${SSH_OPTS[@]}" "$REMOTE_SSH" \
-    if [ -d '$REMOTE_ROLES_DIR' ]; then
+    "find '${REMOTE_ROLES_DIR}' -maxdepth 1 -type f -name 'user_*.sql' | LC_ALL=C sort | tail -n 1"
-      find '$REMOTE_ROLES_DIR' -maxdepth 1 -type f -name '*.sql' -printf '%T@ %p\n' 2>/dev/null \
-        | sort -nr \
-        | head -n 1 \
-        | cut -d' ' -f2-
-    fi
-  "
 )"
 
-REMOTE_ROLES_FILE=""
+if [[ -n "$LAST_REMOTE_ROLES_FILE" ]]; then
-if [[ -n "$REMOTE_ROLES_PATH" ]]; then
+  log "Dernier fichier des rôles sélectionné : ${LAST_REMOTE_ROLES_FILE}"
-  REMOTE_ROLES_FILE="$(basename "$REMOTE_ROLES_PATH")"
-fi
-
-log "Dernier dump distant sélectionné : $REMOTE_DUMP_PATH"
-if [[ -n "$REMOTE_ROLES_PATH" ]]; then
-  log "Dernier fichier des rôles sélectionné : $REMOTE_ROLES_PATH"
 else
   log "Aucun fichier des rôles trouvé sur le serveur distant."
 fi
 
 ###############################################################################
-# Dossier temporaire local
+# Téléchargement du dump principal
-#
-# Les fichiers téléchargés sont stockés dans un dossier temporaire, puis
-# supprimés automatiquement à la fin du script.
 ###############################################################################
-TMP_DIR="$(mktemp -d)"
+LOCAL_DB_DUMP_FILE="${LOCAL_RESTORE_DIR}/$(basename "$LAST_REMOTE_DB_DUMP")"
-LOCAL_DUMP_PATH="${TMP_DIR}/${REMOTE_DUMP_FILE}"
+LOCAL_ROLES_FILE=""
-LOCAL_ROLES_PATH=""
 
-cleanup() {
-  rm -rf "$TMP_DIR"
-}
-trap cleanup EXIT
-
-###############################################################################
-# Téléchargement du dump et des rôles
-###############################################################################
 log "Téléchargement du dump..."
-scp "${SSH_OPTS[@]}" "${IA_SSH}:${REMOTE_DUMP_PATH}" "$LOCAL_DUMP_PATH"
+scp "${SSH_OPTS[@]}" "${REMOTE_SSH}:${LAST_REMOTE_DB_DUMP}" "$LOCAL_DB_DUMP_FILE" \
+  >>"$LOG_FILE" 2>&1 || fail "échec du téléchargement du dump principal"
 
-if [[ ! -f "$LOCAL_DUMP_PATH" ]]; then
+###############################################################################
-  fail "échec du téléchargement du dump : fichier local introuvable"
+# Téléchargement du fichier des rôles si présent
-fi
+###############################################################################
+if [[ -n "$LAST_REMOTE_ROLES_FILE" ]]; then
+  LOCAL_ROLES_FILE="${LOCAL_RESTORE_DIR}/$(basename "$LAST_REMOTE_ROLES_FILE")"
 
-if [[ -n "$REMOTE_ROLES_PATH" ]]; then
-  LOCAL_ROLES_PATH="${TMP_DIR}/${REMOTE_ROLES_FILE}"
   log "Téléchargement du fichier des rôles..."
-  scp "${SSH_OPTS[@]}" "${IA_SSH}:${REMOTE_ROLES_PATH}" "$LOCAL_ROLES_PATH"
+  scp "${SSH_OPTS[@]}" "${REMOTE_SSH}:${LAST_REMOTE_ROLES_FILE}" "$LOCAL_ROLES_FILE" \
-
+    >>"$LOG_FILE" 2>&1 || fail "échec du téléchargement du fichier des rôles"
-  if [[ ! -f "$LOCAL_ROLES_PATH" ]]; then
-    fail "échec du téléchargement du fichier des rôles"
-  fi
 else
   log "La restauration des rôles sera ignorée."
 fi
 
 ###############################################################################
-# Vérification du format du dump
+# Test de connexion PostgreSQL locale avec PGUSER
-#
-# pg_restore --list permet de vérifier que le fichier est bien un dump
-# PostgreSQL lisible au format attendu.
 ###############################################################################
-if ! pg_restore --list "$LOCAL_DUMP_PATH" >/dev/null 2>&1; then
+if ! psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -c "SELECT 1;" \
-  fail "le fichier téléchargé n'est pas un dump PostgreSQL valide : $LOCAL_DUMP_PATH"
+  >>"$LOG_FILE" 2>&1; then
+  fail "connexion PostgreSQL locale impossible avec PGUSER=${PGUSER}"
 fi
 
 ###############################################################################
-# Vérification de l'existence de la base
+# Demande d'écrasement si la base existe déjà
-#
-# Si la base existe déjà, on demande explicitement à l'utilisateur s'il veut
-# l'écraser. Sinon, on la crée simplement.
 ###############################################################################
-DB_EXISTS="false"
+DB_EXISTS="$(
-if psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -tAc \
+  psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -tAc \
-  "SELECT 1 FROM pg_database WHERE datname = '$DB'" | grep -q '^1$'; then
+    "SELECT 1 FROM pg_database WHERE datname='${DB}'" 2>>"$LOG_FILE" || true
-  DB_EXISTS="true"
+)"
-fi
 
-if [[ "$DB_EXISTS" == "true" ]]; then
+if [[ "$DB_EXISTS" == "1" ]]; then
-  if confirm_yes_no "La base '${DB}' existe déjà. Voulez-vous l'écraser ? (oui/non) : "; then
+  read -r -p "La base '${DB}' existe déjà. Voulez-vous l'écraser ? (oui/non) : " CONFIRM_OVERWRITE
-    log "Suppression de la base existante : $DB"
+  if [[ "${CONFIRM_OVERWRITE,,}" != "oui" && "${CONFIRM_OVERWRITE,,}" != "o" ]]; then
-
+    fail "restauration annulée par l'utilisateur"
-    # Coupe les connexions actives sur la base pour permettre sa suppression.
-    psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -c \
-      "SELECT pg_terminate_backend(pid)
-       FROM pg_stat_activity
-       WHERE datname = '$DB'
-         AND pid <> pg_backend_pid();" >/dev/null
-
-    dropdb -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" "$DB"
-    createdb -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" "$DB"
-  else
-    log "Restauration annulée par l'utilisateur."
-    exit 0
   fi
-else
+
-  log "Création de la base : $DB"
+  log "Suppression de la base existante : ${DB}"
-  createdb -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" "$DB"
+  dropdb -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" --if-exists "$DB" \
+    >>"$LOG_FILE" 2>&1 || fail "échec de suppression de la base ${DB}"
 fi
 
 ###############################################################################
-# Restauration éventuelle des rôles PostgreSQL
+# Restauration des rôles
-#
-# Cette étape est optionnelle. Elle permet par exemple de recréer des rôles
-# ou utilisateurs nécessaires avant la restauration de la base.
-#
-# Attention :
-#   le fichier doit être conçu pour être rejouable sans casser l'existant.
 ###############################################################################
-if [[ -n "$LOCAL_ROLES_PATH" && -f "$LOCAL_ROLES_PATH" ]]; then
+if [[ -n "$LOCAL_ROLES_FILE" ]]; then
-  log "Restauration des rôles PostgreSQL..."
+  log "Restauration des rôles depuis : ${LOCAL_ROLES_FILE}"
-  psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -f "$LOCAL_ROLES_PATH"
+
+  FILTERED_ROLES_FILE="${LOCAL_RESTORE_DIR}/filtered_$(basename "$LOCAL_ROLES_FILE")"
+  ROLES_CREATE_LIST="${LOCAL_RESTORE_DIR}/roles_to_create_$(basename "$LOCAL_ROLES_FILE")"
+  ROLES_APPLY_FILE="${LOCAL_RESTORE_DIR}/roles_apply_$(basename "$LOCAL_ROLES_FILE")"
+
+  grep -viE '^(CREATE ROLE|ALTER ROLE) (backup_liot|postgres)\b' "$LOCAL_ROLES_FILE" \
+    > "$FILTERED_ROLES_FILE" || true
+
+  log "Fichier des rôles filtré généré : ${FILTERED_ROLES_FILE}"
+
+  sed -nE 's/^CREATE ROLE "?([^" ;]+)"?;$/\1/p' "$FILTERED_ROLES_FILE" \
+    > "$ROLES_CREATE_LIST" || true
+
+  if [[ -s "$ROLES_CREATE_LIST" ]]; then
+    while IFS= read -r role_name; do
+      [[ -z "$role_name" ]] && continue
+
+      ROLE_EXISTS="$(
+        psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -tAc \
+          "SELECT 1 FROM pg_roles WHERE rolname='${role_name}'" 2>>"$LOG_FILE" || true
+      )"
+
+      if [[ "$ROLE_EXISTS" != "1" ]]; then
+        log "Création du rôle manquant : ${role_name}"
+        psql -v ON_ERROR_STOP=1 \
+          -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres \
+          -c "CREATE ROLE \"${role_name}\";" \
+          >>"$LOG_FILE" 2>&1 || fail "échec de création du rôle ${role_name}"
+      else
+        log "Rôle déjà présent, création ignorée : ${role_name}"
+      fi
+    done < "$ROLES_CREATE_LIST"
+  fi
+
+  grep -viE '^CREATE ROLE ' "$FILTERED_ROLES_FILE" > "$ROLES_APPLY_FILE" || true
+
+  log "Application des ALTER ROLE / privilèges / memberships..."
+  psql \
+    -v ON_ERROR_STOP=1 \
+    -h "$PGHOST" \
+    -p "$PGPORT" \
+    -U "$PGUSER" \
+    -d postgres \
+    -f "$ROLES_APPLY_FILE" \
+    >>"$LOG_FILE" 2>&1 || fail "échec de restauration des rôles via psql"
 else
   log "Aucune restauration des rôles effectuée."
 fi
 
 ###############################################################################
-# Restauration de la base
+# Création de la base
-#
-# --clean / --if-exists :
-#   demande à pg_restore de supprimer les objets avant de les recréer.
-#
-# --no-owner :
-#   évite les problèmes si le propriétaire original n'existe pas localement.
-#
-# --verbose :
-#   détaille la restauration dans les logs.
 ###############################################################################
-log "Restauration de la base '${DB}' depuis ${LOCAL_DUMP_PATH}..."
+log "Création de la base : ${DB}"
+createdb -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" "$DB" \
+  >>"$LOG_FILE" 2>&1 || fail "échec de création de la base ${DB}"
 
+###############################################################################
+# Restauration de la base principale
+###############################################################################
+log "Restauration de la base ${DB}..."
 pg_restore \
   -h "$PGHOST" \
   -p "$PGPORT" \
@@ -502,7 +428,20 @@ pg_restore \
   --clean \
   --if-exists \
   --no-owner \
-  --verbose \
+  --no-privileges \
-  "$LOCAL_DUMP_PATH"
+  "$LOCAL_DB_DUMP_FILE" \
+  >>"$LOG_FILE" 2>&1 || fail "échec de restauration de la base ${DB}"
 
-log "Restauration terminée avec succès pour la base : $DB"
+###############################################################################
+# Fin
+###############################################################################
+log "Restauration terminée avec succès pour la base : ${DB}"
+log "Fichier de log : ${LOG_FILE}"
+
+SUCCESS_MESSAGE="✅ REBUILD BDD ${ENV_NAME}
+Base restaurée : ${DB}
+Hôte PostgreSQL : ${PGHOST}:${PGPORT}
+Dump utilisé : $(basename "$LAST_REMOTE_DB_DUMP")
+Log : ${LOG_FILE}"
+
+send_discord_message "$SUCCESS_MESSAGE"