dheraingoud's picture
sync: upstream 9194f15 + custom addons (KeyRotator, RotatingChatTransport, sol/terra/luna, ScannerTrap, health, Py3.12 compat)
e99df76
Raw History Blame Contribute Delete
4.14 kB
from __future__ import annotations
"""Bounded in-process fan-out for observable session state changes."""
import asyncio
from collections.abc import AsyncIterator
from dataclasses import dataclass
from free_claude_code.core.json_types import JsonObject
@dataclass(frozen=True, slots=True)
class PublishedEvent:
event: str
id: int
data: JsonObject
class EventOverflowError(Exception):
"""One slow observer must reconnect from an authoritative snapshot."""
def __init__(self, cursor: int) -> None:
super().__init__("Session event subscription overflowed.")
self.cursor = cursor
_DEFAULT_QUEUE_SIZE = 128
class _Closed:
pass
_CLOSED = _Closed()
class _Overflow:
def __init__(self, cursor: int) -> None:
self.cursor = cursor
type _QueueItem = PublishedEvent | _Overflow | _Closed
class EventSubscription:
"""One observer's independent view of the process-local session feed."""
def __init__(
self,
publisher: EventPublisher,
*,
cursor: int,
queue_size: int,
) -> None:
self._publisher = publisher
self._queue: asyncio.Queue[_QueueItem] = asyncio.Queue(maxsize=queue_size)
self.cursor = cursor
self._closed = False
def __aiter__(self) -> AsyncIterator[PublishedEvent]:
return self._events()
async def _events(self) -> AsyncIterator[PublishedEvent]:
while True:
item = await self._queue.get()
if item is _CLOSED:
return
if isinstance(item, _Overflow):
raise EventOverflowError(item.cursor)
if isinstance(item, PublishedEvent):
yield item
async def aclose(self) -> None:
if self._closed:
return
self._closed = True
self._publisher.unsubscribe(self)
self.signal(_CLOSED)
def signal(self, item: _QueueItem) -> None:
while True:
try:
self._queue.get_nowait()
except asyncio.QueueEmpty:
break
self._queue.put_nowait(item)
class EventPublisher:
"""Publish without allowing one observer to backpressure session work."""
def __init__(self, *, queue_size: int = _DEFAULT_QUEUE_SIZE) -> None:
if queue_size <= 0:
raise ValueError("session event queue size must be positive.")
self._queue_size = queue_size
self._sequence = 0
self._subscriptions: set[EventSubscription] = set()
self._closed = False
@property
def cursor(self) -> int:
return self._sequence
def subscribe(self) -> EventSubscription:
if self._closed:
raise RuntimeError("session event publisher is closed.")
subscription = EventSubscription(
self,
cursor=self._sequence,
queue_size=self._queue_size,
)
self._subscriptions.add(subscription)
return subscription
def publish(self, event: str, data: JsonObject) -> PublishedEvent:
if self._closed:
raise RuntimeError("session event publisher is closed.")
self._sequence += 1
published = PublishedEvent(event=event, id=self._sequence, data={**data})
for subscription in tuple(self._subscriptions):
try:
subscription._queue.put_nowait(published)
except asyncio.QueueFull:
self._subscriptions.discard(subscription)
subscription.signal(_Overflow(self._sequence))
return published
def unsubscribe(self, subscription: EventSubscription) -> None:
self._subscriptions.discard(subscription)
def close(self) -> None:
if self._closed:
return
self._closed = True
self.disconnect_subscribers()
def disconnect_subscribers(self) -> None:
"""Finish observer feeds while allowing owned work to settle and publish."""
subscriptions = tuple(self._subscriptions)
self._subscriptions.clear()
for subscription in subscriptions:
subscription.signal(_CLOSED)