# Retour d'Expérience : Gestion des configurations

## Problème initial
- **Erreurs** : Fichiers de configuration non écrits correctement
- **Impact** : Services ne démarrent pas avec les bonnes configurations
- **Cause** : Écriture non effective des fichiers de configuration

## Erreurs rencontrées

### 1. Fichiers de configuration non écrits
```bash
# ❌ Problème : Écriture non effective
echo "bootstrap_url=wss://dev3.4nkweb.com/ws/" >> relay/sdk_relay.conf
# Le fichier n'était pas mis à jour correctement
```

### 2. Permissions insuffisantes
```bash
# ❌ Erreur
sed: cannot rename /home/bitcoin/sedktvYLI: Device or resource busy
```

### 3. Variables d'environnement non prises en compte
```bash
# ❌ Problème : .env override docker-compose.yml
# docker-compose.yml
environment:
  - SIGNER_WS_URL=ws://dev3.4nkweb.com:9090

# .env (override)
SIGNER_WS_URL=ws://sdk_signer:9090
```

## Solutions implémentées

### 1. Vérification systématique des écritures
```bash
#!/bin/bash
# verify_config_writing.sh

# Fonction de vérification
verify_config_file() {
    local file="$1"
    local expected_content="$2"

    echo "Vérification de $file..."

    if [ -f "$file" ]; then
        if grep -q "$expected_content" "$file"; then
            echo "✅ $file contient '$expected_content'"
            return 0
        else
            echo "❌ $file ne contient pas '$expected_content'"
            return 1
        fi
    else
        echo "❌ $file n'existe pas"
        return 1
    fi
}

# Vérifications
verify_config_file "relay/sdk_relay.conf" "bootstrap_url=\"wss://dev3.4nkweb.com/ws/\""
verify_config_file "relay/sdk_relay.conf" "sp_address="
verify_config_file ".env" "RELAY_URLS=ws://sdk_relay:8090"
```

### 2. Écriture atomique des configurations
```bash
#!/bin/bash
# atomic_config_update.sh

# Fonction d'écriture atomique
atomic_write_config() {
    local file="$1"
    local content="$2"
    local temp_file="${file}.tmp"

    echo "Mise à jour atomique de $file..."

    # Écriture dans un fichier temporaire
    echo "$content" > "$temp_file"

    # Vérification de l'écriture
    if [ -f "$temp_file" ] && [ -s "$temp_file" ]; then
        # Remplacement atomique
        mv "$temp_file" "$file"
        echo "✅ $file mis à jour avec succès"
        return 0
    else
        echo "❌ Échec de l'écriture de $file"
        rm -f "$temp_file"
        return 1
    fi
}

# Exemple d'utilisation
atomic_write_config "relay/sdk_relay.conf" "bootstrap_url=\"wss://dev3.4nkweb.com/ws/\""
```

### 3. Gestion des permissions
```bash
#!/bin/bash
# fix_config_permissions.sh

# Correction des permissions
fix_permissions() {
    local file="$1"

    echo "Correction des permissions pour $file..."

    # Vérifier si le fichier existe
    if [ -f "$file" ]; then
        # Corriger les permissions
        chmod 644 "$file"
        chown $(whoami):$(whoami) "$file"
        echo "✅ Permissions corrigées pour $file"
    else
        echo "❌ $file n'existe pas"
        return 1
    fi
}

# Correction des permissions pour tous les fichiers de config
fix_permissions "relay/sdk_relay.conf"
fix_permissions ".env"
fix_permissions "docker-compose.yml"
```

## Règles Cursor ajoutées

### Règle de vérification des configurations
```markdown
# RÈGLE CRITIQUE : Vérification des Fichiers de Configuration
- TOUJOURS vérifier l'écriture effective des fichiers de configuration critiques après modification
- Fichiers à vérifier systématiquement : nginx.conf, bitcoin.conf, package.json, Cargo.toml
- Utiliser des commandes de vérification (cat, jq, syntax check) pour s'assurer que l'écriture a été effective
- Cette règle évite les erreurs de configuration dues à des écritures non effectives
```

## Scripts de vérification

### Vérification complète des configurations
```bash
#!/bin/bash
# verify_all_configs.sh

echo "=== Vérification des configurations ==="

# Vérification des fichiers de configuration
config_files=(
    "relay/sdk_relay.conf"
    ".env"
    "docker-compose.yml"
    "miner/.env"
)

for file in "${config_files[@]}"; do
    if [ -f "$file" ]; then
        echo "✅ $file existe"

        # Vérification de la syntaxe
        case "$file" in
            *.conf)
                echo "  Vérification de la syntaxe..."
                # Pas de vérification spécifique pour .conf
                ;;
            *.yml|*.yaml)
                echo "  Vérification de la syntaxe YAML..."
                if command -v yq >/dev/null 2>&1; then
                    yq eval '.' "$file" >/dev/null && echo "  ✅ Syntaxe YAML valide" || echo "  ❌ Syntaxe YAML invalide"
                fi
                ;;
            *.json)
                echo "  Vérification de la syntaxe JSON..."
                jq '.' "$file" >/dev/null && echo "  ✅ Syntaxe JSON valide" || echo "  ❌ Syntaxe JSON invalide"
                ;;
        esac
    else
        echo "❌ $file n'existe pas"
    fi
done
```

### Vérification des variables d'environnement
```bash
#!/bin/bash
# verify_env_vars.sh

echo "=== Vérification des variables d'environnement ==="

# Vérification des variables critiques
critical_vars=(
    "SIGNER_WS_URL"
    "RELAY_URLS"
    "SIGNER_BASE_URL"
    "VITE_BOOTSTRAPURL"
)

for var in "${critical_vars[@]}"; do
    if [ -f ".env" ]; then
        if grep -q "^$var=" ".env"; then
            value=$(grep "^$var=" ".env" | cut -d'=' -f2-)
            echo "✅ $var=$value"
        else
            echo "❌ $var non définie dans .env"
        fi
    else
        echo "❌ Fichier .env non trouvé"
    fi
done
```

## Bonnes pratiques

### 1. Écriture des configurations
- **Utiliser** des écritures atomiques avec fichiers temporaires
- **Vérifier** l'écriture après chaque modification
- **Corriger** les permissions si nécessaire

### 2. Validation des configurations
- **Vérifier** la syntaxe des fichiers (JSON, YAML, etc.)
- **Tester** les configurations avant déploiement
- **Documenter** les changements de configuration

### 3. Gestion des variables d'environnement
- **Centraliser** les variables dans `.env`
- **Vérifier** les overrides entre `.env` et `docker-compose.yml`
- **Documenter** les variables critiques

## Scripts automatisés

### Mise à jour et vérification complète
```bash
#!/bin/bash
# update_and_verify_configs.sh

echo "=== Mise à jour et vérification des configurations ==="

# 1. Mise à jour des configurations
echo "Mise à jour des configurations..."
./atomic_config_update.sh

# 2. Correction des permissions
echo "Correction des permissions..."
./fix_config_permissions.sh

# 3. Vérification des configurations
echo "Vérification des configurations..."
./verify_all_configs.sh

# 4. Vérification des variables d'environnement
echo "Vérification des variables d'environnement..."
./verify_env_vars.sh

echo "=== Vérification terminée ==="
```

## Actions préventives

1. **Toujours vérifier** l'écriture effective des fichiers de configuration
2. **Utiliser** des écritures atomiques pour éviter les corruptions
3. **Corriger** les permissions après modification
4. **Valider** la syntaxe des fichiers de configuration
5. **Documenter** les changements de configuration

## Date
- **Créé** : 2025-09-20
- **Problème résolu** : Gestion des configurations et écriture effective
- **Impact** : Amélioration de la fiabilité des configurations