Broadcasting to multiple clients in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when multiple clients connect to a FastAPI WebSocket endpoint using a shared broadcaster?

Consider a FastAPI WebSocket endpoint that uses a single broadcaster instance to send messages to all connected clients. What is the expected behavior when three clients connect and one client sends a message?

FastAPI

from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from fastapi_broadcast import Broadcast

app = FastAPI()
broadcaster = Broadcast("memory://")

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    await broadcaster.connect(websocket)
    try:
        while True:
            data = await websocket.receive_text()
            await broadcaster.send(data)
    except WebSocketDisconnect:
        await broadcaster.disconnect(websocket)

A No clients receive any messages because the broadcaster does not support multiple clients.

B Only the client that sent the message receives it back through the broadcaster.

C All connected clients receive the message sent by any one client through the broadcaster.

D The server crashes because multiple clients cannot share the same broadcaster instance.

💡 Hint

Think about how a broadcaster is designed to distribute messages.

A broadcaster in FastAPI is designed to send messages to all connected clients. When one client sends a message, the broadcaster distributes it to every client connected to that broadcaster, enabling real-time communication among multiple clients.

📝 Syntax

intermediate

Which code snippet correctly initializes a FastAPI Broadcast instance for in-memory broadcasting?

Choose the correct way to create a Broadcast instance that uses in-memory transport for message broadcasting.

A broadcaster = Broadcast("memory://")

B broadcaster = Broadcast("redis://localhost")

C broadcaster = Broadcast()

D broadcaster = Broadcast("http://memory")

💡 Hint

Check the URI scheme for in-memory transport.

The correct URI scheme for in-memory broadcasting in FastAPI Broadcast is "memory://". This creates a broadcaster that keeps messages in memory without external dependencies.

🔧 Debug

advanced

Why does this FastAPI WebSocket broadcasting code raise a RuntimeError?

Examine the code below. It raises a RuntimeError: 'Task attached to a different loop'. What is the cause?

FastAPI

from fastapi import FastAPI, WebSocket
from fastapi_broadcast import Broadcast
import asyncio

app = FastAPI()
broadcaster = Broadcast("memory://")

@app.on_event("startup")
async def startup_event():
    await broadcaster.connect()

@app.on_event("shutdown")
async def shutdown_event():
    await broadcaster.disconnect()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    await broadcaster.connect(websocket)
    try:
        while True:
            data = await websocket.receive_text()
            await broadcaster.send(data)
    except Exception as e:
        print(e)

A The code is missing an await before broadcaster.send causing the error.

B The WebSocket was not accepted before connecting to the broadcaster.

C The broadcaster URI is invalid causing the RuntimeError.

D The broadcaster instance was connected in the startup event loop but used in a different event loop for WebSocket connections.

💡 Hint

Consider how asyncio event loops work with tasks and connections.

The RuntimeError occurs because the broadcaster was connected during the startup event loop, but WebSocket connections run in a different event loop. Tasks cannot be shared across different event loops, causing this error.

❓ state_output

advanced

What is the value of 'connected_clients' after three clients connect and one disconnects?

Given the code below, what is the value of connected_clients after three clients connect and then one disconnects?

FastAPI

from fastapi import FastAPI, WebSocket
from fastapi_broadcast import Broadcast

app = FastAPI()
broadcaster = Broadcast("memory://")
connected_clients = set()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    connected_clients.add(websocket)
    try:
        while True:
            data = await websocket.receive_text()
            await broadcaster.send(data)
    except Exception:
        connected_clients.remove(websocket)

A 2

B 3

C 1

D 0

💡 Hint

Think about how the set changes when clients connect and disconnect.

Initially, three clients connect, so connected_clients has 3 items. When one disconnects, it is removed from the set, leaving 2 clients connected.

🧠 Conceptual

expert

Which statement best describes the role of the Broadcast instance in FastAPI WebSocket communication?

Choose the statement that correctly explains how the Broadcast instance facilitates communication among multiple WebSocket clients in FastAPI.

A It limits the number of clients that can connect simultaneously to prevent server overload.

B It acts as a central message hub that receives messages from any client and forwards them to all connected clients, enabling real-time group communication.

C It encrypts messages between clients to ensure secure peer-to-peer communication without server intervention.

D It stores all messages permanently and allows clients to retrieve message history on demand.

💡 Hint

Focus on the broadcasting role rather than storage or security features.

The Broadcast instance in FastAPI acts as a central hub that receives messages from any connected client and forwards them to all others, enabling real-time group communication. It does not store messages permanently, encrypt messages, or limit client connections by itself.