4NK_IA_back/scripts/maintenance.sh

#!/bin/bash
# Script de maintenance pour 4NK IA Backend
# Usage: ./maintenance.sh [command]

set -e

# 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

# Fonction pour afficher les messages
log_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

log_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

log_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# Fonction pour afficher l'aide
show_help() {
    echo "Script de maintenance pour 4NK IA Backend"
    echo ""
    echo "Usage: $0 [command]"
    echo ""
    echo "Commandes disponibles:"
    echo "  status      - Afficher le statut des services"
    echo "  logs        - Afficher les logs des services"
    echo "  restart     - Redémarrer tous les services"
    echo "  stop        - Arrêter tous les services"
    echo "  start       - Démarrer tous les services"
    echo "  clean       - Nettoyer les volumes et images Docker"
    echo "  backup      - Créer une sauvegarde des données"
    echo "  restore     - Restaurer une sauvegarde"
    echo "  update      - Mettre à jour les images Docker"
    echo "  health      - Vérifier la santé des services"
    echo "  shell       - Ouvrir un shell dans le container API"
    echo "  help        - Afficher cette aide"
    echo ""
}

# Fonction pour afficher le statut des services
show_status() {
    log_info "Statut des services Docker:"
    echo ""
    docker-compose -f infra/docker-compose.yml ps
    echo ""

    log_info "Utilisation des ressources:"
    echo ""
    docker stats --no-stream --format "table {{.Container}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.NetIO}}\t{{.BlockIO}}"
    echo ""

    log_info "Volumes Docker:"
    echo ""
    docker volume ls | grep 4nk
    echo ""
}

# Fonction pour afficher les logs
show_logs() {
    local service=${1:-}

    if [ -n "$service" ]; then
        log_info "Logs du service $service:"
        docker-compose -f infra/docker-compose.yml logs -f "$service"
    else
        log_info "Logs de tous les services:"
        docker-compose -f infra/docker-compose.yml logs -f
    fi
}

# Fonction pour redémarrer les services
restart_services() {
    local service=${1:-}

    if [ -n "$service" ]; then
        log_info "Redémarrage du service $service..."
        docker-compose -f infra/docker-compose.yml restart "$service"
    else
        log_info "Redémarrage de tous les services..."
        docker-compose -f infra/docker-compose.yml restart
    fi

    log_success "Services redémarrés"
}

# Fonction pour arrêter les services
stop_services() {
    log_info "Arrêt de tous les services..."
    docker-compose -f infra/docker-compose.yml down
    log_success "Services arrêtés"
}

# Fonction pour démarrer les services
start_services() {
    log_info "Démarrage de tous les services..."
    docker-compose -f infra/docker-compose.yml up -d
    log_success "Services démarrés"
}

# Fonction pour nettoyer Docker
clean_docker() {
    log_warning "Cette opération va supprimer tous les volumes et images Docker non utilisés"
    read -p "Êtes-vous sûr de vouloir continuer ? (y/N): " -n 1 -r
    echo

    if [[ $REPLY =~ ^[Yy]$ ]]; then
        log_info "Nettoyage des volumes Docker..."
        docker-compose -f infra/docker-compose.yml down -v

        log_info "Nettoyage des images Docker..."
        docker system prune -a -f

        log_info "Nettoyage des volumes non utilisés..."
        docker volume prune -f

        log_success "Nettoyage terminé"
    else
        log_info "Nettoyage annulé"
    fi
}

# Fonction pour créer une sauvegarde
create_backup() {
    local backup_dir="./backups"
    local timestamp=$(date +"%Y%m%d_%H%M%S")
    local backup_file="$backup_dir/backup_$timestamp.tar.gz"

    log_info "Création d'une sauvegarde..."

    # Création du répertoire de sauvegarde
    mkdir -p "$backup_dir"

    # Sauvegarde des volumes Docker
    docker run --rm -v pgdata:/data -v "$(pwd)":/backup alpine tar czf /backup/postgres_$timestamp.tar.gz -C /data .
    docker run --rm -v redis:/data -v "$(pwd)":/backup alpine tar czf /backup/redis_$timestamp.tar.gz -C /data .
    docker run --rm -v minio:/data -v "$(pwd)":/backup alpine tar czf /backup/minio_$timestamp.tar.gz -C /data .

    # Création de l'archive complète
    tar czf "$backup_file" postgres_$timestamp.tar.gz redis_$timestamp.tar.gz minio_$timestamp.tar.gz .env

    # Nettoyage des fichiers temporaires
    rm postgres_$timestamp.tar.gz redis_$timestamp.tar.gz minio_$timestamp.tar.gz

    log_success "Sauvegarde créée: $backup_file"
}

# Fonction pour restaurer une sauvegarde
restore_backup() {
    local backup_file=${1:-}

    if [ -z "$backup_file" ]; then
        log_error "Veuillez spécifier le fichier de sauvegarde"
        echo "Usage: $0 restore <backup_file>"
        exit 1
    fi

    if [ ! -f "$backup_file" ]; then
        log_error "Fichier de sauvegarde non trouvé: $backup_file"
        exit 1
    fi

    log_warning "Cette opération va remplacer toutes les données existantes"
    read -p "Êtes-vous sûr de vouloir continuer ? (y/N): " -n 1 -r
    echo

    if [[ $REPLY =~ ^[Yy]$ ]]; then
        log_info "Restauration de la sauvegarde: $backup_file"

        # Arrêt des services
        docker-compose -f infra/docker-compose.yml down

        # Extraction de la sauvegarde
        tar xzf "$backup_file"

        # Restauration des volumes
        docker run --rm -v pgdata:/data -v "$(pwd)":/backup alpine tar xzf /backup/postgres_*.tar.gz -C /data
        docker run --rm -v redis:/data -v "$(pwd)":/backup alpine tar xzf /backup/redis_*.tar.gz -C /data
        docker run --rm -v minio:/data -v "$(pwd)":/backup alpine tar xzf /backup/minio_*.tar.gz -C /data

        # Nettoyage des fichiers temporaires
        rm postgres_*.tar.gz redis_*.tar.gz minio_*.tar.gz

        # Redémarrage des services
        docker-compose -f infra/docker-compose.yml up -d

        log_success "Sauvegarde restaurée"
    else
        log_info "Restauration annulée"
    fi
}

# Fonction pour mettre à jour les images
update_images() {
    log_info "Mise à jour des images Docker..."
    docker-compose -f infra/docker-compose.yml pull
    docker-compose -f infra/docker-compose.yml up -d
    log_success "Images mises à jour"
}

# Fonction pour vérifier la santé
check_health() {
    log_info "Vérification de la santé des services..."
    echo ""

    # Vérifier l'API
    if curl -f http://localhost:8000/api/health > /dev/null 2>&1; then
        log_success "✅ API backend accessible"
    else
        log_error "❌ API backend non accessible"
    fi

    # Vérifier MinIO
    if curl -f http://localhost:9000/minio/health/live > /dev/null 2>&1; then
        log_success "✅ MinIO accessible"
    else
        log_error "❌ MinIO non accessible"
    fi

    # Vérifier PostgreSQL
    if docker-compose -f infra/docker-compose.yml exec -T postgres pg_isready -U notariat > /dev/null 2>&1; then
        log_success "✅ PostgreSQL accessible"
    else
        log_error "❌ PostgreSQL non accessible"
    fi

    # Vérifier Redis
    if docker-compose -f infra/docker-compose.yml exec -T redis redis-cli ping > /dev/null 2>&1; then
        log_success "✅ Redis accessible"
    else
        log_error "❌ Redis non accessible"
    fi
}

# Fonction pour ouvrir un shell
open_shell() {
    log_info "Ouverture d'un shell dans le container API..."
    docker-compose -f infra/docker-compose.yml exec host-api bash
}

# Fonction principale
main() {
    local command=${1:-help}

    case "$command" in
        "status")
            show_status
            ;;
        "logs")
            show_logs "$2"
            ;;
        "restart")
            restart_services "$2"
            ;;
        "stop")
            stop_services
            ;;
        "start")
            start_services
            ;;
        "clean")
            clean_docker
            ;;
        "backup")
            create_backup
            ;;
        "restore")
            restore_backup "$2"
            ;;
        "update")
            update_images
            ;;
        "health")
            check_health
            ;;
        "shell")
            open_shell
            ;;
        "help"|"-h"|"--help")
            show_help
            ;;
        *)
            log_error "Commande inconnue: $command"
            show_help
            exit 1
            ;;
    esac
}

# Exécution de la fonction principale
main "$@"