Single User Mode (#21)

- Single User (bb3dc0d48ee95771c99662aa3c51ad7dc6761a2b)
- Remove changes (2dad3c76e77311efa212124aadec3c4c67848750)
- remove changes (e72e68ddd84115a14a5af1018ff5b32223715e1e)

seamless_server/app_pubsub.py

@@ -123,12 +123,12 @@ class ServerLock(TypedDict):
     client_id: str
     member_object: Member
 
-MAX_SPEAKERS = os.environ.get("MAX_SPEAKERS")
+SINGLE_USER = os.environ.get("SINGLE_USER")
 
 if os.environ.get("LOCK_SERVER_COMPLETELY", "0") == "1":
     logger.info("LOCK_SERVER_COMPLETELY is set. Server will be locked on startup.")
-if MAX_SPEAKERS is not None and int(MAX_SPEAKERS):
-    logger.info(f"MAX_SPEAKERS is set to: {MAX_SPEAKERS}")
+if SINGLE_USER == "1":
+    logger.info(f"SINGLE_USER mode is set. Server will only allow one speaker or listener at a time.")
 dummy_server_lock_member_object = Member(
     client_id="seamless_user", session_id="dummy", name="Seamless User"
 )
@@ -428,6 +428,7 @@ async def join_room(sid, client_id, room_id_from_client, config_dict):
     }
     logger.info(f"[event: join_room] {args}")
     session_data = await get_session_data(sid)
+
     logger.info(f"session_data: {session_data}")
 
     room_id = room_id_from_client
@@ -459,6 +460,13 @@ async def join_room(sid, client_id, room_id_from_client, config_dict):
             session_id=sid,
             name=name,
         )
+        allow_user = check_and_lock_single_user(client_id, member)
+        if not allow_user:
+            logger.error(
+                f"In SINGLE_USER mode we only allow one user at a time. Ignoring request to configure stream from client {client_id}."
+            )
+            return {"status": "error", "message": "max_users"}
+
         logger.info(f"Created a new Member object: {member}")
         logger.info(f"Adding {member} to room {room_id}")
         room.members[client_id] = member
@@ -500,15 +508,6 @@ async def join_room(sid, client_id, room_id_from_client, config_dict):
             speaker_id for speaker_id in room.speakers if speaker_id != client_id
         ]
 
-    # If we currently own the server lock and are updating roles and we no longer have server lock specified, release it
-    if (
-        server_lock is not None
-        and server_lock["client_id"] == client_id
-        and config_dict.get("lockServerName") is None
-    ):
-        logger.info(f"[join_room] Releasing server lock: {pformat(server_lock)}")
-        server_lock = None
-
     # Only speakers should be able to lock the server
     if config_dict.get("lockServerName") is not None and "speaker" in config_dict.get(
         "roles", {}
@@ -559,12 +558,21 @@ async def join_room(sid, client_id, room_id_from_client, config_dict):
 
     return {"roomsJoined": sio.rooms(sid), "roomID": room_id}
 
-def allow_speaker(room, client_id):
-    if MAX_SPEAKERS is not None and client_id in room.speakers:
-        room_statuses = {room_id: room.get_room_status_dict() for room_id, room in rooms.items()}
-        speakers = sum(room_status["activeTranscoders"] for room_status in room_statuses.values())
-        return speakers < int(MAX_SPEAKERS)
-    return True
+def check_and_lock_single_user(client_id, member):
+    global server_lock
+
+    if SINGLE_USER is None:
+        return True
+
+    if server_lock is None:
+        server_lock = {
+            "name": "single_user",
+            "client_id": client_id,
+            "member_object": member,
+        }
+        return True
+
+    return server_lock["client_id"] == client_id
 
 # TODO: Add code to prevent more than one speaker from connecting/streaming at a time
 @sio.event

streaming-react-app/src/RoomConfig.tsx

@@ -27,12 +27,14 @@ type Props = {
   serverState: ServerState | null;
   onJoinRoomOrUpdateRoles?: () => void;
   streamingStatus: StreamingStatus;
+  setHasMaxUsers: (hasMaxUsers: boolean) => void;
 };
 
 export default function RoomConfig({
   roomState,
   serverState,
   onJoinRoomOrUpdateRoles,
+  setHasMaxUsers,
   streamingStatus,
 }: Props) {
   const {socket, clientID} = useSocket();
@@ -90,6 +92,13 @@ export default function RoomConfig({
         configObject,
         (result) => {
           console.log('join_room result:', result);
+          if (result.message === 'max_users') {
+            setHasMaxUsers(true);
+            setJoinInProgress(false);
+            return;
+          } else {
+            setHasMaxUsers(false);
+          }
           if (createNewRoom) {
             setRoomID(result.roomID);
           }

streaming-react-app/src/SocketWrapper.tsx

@@ -13,7 +13,7 @@ import {getURLParams} from './URLParams';
 const INITIAL_DISCONNECT_SCREEN_DELAY = 2000;
 const SERVER_URL_DEFAULT = `${window.location.protocol === "https:" ? "wss" : "ws"
                     }://${window.location.host}`;
-                    
+
 export default function SocketWrapper({children}) {
   const [socket, setSocket] = useState<Socket | null>(null);
   const [connected, setConnected] = useState<boolean | null>(null);

streaming-react-app/src/StreamingInterface.tsx

@@ -152,7 +152,7 @@ export default function StreamingInterface() {
     useState<StreamingStatus>('stopped');
 
   const isStreamConfiguredRef = useRef<boolean>(false);
-  const [hasMaxSpeakers, setHasMaxSpeakers] = useState<boolean>(false);
+  const [hasMaxUsers, setHasMaxUsers] = useState<boolean>(false);
 
   const [outputMode, setOutputMode] = useState<SupportedOutputMode>('s2s&t');
   const [inputSource, setInputSource] =
@@ -309,7 +309,6 @@ export default function StreamingInterface() {
       console.log('[configureStreamAsync] sending config', config);
 
       socket.emit('configure_stream', config, (statusObject) => {
-        setHasMaxSpeakers(statusObject.message === 'max_speakers')
         if (statusObject.status === 'ok') {
           isStreamConfiguredRef.current = true;
           console.debug(
@@ -757,20 +756,20 @@ export default function StreamingInterface() {
             <div className="header-container-sra">
               <div>
                 <Typography variant="body2" sx={{color: '#65676B'}}>
-                  Welcome! This space is limited to one speaker at a time. 
-                  If using the live HF space, sharing room code to listeners on another 
-                  IP address may not work because it's running on different replicas. 
+                  Welcome! This space is limited to one user at a time.
+                  If using the live HF space, sharing room code to listeners on another
+                  IP address may not work because it's running on different replicas.
                   Use headphones if you are both speaker and listener to prevent feedback.
                   <br/>
-                  If max speakers reached, please duplicate the space <a target="_blank" rel="noopener noreferrer" href="https://huggingface.co/spaces/facebook/seamless-streaming?duplicate=true">here</a>. 
-                  In your duplicated space, join a room as speaker or listener (or both), 
+                  If max users reached, please duplicate the space <a target="_blank" rel="noopener noreferrer" href="https://huggingface.co/spaces/facebook/seamless-streaming?duplicate=true">here</a>.
+                  In your duplicated space, join a room as speaker or listener (or both),
                   and share the room code to invite listeners.
                   <br/>
                   Check out the seamless_communication <a target="_blank" rel="noopener noreferrer" href="https://github.com/facebookresearch/seamless_communication/tree/main">README</a> for more information.
                   <br/>
                   SeamlessStreaming model is a research model and is not released
-                  for production deployment. It is important to use a microphone with 
-                  noise cancellation (for e.g. a smartphone), otherwise you may see model hallucination on noises. 
+                  for production deployment. It is important to use a microphone with
+                  noise cancellation (for e.g. a smartphone), otherwise you may see model hallucination on noises.
                   It works best if you pause every couple of sentences, or you may wish adjust the VAD threshold
                   in the model config. The real-time performance will degrade
                   if you try streaming multiple speakers at the same time.
@@ -783,6 +782,7 @@ export default function StreamingInterface() {
                   roomState={roomState}
                   serverState={serverState}
                   streamingStatus={streamingStatus}
+                  setHasMaxUsers={setHasMaxUsers}
                   onJoinRoomOrUpdateRoles={() => {
                     // If the user has switched from speaker to listener we need to tell the
                     // player to play eagerly, since currently the listener doesn't have any stop/start controls
@@ -1120,13 +1120,6 @@ export default function StreamingInterface() {
                       </Alert>
                     </div>
                   )}
-                  {serverState != null && hasMaxSpeakers && (
-                    <div>
-                      <Alert severity="error">
-                        {`Maximum number of speakers reached. Please try again at a later time.`}
-                      </Alert>
-                    </div>
-                  )}
                   {serverState != null &&
                     serverState.totalActiveTranscoders >=
                       TOTAL_ACTIVE_TRANSCODER_WARNING_THRESHOLD && (
@@ -1156,6 +1149,13 @@ export default function StreamingInterface() {
             )}
           </div>
 
+          {hasMaxUsers && (
+            <div>
+              <Alert severity="error">
+                {`Maximum number of users reached. Please try again at a later time.`}
+              </Alert>
+            </div>
+          )}
           {debugParam && roomID != null && <DebugSection />}
 
           <div className="translation-text-container-sra horizontal-padding-sra">