Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
43 changes: 37 additions & 6 deletions ring_doorbell/doorbot.py
Original file line number Diff line number Diff line change
Expand Up @@ -4,6 +4,7 @@
from __future__ import annotations

import asyncio
import contextlib
import logging
import time
from pathlib import Path
Expand Down Expand Up @@ -468,10 +469,24 @@ async def _close_callback() -> None:
keep_alive_timeout=keep_alive_timeout,
on_close_callback=_close_callback,
)
sdp_answer = await stream.generate(sdp_offer)
# generate will raise if no sdp answer as no callback passed
assert sdp_answer # noqa: S101
# Register before awaiting generate so ICE candidates arriving
# while the offer is being processed reach the stream instead
# of raising (trickle-ICE race, #560). The stream holds them
# until the offer is sent. Remove the registration again if
# generate fails or is cancelled (CancelledError is a
# BaseException, so `except Exception` would miss it and leave
# a stale stream behind) and close the stream so no half-open
# websocket or reader task is left behind.
self._webrtc_streams[session_id] = stream
try:
sdp_answer = await stream.generate(sdp_offer)
# generate will raise if no sdp answer as no callback passed
assert sdp_answer # noqa: S101
except BaseException:
self._webrtc_streams.pop(session_id, None)
with contextlib.suppress(Exception):
await stream.close()
raise
return sdp_answer
msg = "Unable to generate the stream, could not extract session id from offer."
raise RingError(msg)
Expand All @@ -496,8 +511,17 @@ async def _close_callback() -> None:
keep_alive_timeout=keep_alive_timeout,
on_close_callback=_close_callback,
)
# As in generate_webrtc_stream: remove the registration and close
# the stream if generate fails or is cancelled, so a failed or
# abandoned session does not leave a stale stream behind (#560).
self._webrtc_streams[session_id] = stream
await stream.generate(sdp_offer)
try:
await stream.generate(sdp_offer)
except BaseException:
self._webrtc_streams.pop(session_id, None)
with contextlib.suppress(Exception):
await stream.close()
raise

async def on_webrtc_candidate(
self, session_id: str, candidate: str, multi_line_index: int
Expand All @@ -506,8 +530,15 @@ async def on_webrtc_candidate(
if stream := self._webrtc_streams.get(session_id):
await stream.on_ice_candidate(candidate, multi_line_index)
else:
msg = "Ice candidate received before stream has been created."
raise RingError(msg)
# Candidates can legitimately arrive before the stream is
# created (trickle ICE) or after it was closed; there is no
# stream to deliver them to, so drop them instead of raising
# (#560). Raising only produced "Unknown error" tracebacks in
# callers that do not expect this call to fail.
_LOGGER.debug(
"Ignoring ICE candidate for unknown or closed WebRTC session %s.",
session_id,
)

async def close_webrtc_stream(self, session_id: str) -> None:
"""Close the rtc stream."""
Expand Down
145 changes: 145 additions & 0 deletions tests/test_webrtc.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,145 @@
"""Tests for the WebRTC stream handling on RingDoorBell (issue #560)."""

import asyncio
from unittest.mock import AsyncMock

import pytest
from ring_doorbell.doorbot import RingDoorBell
from ring_doorbell.webrtcstream import RingWebRtcStream

SDP_OFFER = "v=0\r\n" "o=- 987654321 1 IN IP4 127.0.0.1\r\n" "s=-\r\n" "t=0 0\r\n"
SESSION_ID = "987654321"
CANDIDATE = "candidate:1 1 udp 123 192.168.1.2 5000 typ host"


def get_doorbell(ring) -> RingDoorBell:
"""Return the mocked doorbell device."""
return ring.devices()["doorbots"][0]


async def test_on_webrtc_candidate_unknown_session_does_not_raise(ring) -> None:
"""An ICE candidate for a session with no stream must not raise (#560)."""
dev = get_doorbell(ring)

# No stream registered for this session: the trickle-ICE race.
await dev.on_webrtc_candidate("no-such-session", CANDIDATE, 0)


async def test_on_webrtc_candidate_after_close_does_not_raise(ring) -> None:
"""An ICE candidate arriving after the stream closed must not raise."""
dev = get_doorbell(ring)
stream = AsyncMock()
dev._webrtc_streams[SESSION_ID] = stream

await dev.close_webrtc_stream(SESSION_ID)
assert SESSION_ID not in dev._webrtc_streams

await dev.on_webrtc_candidate(SESSION_ID, CANDIDATE, 0)


async def test_on_webrtc_candidate_during_generate_is_delivered(ring, mocker) -> None:
"""A candidate arriving while generate is running reaches the stream."""
dev = get_doorbell(ring)
generate_started = asyncio.Event()
release_generate = asyncio.Event()

async def fake_generate(self, _offer: str) -> str:
generate_started.set()
await release_generate.wait()
return "v=0\r\ns=answer\r\n"

# Patch the methods, not the class: patching the class would also
# replace get_sdp_session_id, so the stream would register under a
# mock session id instead of the offer's real one.
on_ice = mocker.patch.object(RingWebRtcStream, "on_ice_candidate", new=AsyncMock())
mocker.patch.object(RingWebRtcStream, "generate", new=fake_generate)

task = asyncio.create_task(dev.generate_webrtc_stream(SDP_OFFER))
try:
await generate_started.wait()
# The stream is not yet registered on base: this raises RingError.
await dev.on_webrtc_candidate(SESSION_ID, CANDIDATE, 0)
finally:
release_generate.set()
await task

on_ice.assert_awaited_once_with(CANDIDATE, 0)
assert SESSION_ID in dev._webrtc_streams


async def test_generate_webrtc_stream_unregisters_on_failure(ring, mocker) -> None:
"""A failed generate must not leave a stale stream registered."""
dev = get_doorbell(ring)
mocker.patch.object(
RingWebRtcStream,
"generate",
new=AsyncMock(side_effect=RuntimeError("boom")),
)

with pytest.raises(RuntimeError, match="boom"):
await dev.generate_webrtc_stream(SDP_OFFER)

assert SESSION_ID not in dev._webrtc_streams


async def test_generate_webrtc_stream_cancellation_unregisters(ring, mocker) -> None:
"""Cancelling generate must not leave a stale stream registered."""
dev = get_doorbell(ring)
generate_started = asyncio.Event()

async def fake_generate(self, _offer: str) -> str:
generate_started.set()
await asyncio.Event().wait()
return "v=0\r\ns=answer\r\n"

mocker.patch.object(RingWebRtcStream, "generate", new=fake_generate)

task = asyncio.create_task(dev.generate_webrtc_stream(SDP_OFFER))
await generate_started.wait()
stream = dev._webrtc_streams[SESSION_ID]

task.cancel()
with pytest.raises(asyncio.CancelledError):
await task

assert SESSION_ID not in dev._webrtc_streams
assert stream.is_alive is False


async def test_generate_async_webrtc_stream_cancellation_unregisters(
ring, mocker
) -> None:
"""Cancelling the async generate must not leave a stale stream."""
dev = get_doorbell(ring)
generate_started = asyncio.Event()

async def fake_generate(self, _offer: str) -> str:
generate_started.set()
await asyncio.Event().wait()
return "v=0\r\ns=answer\r\n"

mocker.patch.object(RingWebRtcStream, "generate", new=fake_generate)

task = asyncio.create_task(
dev.generate_async_webrtc_stream(SDP_OFFER, SESSION_ID, lambda _: None)
)
await generate_started.wait()
stream = dev._webrtc_streams[SESSION_ID]

task.cancel()
with pytest.raises(asyncio.CancelledError):
await task

assert SESSION_ID not in dev._webrtc_streams
assert stream.is_alive is False


async def test_on_webrtc_candidate_live_stream_forwards(ring) -> None:
"""A candidate for a live stream is still forwarded (control case)."""
dev = get_doorbell(ring)
stream = AsyncMock()
dev._webrtc_streams[SESSION_ID] = stream

await dev.on_webrtc_candidate(SESSION_ID, CANDIDATE, 0)

stream.on_ice_candidate.assert_awaited_once_with(CANDIDATE, 0)