async def test_wait_stop_streaming_errors():
response = EventSourceResponse(0)
with pytest.raises(RuntimeError) as ctx:
await response.wait()
assert str(ctx.value) == "Response is not started"
with pytest.raises(RuntimeError) as ctx:
response.stop_streaming()
assert str(ctx.value) == "Response is not started"
def test_ping_property():
response = EventSourceResponse(0)
default = response.DEFAULT_PING_INTERVAL
assert response.ping_interval == default
response.ping_interval = 25
assert response.ping_interval == 25
with pytest.raises(TypeError) as ctx:
response.ping_interval = "ten"
assert str(ctx.value) == "ping interval must be int"
with pytest.raises(ValueError):
response.ping_interval = -42
async def stream_iracing_data(request: Request):
"""
Stream iracing data via server sent events. This endpoint also
supports websocket connections.
"""
event_generator = SSEGenerators.get_generator(request, "iracing")
return EventSourceResponse(event_generator)
async def endless(req: Request):
"""Simulates and endless stream
In case of server shutdown the running task has to be stopped via signal handler in order
to enable proper server shutdown. Otherwise there will be dangling tasks preventing proper shutdown.
"""
async def event_publisher():
i = 0
try:
while True:
disconnected = await req.is_disconnected()
if disconnected:
_log.info(f"Disconnecting client {req.client}")
break
# yield dict(id=..., event=..., data=...)
i += 1
yield dict(data=i)
await asyncio.sleep(0.9)
_log.info(f"Disconnected from client {req.client}")
except asyncio.CancelledError as e:
_log.info(f"Disconnected from client (via refresh/close) {req.client}")
# Do any other cleanup, if any
raise e
return EventSourceResponse(event_publisher())
async def get_notifications(request):
async def generate():
while True:
await change_event.wait()
yield {"data": "1"}
return EventSourceResponse(generate())
async def join_lobby(
room_code: str,
req: Request,
playerAndRoom=Depends(get_current_player_and_room),
db: Session = Depends(get_db),
):
player, room = playerAndRoom
if room.code != room_code:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN, detail="Not authorized"
)
async def streamLobbyActivity():
players = crud.get_room_players(db, room.code)
yield json.dumps(",".join(players))
while True:
disconnected = await req.is_disconnected()
if disconnected:
# TODO remove player from the room? What if they're exiting
# the lobby, to ENTER the room?
# TODO have a lobby_players table?
break
async with broadcast.subscribe(channel=room.code) as subscriber:
async for event in subscriber:
msg = event.message
yield json.dumps(msg)
return EventSourceResponse(streamLobbyActivity())
async def sse(req: Request):
async def streamFibonacci(num):
sumBefore, sum = 0, 1
while sum <= num:
disconnected = await req.is_disconnected()
if disconnected:
break
yield str(sum)
sumBefore, sum = sum, sum + sumBefore
await asyncio.sleep(1)
return EventSourceResponse(streamFibonacci(10000))
async def subscribe(key: str, request: Request):
"""Subscribe the user to receive updates from other clients"""
user_id = sub_keys.pop(key, None)
if user_id is None:
raise HTTPException(
status_code=401,
detail="You need to authorize in the /subscribe_auth endpoint first"
)
if user_id not in queues:
queues[user_id] = Queue()
updates = updates_generator(user_id, request)
return EventSourceResponse(updates)
async def app(scope, receive, send):
async def numbers(minimum, maximum):
for i in range(minimum, maximum + 1):
await asyncio.sleep(0.1)
if input == "integer":
yield i
elif input == "dict1":
yield dict(data=i)
elif input == "dict2":
yield dict(data=i, event="message")
generator = numbers(1, 5)
response = EventSourceResponse(generator, ping=0.2) # type: ignore
await response(scope, receive, send)
async def handle_log_deployment(deployment_id: str):
"""
Handles log event source requests to /<deployment_id>/logs/eventsource.
Parameters
----------
deployment_id : str
Returns
-------
EventSourceResponse
"""
controller = LogController()
stream = controller.deployment_event_logs(deployment_id)
return EventSourceResponse(stream)
async def enterLobby(req: Request, room_code):
# TODO "validate" the room_code
async def streamLobbyActivity():
yield 'Someone entered the lobby.'
while True:
disconnected = await req.is_disconnected()
if disconnected:
break
try:
lobbyActivity = lobbyQueue.get(block=False)
except Empty:
pass
else:
yield lobbyActivity
return EventSourceResponse(streamLobbyActivity())
async def message_stream(request: Request):
global queue
async def event_generator():
while True:
# If client was closed the connection
if await request.is_disconnected():
break
if queue.empty():
await asyncio.sleep(1)
continue
m = queue.get()
yield m.toJson()
await asyncio.sleep(0.1)
return EventSourceResponse(event_generator())
async def handle_experiment_operator_stream(experiment_id: str,
session: Session = Depends(
database.session_scope)):
"""
Handle event source requests to /eventsource.
Parameters
----------
experiment_id : str
session : sqlalchemy.orm.session.Session
Returns
-------
EventSourceResponse
"""
controller = OperatorController(session)
stream = controller.watch_operator(experiment_id=experiment_id)
return EventSourceResponse(stream)
async def stream(request: Request, dealy: Optional[int] = 1):
async def generator() -> dict:
__sep__ = '\n\n'
with concurrent.futures.ThreadPoolExecutor() as executor:
while True:
if await request.is_disconnected():
break
future = executor.submit(get_current_data_stamp)
result = json.dumps(future.result())
yield {"id": uuid.uuid4().hex, "retry": 1500, "data": result}
time.sleep(dealy)
return EventSourceResponse(generator())
async def join_room(
room_code: str, req: Request, playerAndRoom=Depends(get_current_player_and_room),
):
player, room = playerAndRoom
if room.code != room_code:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN, detail="Not authorized"
)
async def streamRoomActivity():
while True:
disconnected = await req.is_disconnected()
if disconnected:
# TODO Remove player from the room
# TODO If the room no longer has players, remove room
break
async with broadcast.subscribe(channel=room.code) as subscriber:
async for event in subscriber:
yield json.dumps(event.message)
return EventSourceResponse(streamRoomActivity())
async def subscribe(req: Request):
""" Subscribe to SSE events """
msg_que: Queue = Queue(3)
next_sub = max(subscribers.keys(), default=0) + 1
subscribers[next_sub] = msg_que
async def stream():
try:
while True:
if await req.is_disconnected():
print('disconnected')
break
if not msg_que.empty():
msg = msg_que.get()
yield msg
await asyncio.sleep(0.2)
print(f"Disconnected from client {req.client}")
except asyncio.CancelledError as exc:
print(f"Disconnected from client (via refresh/close) {req.client}")
# Do any other cleanup, if any
raise exc
return EventSourceResponse(stream())
async def endless(req: Request):
"""Simulates and endless stream
In case of server shutdown the running task has to be stopped via signal handler in order
to enable proper server shutdown. Otherwise there will be dangling tasks preventing proper shutdown.
"""
async def event_publisher():
# The event publisher only conditionally emits items
has_data = True
while True:
disconnected = await req.is_disconnected()
if disconnected:
_log.info(f"Disconnecting client {req.client}")
break
# Simulate only sending one response
if has_data:
yield dict(data="u can haz the data")
has_data = False
await asyncio.sleep(0.9)
_log.info(f"Disconnected from client {req.client}")
return EventSourceResponse(event_publisher())
async def feed(request: Request) -> EventSourceResponse:
client_queue: asyncio.Queue = asyncio.Queue()
await socket_receiver.add_connecetion_queue(client_queue)
return EventSourceResponse(
socket_receiver.get_collected_data(client_queue))
async def all_sse_stats(request: Request, Authorize: AuthJWT = Depends()):
auth_check(Authorize)
stat_generator = actions.all_stat_generator(request)
return EventSourceResponse(stat_generator)
async def sse(request):
generator = numbers(1, 25)
return EventSourceResponse(generator)
async def handle():
generator = numbers(1, 100)
return EventSourceResponse(generator, headers={"Server": "nini"})
def test_compression_not_implemented():
response = EventSourceResponse(0)
with pytest.raises(NotImplementedError):
response.enable_compression()
async def get(request: Request, user_id: Optional[str] = None):
event_generator = kafka_stream(request, user_id)
return EventSourceResponse(event_generator)
async def event_stream(request: Request):
return EventSourceResponse(estream())
async def game_event_stream(request: Request):
game_id = request.path_params.get('game_id')
return EventSourceResponse(game_stream(game_id),
media_type='text/event-stream')
async def get_messages():
events = get_stream("https://stream.wikimedia.org/v2/stream/recentchange")
return EventSourceResponse(events)
async def logs(app_name: str, request: Request,
Authorize: AuthJWT = Depends()):
auth_check(Authorize)
log_generator = actions.log_generator(request, app_name)
return EventSourceResponse(log_generator)
async def sse():
generator = numbers(0, 10)
return EventSourceResponse(generator)
async def stream(url):
eg = event_generator(url)
event_source = EventSourceResponse(eg)
event_source.ping_interval = 600 #ping every 10 mins
return event_source
async def sse_stats(app_name: str,
request: Request,
Authorize: AuthJWT = Depends()):
auth_check(Authorize)
stat_generator = actions.stat_generator(request, app_name)
return EventSourceResponse(stat_generator)