d02a183abb
- Correction complète du script generate_nginx_configs.sh - Tous les fichiers nginx sont maintenant générés dans _4NK_modules/nginx/ - Désactivation du traitement du répertoire nginx/ dans replace_variables_and_copy.sh - Mise à jour des messages d'affichage dans generate.sh - Cohérence avec la structure des modules 4NK - Nginx traité comme un module 4NK standard dans _4NK_modules/
349 lines
12 KiB
Bash
Executable File
349 lines
12 KiB
Bash
Executable File
#!/bin/bash
|
||
|
||
# Script de remplacement de variables et copie vers storage/
|
||
# Remplace les variables d'environnement dans les fichiers générés et les copie vers storage/
|
||
|
||
set -euo pipefail
|
||
|
||
# Couleurs pour les messages
|
||
RED='\033[0;31m'
|
||
GREEN='\033[0;32m'
|
||
YELLOW='\033[1;33m'
|
||
BLUE='\033[0;34m'
|
||
PURPLE='\033[0;35m'
|
||
CYAN='\033[0;36m'
|
||
NC='\033[0m' # No Color
|
||
|
||
# Fonctions d'affichage
|
||
print_error() { echo -e "${RED}❌ ERREUR${NC}: $1"; }
|
||
print_success() { echo -e "${GREEN}✅ SUCCÈS${NC}: $1"; }
|
||
print_info() { echo -e "${BLUE}ℹ️ INFO${NC}: $1"; }
|
||
print_warning() { echo -e "${YELLOW}⚠️ ATTENTION${NC}: $1"; }
|
||
print_step() { echo -e "${CYAN}🔄 $1${NC}"; }
|
||
|
||
# Variables globales
|
||
TEMPLATES_DIR="$(pwd)"
|
||
STORAGE_DIR="../../storage/dev"
|
||
FILES_PROCESSED=0
|
||
FILES_COPIED=0
|
||
|
||
# Fonction pour charger toutes les variables d'environnement
|
||
load_all_env_vars() {
|
||
print_step "Chargement des variables d'environnement"
|
||
|
||
# Exporter automatiquement toutes les variables sourcées
|
||
set -a
|
||
|
||
local env_files=(".env.secrets" ".env")
|
||
local total_vars=0
|
||
|
||
for env_file in "${env_files[@]}"; do
|
||
if [ -f "$env_file" ]; then
|
||
print_info "Chargement de $env_file..."
|
||
|
||
# Désactiver temporairement l'option 'set -u' pour éviter les erreurs sur les variables non définies
|
||
set +u
|
||
# Compter les variables avant le chargement
|
||
local vars_before=$(env | wc -l)
|
||
# shellcheck source=/dev/null
|
||
source "$env_file" 2>/dev/null || {
|
||
print_warning "Erreur lors du chargement de $env_file, tentative de chargement ligne par ligne"
|
||
|
||
# Chargement ligne par ligne en ignorant les erreurs
|
||
while IFS='=' read -r key value || [ -n "$key" ]; do
|
||
# Ignorer les commentaires et lignes vides
|
||
if [[ ! "$key" =~ ^[[:space:]]*# ]] && [[ -n "$key" ]]; then
|
||
# Nettoyer la clé et la valeur
|
||
key=$(echo "$key" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
|
||
value=$(echo "$value" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
|
||
|
||
# Ignorer les tableaux bash (lignes avec des parenthèses)
|
||
if [[ ! "$key" =~ \($ ]] && [[ -n "$key" ]]; then
|
||
export "$key"="$value" 2>/dev/null || true
|
||
total_vars=$((total_vars + 1))
|
||
fi
|
||
fi
|
||
done < "$env_file"
|
||
}
|
||
# Compter les variables après le chargement
|
||
local vars_after=$(env | wc -l)
|
||
local vars_added=$((vars_after - vars_before))
|
||
total_vars=$((total_vars + vars_added))
|
||
print_info "Variables ajoutées depuis $env_file: $vars_added"
|
||
|
||
# Exporter toutes les variables définies dans ce fichier
|
||
if [ -f "$env_file" ]; then
|
||
while IFS='=' read -r key value || [ -n "$key" ]; do
|
||
# Ignorer les commentaires et lignes vides
|
||
if [[ ! "$key" =~ ^[[:space:]]*# ]] && [[ -n "$key" ]]; then
|
||
# Nettoyer la clé et la valeur
|
||
key=$(echo "$key" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
|
||
value=$(echo "$value" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
|
||
|
||
# Ignorer les tableaux bash (lignes avec des parenthèses)
|
||
if [[ ! "$key" =~ \($ ]] && [[ -n "$key" ]]; then
|
||
export "$key"="$value" 2>/dev/null || true
|
||
fi
|
||
fi
|
||
done < "$env_file"
|
||
fi
|
||
|
||
# Réactiver l'option 'set -u'
|
||
set -u
|
||
else
|
||
print_warning "Fichier $env_file non trouvé, ignoré"
|
||
fi
|
||
done
|
||
|
||
# Traiter .env.auto pour charger les variables générées
|
||
if [ -f ".env.auto" ]; then
|
||
print_info "Traitement de .env.auto pour charger les variables générées..."
|
||
local temp_env=$(mktemp)
|
||
envsubst < .env.auto > "$temp_env"
|
||
source "$temp_env" 2>/dev/null || {
|
||
print_warning "Erreur lors du chargement de .env.auto traité"
|
||
}
|
||
rm -f "$temp_env"
|
||
fi
|
||
|
||
# Traiter .env.post pour charger les variables finales
|
||
if [ -f ".env.post" ]; then
|
||
print_info "Traitement de .env.post pour charger les variables finales..."
|
||
local temp_env=$(mktemp)
|
||
envsubst < .env.post > "$temp_env"
|
||
source "$temp_env" 2>/dev/null || {
|
||
print_warning "Erreur lors du chargement de .env.post traité"
|
||
}
|
||
rm -f "$temp_env"
|
||
fi
|
||
|
||
# Désactiver l'export automatique
|
||
set +a
|
||
|
||
print_success "$total_vars variables d'environnement chargées"
|
||
}
|
||
|
||
# Fonction pour remplacer les variables dans un fichier
|
||
replace_variables_in_file() {
|
||
local input_file="$1"
|
||
local output_file="$2"
|
||
|
||
if [ ! -f "$input_file" ]; then
|
||
print_warning "Fichier source $input_file non trouvé, ignoré"
|
||
return 1
|
||
fi
|
||
|
||
print_info "Traitement de $input_file -> $output_file"
|
||
|
||
# Créer le répertoire de destination si nécessaire
|
||
mkdir -p "$(dirname "$output_file")"
|
||
|
||
# Copier le fichier et remplacer les variables
|
||
cp "$input_file" "$output_file"
|
||
|
||
# Remplacer toutes les variables $VARIABLE par leurs valeurs
|
||
# Utiliser envsubst pour le remplacement sécurisé avec résolution multi-passes
|
||
if command -v envsubst >/dev/null 2>&1; then
|
||
# Faire plusieurs passes pour résoudre les variables imbriquées
|
||
local temp_file1=$(mktemp)
|
||
local temp_file2=$(mktemp)
|
||
|
||
# Première passe
|
||
envsubst < "$input_file" > "$temp_file1"
|
||
|
||
# Faire jusqu'à 5 passes pour résoudre les variables imbriquées
|
||
for i in {1..5}; do
|
||
# Vérifier s'il y a encore des variables non résolues
|
||
if grep -q '\$[A-Za-z_][A-Za-z0-9_]*' "$temp_file1"; then
|
||
# Passer par envsubst
|
||
envsubst < "$temp_file1" > "$temp_file2"
|
||
# Échanger les fichiers
|
||
mv "$temp_file2" "$temp_file1"
|
||
else
|
||
break
|
||
fi
|
||
done
|
||
|
||
# Copier le résultat final
|
||
cp "$temp_file1" "$output_file"
|
||
|
||
# Nettoyer les fichiers temporaires
|
||
rm -f "$temp_file1" "$temp_file2"
|
||
else
|
||
print_warning "envsubst non disponible, utilisation de sed pour le remplacement basique"
|
||
|
||
# Méthode de remplacement basique avec sed
|
||
local temp_file=$(mktemp)
|
||
cp "$input_file" "$temp_file"
|
||
|
||
# Remplacer les variables une par une
|
||
while IFS='=' read -r key value || [ -n "$key" ]; do
|
||
if [[ ! "$key" =~ ^[[:space:]]*# ]] && [[ -n "$key" ]]; then
|
||
key=$(echo "$key" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
|
||
if [[ -n "$key" ]]; then
|
||
# Échapper les caractères spéciaux dans la valeur
|
||
escaped_value=$(echo "$value" | sed 's/[[\.*^$()+?{|]/\\&/g')
|
||
# Remplacer \$KEY par la valeur
|
||
sed -i "s|\\\$${key}|${escaped_value}|g" "$temp_file"
|
||
fi
|
||
fi
|
||
done < <(env | grep -v '^_')
|
||
|
||
mv "$temp_file" "$output_file"
|
||
fi
|
||
|
||
FILES_PROCESSED=$((FILES_PROCESSED + 1))
|
||
print_success "Variables remplacées dans $input_file"
|
||
}
|
||
|
||
# Fonction pour copier un fichier vers storage/
|
||
copy_file_to_storage() {
|
||
local source_file="$1"
|
||
local relative_path="$2"
|
||
local dest_file="$STORAGE_DIR/$relative_path"
|
||
|
||
if [ ! -f "$source_file" ]; then
|
||
print_warning "Fichier source $source_file non trouvé, ignoré"
|
||
return 1
|
||
fi
|
||
|
||
print_info "Copie de $source_file vers $dest_file"
|
||
|
||
# Créer le répertoire de destination si nécessaire
|
||
mkdir -p "$(dirname "$dest_file")"
|
||
|
||
# Copier le fichier
|
||
cp "$source_file" "$dest_file"
|
||
|
||
FILES_COPIED=$((FILES_COPIED + 1))
|
||
print_success "Fichier copié: $relative_path"
|
||
}
|
||
|
||
# Fonction pour traiter un fichier (remplacer variables + copier)
|
||
process_and_copy_file() {
|
||
local source_file="$1"
|
||
local relative_path="$2"
|
||
|
||
# Créer un fichier temporaire avec les variables remplacées
|
||
local temp_file=$(mktemp)
|
||
|
||
# Remplacer les variables dans le fichier source
|
||
if replace_variables_in_file "$source_file" "$temp_file"; then
|
||
# Copier le fichier traité vers storage/
|
||
copy_file_to_storage "$temp_file" "$relative_path"
|
||
fi
|
||
|
||
# Nettoyer le fichier temporaire
|
||
rm -f "$temp_file"
|
||
}
|
||
|
||
# Fonction pour traiter un répertoire récursivement
|
||
process_directory() {
|
||
local source_dir="$1"
|
||
local relative_base="$2"
|
||
|
||
if [ ! -d "$source_dir" ]; then
|
||
print_warning "Répertoire source $source_dir non trouvé, ignoré"
|
||
return 1
|
||
fi
|
||
|
||
print_step "Traitement du répertoire $source_dir"
|
||
|
||
# Traiter tous les fichiers dans le répertoire (sauf _keys)
|
||
find "$source_dir" -type f -not -path "*/_keys/*" | while read -r file; do
|
||
# Calculer le chemin relatif
|
||
local relative_path="${file#$source_dir/}"
|
||
local full_relative_path="$relative_base/$relative_path"
|
||
|
||
# Traiter le fichier
|
||
process_and_copy_file "$file" "$full_relative_path"
|
||
done
|
||
}
|
||
|
||
# Fonction principale
|
||
main() {
|
||
echo -e "${BLUE}🚀 REMPLACEMENT DE VARIABLES ET COPIE VERS STORAGE${NC}"
|
||
echo -e "${BLUE}==================================================${NC}"
|
||
|
||
# Vérifier que nous sommes dans le bon répertoire
|
||
if [ ! -f "generate_variables.sh" ]; then
|
||
print_error "Script generate_variables.sh non trouvé. Assurez-vous d'être dans templates/dev/"
|
||
exit 1
|
||
fi
|
||
|
||
# Charger toutes les variables d'environnement
|
||
load_all_env_vars
|
||
|
||
# Vérifier que le répertoire storage existe
|
||
if [ ! -d "$STORAGE_DIR" ]; then
|
||
print_error "Répertoire storage non trouvé: $STORAGE_DIR"
|
||
exit 1
|
||
fi
|
||
|
||
print_step "Début du traitement des fichiers"
|
||
|
||
# Traiter les fichiers individuels
|
||
print_step "Traitement des fichiers individuels"
|
||
|
||
# Variables d'environnement
|
||
[ -f ".env.auto" ] && process_and_copy_file ".env.auto" ".env.auto"
|
||
|
||
# Docker Compose
|
||
[ -f "docker-compose.yml.auto" ] && process_and_copy_file "docker-compose.yml.auto" "docker-compose.yml.auto"
|
||
|
||
# Traiter les répertoires
|
||
print_step "Traitement des répertoires"
|
||
|
||
# Modules 4NK (avec underscore)
|
||
[ -d "_4NK_modules" ] && process_directory "_4NK_modules" "_4NK_modules"
|
||
|
||
# Modules 4NK (sans underscore) - DÉSACTIVÉ car générés dans _4NK_modules
|
||
# [ -d "4NK_modules" ] && process_directory "4NK_modules" "4NK_modules"
|
||
|
||
# Configurations logrotate
|
||
[ -d "logrotade" ] && process_directory "logrotade" "logrotade"
|
||
|
||
# Configurations nginx - DÉSACTIVÉ car généré dans _4NK_modules/nginx
|
||
# [ -d "nginx" ] && process_directory "nginx" "nginx"
|
||
|
||
# Configuration git
|
||
[ -d "git" ] && process_directory "git" "git"
|
||
|
||
# Monitoring
|
||
[ -d "monitoring" ] && process_directory "monitoring" "monitoring"
|
||
|
||
# Projets
|
||
[ -d "projects" ] && process_directory "projects" "projects"
|
||
|
||
# Supervisor
|
||
[ -d "supervisor" ] && process_directory "supervisor" "supervisor"
|
||
|
||
# Clés et certificats (EXCLUSION - ne pas traiter)
|
||
# [ -d "_keys" ] && process_directory "_keys" "_keys" # DÉSACTIVÉ - répertoire sensible
|
||
|
||
# Afficher le résumé
|
||
echo -e "\n${PURPLE}📊 RÉSUMÉ DU TRAITEMENT${NC}"
|
||
echo -e "${PURPLE}========================${NC}"
|
||
echo -e "Fichiers traités: ${GREEN}$FILES_PROCESSED${NC}"
|
||
echo -e "Fichiers copiés: ${GREEN}$FILES_COPIED${NC}"
|
||
echo -e "Répertoire source: ${CYAN}$TEMPLATES_DIR${NC}"
|
||
echo -e "Répertoire destination: ${CYAN}$STORAGE_DIR${NC}"
|
||
|
||
if [ $FILES_COPIED -gt 0 ]; then
|
||
print_success "Traitement terminé avec succès !"
|
||
echo -e "\n${CYAN}🚀 Prochaines étapes:${NC}"
|
||
echo -e " 1. Vérifiez les fichiers dans $STORAGE_DIR"
|
||
echo -e " 2. Testez les configurations générées"
|
||
echo -e " 3. Déployez si nécessaire"
|
||
else
|
||
print_warning "Aucun fichier n'a été traité"
|
||
echo -e "\n${YELLOW}🔧 Vérifications recommandées:${NC}"
|
||
echo -e " 1. Vérifiez que les scripts de génération ont été exécutés"
|
||
echo -e " 2. Vérifiez que les fichiers sources existent dans templates/dev/"
|
||
echo -e " 3. Vérifiez les variables d'environnement"
|
||
fi
|
||
}
|
||
|
||
# Exécuter le script principal
|
||
main "$@"
|