Update app.py

app.py

@@ -53,16 +53,18 @@ def get_node_name():
     parser = argparse.ArgumentParser(description='Start a chat node with a specific name')
     parser.add_argument('--node-name', type=str, default=None, help='Name for this chat node')
     parser.add_argument('--port', type=int, default=7860, help='Port to run the Gradio interface on')
+    parser.add_argument('--ws-port', type=int, default=8765, help='Port to run the WebSocket server on')
     
     args = parser.parse_args()
     node_name = args.node_name
     port = args.port
+    ws_port = args.ws_port
     
     # If no node name specified, generate a random one
     if not node_name:
         node_name = f"node-{uuid.uuid4().hex[:8]}"
         
-    return node_name, port
+    return node_name, port, ws_port
 
 def get_room_history_file(room_id):
     """Get the filename for a room's history."""
@@ -300,9 +302,18 @@ async def broadcast_message(message, room_id):
 
 async def start_websocket_server(host='0.0.0.0', port=8765):
     """Start the WebSocket server."""
-    server = await websockets.serve(websocket_handler, host, port)
-    logger.info(f"WebSocket server started on ws://{host}:{port}")
-    return server
+    try:
+        server = await websockets.serve(websocket_handler, host, port)
+        logger.info(f"WebSocket server started on ws://{host}:{port}")
+        return server
+    except OSError as e:
+        if e.errno == 98:  # Address already in use
+            logger.warning(f"Port {port} already in use, trying port {port+1}")
+            # Try a different port
+            return await start_websocket_server(host, port+1)
+        else:
+            # If it's a different error, re-raise it
+            raise
 
 def send_message(message, username, room_id):
     """Function to send a message from the Gradio interface."""
@@ -741,51 +752,73 @@ def create_gradio_interface():
 async def main():
     """Main function to start the application."""
     global NODE_NAME, main_event_loop
-    NODE_NAME, port = get_node_name()
+    NODE_NAME, port, ws_port = get_node_name()
     
     # Store the main event loop for later use
     main_event_loop = asyncio.get_running_loop()
     
     # Start WebSocket server
-    server = await start_websocket_server()
-    
-    # Start message queue processor
-    asyncio.create_task(process_message_queue())
-    
-    # Create and launch Gradio interface
-    interface = create_gradio_interface()
-    
-    # Custom middleware to extract node name from URL query parameters
-    from starlette.middleware.base import BaseHTTPMiddleware
-    
-    class NodeNameMiddleware(BaseHTTPMiddleware):
-        async def dispatch(self, request, call_next):
-            global NODE_NAME
-            query_params = dict(request.query_params)
-            if "node_name" in query_params:
-                NODE_NAME = query_params["node_name"]
-                logger.info(f"Node name set to {NODE_NAME} from URL parameter")
+    try:
+        server = await start_websocket_server(port=ws_port)
+        
+        # Start message queue processor
+        asyncio.create_task(process_message_queue())
+        
+        # Create and launch Gradio interface
+        interface = create_gradio_interface()
+        
+        # Custom middleware to extract node name from URL query parameters
+        from starlette.middleware.base import BaseHTTPMiddleware
+        
+        class NodeNameMiddleware(BaseHTTPMiddleware):
+            async def dispatch(self, request, call_next):
+                global NODE_NAME
+                query_params = dict(request.query_params)
+                if "node_name" in query_params:
+                    NODE_NAME = query_params["node_name"]
+                    logger.info(f"Node name set to {NODE_NAME} from URL parameter")
+                
+                response = await call_next(request)
+                return response
+        
+        # Apply middleware
+        app = gr.routes.App.create_app(interface)
+        app.add_middleware(NodeNameMiddleware)
+        
+        # Launch with the modified app
+        gr.routes.mount_gradio_app(app, interface, path="/")
+        
+        # Run the FastAPI app with uvicorn
+        import uvicorn
+        config = uvicorn.Config(app, host="0.0.0.0", port=port)
+        
+        # Try to create the server with retries for port conflicts
+        server_started = False
+        max_retries = 5
+        current_port = port
+        
+        for attempt in range(max_retries):
+            try:
+                config = uvicorn.Config(app, host="0.0.0.0", port=current_port)
+                server = uvicorn.Server(config)
+                logger.info(f"Starting Gradio interface on http://0.0.0.0:{current_port} with node name '{NODE_NAME}'")
+                logger.info("Starting message queue processor")
+                await server.serve()
+                server_started = True
+                break
+            except OSError as e:
+                if e.errno == 98:  # Address already in use
+                    current_port += 1
+                    logger.warning(f"Port {current_port-1} already in use, trying port {current_port}")
+                else:
+                    raise
+        
+        if not server_started:
+            logger.error(f"Failed to start server after {max_retries} attempts")
             
-            response = await call_next(request)
-            return response
-    
-    # Apply middleware
-    app = gr.routes.App.create_app(interface)
-    app.add_middleware(NodeNameMiddleware)
-    
-    # Launch with the modified app
-    gr.routes.mount_gradio_app(app, interface, path="/")
-    
-    # Run the FastAPI app with uvicorn
-    import uvicorn
-    config = uvicorn.Config(app, host="0.0.0.0", port=port)
-    server = uvicorn.Server(config)
-    
-    logger.info(f"Starting Gradio interface on http://0.0.0.0:{port} with node name '{NODE_NAME}'")
-    logger.info("Starting message queue processor")
-    
-    # Start the server
-    await server.serve()
+    except Exception as e:
+        logger.error(f"Error in main: {e}")
+        raise
 
 if __name__ == "__main__":
     asyncio.run(main())