4NK_vault/templates/dev/generate_docker_compose.sh

#!/bin/bash
# Script de génération du fichier docker-compose.yml.auto
# Génère uniquement docker-compose.yml.auto

set -euo pipefail

# Couleurs pour les messages
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Fonctions de couleur
print_error() { echo -e "${RED}❌ ERREUR${NC}: $1" >&2; }
print_success() { echo -e "${GREEN}✅ SUCCÈS${NC}: $1"; }
print_warning() { echo -e "${YELLOW}⚠️  ATTENTION${NC}: $1"; }
print_info() { echo -e "${BLUE}ℹ️  INFO${NC}: $1"; }

# Fonction pour charger les variables d'environnement
load_env_files() {
    local env_files=(".env.secrets" ".env")

    for env_file in "${env_files[@]}"; do
        if [ -f "$env_file" ]; then
            print_info "Chargement de $env_file..."
            # shellcheck source=/dev/null
            source "$env_file"
        else
            print_warning "Fichier $env_file non trouvé"
        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
    
    # Charger .env.post en ignorant les erreurs
    if [ -f ".env.post" ]; then
        print_info "Chargement de .env.post (avec gestion d'erreurs)..."
        local temp_env_post=$(mktemp)
        envsubst < .env.post > "$temp_env_post"
        source "$temp_env_post" 2>/dev/null || {
            print_warning "Erreurs lors du chargement de .env.post traité, continuons..."
        }
        rm -f "$temp_env_post"
    fi
}

# Fonction pour générer docker-compose.yml.auto
generate_docker_compose() {
    print_info "Génération du fichier docker-compose.yml.auto"
    
    # Supprimer le fichier existant
    rm -f docker-compose.yml.auto
    
    # Commencer le fichier docker-compose
    cat > docker-compose.yml.auto << 'EOF'
version: '3.8'

services:
EOF

    # Générer les services pour chaque variable dans SERVICES
    for VARIABLE in "${SERVICES[@]}"; do
        print_info "Génération du service pour $VARIABLE"
        
        # Variables du service
        local SERVICE_NAME="${VARIABLE,,}"
        local DOCKER_NAME_VAR="${VARIABLE}_DOCKER_NAME"
        local DOCKER_IMAGE_VAR="${VARIABLE}_DOCKER_IMAGE"
        local DOCKER_TAG_VAR="${VARIABLE}_DOCKER_TAG"
        local PORT_VAR="${VARIABLE}_PORT"
        local LOGS_DIR_VAR="${VARIABLE}_LOGS_DIR"
        local VOLUMES_VAR="${VARIABLE}_VOLUMES"
        local ENV_VAR="${VARIABLE}_ENV"
        local COMMAND_VAR="${VARIABLE}_COMMAND"
        local RESTART_VAR="${VARIABLE}_RESTART"
        local DEPENDS_ON_VAR="${VARIABLE}_DEPENDS_ON"
        
        # Ajouter le service au docker-compose
        cat >> docker-compose.yml.auto << EOF

  \$${DOCKER_NAME_VAR}:
    image: \$${DOCKER_IMAGE_VAR}:\$${DOCKER_TAG_VAR}
    container_name: \$${DOCKER_NAME_VAR}
    restart: \$${RESTART_VAR}
    networks:
      - btcnet
EOF

        # Ajouter le port si défini
        if [ -n "\$${PORT_VAR}" ]; then
            cat >> docker-compose.yml.auto << EOF
    ports:
      - "\$${PORT_VAR}:\$${PORT_VAR}"
EOF
        fi

        # Ajouter les volumes si définis
        if [ -n "\$${VOLUMES_VAR}" ]; then
            cat >> docker-compose.yml.auto << EOF
    volumes:
      \$${VOLUMES_VAR}
EOF
        fi

        # Ajouter les variables d'environnement si définies
        if [ -n "\$${ENV_VAR}" ]; then
            cat >> docker-compose.yml.auto << EOF
    environment:
      \$${ENV_VAR}
EOF
        fi

        # Ajouter la commande si définie
        if [ -n "\$${COMMAND_VAR}" ]; then
            cat >> docker-compose.yml.auto << EOF
    command: \$${COMMAND_VAR}
EOF
        fi

        # Ajouter les dépendances si définies
        if [ -n "\$${DEPENDS_ON_VAR}" ]; then
            cat >> docker-compose.yml.auto << EOF
    depends_on:
      \$${DEPENDS_ON_VAR}
EOF
        fi
    done

    # Ajouter les réseaux
    cat >> docker-compose.yml.auto << 'EOF'

networks:
  btcnet:
    name: _4NK_node_btcnet
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.0.0/16

EOF

    print_success "Fichier docker-compose.yml.auto généré"
}

# Fonction principale
main() {
    echo "🚀 GÉNÉRATION DU DOCKER-COMPOSE"
    echo "==============================="

    # Charger les variables d'environnement
    load_env_files

    # Vérifier que SERVICES est défini
    if [ -z "${SERVICES[*]:-}" ]; then
        print_error "Variable SERVICES non définie dans .env"
        exit 1
    fi

    print_info "Génération du docker-compose pour ${#SERVICES[@]} services..."
    print_info "Services: ${SERVICES[*]}"

    # Générer le docker-compose
    generate_docker_compose

    echo ""
    print_success "GÉNÉRATION TERMINÉE !"
    print_info "Fichier généré: docker-compose.yml.auto"
    print_info "Services traités: ${#SERVICES[@]}"
}

main "$@"