set default ringing timeout

Author: davidzhao

livekit-api/livekit/api/_dial_timeout.py

@@ -14,27 +14,41 @@
 ]
 """@private"""
 
-# Calls that dial a phone (SIP CreateSIPParticipant with wait_until_answered and
-# TransferSIPParticipant; WhatsApp AcceptWhatsAppCall with wait_until_answered)
-# take longer than a normal request.
-DIAL_TIMEOUT = 30.0
+# Ring window (seconds) assumed when a request doesn't set ringing_timeout;
+# matches the server default. A dialing request must outlast it.
+DEFAULT_RINGING_TIMEOUT = 30.0
 """@private"""
 
 # A dialing request must outlast the ringing window, or it would abort before
 # the call can be answered. Keep the request timeout at least this many seconds
-# above the request's ringing_timeout.
+# above the ringing timeout.
 RINGING_TIMEOUT_MARGIN = 2.0
 """@private"""
 
 
+def pin_ringing_timeout(request: DialRequest) -> None:
+    """Set the ring window explicitly on a dialing request when the caller left it
+    unset, so the derived request timeout doesn't depend on the server's default
+    (which could change out from under us).
+
+    @private
+    """
+    if not request.HasField("ringing_timeout"):
+        request.ringing_timeout.seconds = int(DEFAULT_RINGING_TIMEOUT)
+
+
 def dial_timeout(user_timeout: Optional[float], request: DialRequest) -> float:
-    """Request timeout (seconds) for a phone-dialing call: the user-supplied
-    value (or the dial default) raised, when needed, to stay at least
-    RINGING_TIMEOUT_MARGIN above the request's ringing_timeout.
+    """Request timeout (seconds) for a phone-dialing call: the ring window plus a
+    margin, so the request doesn't abort before the call can be answered. The
+    ring window is the request's ringing_timeout when set, else
+    DEFAULT_RINGING_TIMEOUT. A longer user_timeout is honored; a shorter one is
+    raised to the floor.
 
     @private
     """
-    effective = user_timeout if user_timeout else DIAL_TIMEOUT
     if request.HasField("ringing_timeout"):
-        effective = max(effective, request.ringing_timeout.seconds + RINGING_TIMEOUT_MARGIN)
-    return effective
+        ring: float = request.ringing_timeout.seconds
+    else:
+        ring = DEFAULT_RINGING_TIMEOUT
+    floor = ring + RINGING_TIMEOUT_MARGIN
+    return max(user_timeout if user_timeout else floor, floor)

livekit-api/livekit/api/connector_service.py

@@ -18,7 +18,7 @@
     ConnectTwilioCallResponse,
 )
 from ._service import Service
-from ._dial_timeout import dial_timeout
+from ._dial_timeout import dial_timeout, pin_ringing_timeout
 from .access_token import VideoGrants
 
 SVC = "Connector"
@@ -129,7 +129,9 @@ async def accept_whatsapp_call(
         client_timeout: Optional[aiohttp.ClientTimeout] = None
         if request.wait_until_answered:
             # Waiting for the call to be answered dials a phone, which takes
-            # longer than a normal request and must outlast ringing.
+            # longer than a normal request and must outlast ringing. Pin the ring
+            # window so the timeout doesn't depend on the server's default.
+            pin_ringing_timeout(request)
             client_timeout = aiohttp.ClientTimeout(total=dial_timeout(timeout, request))
         elif timeout:
             client_timeout = aiohttp.ClientTimeout(total=timeout)

livekit-api/livekit/api/sip_service.py

@@ -35,7 +35,7 @@
     SIPTransport,
 )
 from ._service import Service
-from ._dial_timeout import dial_timeout as _dial_timeout
+from ._dial_timeout import dial_timeout as _dial_timeout, pin_ringing_timeout as _pin_ringing_timeout
 from .access_token import VideoGrants, SIPGrants
 
 SVC = "SIP"
@@ -784,7 +784,9 @@ async def create_sip_participant(
         client_timeout: Optional[aiohttp.ClientTimeout] = None
         if create.wait_until_answered:
             # Dialing a phone and waiting for an answer takes longer than a
-            # normal call, and the request must outlast ringing.
+            # normal call, and the request must outlast ringing. Pin the ring
+            # window so the timeout doesn't depend on the server's default.
+            _pin_ringing_timeout(create)
             client_timeout = aiohttp.ClientTimeout(total=_dial_timeout(timeout, create))
         elif timeout:
             # obey user specified timeout
@@ -823,8 +825,9 @@ async def transfer_sip_participant(
             Updated SIP participant information
         """
         # Transferring a call dials a phone, which takes longer than a normal
-        # call, so use a longer default unless the user specified a timeout, and
-        # keep the request alive past ringing so the destination can answer.
+        # call, so keep the request alive past ringing. Pin the ring window so the
+        # timeout doesn't depend on the server's default.
+        _pin_ringing_timeout(transfer)
         client_timeout = aiohttp.ClientTimeout(total=_dial_timeout(timeout, transfer))
         return await self._client.request(
             SVC,