add Managemen sessions

app.py

@@ -7,21 +7,32 @@ from pydub import AudioSegment
 import time
 import os
 import spaces
-import uuid
 from app.utils import generate_coturn_config
 
-
+# ✅ Import des fonctions externalisées
+from app.session_utils import (
+    generate_session_id,
+    register_session,
+    unregister_session,
+    get_active_sessions,
+    stop_file_path,
+    create_stop_flag,
+    clear_stop_flag,
+)
+
+# --- Constants ---
 EXAMPLE_FILES = ["data/bonjour.wav", "data/bonjour2.wav"]
 DEFAULT_FILE = EXAMPLE_FILES[0]
 
 
+# --- Streaming logic ---
 @spaces.GPU
 def read_and_stream_audio(filepath_to_stream: str, session_id: str):
     """
     Stream audio chunks for a specific session.
     Stops when the corresponding stop flag file exists.
     """
-    stop_file = f"/tmp/stream_stop_flag_{session_id}.txt"
+    stop_file = stop_file_path(session_id)
     logging.debug(f"[{session_id}] read_and_stream_audio() started with file: {filepath_to_stream}")
 
     if not filepath_to_stream or not os.path.exists(filepath_to_stream):
@@ -34,9 +45,10 @@ def read_and_stream_audio(filepath_to_stream: str, session_id: str):
             return
 
     # Clear any leftover stop flag
-    if os.path.exists(stop_file):
-        os.remove(stop_file)
-        logging.debug(f"[{session_id}] Old stop flag cleared.")
+    clear_stop_flag(session_id)
+
+    # Register session
+    register_session(session_id, filepath_to_stream)
 
     try:
         segment = AudioSegment.from_file(filepath_to_stream)
@@ -46,7 +58,7 @@ def read_and_stream_audio(filepath_to_stream: str, session_id: str):
         for i, chunk in enumerate(segment[::chunk_ms]):
             if os.path.exists(stop_file):
                 logging.info(f"[{session_id}] Stop flag detected at chunk {i+1}. Ending stream.")
-                os.remove(stop_file)
+                clear_stop_flag(session_id)
                 break
 
             iter_start = time.perf_counter()
@@ -72,34 +84,26 @@ def read_and_stream_audio(filepath_to_stream: str, session_id: str):
         logging.error(f"[{session_id}] Error during streaming: {e}", exc_info=True)
         raise
     finally:
-        if os.path.exists(stop_file):
-            os.remove(stop_file)
-            logging.debug(f"[{session_id}] Stop file cleaned up in finally block.")
+        unregister_session(session_id)
+        clear_stop_flag(session_id)
         logging.debug(f"[{session_id}] Exiting read_and_stream_audio().")
 
 
+# --- Stop Streaming ---
 def stop_streaming(session_id: str):
-    """Create the stop flag file for this user's session."""
-    stop_file = f"/tmp/stream_stop_flag_{session_id}.txt"
-    with open(stop_file, "w") as f:
-        f.write("1")
-    logging.info(f"[{session_id}] Stop button clicked → stop flag file created.")
+    create_stop_flag(session_id)
+    logging.info(f"[{session_id}] Stop button clicked → stop flag created.")
     return None
 
 
-def generate_session_id():
-    sid = str(uuid.uuid4())
-    logging.debug(f"[{sid}] New session created.")
-    return sid
-
-
+# --- Gradio UI ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown(
         "## Application 'Streamer' WebRTC (multi-utilisateur)\n"
-        "Chaque utilisateur contrôle son propre flux audio."
+        "Chaque utilisateur contrôle son propre flux audio, avec suivi des sessions actives."
     )
 
-    # Each user gets their own session ID (unique per tab)
+    # State
     session_id = gr.State(value=generate_session_id)
     active_filepath = gr.State(value=DEFAULT_FILE)
 
@@ -128,12 +132,14 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         with gr.Column():
             gr.Text()
 
+    # --- Audio selection ---
     def set_new_file(filepath):
         return filepath if filepath else DEFAULT_FILE
 
     main_audio.change(fn=set_new_file, inputs=[main_audio], outputs=[active_filepath])
     main_audio.stop_recording(fn=set_new_file, inputs=[main_audio], outputs=[active_filepath])
 
+    # --- UI state updates ---
     def start_streaming_ui(session_id):
         logging.debug(f"[{session_id}] UI: Start clicked → disabling controls.")
         return {
@@ -159,7 +165,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
     ui_components = [start_button, stop_button, main_audio]
 
     # --- Streaming event ---
-    stream_event = webrtc_stream.stream(
+    webrtc_stream.stream(
         fn=read_and_stream_audio,
         inputs=[active_filepath, session_id],
         outputs=[webrtc_stream],
@@ -185,6 +191,20 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         outputs=ui_components,
     )
 
+    # --- Sessions Table ---
+    with gr.Accordion("📊 Sessions actives", open=False):
+        sessions_table = gr.DataFrame(
+            headers=["session_id", "file", "start_time", "status"],
+            interactive=False,
+            wrap=True,
+            label="Utilisateurs connectés",
+            max_height=200,
+        )
+
+    # ✅ Timer pour mise à jour automatique du tableau
+    timer = gr.Timer(3.0)
+    timer.tick(fn=get_active_sessions, outputs=sessions_table)
+
 
 if __name__ == "__main__":
     demo.queue(max_size=50, api_open=False).launch(show_api=False, debug=True)

app/session_utils.py

@@ -0,0 +1,102 @@
+import os
+import json
+import uuid
+from datetime import datetime
+from app.logger_config import logger as logging
+
+ACTIVE_SESSIONS_FILE = "/tmp/active_sessions.json"
+
+
+# --- ID Management ---
+def generate_session_id() -> str:
+    """Génère un identifiant unique de session."""
+    sid = str(uuid.uuid4())
+    logging.debug(f"[{sid}] New session created.")
+    return sid
+
+
+# --- Active Session Registry ---
+def register_session(session_id: str, filepath: str):
+    """Ajoute une session au registre."""
+    data = {}
+    if os.path.exists(ACTIVE_SESSIONS_FILE):
+        with open(ACTIVE_SESSIONS_FILE, "r") as f:
+            try:
+                data = json.load(f)
+            except Exception:
+                data = {}
+
+    data[session_id] = {
+        "session_id": session_id,
+        "file": filepath,
+        "start_time": datetime.utcnow().strftime("%H:%M:%S"),
+        "status": "active",
+    }
+
+    with open(ACTIVE_SESSIONS_FILE, "w") as f:
+        json.dump(data, f)
+
+    logging.debug(f"[{session_id}] Registered session in active_sessions.json.")
+
+
+def unregister_session(session_id: str):
+    """Retire une session du registre."""
+    if not os.path.exists(ACTIVE_SESSIONS_FILE):
+        return
+
+    try:
+        with open(ACTIVE_SESSIONS_FILE, "r") as f:
+            data = json.load(f)
+        if session_id in data:
+            data.pop(session_id)
+            with open(ACTIVE_SESSIONS_FILE, "w") as f:
+                json.dump(data, f)
+            logging.debug(f"[{session_id}] Unregistered session.")
+    except Exception as e:
+        logging.error(f"[{session_id}] Error unregistering session: {e}")
+
+
+def get_active_sessions():
+    """Retourne les sessions actives sous forme de tableau pour le DataFrame."""
+    if not os.path.exists(ACTIVE_SESSIONS_FILE):
+        return []
+
+    try:
+        with open(ACTIVE_SESSIONS_FILE, "r") as f:
+            data = json.load(f)
+
+        rows = []
+        for session in data.values():
+            rows.append([
+                session.get("session_id", ""),
+                session.get("file", ""),
+                session.get("start_time", ""),
+                session.get("status", ""),
+            ])
+        return rows
+
+    except Exception as e:
+        logging.error(f"Erreur lecture sessions actives: {e}")
+        return []
+
+
+# --- Stop Flag Management ---
+def stop_file_path(session_id: str) -> str:
+    """Retourne le chemin du fichier stop d'une session."""
+    return f"/tmp/stream_stop_flag_{session_id}.txt"
+
+
+def create_stop_flag(session_id: str):
+    """Crée le fichier de stop pour cette session."""
+    path = stop_file_path(session_id)
+    with open(path, "w") as f:
+        f.write("1")
+    logging.info(f"[{session_id}] Stop flag file created at {path}.")
+
+
+def clear_stop_flag(session_id: str):
+    """Supprime le fichier de stop s'il existe."""
+    path = stop_file_path(session_id)
+    if os.path.exists(path):
+        os.remove(path)
+        logging.debug(f"[{session_id}] Stop flag cleared.")