janus-api-streaming 0.2.0__py3-none-any.whl

janus_streaming/runtime.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+from . import _compat
+from .admin import StreamingAdminClient
+from .errors import StreamingNotStarted
+from .viewer import StreamingViewer
+
+
+@dataclass(frozen=True, slots=True)
+class StreamingRuntimeSettings:
+    admin_key: str | None = field(default=None, repr=False)
+    request_timeout: float = 10.0
+    negotiation_timeout: float = 15.0
+    attach_timeout: float = 5.0
+    max_admin_concurrency: int = 32
+
+    def __post_init__(self) -> None:
+        if self.request_timeout <= 0:
+            raise ValueError("request_timeout must be greater than zero")
+        if self.negotiation_timeout <= 0:
+            raise ValueError("negotiation_timeout must be greater than zero")
+        if self.attach_timeout <= 0:
+            raise ValueError("attach_timeout must be greater than zero")
+        if self.max_admin_concurrency < 1:
+            raise ValueError("max_admin_concurrency must be at least one")
+
+
+class StreamingRuntime:
+    """Owns Streaming-plugin resources for an already-created Janus session."""
+
+    def __init__(self, session: Any, settings: StreamingRuntimeSettings | None = None) -> None:
+        self.session = session
+        self.settings = settings or StreamingRuntimeSettings()
+        self._admin: StreamingAdminClient | None = None
+        self._viewers: set[StreamingViewer] = set()
+        self._lock = asyncio.Lock()
+
+    @property
+    def admin(self) -> StreamingAdminClient:
+        if self._admin is None:
+            raise StreamingNotStarted("StreamingRuntime.start() has not been called")
+        return self._admin
+
+    async def start(self) -> None:
+        async with self._lock:
+            if self._admin is not None:
+                return
+            admin = StreamingAdminClient(
+                self.session,
+                admin_key=self.settings.admin_key,
+                request_timeout=self.settings.request_timeout,
+                attach_timeout=self.settings.attach_timeout,
+                max_concurrency=self.settings.max_admin_concurrency,
+            )
+            await admin.start()
+            self._admin = admin
+
+    def create_viewer(self, mountpoint_id: int, **kwargs: Any) -> StreamingViewer:
+        viewer = StreamingViewer(
+            self.session,
+            mountpoint_id=mountpoint_id,
+            request_timeout=self.settings.request_timeout,
+            negotiation_timeout=self.settings.negotiation_timeout,
+            attach_timeout=self.settings.attach_timeout,
+            **kwargs,
+        )
+        self._viewers.add(viewer)
+        return viewer
+
+    async def release_viewer(self, viewer: StreamingViewer) -> None:
+        try:
+            await viewer.close()
+        finally:
+            self._viewers.discard(viewer)
+
+    async def close(self) -> None:
+        async with self._lock:
+            admin, self._admin = self._admin, None
+            viewers = tuple(self._viewers)
+            self._viewers.clear()
+        if viewers:
+            await asyncio.gather(*(viewer.close() for viewer in viewers), return_exceptions=True)
+        if admin is not None:
+            await admin.close()
+
+
+class ManagedStreamingRuntime:
+    """Optional helper that also owns `janus-api`'s session manager.
+
+    The import is lazy so applications that inject an existing Janus session do
+    not import the `janus-api` server/Redis stack.
+    """
+
+    def __init__(
+        self,
+        settings: StreamingRuntimeSettings | None = None,
+        *,
+        manager_factory: Callable[[], Any] | None = None,
+    ) -> None:
+        self.settings = settings or StreamingRuntimeSettings()
+        self._manager_factory = manager_factory
+        self._manager: Any | None = None
+        self._runtime: StreamingRuntime | None = None
+
+    @property
+    def runtime(self) -> StreamingRuntime:
+        if self._runtime is None:
+            raise StreamingNotStarted("ManagedStreamingRuntime.start() has not been called")
+        return self._runtime
+
+    async def start(self) -> None:
+        if self._runtime is not None:
+            return
+        if self._manager_factory is None:
+            manager = _compat.create_session_manager()
+        else:
+            manager = self._manager_factory()
+        await manager.start()
+        session = manager.get_session()
+        if session is None:
+            await manager.stop()
+            raise StreamingNotStarted("janus-api started without an available session")
+        runtime = StreamingRuntime(session, self.settings)
+        try:
+            await runtime.start()
+        except BaseException:
+            await manager.stop()
+            raise
+        self._manager = manager
+        self._runtime = runtime
+
+    async def close(self) -> None:
+        runtime, self._runtime = self._runtime, None
+        manager, self._manager = self._manager, None
+        if runtime is not None:
+            await runtime.close()
+        if manager is not None:
+            await manager.stop()

janus_streaming/viewer.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable, Iterable
+from contextlib import suppress
+from typing import Any
+
+from . import _compat
+from .errors import InvalidViewerState, StreamingProtocolError
+from .models import ConfigureStream, IceCandidate, SessionDescription, ViewerState
+
+HandleFactory = Callable[..., Awaitable[_compat.JanusStreamingHandle]]
+
+
+class StreamingViewer:
+    """One Janus Streaming handle and one browser PeerConnection."""
+
+    def __init__(
+        self,
+        session: Any,
+        *,
+        mountpoint_id: int,
+        request_timeout: float = 10.0,
+        negotiation_timeout: float = 15.0,
+        attach_timeout: float = 5.0,
+        handle_factory: HandleFactory | None = None,
+        on_event: Callable[[Any], Any] | None = None,
+    ) -> None:
+        if mountpoint_id < 0:
+            raise ValueError("mountpoint_id must not be negative")
+        if request_timeout <= 0:
+            raise ValueError("request_timeout must be greater than zero")
+        if negotiation_timeout <= 0:
+            raise ValueError("negotiation_timeout must be greater than zero")
+        if attach_timeout <= 0:
+            raise ValueError("attach_timeout must be greater than zero")
+        self.mountpoint_id = mountpoint_id
+        self.state = ViewerState.NEW
+        self._session = session
+        self._request_timeout = request_timeout
+        self._negotiation_timeout = negotiation_timeout
+        self._attach_timeout = attach_timeout
+        self._handle_factory = handle_factory or _compat.JanusStreamingHandle.attach
+        self._on_event = on_event
+        self._handle: _compat.JanusStreamingHandle | None = None
+        self._state_lock = asyncio.Lock()
+
+    async def prepare(
+        self,
+        *,
+        pin: str | None = None,
+        media: Iterable[str] = (),
+        offer_audio: bool | None = None,
+        offer_video: bool | None = None,
+        offer_data: bool | None = None,
+    ) -> SessionDescription:
+        async with self._state_lock:
+            self._require_state(ViewerState.NEW)
+            selected = list(dict.fromkeys(media))
+            self._handle = await self._handle_factory(
+                self._session,
+                mountpoint_id=self.mountpoint_id,
+                attach_timeout=self._attach_timeout,
+                default_timeout=self._request_timeout,
+                on_event=self._on_event,
+            )
+            try:
+                response = await self._handle.request(
+                    _compat.watch_request(
+                        self.mountpoint_id,
+                        pin=pin,
+                        media=selected,
+                        offer_audio=offer_audio,
+                        offer_video=offer_video,
+                        offer_data=offer_data,
+                    ),
+                    operation="watch",
+                    timeout_seconds=self._negotiation_timeout,
+                )
+                offer = _compat.response_jsep(response)
+                if offer.type != "offer":
+                    raise StreamingProtocolError("watch response JSEP was not an offer")
+                self.state = ViewerState.OFFERED
+                return offer
+            except BaseException:
+                self.state = ViewerState.FAILED
+                if self._handle is not None:
+                    with suppress(Exception):
+                        await asyncio.shield(self._handle.close())
+                self._handle = None
+                raise
+
+    async def accept_answer(self, answer: SessionDescription) -> None:
+        if answer.type != "answer":
+            raise ValueError("expected an SDP answer")
+        async with self._state_lock:
+            self._require_state(ViewerState.OFFERED)
+            await self._require_handle().request(
+                _compat.start_request(),
+                operation="start",
+                jsep=_compat.answer_jsep(answer),
+                timeout_seconds=self._negotiation_timeout,
+            )
+            self.state = ViewerState.ACTIVE
+
+    async def add_ice_candidate(self, candidate: IceCandidate) -> None:
+        self._require_state(ViewerState.OFFERED, ViewerState.ACTIVE, ViewerState.PAUSED)
+        await self._require_handle().trickle([_compat.trickle_candidate(candidate)])
+
+    async def complete_ice(self) -> None:
+        self._require_state(ViewerState.OFFERED, ViewerState.ACTIVE, ViewerState.PAUSED)
+        await self._require_handle().trickle([_compat.trickle_complete()])
+
+    async def pause(self) -> None:
+        async with self._state_lock:
+            self._require_state(ViewerState.ACTIVE)
+            await self._require_handle().request(_compat.pause_request(), operation="pause")
+            self.state = ViewerState.PAUSED
+
+    async def resume(self) -> None:
+        async with self._state_lock:
+            self._require_state(ViewerState.PAUSED)
+            await self._require_handle().request(_compat.start_request(), operation="resume")
+            self.state = ViewerState.ACTIVE
+
+    async def configure(self, streams: list[ConfigureStream]) -> None:
+        self._require_state(ViewerState.ACTIVE, ViewerState.PAUSED)
+        await self._require_handle().request(
+            _compat.configure_request(streams),
+            operation="configure",
+        )
+
+    async def switch(self, mountpoint_id: int) -> None:
+        if mountpoint_id < 0:
+            raise ValueError("mountpoint_id must not be negative")
+        self._require_state(ViewerState.ACTIVE, ViewerState.PAUSED)
+        await self._require_handle().request(
+            _compat.switch_request(mountpoint_id),
+            operation="switch",
+        )
+        self.mountpoint_id = mountpoint_id
+
+    async def close(self) -> None:
+        async with self._state_lock:
+            if self.state is ViewerState.CLOSED:
+                return
+            handle, self._handle = self._handle, None
+            previous = self.state
+            self.state = ViewerState.CLOSED
+        if handle is None:
+            return
+        if previous in {
+            ViewerState.OFFERED,
+            ViewerState.ACTIVE,
+            ViewerState.PAUSED,
+            ViewerState.FAILED,
+        }:
+            with suppress(Exception):
+                await handle.request(_compat.stop_request(), operation="stop", timeout_seconds=3.0)
+        with suppress(Exception):
+            await handle.close()
+
+    def _require_state(self, *states: ViewerState) -> None:
+        if self.state not in states:
+            raise InvalidViewerState(self.state, states)
+
+    def _require_handle(self) -> _compat.JanusStreamingHandle:
+        if self._handle is None:
+            raise StreamingProtocolError("viewer has no attached Janus handle")
+        return self._handle