getstream 3.3.0__tar.gz → 3.3.2__tar.gz

{getstream-3.3.0 → getstream-3.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: getstream
-Version: 3.3.0
+Version: 3.3.2
 Summary: GetStream Python SDK - Build scalable activity feeds, chat, and video calling applications
 Author-email: sachaarbonel <sacha.arbonel@hotmail.fr>, tbarbugli <tbarbugli@gmail.com>
 License-File: LICENSE.md

{getstream-3.3.0 → getstream-3.3.2}/getstream/video/rtc/connection_manager.py

@@ -36,7 +36,7 @@ from getstream.video.rtc.network_monitor import NetworkMonitor
 from getstream.video.rtc.recording import RecordingManager
 from getstream.video.rtc.participants import ParticipantsState
 from getstream.video.rtc.tracks import SubscriptionConfig, SubscriptionManager
-from getstream.video.rtc.reconnection import ReconnectionManager
+from getstream.video.rtc.reconnection import ReconnectionManager, ReconnectionStrategy
 from getstream.video.rtc.peer_connection import PeerConnectionManager
 from getstream.video.rtc.models import JoinCallResponse
 from getstream.video.rtc.tracer import Tracer
@@ -198,6 +198,17 @@ class ConnectionManager(StreamAsyncIOEventEmitter):
     async def _on_subscriber_offer(self, event: events_pb2.SubscriberOffer):
         logger.info("Subscriber offer received")
 
+        # Offers can arrive after the subscriber peer connection has been
+        # torn down (slow asyncio loop under load, SFU sending a late
+        # renegotiation). `setRemoteDescription` would raise
+        # `InvalidStateError: Cannot handle offer in signaling state "closed"`
+        # and the exception propagates through the pyee error path, killing
+        # the session. Drop the offer instead — there is nothing to
+        # negotiate with a closed connection.
+        if self.subscriber_pc is None or self.subscriber_pc.signalingState == "closed":
+            logger.debug("Subscriber offer arrived after PC closed; dropping")
+            return
+
         with telemetry.start_as_current_span("rtc.on_subscriber_offer") as span:
             await self.subscriber_negotiation_lock.acquire()
 
@@ -266,6 +277,25 @@ class ConnectionManager(StreamAsyncIOEventEmitter):
             finally:
                 self.subscriber_negotiation_lock.release()
 
+    async def _on_signaling_connection_lost(self, reason: str) -> None:
+        """Reconnect when the signaling WebSocket drops unexpectedly.
+
+        The WebSocketClient itself only logs the error and stops; it has
+        no reconnect of its own. This handler bridges that gap by routing
+        the loss into the existing `ReconnectionManager`, so a transient
+        TCP reset or a missed health check no longer means a dead session.
+        """
+        if not self.running:
+            return
+        logger.warning(f"Signaling WS lost; triggering reconnect: {reason}")
+        try:
+            await self._reconnector.reconnect(
+                strategy=ReconnectionStrategy.FAST,
+                reason=f"signaling ws lost: {reason}",
+            )
+        except Exception:
+            logger.exception("Reconnect after signaling WS loss failed")
+
     async def _connect_coordinator_ws(self):
         """
         Connects to the coordinator websocket and subscribes to events.
@@ -403,6 +433,15 @@ class ConnectionManager(StreamAsyncIOEventEmitter):
             # Connect subscriber offer event to handle SDP negotiation
             self._ws_client.on_event("subscriber_offer", self._on_subscriber_offer)
 
+            # Drive reconnection when the signaling WS drops outside of an
+            # SFU-level error event (raw socket close, health-check timeout,
+            # transport-level exceptions). Without this handler the
+            # WebSocketClient just logs and stops; the session sits hanging
+            # until the frontend times out and tears it down.
+            self._ws_client.on_event(
+                "connection_lost", self._on_signaling_connection_lost
+            )
+
             # Re-emit the events so they can be subscribed to on the ConnectionManager
             self._ws_client.on_wildcard("*", self.emit)
 

{getstream-3.3.0 → getstream-3.3.2}/getstream/video/rtc/reconnection.py

@@ -209,10 +209,13 @@ class ReconnectionManager:
                 self.connection_manager._connection_options.fast_reconnect = True
                 previous_ws_client = self.connection_manager.ws_client
 
-                # Use _connect_internal with existing connection info
+                # Use _connect_internal with existing connection info.
+                # `self.join_response` is already the unwrapped data payload
+                # (see ConnectionManager._connect_internal: it stores
+                # `join_response.data`), so credentials live at the top level.
                 await self.connection_manager._connect_internal(
                     region=self.connection_manager._connection_options.region,
-                    token=self.connection_manager.join_response.data.credentials.token
+                    token=self.connection_manager.join_response.credentials.token
                     if self.connection_manager.join_response
                     else None,
                     session_id=self.connection_manager.session_id,

{getstream-3.3.0 → getstream-3.3.2}/getstream/video/rtc/signaling.py

@@ -1,12 +1,14 @@
 import asyncio
-import threading
-import websocket
 import logging
+import threading
 import time
-from typing import TYPE_CHECKING, Any, Callable, Awaitable, Optional, Set
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, Optional, Set
+
+import websocket
 
 from getstream.common import telemetry
 from getstream.utils import StreamAsyncIOEventEmitter
+
 from .pb.stream.video.sfu.event import events_pb2
 
 if TYPE_CHECKING:
@@ -65,6 +67,7 @@ class WebSocketClient(StreamAsyncIOEventEmitter):
         self.thread = None
         self.running = False
         self.closed = False
+        self._connection_lost_sent = False
 
         # For ping/health check mechanism
         self.ping_thread = None
@@ -196,18 +199,64 @@ class WebSocketClient(StreamAsyncIOEventEmitter):
 
     def _on_error(self, ws, error):
         """Handle WebSocket error."""
-        logger.error(f"WebSocket error: {str(error)}")
+        if (
+            isinstance(error, websocket.ABNF)
+            and error.opcode == websocket.ABNF.OPCODE_CLOSE
+        ):
+            # For some reason, websockets lib propagates closing frame as an error.
+            # Simply log a debug here if that happens.
+            logger.debug(f"WebSocket closed by server: {error}")
+        else:
+            logger.error(f"WebSocket error: {error}")
+
         if not self.first_message_event.is_set():
             # Create an error event
             error_event = events_pb2.SfuEvent()
             error_event.error.error.message = str(error)
             self.first_message = error_event
             self.first_message_event.set()
+        elif not self.closed:
+            self._notify_connection_lost(f"error: {error}")
 
     def _on_close(self, ws, close_status_code, close_msg):
         """Handle WebSocket close event."""
         logger.debug(f"WebSocket connection closed: {close_status_code} {close_msg}")
+        was_unexpected = not self.closed
         self.running = False
+        if was_unexpected:
+            self._notify_connection_lost(
+                f"closed by remote (code={close_status_code} msg={close_msg})"
+            )
+
+    def _notify_connection_lost(self, reason: str) -> None:
+        """Schedule a ``connection_lost`` emit on the main loop.
+
+        Idempotent per ``WebSocketClient`` instance — only the first call
+        per disconnect actually emits. Callers run on the WS worker thread
+        or ``_ping_loop`` thread; pyee schedules async listeners via
+        ``loop.create_task``, which is not thread-safe, hence the hop.
+        Same pattern as ``_on_message`` for SFU events.
+        """
+        if not self._claim_connection_lost():
+            return
+        try:
+            asyncio.run_coroutine_threadsafe(
+                self._emit_connection_lost(reason),
+                self.main_loop,
+            )
+        except Exception:
+            logger.exception("Failed to schedule connection_lost emit")
+
+    def _claim_connection_lost(self) -> bool:
+        """Return True iff this is the first connection-lost notification."""
+        if self._connection_lost_sent:
+            return False
+        self._connection_lost_sent = True
+        return True
+
+    async def _emit_connection_lost(self, reason: str) -> None:
+        with telemetry.attach_span(self.parent_span):
+            self.emit("connection_lost", reason)
 
     def _start_ping_handler(self):
         """Start the ping mechanism in a background thread."""
@@ -231,6 +280,10 @@ class WebSocketClient(StreamAsyncIOEventEmitter):
             current_time = time.time()
             if current_time - self.last_health_check_time > self.ping_interval * 2:
                 logger.warning("Health check failed, closing connection")
+                # Notify before close() so the owner can reconnect; close()
+                # itself sets `self.closed=True` and would suppress the
+                # notification in `_on_close`.
+                self._notify_connection_lost("health check timeout")
                 self.close()
                 return