507 lines
18 KiB
Bash
507 lines
18 KiB
Bash
#!/usr/bin/env bash
|
|
set -euo pipefail
|
|
umask 077
|
|
|
|
###############################################################################
|
|
# rebuild-bdd-recette.sh
|
|
#
|
|
# Script de reconstruction d'une base PostgreSQL à partir d'un dump distant.
|
|
#
|
|
# Fonctionnement global :
|
|
# 1. charge la configuration depuis le fichier .env ;
|
|
# 2. prépare les chemins, logs et options SSH ;
|
|
# 3. installe PostgreSQL si absent ;
|
|
# 4. démarre PostgreSQL si nécessaire ;
|
|
# 5. crée le rôle PGUSER uniquement si PostgreSQL vient d'être installé ;
|
|
# 6. propose à l'utilisateur de choisir une base à reconstruire ;
|
|
# 7. teste la connexion SSH au serveur distant ;
|
|
# 8. recherche le dernier dump distant de la base choisie ;
|
|
# 9. recherche le dernier fichier SQL des rôles dans le dossier "user" ;
|
|
# 10. télécharge les fichiers nécessaires ;
|
|
# 11. restaure les rôles via psql (avec filtrage des rôles sensibles) ;
|
|
# 12. supprime puis recrée la base cible ;
|
|
# 13. restaure la base choisie via pg_restore ;
|
|
# 14. envoie une notification Discord si tout s'est bien passé.
|
|
###############################################################################
|
|
|
|
###############################################################################
|
|
# Chemins fixes du script
|
|
###############################################################################
|
|
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
|
|
|
|
###############################################################################
|
|
# Variables obligatoires
|
|
###############################################################################
|
|
: "${ENV_NAME:?Variable ENV_NAME manquante}"
|
|
[[ "$ENV_NAME" =~ ^[a-zA-Z0-9_-]+$ ]] || {
|
|
echo "Variable ENV_NAME invalide : $ENV_NAME" >&2
|
|
exit 1
|
|
}
|
|
: "${PGHOST:?Variable PGHOST manquante}"
|
|
: "${PGPORT:?Variable PGPORT manquante}"
|
|
: "${PGUSER:?Variable PGUSER manquante}"
|
|
: "${PGPASSWORD:?Variable PGPASSWORD 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}"
|
|
: "${BACKUP_LOG_DIR:?Variable BACKUP_LOG_DIR manquante}"
|
|
|
|
###############################################################################
|
|
# Variables optionnelles
|
|
###############################################################################
|
|
LOCAL_RESTORE_DIR="${LOCAL_RESTORE_DIR:-${SCRIPT_DIR}/restore_tmp}"
|
|
REMOTE_ROLES_DIR_NAME="${REMOTE_ROLES_DIR_NAME:-user}"
|
|
BACKUP_REMOTE_SSH_PORT="${BACKUP_REMOTE_SSH_PORT:-22}"
|
|
SSH_CONNECT_TIMEOUT="${SSH_CONNECT_TIMEOUT:-8}"
|
|
DISCORD_WEBHOOK_URL="${DISCORD_WEBHOOK_URL:-}"
|
|
EXCLUDED_RESTORE_ROLES="${EXCLUDED_RESTORE_ROLES:-postgres}"
|
|
|
|
###############################################################################
|
|
# Préparation des dossiers locaux
|
|
###############################################################################
|
|
mkdir -p "$BACKUP_LOG_DIR" || {
|
|
echo "ERROR: impossible de créer le dossier de logs : $BACKUP_LOG_DIR" >&2
|
|
exit 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
|
|
###############################################################################
|
|
log() {
|
|
echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
|
|
}
|
|
|
|
fail() {
|
|
log "ERROR: $*"
|
|
exit 1
|
|
}
|
|
|
|
cleanup() {
|
|
rm -f \
|
|
"${LOCAL_DB_DUMP_FILE:-}" \
|
|
"${LOCAL_ROLES_FILE:-}" \
|
|
"${FILTERED_ROLES_FILE:-}" \
|
|
"${ROLES_CREATE_LIST:-}" \
|
|
"${ROLES_APPLY_FILE:-}"
|
|
rm -rf "${LOCAL_RESTORE_DIR:-}" 2>/dev/null || true
|
|
}
|
|
trap cleanup EXIT
|
|
|
|
require_cmd() {
|
|
command -v "$1" >/dev/null 2>&1 || fail "commande requise absente : $1"
|
|
}
|
|
|
|
has_cmd() {
|
|
command -v "$1" >/dev/null 2>&1
|
|
}
|
|
|
|
sql_escape_literal() {
|
|
local s="${1:-}"
|
|
s="${s//\'/\'\'}"
|
|
printf "%s" "$s"
|
|
}
|
|
|
|
validate_db_name() {
|
|
local db_name="${1:-}"
|
|
|
|
[[ -n "$db_name" ]] || return 1
|
|
[[ "$db_name" =~ ^[a-zA-Z0-9_]+$ ]] || return 1
|
|
}
|
|
|
|
build_excluded_roles_regex() {
|
|
local role regex=""
|
|
|
|
for role in $EXCLUDED_RESTORE_ROLES; do
|
|
[[ -z "$role" ]] && continue
|
|
[[ "$role" =~ ^[a-zA-Z_][a-zA-Z0-9_-]*$ ]] || fail "rôle exclu invalide : ${role}"
|
|
if [[ -n "$regex" ]]; then
|
|
regex+="|"
|
|
fi
|
|
regex+="$role"
|
|
done
|
|
|
|
printf '%s' "$regex"
|
|
}
|
|
|
|
###############################################################################
|
|
# Envoi Discord
|
|
#
|
|
# Envoi simple d'un message texte via webhook Discord.
|
|
# Si DISCORD_WEBHOOK_URL n'est pas défini, on ignore silencieusement l'envoi.
|
|
###############################################################################
|
|
send_discord() {
|
|
local message="$1"
|
|
local payload=""
|
|
|
|
[[ -n "$DISCORD_WEBHOOK_URL" ]] || return 0
|
|
has_cmd jq || return 0
|
|
has_cmd curl || return 0
|
|
|
|
payload="$(jq -n --arg content "$message" '{content: $content}')" || return 0
|
|
|
|
curl -fsS "$DISCORD_WEBHOOK_URL" \
|
|
-H "Content-Type: application/json" \
|
|
-d "$payload" \
|
|
>/dev/null || true
|
|
}
|
|
|
|
###############################################################################
|
|
# Vérifications de base
|
|
###############################################################################
|
|
[[ -f "$SSH_KEY" ]] || fail "clé SSH introuvable : $SSH_KEY"
|
|
[[ -r "$SSH_KEY" ]] || fail "clé SSH non lisible : $SSH_KEY"
|
|
[[ ! -L "$SSH_KEY" ]] || fail "clé SSH ne doit pas être un lien symbolique : $SSH_KEY"
|
|
[[ "$PGPORT" =~ ^[0-9]+$ ]] || fail "PGPORT invalide"
|
|
[[ "$BACKUP_REMOTE_SSH_PORT" =~ ^[0-9]+$ ]] || fail "BACKUP_REMOTE_SSH_PORT invalide"
|
|
[[ "$PGUSER" =~ ^[a-zA-Z0-9_][a-zA-Z0-9_-]*$ ]] || fail "PGUSER invalide"
|
|
|
|
export PGPASSWORD
|
|
|
|
SSH_OPTS=(
|
|
-i "$SSH_KEY"
|
|
-p "$BACKUP_REMOTE_SSH_PORT"
|
|
-o IdentitiesOnly=yes
|
|
-o BatchMode=yes
|
|
-o ConnectTimeout="$SSH_CONNECT_TIMEOUT"
|
|
-o StrictHostKeyChecking=yes
|
|
)
|
|
|
|
SCP_OPTS=(
|
|
-i "$SSH_KEY"
|
|
-P "$BACKUP_REMOTE_SSH_PORT"
|
|
-o IdentitiesOnly=yes
|
|
-o BatchMode=yes
|
|
-o ConnectTimeout="$SSH_CONNECT_TIMEOUT"
|
|
-o StrictHostKeyChecking=yes
|
|
)
|
|
|
|
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 ! has_cmd psql || ! has_cmd pg_restore || ! has_cmd createdb || ! has_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..."
|
|
PG_READY=false
|
|
for _ in {1..20}; do
|
|
if sudo -u postgres psql -d postgres -c "SELECT 1;" >/dev/null 2>&1; then
|
|
PG_READY=true
|
|
log "PostgreSQL répond correctement."
|
|
break
|
|
fi
|
|
sleep 1
|
|
done
|
|
|
|
if [[ "$PG_READY" != true ]]; 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 '$(sql_escape_literal "$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
|
|
fi
|
|
|
|
validate_db_name "$DB" || fail "nom de base invalide"
|
|
|
|
log "Environnement : $ENV_NAME"
|
|
log "Base cible sélectionnée : $DB"
|
|
|
|
###############################################################################
|
|
# Test de connexion SSH
|
|
###############################################################################
|
|
log "Test de connexion SSH vers ${REMOTE_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
|
|
###############################################################################
|
|
REMOTE_DB_DIR="${BACKUP_REMOTE_DIR}/${DB}"
|
|
REMOTE_ROLES_DIR="${BACKUP_REMOTE_DIR}/${REMOTE_ROLES_DIR_NAME}"
|
|
|
|
log "Recherche du dernier dump distant pour ${DB} dans : ${REMOTE_DB_DIR}"
|
|
log "Recherche du dernier fichier de rôles dans : ${REMOTE_ROLES_DIR}"
|
|
|
|
###############################################################################
|
|
# Recherche du dernier dump de base
|
|
###############################################################################
|
|
LAST_REMOTE_DB_DUMP="$(
|
|
ssh "${SSH_OPTS[@]}" "$REMOTE_SSH" \
|
|
"find '${REMOTE_DB_DIR}' -maxdepth 1 -type f -name '${DB}_*.dump' | LC_ALL=C sort | tail -n 1"
|
|
)"
|
|
|
|
if [[ -z "$LAST_REMOTE_DB_DUMP" ]]; then
|
|
fail "aucun dump trouvé pour la base ${DB} dans ${REMOTE_DB_DIR}"
|
|
fi
|
|
|
|
log "Dernier dump distant sélectionné : ${LAST_REMOTE_DB_DUMP}"
|
|
|
|
###############################################################################
|
|
# Recherche du dernier fichier SQL des rôles
|
|
###############################################################################
|
|
LAST_REMOTE_ROLES_FILE="$(
|
|
ssh "${SSH_OPTS[@]}" "$REMOTE_SSH" \
|
|
"find '${REMOTE_ROLES_DIR}' -maxdepth 1 -type f -name 'user_*.sql' | LC_ALL=C sort | tail -n 1"
|
|
)"
|
|
|
|
if [[ -n "$LAST_REMOTE_ROLES_FILE" ]]; then
|
|
log "Dernier fichier des rôles sélectionné : ${LAST_REMOTE_ROLES_FILE}"
|
|
else
|
|
log "Aucun fichier des rôles trouvé sur le serveur distant."
|
|
fi
|
|
|
|
###############################################################################
|
|
# Téléchargement du dump principal
|
|
###############################################################################
|
|
LOCAL_DB_DUMP_FILE="${LOCAL_RESTORE_DIR}/$(basename "$LAST_REMOTE_DB_DUMP")"
|
|
LOCAL_ROLES_FILE=""
|
|
|
|
log "Téléchargement du dump..."
|
|
scp "${SCP_OPTS[@]}" "${REMOTE_SSH}:${LAST_REMOTE_DB_DUMP}" "$LOCAL_DB_DUMP_FILE" \
|
|
>>"$LOG_FILE" 2>&1 || fail "échec du téléchargement du dump principal"
|
|
|
|
###############################################################################
|
|
# Téléchargement du fichier des rôles si présent
|
|
###############################################################################
|
|
if [[ -n "$LAST_REMOTE_ROLES_FILE" ]]; then
|
|
LOCAL_ROLES_FILE="${LOCAL_RESTORE_DIR}/$(basename "$LAST_REMOTE_ROLES_FILE")"
|
|
|
|
log "Téléchargement du fichier des rôles..."
|
|
scp "${SCP_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"
|
|
else
|
|
log "La restauration des rôles sera ignorée."
|
|
fi
|
|
|
|
###############################################################################
|
|
# Test de connexion PostgreSQL locale avec PGUSER
|
|
###############################################################################
|
|
if ! psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -c "SELECT 1;" \
|
|
>>"$LOG_FILE" 2>&1; then
|
|
fail "connexion PostgreSQL locale impossible avec PGUSER=${PGUSER}"
|
|
fi
|
|
|
|
###############################################################################
|
|
# Demande d'écrasement si la base existe déjà
|
|
###############################################################################
|
|
DB_EXISTS="$(
|
|
psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -tAc \
|
|
"SELECT 1 FROM pg_database WHERE datname='$(sql_escape_literal "$DB")'" 2>>"$LOG_FILE" || true
|
|
)"
|
|
|
|
if [[ "$DB_EXISTS" == "1" ]]; then
|
|
read -r -p "La base '${DB}' existe déjà. Voulez-vous l'écraser ? (oui/non) : " CONFIRM_OVERWRITE
|
|
if [[ "${CONFIRM_OVERWRITE,,}" != "oui" && "${CONFIRM_OVERWRITE,,}" != "o" ]]; then
|
|
fail "restauration annulée par l'utilisateur"
|
|
fi
|
|
|
|
log "Suppression de la base existante : ${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 des rôles
|
|
###############################################################################
|
|
if [[ -n "$LOCAL_ROLES_FILE" ]]; then
|
|
log "Restauration des rôles depuis : ${LOCAL_ROLES_FILE}"
|
|
|
|
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")"
|
|
EXCLUDED_ROLES_REGEX="$(build_excluded_roles_regex)"
|
|
|
|
if [[ -n "$EXCLUDED_ROLES_REGEX" ]]; then
|
|
grep -viE "^(CREATE ROLE|ALTER ROLE) (${EXCLUDED_ROLES_REGEX})\\b" "$LOCAL_ROLES_FILE" \
|
|
> "$FILTERED_ROLES_FILE" || true
|
|
else
|
|
cp "$LOCAL_ROLES_FILE" "$FILTERED_ROLES_FILE"
|
|
fi
|
|
|
|
sed -i -E '/^ALTER ROLE .* (NO)?SUPERUSER\b/d' "$FILTERED_ROLES_FILE"
|
|
|
|
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
|
|
if [[ ! "$role_name" =~ ^[a-zA-Z_][a-zA-Z0-9_]*$ ]]; then
|
|
log "WARNING: nom de rôle suspect ignoré : ${role_name}"
|
|
continue
|
|
fi
|
|
|
|
ROLE_EXISTS="$(
|
|
psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -tAc \
|
|
"SELECT 1 FROM pg_roles WHERE rolname='$(sql_escape_literal "$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
|
|
|
|
###############################################################################
|
|
# Création de la base
|
|
###############################################################################
|
|
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" \
|
|
-U "$PGUSER" \
|
|
-d "$DB" \
|
|
--clean \
|
|
--if-exists \
|
|
--no-owner \
|
|
--no-privileges \
|
|
"$LOCAL_DB_DUMP_FILE" \
|
|
>>"$LOG_FILE" 2>&1 || fail "échec de restauration de 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 "$SUCCESS_MESSAGE"
|