Update app.py

app.py

@@ -13,8 +13,15 @@ from threading import Lock
 import logging
 import sys
 from functools import partial
+from jinja2 import Undefined  # Pour gérer les valeurs Undefined
 
-# Configuration ydu logging
+# Définition d'une fonction pour convertir les objets Undefined en chaîne vide
+def default_json(o):
+    if isinstance(o, Undefined):
+        return ''
+    raise TypeError(f"Object of type {type(o).__name__} is not JSON serializable")
+
+# Configuration du logger
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
@@ -27,6 +34,15 @@ logger = logging.getLogger('website_requester')
 
 app = Flask(__name__)
 
+# Définir un encodeur JSON personnalisé pour Flask
+from flask.json import JSONEncoder
+class CustomJSONEncoder(JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, Undefined):
+            return ''
+        return super().default(obj)
+app.json_encoder = CustomJSONEncoder
+
 # Variables globales pour stocker l'état, utilisation d'un gestionnaire multiprocessing
 manager = multiprocessing.Manager()
 requests_in_progress = manager.Value('b', False)
@@ -37,15 +53,15 @@ requests_lock = manager.Lock()  # Pour sécuriser l'accès aux données partagé
 process_pool = None
 background_tasks = []
 
-# Configuration de paramètres avancés
-MAX_CONNECTIONS = 1000  # Nombre maximal de connexions simultanées
-SAVE_FREQUENCY = 100  # Fréquence de sauvegarde des résultats (tous les X requêtes)
-CHUNK_SIZE = 5000  # Nombre de requêtes à traiter par processus
-MAX_RETRIES = 5  # Nombre maximum de tentatives pour chaque opération
-RETRY_DELAY = 0.5  # Délai entre les tentatives en secondes
+# Paramètres avancés
+MAX_CONNECTIONS = 1000           # Nombre maximal de connexions simultanées
+SAVE_FREQUENCY = 100             # Fréquence de sauvegarde des résultats (tous les X requêtes)
+CHUNK_SIZE = 5000                # Nombre de requêtes à traiter par processus
+MAX_RETRIES = 5                  # Nombre maximum de tentatives pour chaque opération
+RETRY_DELAY = 0.5                # Délai entre les tentatives en secondes
 REQUESTS_FILE = "requetes_gabaohub.json"
-IP_ROTATION_COUNT = 50  # Rotation des IP après ce nombre de requêtes
-REQUEST_TIMEOUT = 15  # Timeout des requêtes en secondes
+IP_ROTATION_COUNT = 50           # Rotation des IP après ce nombre de requêtes
+REQUEST_TIMEOUT = 15             # Timeout des requêtes en secondes
 
 def generate_gabonese_ip():
     """Génère une adresse IP du Gabon (plage 41.158.0.0/16)"""
@@ -100,13 +116,12 @@ async def with_retries(func, *args, max_retries=MAX_RETRIES, **kwargs):
 
 async def create_session(request_counter):
     """Crée une session HTTP optimisée avec rotation d'IP"""
-    # Configurer la session avec un meilleur contrôle des connexions
     connector = aiohttp.TCPConnector(
-        limit=MAX_CONNECTIONS,  # Nombre maximum de connexions simultanées
-        ssl=False,              # Désactiver la vérification SSL pour plus de performance
-        force_close=False,      # Réutiliser les connexions quand c'est possible
-        use_dns_cache=True,     # Utiliser le cache DNS
-        ttl_dns_cache=300      # Cache DNS valide pendant 5 minutes
+        limit=MAX_CONNECTIONS,
+        ssl=False,
+        force_close=False,
+        use_dns_cache=True,
+        ttl_dns_cache=300
     )
     
     timeout = aiohttp.ClientTimeout(
@@ -131,13 +146,12 @@ async def create_session(request_counter):
         }
     )
     
-    # Middleware pour faire une rotation des IPs et des User-Agents
+    # Middleware pour la rotation des IP, User-Agent et référents
     original_request = session._request
     
     async def request_middleware(method, url, **kwargs):
         nonlocal request_counter
         
-        # Rotation des IPs, des User-Agents et des référents après un certain nombre de requêtes
         if request_counter.value % IP_ROTATION_COUNT == 0:
             kwargs.setdefault('headers', {}).update({
                 "X-Forwarded-For": generate_gabonese_ip(),
@@ -156,14 +170,10 @@ async def make_homepage_request(session, request_index, request_counter):
     global requests_being_made
     
     try:
-        # URL de la page d'accueil
         url = "https://gabaohub.alwaysdata.net"
-        
-        # Paramètres aléatoires pour simuler des utilisateurs réels
         params = {}
         
-        # Ajouter des paramètres UTM aléatoires occasionnellement
-        if random.random() < 0.3:  # 30% de chance
+        if random.random() < 0.3:
             utm_sources = ["facebook", "twitter", "instagram", "direct", "google", "bing"]
             utm_mediums = ["social", "cpc", "email", "referral", "organic"]
             utm_campaigns = ["spring_promo", "launch", "awareness", "brand", "product"]
@@ -172,7 +182,6 @@ async def make_homepage_request(session, request_index, request_counter):
             params["utm_medium"] = random.choice(utm_mediums)
             params["utm_campaign"] = random.choice(utm_campaigns)
         
-        # Mettre à jour les informations de la requête dans la liste
         with requests_lock:
             if request_index < len(requests_being_made):
                 requests_being_made[request_index]["url"] = url
@@ -180,16 +189,13 @@ async def make_homepage_request(session, request_index, request_counter):
                 requests_being_made[request_index]["status"] = "in_progress"
                 requests_being_made[request_index]["start_time"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         
-        # Effectuer la requête avec retries
         try:
             start_time = time.time()
             async with session.get(url, params=params, allow_redirects=True) as response:
-                # Lire le contenu pour simuler le chargement complet de la page
                 content = await response.read()
                 end_time = time.time()
                 response_time = end_time - start_time
                 
-                # Mettre à jour le statut
                 with requests_lock:
                     if request_index < len(requests_being_made):
                         requests_being_made[request_index]["status"] = "success"
@@ -217,13 +223,9 @@ async def make_homepage_request(session, request_index, request_counter):
 async def process_request_chunk(start_index, chunk_size, process_id=0):
     """Traite un groupe de requêtes dans un processus séparé"""
     logger.info(f"Processus {process_id}: Démarrage du traitement pour les indices {start_index} à {start_index+chunk_size-1}")
-    
-    # Créer un compteur de requêtes partagé
     request_counter = multiprocessing.Value('i', 0)
     
-    # Créer une nouvelle session HTTP pour ce processus
     async with await create_session(request_counter) as session:
-        # Créer un sémaphore pour limiter les connexions simultanées
         semaphore = asyncio.Semaphore(MAX_CONNECTIONS // multiprocessing.cpu_count())
         
         async def process_request(i):
@@ -233,15 +235,10 @@ async def process_request_chunk(start_index, chunk_size, process_id=0):
                 
             async with semaphore:
                 await make_homepage_request(session, request_index, request_counter)
-                
-                # Pause aléatoire pour éviter les modèles de trafic détectables
-                await asyncio.sleep(random.uniform(0.2, 2.0))  # Temps d'attente plus naturel entre les requêtes
-                
-                # Sauvegarde périodique
+                await asyncio.sleep(random.uniform(0.2, 2.0))
                 if progress_counter.value % SAVE_FREQUENCY == 0:
                     save_results_to_file()
         
-        # Créer et exécuter toutes les tâches pour ce chunk
         tasks = [process_request(i) for i in range(min(chunk_size, total_requests.value - start_index))]
         await asyncio.gather(*tasks)
     
@@ -251,17 +248,11 @@ def save_results_to_file():
     """Sauvegarde l'état actuel dans un fichier JSON de manière thread-safe"""
     with requests_lock:
         try:
-            # Créer une copie des données actuelles
             data_to_save = list(requests_being_made)
-            
-            # Utiliser un fichier temporaire pour éviter la corruption
             temp_file = f"{REQUESTS_FILE}.tmp"
             with open(temp_file, "w", encoding="utf-8") as f:
-                json.dump(data_to_save, f, indent=2, ensure_ascii=False)
-            
-            # Remplacer le fichier original par le fichier temporaire
+                json.dump(data_to_save, f, indent=2, ensure_ascii=False, default=default_json)
             os.replace(temp_file, REQUESTS_FILE)
-            
             logger.info(f"Sauvegarde effectuée: {progress_counter.value}/{total_requests.value} requêtes")
         except Exception as e:
             logger.error(f"Erreur lors de la sauvegarde: {str(e)}")
@@ -269,11 +260,8 @@ def save_results_to_file():
 def run_request_process(start_index, chunk_size, process_id):
     """Fonction exécutée dans chaque processus pour effectuer des requêtes"""
     try:
-        # Configurer la nouvelle boucle asyncio pour ce processus
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
-        
-        # Exécuter le traitement du chunk
         loop.run_until_complete(process_request_chunk(start_index, chunk_size, process_id))
         loop.close()
     except Exception as e:
@@ -283,19 +271,15 @@ def start_request_process(num_requests, concurrency):
     """Démarre le processus d'envoi de requêtes avec multiprocessing"""
     global requests_in_progress, total_requests, progress_counter, requests_being_made, process_pool, background_tasks
     
-    # Réinitialiser les compteurs
     with requests_lock:
         progress_counter.value = 0
         total_requests.value = num_requests
         requests_being_made[:] = [{"status": "pending"} for _ in range(num_requests)]
     
-    # Déterminer le nombre optimal de processus
     num_cpus = multiprocessing.cpu_count()
     num_processes = min(num_cpus, (num_requests + CHUNK_SIZE - 1) // CHUNK_SIZE)
     
     logger.info(f"Démarrage de l'envoi de {num_requests} requêtes avec {num_processes} processus et concurrence de {concurrency}")
-    
-    # Diviser le travail en chunks
     process_pool = ProcessPoolExecutor(max_workers=num_processes)
     background_tasks = []
     
@@ -310,25 +294,17 @@ def start_request_process(num_requests, concurrency):
             )
             background_tasks.append(task)
     
-    # Démarrer un thread de surveillance pour les tâches en arrière-plan
     monitor_thread = ThreadPoolExecutor(max_workers=1)
     monitor_thread.submit(monitor_background_tasks)
 
 def monitor_background_tasks():
     """Surveille les tâches en arrière-plan et marque le processus comme terminé lorsque tout est fait"""
     global requests_in_progress, background_tasks
-    
     try:
-        # Attendre que toutes les tâches soient terminées
         for task in background_tasks:
-            task.result()  # Ceci bloquera jusqu'à ce que la tâche soit terminée
-        
+            task.result()
         logger.info(f"Toutes les tâches d'envoi de requêtes sont terminées. {progress_counter.value}/{total_requests.value} requêtes traitées.")
-        
-        # Sauvegarde finale
         save_results_to_file()
-        
-        # Marquer le processus comme terminé
         requests_in_progress.value = False
     except Exception as e:
         logger.error(f"Erreur lors de la surveillance des tâches: {str(e)}")
@@ -337,7 +313,6 @@ def monitor_background_tasks():
 @app.route('/')
 def index():
     """Page d'accueil"""
-    # Charger les requêtes existantes si elles existent
     requests_data = []
     if os.path.exists(REQUESTS_FILE):
         try:
@@ -348,7 +323,7 @@ def index():
     
     return render_template('index.html', 
                            requests_in_progress=requests_in_progress.value,
-                           requests=requests_data[:1000],  # Limiter pour des raisons de performance UI
+                           requests=requests_data[:1000],
                            progress=progress_counter.value,
                            total=total_requests.value)
 
@@ -356,16 +331,10 @@ def index():
 def start_requests():
     """Démarrer l'envoi de requêtes"""
     if not requests_in_progress.value:
-        # Récupérer les paramètres
         num_requests = int(request.form.get('num_requests', 1000))
         concurrency = int(request.form.get('concurrency', MAX_CONNECTIONS))
-        
-        # Marquer comme en cours
         requests_in_progress.value = True
-        
-        # Démarrer l'envoi de requêtes
         start_request_process(num_requests, concurrency)
-        
         logger.info(f"Envoi de {num_requests} requêtes lancé avec concurrence {concurrency}")
     else:
         logger.warning("Un processus d'envoi de requêtes est déjà en cours")
@@ -375,7 +344,6 @@ def start_requests():
 @app.route('/progress')
 def get_progress():
     """Endpoint API pour obtenir la progression complète"""
-    # Charger les dernières données
     requests_data = []
     if os.path.exists(REQUESTS_FILE):
         try:
@@ -388,7 +356,7 @@ def get_progress():
         'requests_in_progress': requests_in_progress.value,
         'progress': progress_counter.value,
         'total': total_requests.value,
-        'requests': requests_data[:200]  # Limiter pour des raisons de performance
+        'requests': requests_data[:200]
     })
 
 @app.route('/status')
@@ -409,16 +377,12 @@ def reset():
     global requests_in_progress, requests_being_made, progress_counter, total_requests, process_pool, background_tasks
     
     if not requests_in_progress.value:
-        # Réinitialiser les compteurs et les données
         with requests_lock:
             requests_being_made[:] = []
             progress_counter.value = 0
             total_requests.value = 0
-        
-        # Supprimer le fichier JSON s'il existe
         if os.path.exists(REQUESTS_FILE):
             os.remove(REQUESTS_FILE)
-        
         logger.info("Réinitialisation effectuée")
     else:
         logger.warning("Impossible de réinitialiser pendant un processus en cours")
@@ -429,15 +393,11 @@ def reset():
 def stop_requests():
     """Arrête le processus d'envoi de requêtes en cours"""
     global requests_in_progress, process_pool
-    
     if requests_in_progress.value and process_pool:
         logger.info("Arrêt des processus d'envoi de requêtes...")
         process_pool.shutdown(wait=False)
         requests_in_progress.value = False
-        
-        # Sauvegarde l'état actuel
         save_results_to_file()
-        
         logger.info("Processus d'envoi de requêtes arrêté")
     
     return redirect(url_for('index'))
@@ -453,23 +413,19 @@ def get_stats():
         except json.JSONDecodeError:
             requests_data = []
     
-    # Calculer les statistiques de base
     successful_requests = [req for req in requests_data if req.get('status') == 'success']
     failed_requests = [req for req in requests_data if req.get('status') == 'failed']
     
-    # Temps de réponse moyen pour les requêtes réussies
     avg_response_time = 0
     if successful_requests:
         avg_response_time = sum(req.get('response_time', 0) for req in successful_requests) / len(successful_requests)
     
-    # Codes de statut des réponses
     status_codes = {}
     for req in successful_requests:
         code = req.get('status_code')
         if code:
             status_codes[code] = status_codes.get(code, 0) + 1
     
-    # Types d'erreurs pour les requêtes échouées
     error_types = {}
     for req in failed_requests:
         error = req.get('error', 'Unknown')
@@ -617,8 +573,7 @@ def get_template():
                                     <th>Temps (s)</th>
                                     <th>Heure</th>
                                 </tr>
-
-                                </thead>
+                            </thead>
                             <tbody id="requests-table">
                                 <tr>
                                     <td colspan="6" class="text-center">Chargement des données...</td>
@@ -632,17 +587,14 @@ def get_template():
 
         <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js"></script>
         <script>
-            // Variables globales
             let isPolling = false;
             let pollingInterval;
             
-            // Démarrer la mise à jour automatique
             window.onload = function() {
                 updateProgress();
                 updateRequests();
                 updateStats();
                 
-                // Mettre en place une mise à jour périodique
                 pollingInterval = setInterval(() => {
                     if (isPolling) {
                         updateProgress();
@@ -651,33 +603,24 @@ def get_template():
                 }, 5000);
             };
             
-            // Mettre à jour les informations de progression
             function updateProgress() {
                 fetch('/status')
                     .then(response => response.json())
                     .then(data => {
-                        // Mettre à jour la barre de progression
                         const percentage = data.total > 0 ? (data.progress / data.total * 100) : 0;
                         document.getElementById('progress-bar').style.width = percentage + '%';
                         document.getElementById('progress-bar').setAttribute('aria-valuenow', percentage);
                         
-                        // Mettre à jour le texte de progression
                         document.getElementById('progress-text').textContent = 
                             `${data.progress} / ${data.total} requêtes traitées (${percentage.toFixed(1)}%)`;
-                        
-                        // Mettre à jour l'état
                         document.getElementById('status-text').textContent = 
                             `État: ${data.requests_in_progress ? 'En cours' : 'Inactif'}`;
                         
-                        // Mettre à jour les compteurs
                         document.getElementById('success-count').textContent = data.success_count;
                         document.getElementById('failed-count').textContent = data.failed_count;
                         document.getElementById('pending-count').textContent = data.pending_count;
                         
-                        // Activer/désactiver le polling automatique
                         isPolling = data.requests_in_progress;
-                        
-                        // Mettre à jour l'état des boutons
                         document.getElementById('start-button').disabled = data.requests_in_progress;
                         document.getElementById('stop-button').disabled = !data.requests_in_progress;
                         document.getElementById('reset-button').disabled = data.requests_in_progress;
@@ -687,30 +630,22 @@ def get_template():
                     });
             }
             
-            // Mettre à jour la liste des requêtes
             function updateRequests() {
                 fetch('/progress')
                     .then(response => response.json())
                     .then(data => {
                         const tableBody = document.getElementById('requests-table');
-                        
-                        // Effacer le contenu actuel
                         tableBody.innerHTML = '';
                         
-                        // Si aucune requête, afficher un message
                         if (data.requests.length === 0) {
                             tableBody.innerHTML = '<tr><td colspan="6" class="text-center">Aucune requête effectuée.</td></tr>';
                             return;
                         }
                         
-                        // Ajouter chaque requête au tableau
                         data.requests.forEach((req, index) => {
                             const row = document.createElement('tr');
-                            
-                            // Déterminer la classe de statut
                             const statusClass = `status-${req.status || 'pending'}`;
                             
-                            // Créer les cellules
                             row.innerHTML = `
                                 <td>${index + 1}</td>
                                 <td>${req.url || 'N/A'}</td>
@@ -728,14 +663,12 @@ def get_template():
                     });
             }
             
-            // Mettre à jour les statistiques
             function updateStats() {
                 fetch('/stats')
                     .then(response => response.json())
                     .then(data => {
                         const statsContainer = document.getElementById('stats-container');
                         
-                        // Formater les codes de statut
                         let statusCodeHtml = '<div class="mt-3"><h5>Codes de statut</h5>';
                         if (Object.keys(data.status_codes).length > 0) {
                             statusCodeHtml += '<div class="row">';
@@ -760,7 +693,6 @@ def get_template():
                         }
                         statusCodeHtml += '</div>';
                         
-                        // Formater les types d'erreurs
                         let errorTypesHtml = '<div class="mt-3"><h5>Types d\'erreurs</h5>';
                         if (Object.keys(data.error_types).length > 0) {
                             errorTypesHtml += '<ul class="list-group">';
@@ -778,7 +710,6 @@ def get_template():
                         }
                         errorTypesHtml += '</div>';
                         
-                        // Mettre à jour le contenu
                         statsContainer.innerHTML = `
                             <div class="row">
                                 <div class="col-md-6">
@@ -822,4 +753,4 @@ def get_template():
     """
 
 if __name__ == '__main__':
-    app.run(debug=True)
+    app.run(debug=True)