Merge pull request #1715 from roboflow/turn-server-sdk-config

Turn server sdk config

Author: grzegorz-roboflow

inference_sdk/config.py

@@ -11,6 +11,17 @@
 EXECUTION_ID_HEADER = os.getenv("EXECUTION_ID_HEADER", "execution_id")
 PROCESSING_TIME_HEADER = os.getenv("PROCESSING_TIME_HEADER", "X-Processing-Time")
 
+
+ALL_ROBOFLOW_API_URLS = {
+    "https://detect.roboflow.com",
+    "https://outline.roboflow.com",
+    "https://classify.roboflow.com",
+    "https://infer.roboflow.com",
+    "https://serverless.roboflow.com",
+    "https://serverless.roboflow.one",
+}
+
+
 # WebRTC configuration
 WEBRTC_INITIAL_FRAME_TIMEOUT = float(os.getenv("WEBRTC_INITIAL_FRAME_TIMEOUT", "90.0"))
 WEBRTC_VIDEO_QUEUE_MAX_SIZE = int(os.getenv("WEBRTC_VIDEO_QUEUE_MAX_SIZE", "8"))
@@ -26,6 +37,9 @@
     os.getenv("WEBRTC_VIDEO_UPLOAD_BUFFER_LIMIT", "262144")
 )  # 256KB max buffered before backpressure
 
+# Roboflow API base URL for TURN config and other services
+RF_API_BASE_URL = os.getenv("RF_API_BASE_URL", "https://api.roboflow.com")
+
 
 class InferenceSDKDeprecationWarning(Warning):
     """Class used for warning of deprecated features in the Inference SDK"""

inference_sdk/http/entities.py

@@ -6,7 +6,10 @@
 from dataclasses_json import DataClassJsonMixin
 from PIL import Image
 
-from inference_sdk.config import WORKFLOW_RUN_RETRIES_ENABLED
+from inference_sdk.config import (  # noqa: F401
+    ALL_ROBOFLOW_API_URLS,
+    WORKFLOW_RUN_RETRIES_ENABLED,
+)
 from inference_sdk.http.errors import ModelTaskTypeNotSupportedError
 from inference_sdk.http.utils.iterables import remove_empty_values
 
@@ -21,15 +24,6 @@
 KEYPOINTS_DETECTION_TASK = "keypoint-detection"
 DEFAULT_MAX_INPUT_SIZE = 1024
 
-ALL_ROBOFLOW_API_URLS = {
-    "https://detect.roboflow.com",
-    "https://outline.roboflow.com",
-    "https://classify.roboflow.com",
-    "https://infer.roboflow.com",
-    "https://serverless.roboflow.com",
-    "https://serverless.roboflow.one",
-}
-
 
 @dataclass(frozen=True)
 class ServerInfo(DataClassJsonMixin):

inference_sdk/webrtc/session.py

@@ -17,8 +17,11 @@
 import cv2
 import numpy as np
 import requests
+from aiortc import RTCConfiguration, RTCIceServer
 
 from inference_sdk.config import (
+    ALL_ROBOFLOW_API_URLS,
+    RF_API_BASE_URL,
     WEBRTC_EVENT_LOOP_SHUTDOWN_TIMEOUT,
     WEBRTC_INITIAL_FRAME_TIMEOUT,
     WEBRTC_VIDEO_QUEUE_MAX_SIZE,
@@ -557,25 +560,72 @@ def _invoke_data_handler(
             )
             raise
 
-    async def _get_turn_config(self) -> Optional[dict]:
-        """Get TURN configuration from user-provided config.
+    @staticmethod
+    def _to_list(value: Any) -> List[Any]:
+        """Convert value to list if it is not already a list."""
+        if isinstance(value, list):
+            return value
+        return [value]
+
+    async def _get_turn_config(self) -> Optional[RTCConfiguration]:
+        """Get TURN configuration from user-provided config or Roboflow API.
 
         Priority order:
         1. User-provided config via StreamConfig.turn_server (highest priority)
-        2. Skip TURN for localhost connections
-        3. Return None if not provided
+        2. Auto-fetch from Roboflow API for serverless connections
+        3. Return None for non-serverless connections
 
         Returns:
             TURN configuration dict or None
         """
+        turn_config = None
         # 1. Use user-provided config if available
         if self._config.turn_server:
+            turn_config = self._config.turn_server
             logger.debug("Using user-provided TURN configuration")
-            return self._config.turn_server
 
-        # 3. No TURN config provided
-        logger.debug("No TURN configuration provided, proceeding without TURN server")
-        return None
+        # 2. Auto-fetch from Roboflow API for Roboflow-hosted connections
+        elif self._api_url in ALL_ROBOFLOW_API_URLS:
+            try:
+                logger.debug(
+                    "Fetching TURN config from Roboflow API for serverless connection"
+                )
+                response = requests.get(
+                    f"{RF_API_BASE_URL}/webrtc_turn_config",
+                    params={"api_key": self._api_key},
+                    timeout=5,
+                )
+                response.raise_for_status()
+                turn_config = response.json()
+                logger.debug("Successfully fetched TURN config from Roboflow API")
+            except Exception as e:
+                logger.warning(f"Failed to fetch TURN config from Roboflow API: {e}")
+                return None
+        # standardize the TURN config to the iceServers format
+        if turn_config and "iceServers" in turn_config:
+            turn_config = RTCConfiguration(
+                iceServers=[
+                    RTCIceServer(
+                        urls=WebRTCSession._to_list(server.get("urls", [])),
+                        username=server.get("username"),
+                        credential=server.get("credential"),
+                    )
+                    for server in turn_config["iceServers"]
+                ]
+            )
+            logger.debug("Successfully converted TURN config to iceServers format")
+        elif turn_config and "urls" in turn_config:
+            turn_config = RTCConfiguration(
+                iceServers=[
+                    RTCIceServer(
+                        urls=[turn_config["urls"]],
+                        username=turn_config["username"],
+                        credential=turn_config["credential"],
+                    )
+                ]
+            )
+            logger.debug("Successfully converted TURN config to iceServers format")
+        return turn_config
 
     def _handle_datachannel_video_frame(
         self, serialized_data: Any, metadata: Optional[VideoMetadata]
@@ -627,17 +677,7 @@ async def _init(self) -> None:
         # Fetch TURN configuration (auto-fetch or user-provided)
         turn_config = await self._get_turn_config()
 
-        # Create peer connection with TURN config if available
-        configuration = None
-        if turn_config:
-            ice = RTCIceServer(
-                urls=[turn_config.get("urls")],
-                username=turn_config.get("username"),
-                credential=turn_config.get("credential"),
-            )
-            configuration = RTCConfiguration(iceServers=[ice])
-
-        pc = RTCPeerConnection(configuration=configuration)
+        pc = RTCPeerConnection(configuration=turn_config)
         relay = MediaRelay()
 
         # Setup video receiver for frames from server
@@ -812,9 +852,19 @@ def _on_data_message(message: Any) -> None:  # noqa: ANN401
             "data_output": self._config.data_output,
         }
 
-        # Add TURN config if available (auto-fetched or user-provided)
+        # Add WebRTC config if available (auto-fetched or user-provided)
+        # Server accepts webrtc_config with iceServers array format
         if turn_config:
-            payload["webrtc_turn_config"] = turn_config
+            payload["webrtc_config"] = {
+                "iceServers": [
+                    {
+                        "urls": ice_server.urls,
+                        "username": ice_server.username,
+                        "credential": ice_server.credential,
+                    }
+                    for ice_server in turn_config.iceServers
+                ]
+            }
 
         # Add FPS if provided
         if self._config.declared_fps: