Update app.py

app.py

@@ -166,20 +166,28 @@ class GameDatabase:
             conn.commit()
     
     def create_room(self, room_id: str, total_rounds: int = 8) -> bool:
-        with self.lock, self.get_connection() as conn:
-            # Cleanup old rooms before creating new one
-            self.cleanup_old_rooms()
-            
-            try:
-                conn.execute("""
-                    INSERT INTO rooms (room_id, total_rounds, created_at, status)
-                    VALUES (?, ?, ?, 'waiting')
-                """, (room_id, total_rounds, datetime.now().isoformat()))
-                conn.commit()
-                print(f"✨ Created room {room_id}")
-                return True
-            except sqlite3.IntegrityError:
-                return False
+        try:
+            with self.lock, self.get_connection() as conn:
+                # Cleanup old rooms before creating new one (inline to avoid nested locks)
+                stale_cutoff = (datetime.now() - timedelta(hours=24)).isoformat()
+                conn.execute("DELETE FROM rooms WHERE status = 'waiting' AND created_at < ?", (stale_cutoff,))
+                
+                try:
+                    conn.execute("""
+                        INSERT INTO rooms (room_id, total_rounds, created_at, status)
+                        VALUES (?, ?, ?, 'waiting')
+                    """, (room_id, total_rounds, datetime.now().isoformat()))
+                    conn.commit()
+                    print(f"✨ Created room {room_id}")
+                    return True
+                except sqlite3.IntegrityError as e:
+                    print(f"IntegrityError creating room: {e}")
+                    return False
+        except Exception as e:
+            print(f"Exception in create_room: {e}")
+            import traceback
+            traceback.print_exc()
+            return False
     
     def join_room(self, room_id: str, player_id: str, name: str, 
                   character_id: str) -> Tuple[bool, Optional[int], str]:
@@ -254,43 +262,49 @@ class GameDatabase:
     
     def cleanup_old_rooms(self):
         """Remove empty or stale rooms."""
-        with self.lock, self.get_connection() as conn:
-            # Using ISO 8601 format for comparisons
-            stale_cutoff = (datetime.now() - timedelta(hours=24)).isoformat()
-            empty_cutoff = (datetime.now() - timedelta(hours=1)).isoformat()
+        try:
+            with self.lock, self.get_connection() as conn:
+                # Using ISO 8601 format for comparisons
+                stale_cutoff = (datetime.now() - timedelta(hours=24)).isoformat()
+                empty_cutoff = (datetime.now() - timedelta(hours=1)).isoformat()
 
-            # Find rooms waiting for more than 24 hours
-            stale_rooms_q = conn.execute(
-                "SELECT room_id FROM rooms WHERE status = 'waiting' AND created_at < ?",
-                (stale_cutoff,)
-            )
-            stale_ids = {row['room_id'] for row in stale_rooms_q.fetchall()}
+                # Find rooms waiting for more than 24 hours
+                stale_rooms_q = conn.execute(
+                    "SELECT room_id FROM rooms WHERE status = 'waiting' AND created_at < ?",
+                    (stale_cutoff,)
+                )
+                stale_ids = {row['room_id'] for row in stale_rooms_q.fetchall()}
 
-            # Find rooms waiting for more than 1 hour with no players
-            empty_rooms_q = conn.execute(
-                """
-                SELECT room_id FROM rooms
-                WHERE status = 'waiting'
-                AND created_at < ?
-                AND room_id NOT IN (SELECT DISTINCT room_id FROM players WHERE room_id IS NOT NULL)
-                """,
-                (empty_cutoff,)
-            )
-            empty_ids = {row['room_id'] for row in empty_rooms_q.fetchall()}
+                # Find rooms waiting for more than 1 hour with no players
+                empty_rooms_q = conn.execute(
+                    """
+                    SELECT room_id FROM rooms
+                    WHERE status = 'waiting'
+                    AND created_at < ?
+                    AND room_id NOT IN (SELECT DISTINCT room_id FROM players WHERE room_id IS NOT NULL)
+                    """,
+                    (empty_cutoff,)
+                )
+                empty_ids = {row['room_id'] for row in empty_rooms_q.fetchall()}
 
-            rooms_to_delete = stale_ids.union(empty_ids)
+                rooms_to_delete = stale_ids.union(empty_ids)
 
-            if not rooms_to_delete:
-                return 0
+                if not rooms_to_delete:
+                    return 0
 
-            for room_id in rooms_to_delete:
-                conn.execute("DELETE FROM rooms WHERE room_id = ?", (room_id,))
-                conn.execute("DELETE FROM players WHERE room_id = ?", (room_id,))
-                conn.execute("DELETE FROM spectators WHERE room_id = ?", (room_id,))
-                print(f"🧹 Cleaned up stale/empty room: {room_id}")
+                for room_id in rooms_to_delete:
+                    conn.execute("DELETE FROM rooms WHERE room_id = ?", (room_id,))
+                    conn.execute("DELETE FROM players WHERE room_id = ?", (room_id,))
+                    conn.execute("DELETE FROM spectators WHERE room_id = ?", (room_id,))
+                    print(f"🧹 Cleaned up stale/empty room: {room_id}")
 
-            conn.commit()
-            return len(rooms_to_delete)
+                conn.commit()
+                return len(rooms_to_delete)
+        except Exception as e:
+            print(f"Exception in cleanup_old_rooms: {e}")
+            import traceback
+            traceback.print_exc()
+            return 0
     
     def get_room_state(self, room_id: str) -> Optional[Dict]:
         """Get complete room state including players"""