Fix: Use reference logic with user_lock pattern, remove eventlet dependency

app.py

@@ -4,10 +4,6 @@ Pong backend (GPU, eager) for Hugging Face Spaces.
 Broadcasts readiness via Socket.IO so the frontend can auto-hide a loading overlay once the model is ready.
 """
 
-# Eventlet must be imported first and monkey-patched before other imports
-import eventlet
-eventlet.monkey_patch()
-
 import sys
 import os
 import time
@@ -42,11 +38,11 @@ from src.config import Config
 # --------------------------
 app = Flask(__name__, static_folder='static')
 CORS(app)
-# Configure SocketIO - use eventlet for proper WebSocket support
+# Configure SocketIO - use threading mode (no eventlet needed)
 socketio = SocketIO(
     app, 
     cors_allowed_origins="*", 
-    async_mode='eventlet', 
+    async_mode='threading', 
     logger=False, 
     engineio_logger=False,
     ping_timeout=60,
@@ -63,10 +59,13 @@ device = None
 
 server_ready = False    # <--- readiness flag
 
+# Single-user limitation
+active_user_sid = None  # Session ID of the active user
+user_lock = threading.Lock()  # Protects active_user_sid
+
 stream_lock = threading.Lock()
 stream_thread = None
 stream_running = False
-current_player_sid = None  # Track which session is currently playing
 latest_action = 1  # 0=init, 1=nothing, 2=up, 3=down
 target_fps = 30
 frame_index = 0
@@ -148,7 +147,7 @@ def _reset_cache_fresh():
 
 def _broadcast_ready():
     """Tell all clients whether the server is ready."""
-    socketio.emit('server_status', {'ready': server_ready, 'busy': False})
+    socketio.emit('server_status', {'ready': server_ready})
 
 # --------------------------
 # Model init (pure eager) & warmup
@@ -369,16 +368,13 @@ def generate_frames():
 # --------------------------
 # Socket events & helpers
 # --------------------------
-def start_stream(n_steps=8, cfg=0.0, fps=30, clamp=True, player_sid=None):
-    global stream_thread, stream_running, frame_index, target_fps, latest_action, current_player_sid
+def start_stream(n_steps=8, cfg=0.0, fps=30, clamp=True):
+    global stream_thread, stream_running, frame_index, target_fps, latest_action
     if not server_ready:
         _broadcast_ready()
         raise RuntimeError("Server not ready")
     with stream_lock:
-        if stream_running and current_player_sid is not None:
-            raise RuntimeError(f"Another player is already using the stream (session: {current_player_sid[:8]}...)")
         stop_stream()
-        current_player_sid = player_sid
         target_fps = int(fps)
         frame_index = 0
         _reset_cache_fresh()
@@ -388,16 +384,12 @@ def start_stream(n_steps=8, cfg=0.0, fps=30, clamp=True, player_sid=None):
         stream_thread.start()
 
 def stop_stream():
-    global stream_thread, stream_running, current_player_sid
-    with stream_lock:
-        if stream_thread is not None:
-            stream_thread.stop()
-            stream_thread.join(timeout=1.0)
-            stream_thread = None
-        stream_running = False
-        current_player_sid = None
-        # Notify all clients that the stream is available
-        socketio.emit('stream_available', {'status': 'available'})
+    global stream_thread, stream_running
+    if stream_thread is not None:
+        stream_thread.stop()
+        stream_thread.join(timeout=1.0)
+        stream_thread = None
+    stream_running = False
 
 @socketio.on_error_default
 def default_error_handler(e):
@@ -411,15 +403,20 @@ def handle_connect():
         sid = request.sid
         print(f'Client connected: {sid}')
         
-        # Immediately tell the new client current readiness
+        with user_lock:
+            is_busy = active_user_sid is not None and active_user_sid != sid
+        
+        # Immediately tell the new client current readiness and availability
         emit('server_status', {
             'ready': server_ready,
-            'busy': False
+            'busy': is_busy,
+            'is_active_user': not is_busy
         })
         emit('connected', {
             'status': 'connected',
             'model_loaded': model is not None,
-            'ready': server_ready
+            'ready': server_ready,
+            'busy': is_busy
         })
     except Exception as e:
         print(f"Error in handle_connect: {e}")
@@ -428,50 +425,73 @@ def handle_connect():
 
 @socketio.on('disconnect')
 def handle_disconnect(*args):
+    global active_user_sid
     sid = request.sid
     print(f'Client disconnected: {sid}')
-    # If the current player disconnects, free up the stream
-    with stream_lock:
-        if current_player_sid == sid:
-            print(f'Current player disconnected, freeing stream')
-            stop_stream()
+    
+    # Release the active user slot if this was the active user
+    with user_lock:
+        if active_user_sid == sid:
+            print(f'Active user {sid} disconnected, freeing slot')
+            active_user_sid = None
+            # Notify all other clients that server is now available
+            socketio.emit('server_status', {
+                'ready': server_ready,
+                'busy': False,
+                'is_active_user': False
+            })
+    
+    stop_stream()
 
 @socketio.on('start_stream')
 def handle_start_stream(data):
+    global active_user_sid
     try:
         sid = request.sid
+        
         if not server_ready:
             # Tell client to keep showing spinner
-            emit('server_status', {'ready': server_ready, 'busy': False})
+            emit('server_status', {'ready': server_ready})
             return
         
-        # Check if someone else is already playing
-        with stream_lock:
-            if stream_running and current_player_sid is not None and current_player_sid != sid:
-                emit('error', {'message': 'Another player is currently using the stream. Please wait for them to finish.'})
-                emit('stream_busy', {'current_player': current_player_sid[:8] if current_player_sid else 'unknown'})
+        # Check if server is busy with another user
+        with user_lock:
+            if active_user_sid is not None and active_user_sid != sid:
+                emit('error', {'message': 'Server is currently being used by another user. Please wait.'})
+                emit('server_status', {
+                    'ready': server_ready,
+                    'busy': True,
+                    'is_active_user': False
+                })
+                emit('stream_busy', {'current_player': active_user_sid[:8] if active_user_sid else 'unknown'})
                 return
+            # Claim the active user slot
+            active_user_sid = sid
+            print(f'User {sid} claimed active slot')
+        
+        # Notify all clients about the new busy state
+        socketio.emit('server_status', {
+            'ready': server_ready,
+            'busy': True,
+            'is_active_user': False
+        }, include_self=False)
         
         n_steps = int(data.get('n_steps', 8))
         cfg = float(data.get('cfg', 0))
         fps = int(data.get('fps', 30))
         clamp = bool(data.get('clamp', True))
-        print(f"Starting stream @ {fps} FPS (n_steps={n_steps}, cfg={cfg}, clamp={clamp}) for session {sid[:8]}")
+        print(f"Starting stream @ {fps} FPS (n_steps={n_steps}, cfg={cfg}, clamp={clamp})")
         try:
-            start_stream(n_steps=n_steps, cfg=cfg, fps=fps, clamp=clamp, player_sid=sid)
+            start_stream(n_steps=n_steps, cfg=cfg, fps=fps, clamp=clamp)
             emit('stream_started', {'status': 'ok'})
-            # Notify other clients that stream is now busy
-            socketio.emit('stream_busy', {'current_player': sid[:8]}, include_self=False)
-        except RuntimeError as e:
-            if "already using" in str(e):
-                emit('error', {'message': str(e)})
-                emit('stream_busy', {'current_player': current_player_sid[:8] if current_player_sid else 'unknown'})
-            else:
-                raise
         except Exception as e:
             print(f"Error starting stream: {e}")
             import traceback
             traceback.print_exc()
+            # Release the slot on error
+            with user_lock:
+                if active_user_sid == sid:
+                    active_user_sid = None
             emit('error', {'message': str(e)})
     except Exception as e:
         print(f"Error in handle_start_stream: {e}")
@@ -481,34 +501,43 @@ def handle_start_stream(data):
 
 @socketio.on('action')
 def handle_action(data):
-    global latest_action, current_player_sid
+    global latest_action
     sid = request.sid
-    # Only allow actions from the current player
+    
+    # Only accept actions from the active user
+    with user_lock:
+        if active_user_sid != sid:
+            return  # Silently ignore actions from non-active users
+    
+    action = int(data.get('action', 1))
     with stream_lock:
-        if current_player_sid != sid:
-            emit('error', {'message': 'You are not the current player. Please wait your turn.'})
-            return
-        action = int(data.get('action', 1))
         latest_action = action
     emit('action_ack', {'received': action, 'will_apply_to_frame_index': frame_index})
 
 @socketio.on('stop_stream')
 def handle_stop_stream():
+    global active_user_sid
     sid = request.sid
-    print(f'Stopping stream for session {sid[:8]}')
-    try:
-        # Only allow the current player to stop
-        with stream_lock:
-            if current_player_sid != sid:
-                emit('error', {'message': 'You are not the current player. Only the current player can stop the stream.'})
-                return
-        stop_stream()
-        emit('stream_stopped', {'status': 'ok'})
-    except Exception as e:
-        print(f"Error stopping stream: {e}")
-        import traceback
-        traceback.print_exc()
-        emit('error', {'message': f'Failed to stop stream: {str(e)}'})
+    
+    # Only the active user can stop the stream
+    with user_lock:
+        if active_user_sid != sid:
+            return  # Silently ignore stop requests from non-active users
+        # Release the active user slot
+        print(f'User {sid} stopped stream and released slot')
+        active_user_sid = None
+    
+    # Notify all clients that server is now available
+    socketio.emit('server_status', {
+        'ready': server_ready,
+        'busy': False,
+        'is_active_user': False
+    })
+    socketio.emit('stream_available', {'status': 'available'})
+    
+    print('Stopping stream')
+    stop_stream()
+    emit('stream_stopped', {'status': 'ok'})
 
 # --------------------------
 # Entrypoint