update error message and avoid double benchmark generation

backend/routes/benchmark.py

@@ -34,6 +34,24 @@ async def generate_benchmark(data: Dict[str, Any]):
     if not session_id or session_id not in router.session_files:
         return {"error": "Invalid or missing session ID"}
     
+    # Vérifier si un benchmark est déjà en cours ou complété pour cette session
+    if session_id in active_tasks:
+        task = active_tasks[session_id]
+        # Si le benchmark est déjà terminé, retourner les logs existants
+        if task.is_task_completed():
+            return {
+                "status": "already_completed",
+                "logs": task.get_logs(),
+                "is_completed": True
+            }
+        # Si le benchmark est en cours d'exécution, retourner les logs actuels
+        else:
+            return {
+                "status": "already_running",
+                "logs": task.get_logs(),
+                "is_completed": False
+            }
+    
     file_path = router.session_files[session_id]
     all_logs = []
     

backend/tasks/create_bench.py

@@ -107,6 +107,9 @@ class CreateBenchTask:
         """
         self._add_log("[INFO] Starting output capture")
         
+        # Flag pour détecter les erreurs de rate limiting
+        rate_limit_detected = False
+        
         try:
             while self.is_running() and self.process:
                 line = self.process.stdout.readline()
@@ -122,6 +125,14 @@ class CreateBenchTask:
                 # Process the output line
                 line = line.strip()
                 if line:
+                    # Detect rate limiting errors
+                    if ("too many requests" in line.lower() or 
+                        "rate limit" in line.lower() or 
+                        "429" in line or 
+                        "too many concurrent requests" in line.lower()):
+                        rate_limit_detected = True
+                        self._add_log("[ERROR] RATE_LIMIT_EXCEEDED: The demo is under heavy load at the moment.")
+                    
                     # Log raw output for debugging
                     self._add_log(f"[DEBUG] Raw output: {line}")
                     # Filter and format the line as needed
@@ -137,6 +148,9 @@ class CreateBenchTask:
                             # Standardiser les noms d'étapes pour correspondre au frontend
                             stage = self._standardize_stage_name(stage)
                             self._add_log(f"[SUCCESS] Stage completed: {stage}")
+                        # Vérifier spécifiquement la complétion de l'étape upload_ingest_to_hub
+                        elif "Successfully completed 'upload_ingest_to_hub' stage" in line:
+                            self._add_log(f"[SUCCESS] Stage completed: upload_ingest_to_hub")
                         else:
                             self._add_log(f"[INFO] {line}")
             
@@ -146,7 +160,11 @@ class CreateBenchTask:
                 if exit_code == 0:
                     self._add_log("[SUCCESS] Benchmark process completed successfully")
                 else:
-                    self._add_log(f"[ERROR] Benchmark process terminated with error code: {exit_code}")
+                    # Si une erreur de rate limiting a été détectée, afficher un message spécifique
+                    if rate_limit_detected:
+                        self._add_log("[ERROR] Benchmark process failed due to API rate limiting. The demo is under heavy load at the moment.")
+                    else:
+                        self._add_log(f"[ERROR] Benchmark process terminated with error code: {exit_code}")
         except Exception as e:
             self._add_log(f"[ERROR] Error during output capture: {str(e)}")
         finally:

backend/tasks/create_bench_config_file.py

@@ -146,6 +146,10 @@ class CreateBenchConfigTask:
             self._add_log(f"[ERROR] {error_msg}")
             raise RuntimeError(error_msg)
         
+        # Ajouter un délai minimum de 2 secondes pour l'étape provider_check
+        self._add_log("[INFO] Finalizing provider check...")
+        time.sleep(2)
+        
         # Mark provider check stage as completed
         self._add_log("[SUCCESS] Stage completed: provider_check")
         

frontend/src/components/BenchmarkCreateForm.jsx

@@ -10,6 +10,10 @@ import {
   Grid,
   IconButton,
   Tooltip,
+  Dialog,
+  DialogTitle,
+  DialogContent,
+  DialogActions,
 } from "@mui/material";
 import { alpha } from "@mui/material/styles";
 import CloudUploadIcon from "@mui/icons-material/CloudUpload";
@@ -19,6 +23,8 @@ import DescriptionIcon from "@mui/icons-material/Description";
 import ArticleIcon from "@mui/icons-material/Article";
 import MenuBookIcon from "@mui/icons-material/MenuBook";
 import DownloadIcon from "@mui/icons-material/Download";
+import VisibilityIcon from "@mui/icons-material/Visibility";
+import CloseIcon from "@mui/icons-material/Close";
 import { useThemeMode } from "../hooks/useThemeMode";
 import getTheme from "../config/theme";
 import API_CONFIG from "../config/api";
@@ -41,6 +47,10 @@ function BenchmarkCreateForm({ onStartGeneration }) {
   const [selectedDocument, setSelectedDocument] = useState(null);
   const [isDefaultDocument, setIsDefaultDocument] = useState(false);
   const [isDownloading, setIsDownloading] = useState(false);
+  const [documentContent, setDocumentContent] = useState("");
+  const [openContentModal, setOpenContentModal] = useState(false);
+  const [isLoadingContent, setIsLoadingContent] = useState(false);
+  const [modalDocument, setModalDocument] = useState(null);
   const fileInputRef = useRef(null);
 
   const defaultDocuments = [
@@ -243,6 +253,48 @@ function BenchmarkCreateForm({ onStartGeneration }) {
     }
   };
 
+  const handleViewDocument = async (doc) => {
+    setIsLoadingContent(true);
+
+    try {
+      let extension = "";
+      if (doc.id === "the-bitter-lesson") {
+        extension = "html";
+      } else if (doc.id === "hurricane-faq") {
+        extension = "md";
+      } else {
+        extension = "txt";
+      }
+
+      // Mettre à jour l'état du document pour la modale
+      setModalDocument(doc);
+
+      const response = await fetch(`/${doc.id}.${extension}`);
+      const text = await response.text();
+
+      setDocumentContent(text);
+      setOpenContentModal(true);
+    } catch (error) {
+      console.error("Error loading document content:", error);
+      setUploadStatus({
+        success: false,
+        message: "Error loading document content",
+      });
+      setOpenSnackbar(true);
+    } finally {
+      setIsLoadingContent(false);
+    }
+  };
+
+  const handleCloseContentModal = () => {
+    setOpenContentModal(false);
+    // Réinitialiser après la fermeture de la modale
+    setTimeout(() => {
+      setDocumentContent("");
+      setModalDocument(null);
+    }, 300);
+  };
+
   return (
     <Box sx={{ mt: -2 }}>
       <Typography
@@ -280,33 +332,33 @@ function BenchmarkCreateForm({ onStartGeneration }) {
               }}
               onClick={() => handleDefaultDocClick(doc)}
             >
-              <Tooltip title="Download document">
+              <Tooltip title="View content">
                 <IconButton
                   onClick={(e) => {
                     e.stopPropagation();
-                    handleDownloadDocument(doc);
+                    handleViewDocument(doc);
                   }}
                   sx={{
                     position: "absolute",
                     top: 4,
                     right: 4,
                     color: "text.secondary",
-                    opacity: 0.6,
+                    opacity: 0.4,
                     "&:hover": {
-                      opacity: 1,
+                      opacity: 0.8,
                       backgroundColor: alpha(theme.palette.primary.main, 0.05),
                     },
-                    padding: 0.5,
+                    padding: 0.3,
                     "& .MuiSvgIcon-root": {
-                      fontSize: 18,
+                      fontSize: 16,
                     },
                   }}
-                  disabled={isDownloading}
+                  disabled={isLoadingContent}
                 >
-                  {isDownloading ? (
-                    <CircularProgress size={16} />
+                  {isLoadingContent && selectedDocument?.id === doc.id ? (
+                    <CircularProgress size={14} />
                   ) : (
-                    <DownloadIcon />
+                    <VisibilityIcon />
                   )}
                 </IconButton>
               </Tooltip>
@@ -431,6 +483,92 @@ function BenchmarkCreateForm({ onStartGeneration }) {
           {uploadStatus?.message}
         </Alert>
       </Snackbar>
+
+      <Dialog
+        open={openContentModal}
+        onClose={handleCloseContentModal}
+        maxWidth="md"
+        fullWidth
+        aria-labelledby="document-content-dialog-title"
+      >
+        <DialogTitle id="document-content-dialog-title">
+          <Box
+            sx={{
+              display: "flex",
+              justifyContent: "space-between",
+              alignItems: "flex-start",
+            }}
+          >
+            <Box>
+              {modalDocument && (
+                <Typography variant="h6" sx={{ fontWeight: 600 }}>
+                  {modalDocument.name}
+                </Typography>
+              )}
+              <Typography variant="body2" color="text.secondary">
+                {modalDocument &&
+                  (modalDocument.id === "the-bitter-lesson"
+                    ? "HTML"
+                    : modalDocument.id === "hurricane-faq"
+                    ? "Markdown"
+                    : "Text")}
+              </Typography>
+            </Box>
+            <Box sx={{ display: "flex", gap: 1 }}>
+              {modalDocument && (
+                <Tooltip title="Download document">
+                  <IconButton
+                    edge="end"
+                    color="inherit"
+                    onClick={() => handleDownloadDocument(modalDocument)}
+                    disabled={isDownloading}
+                    aria-label="download"
+                  >
+                    {isDownloading ? (
+                      <CircularProgress size={20} />
+                    ) : (
+                      <DownloadIcon />
+                    )}
+                  </IconButton>
+                </Tooltip>
+              )}
+              <IconButton
+                edge="end"
+                color="inherit"
+                onClick={handleCloseContentModal}
+                aria-label="close"
+              >
+                <CloseIcon />
+              </IconButton>
+            </Box>
+          </Box>
+        </DialogTitle>
+        <DialogContent
+          dividers
+          sx={{
+            padding: 0,
+          }}
+        >
+          {isLoadingContent ? (
+            <Box sx={{ display: "flex", justifyContent: "center", my: 4 }}>
+              <CircularProgress />
+            </Box>
+          ) : (
+            <Box
+              sx={{
+                maxHeight: "60vh",
+                overflow: "auto",
+                whiteSpace: "pre-wrap",
+                fontFamily: "monospace",
+                fontSize: "0.875rem",
+                p: 2.5,
+              }}
+            >
+              {documentContent}
+            </Box>
+          )}
+        </DialogContent>
+      </Dialog>
     </Box>
   );
 }

frontend/src/components/BenchmarkGenerator.jsx

@@ -6,8 +6,8 @@ import LogDisplay from "./LogDisplay";
 import { useNavigate, useSearchParams } from "react-router-dom";
 import API_CONFIG from "../config/api";
 
-// Temps de simulation en millisecondes pour les documents précalculés
-const SIMULATION_DURATION = 80000; // 20 secondes
+// Simulation time in milliseconds for pre-calculated documents
+const SIMULATION_DURATION = 80000; // 20 seconds
 
 // Define all benchmark steps in sequence
 const BENCHMARK_STEPS = [
@@ -93,7 +93,7 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
     // Set start time
     startTimeRef.current = Date.now();
 
-    // Référence pour le timeout
+    // Reference for the timeout
     let timeoutRef = null;
 
     // Start timer
@@ -103,15 +103,15 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
       );
       setElapsedTime(timeElapsed);
 
-      // Vérifier si le temps écoulé dépasse 8 minutes (480 secondes) et que nous ne sommes pas en mode simulation
+      // Check if the elapsed time exceeds 8 minutes (480 seconds) and we are not in simulation mode
       if (timeElapsed > 480 && !isDefault && !generationComplete) {
-        // Afficher un message d'erreur en cas de timeout
+        // Display an error message in case of timeout
         setError(
           "The benchmark generation is taking too long. The demo is currently under heavy load, please try again later."
         );
         setGenerationComplete(true);
 
-        // Nettoyer les intervalles
+        // Clear intervals
         if (pollingIntervalRef.current) {
           clearInterval(pollingIntervalRef.current);
         }
@@ -122,7 +122,7 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
       }
     }, 1000);
 
-    // Gestionnaire pour détecter quand la page redevient visible
+    // Handler to detect when the page becomes visible again
     const handleVisibilityChange = () => {
       if (
         document.visibilityState === "visible" &&
@@ -130,10 +130,10 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
         !generationComplete
       ) {
         console.log("Page became visible, checking for missed steps...");
-        // Force une nouvelle requête pour récupérer les logs
+        // Force a new request to retrieve the logs
         const checkCurrentState = async () => {
           try {
-            // D'abord essayer de récupérer les logs de benchmark
+            // First try to retrieve the benchmark logs
             const logsResponse = await fetch(
               `${API_CONFIG.BASE_URL}/benchmark-logs/${sessionId}`
             );
@@ -144,7 +144,7 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
                 setGenerationLogs(logsResult.logs);
               }
 
-              // Si la tâche est terminée, mettre à jour l'état
+              // If the task is complete, update the state
               if (logsResult.is_completed) {
                 setGenerationComplete(true);
                 if (pollingIntervalRef.current) {
@@ -159,7 +159,7 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
                 }
               }
             } else {
-              // Si la tâche de benchmark n'existe pas, essayer les logs de configuration
+              // If the benchmark task does not exist, try the configuration logs
               const configResponse = await fetch(
                 `${API_CONFIG.BASE_URL}/config-logs/${sessionId}`
               );
@@ -180,7 +180,7 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
       }
     };
 
-    // Ajouter l'écouteur pour le changement de visibilité
+    // Add the listener for visibility change
     document.addEventListener("visibilitychange", handleVisibilityChange);
 
     if (isDefault) {
@@ -253,11 +253,27 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
   useEffect(() => {
     if (generationLogs.length === 0) return;
 
-    // Recalculer complètement les étapes complétées à chaque fois
-    // au lieu de simplement ajouter les nouvelles étapes
+    // Recalculate completed steps completely each time
+    // instead of just adding new steps
     const newCompletedSteps = [];
 
-    // Identifier toutes les étapes complétées dans tous les logs
+    // Check for rate limiting errors
+    const hasRateLimitError = generationLogs.some(
+      (log) => log.includes("RATE_LIMIT_EXCEEDED") || log.includes("heavy load")
+    );
+
+    if (hasRateLimitError) {
+      setError(
+        "The demo is under heavy load at the moment. Please try again later."
+      );
+      setGenerationComplete(true);
+      if (pollingIntervalRef.current) {
+        clearInterval(pollingIntervalRef.current);
+      }
+      return;
+    }
+
+    // Identify all completed steps in all logs
     generationLogs.forEach((log) => {
       const match = log.match(/\[SUCCESS\] Stage completed: (\w+)/);
       if (match && match[1]) {
@@ -271,37 +287,37 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
       }
     });
 
-    // Déterminer l'étape active basée sur les étapes complétées
+    // Determine the active step based on completed steps
     let newActiveStep = activeStep;
 
     if (newCompletedSteps.length > 0) {
-      // Trouver l'étape la plus avancée dans les logs
+      // Find the most advanced step in the logs
       const maxCompletedStepIndex = Math.max(
         ...newCompletedSteps.map((step) => BENCHMARK_STEPS.indexOf(step))
       );
-      // Passer à l'étape suivante
+      // Move to the next step
       const calculatedStep = maxCompletedStepIndex + 1;
 
-      // Ne mettre à jour que si la nouvelle étape est plus avancée que l'étape actuelle
+      // Update only if the new step is more advanced than the current step
       if (calculatedStep > activeStep) {
         newActiveStep = calculatedStep;
       }
 
-      // S'assurer que l'activeStep ne dépasse pas le nombre total d'étapes
+      // Ensure that activeStep does not exceed the total number of steps
       if (newActiveStep >= BENCHMARK_STEPS.length) {
         newActiveStep = BENCHMARK_STEPS.length;
       }
     } else if (activeStep === 0) {
-      // Si aucune étape n'est trouvée et l'étape active est 0, passer à 1
+      // If no step is found and the active step is 0, move to 1
       newActiveStep = 1;
     }
 
-    // Mettre à jour l'état si les étapes ont changé
+    // Update the state if the steps have changed
     if (JSON.stringify(newCompletedSteps) !== JSON.stringify(completedSteps)) {
       setCompletedSteps(newCompletedSteps);
     }
 
-    // Mettre à jour l'étape active seulement si elle a changé
+    // Update the active step only if it has changed
     if (newActiveStep !== activeStep) {
       setActiveStep(newActiveStep);
     }
@@ -390,16 +406,16 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
       if (response.ok) {
         setGenerationLogs(result.logs || []);
 
-        // Configurer le polling pour suivre la progression
+        // Set up polling to track progress
         pollingIntervalRef.current = setInterval(async () => {
-          // Vérifier si on a déjà terminé
+          // Check if we have already completed
           if (generationComplete) {
             clearInterval(pollingIntervalRef.current);
             return;
           }
 
           try {
-            // Appeler l'API pour obtenir les derniers logs
+            // Call the API to get the latest logs
             const logsResponse = await fetch(
               `${API_CONFIG.BASE_URL}/benchmark-progress/${sessionId}`
             );
@@ -407,7 +423,7 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
             if (logsResponse.ok) {
               const logsResult = await logsResponse.json();
 
-              // Mettre à jour les logs s'il y en a de nouveaux
+              // Update logs if there are new ones
               if (
                 logsResult.logs &&
                 logsResult.logs.length > generationLogs.length
@@ -415,18 +431,18 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
                 setGenerationLogs(logsResult.logs);
               }
 
-              // Vérifier si la tâche est terminée
+              // Check if the task is complete
               if (logsResult.is_completed) {
                 setGenerationComplete(true);
                 clearInterval(pollingIntervalRef.current);
-                // La notification est maintenant gérée dans le useEffect ci-dessus
+                // Notification is now handled in the useEffect above
               }
             }
           } catch (error) {
             console.log("Error polling for logs:", error);
-            // Ne pas arrêter le polling en cas d'erreurs réseau
+            // Do not stop polling in case of network errors
           }
-        }, 2000); // Interroger toutes les 2 secondes
+        }, 2000); // Poll every 2 seconds
       } else {
         // Handle error
         setGenerationLogs([`Error: ${result.error || "Unknown error"}`]);
@@ -514,7 +530,7 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
         position: "relative",
       }}
     >
-      {/* Temps estimé */}
+      {/* Estimated time */}
       <Box
         sx={{
           position: "absolute",
@@ -536,7 +552,7 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
             fontWeight: 500,
           }}
         >
-          Estimated time: ~2 min
+          Estimated time: ~ 1 min 30s
         </Typography>
       </Box>
 

frontend/src/pages/BenchmarkGenerationPage.jsx

@@ -1,4 +1,4 @@
-import React, { useState, useEffect } from "react";
+import React, { useState, useEffect, useRef } from "react";
 import { Box, CircularProgress } from "@mui/material";
 import { useNavigate, useSearchParams, Navigate } from "react-router-dom";
 import Intro from "../components/Intro";
@@ -10,6 +10,7 @@ function BenchmarkGenerationPage() {
   const sessionId = searchParams.get("session");
   const isDefault = searchParams.get("isDefault") === "true";
   const [isValidSession, setIsValidSession] = useState(true);
+  const hasRedirectedRef = useRef(false);
 
   useEffect(() => {
     if (!sessionId) {
@@ -19,8 +20,12 @@ function BenchmarkGenerationPage() {
 
   const handleGenerationComplete = (result) => {
     console.log("Benchmark generation completed:", result);
-    if (result && result.success) {
-      navigate(`/benchmark-display?session=${sessionId}`);
+    if (result && result.success && !hasRedirectedRef.current) {
+      hasRedirectedRef.current = true; // Marquer que la redirection a été faite
+      // Légère pause avant de naviguer pour éviter les problèmes de synchronisation
+      setTimeout(() => {
+        navigate(`/benchmark-display?session=${sessionId}`);
+      }, 500);
     }
   };