Skip to content

Self-improving AI Employees for everyone

chore(events): retire event_waiter Redis-Streams branch (Wave 15.3, D2b)

trohitg76576b17b039
diff --git a/server/core/cache.py b/server/core/cache.py
index 6142c261..f7649ed5 100644
--- a/server/core/cache.py
+++ b/server/core/cache.py
@@ -331,109 +331,12 @@ class CacheService:
logger.error(f"Stream read failed: {streams.keys()}", error=str(e))
return None
- async def stream_create_group(self, stream: str, group: str, start_id: str = "$") -> bool:
- """Create consumer group for stream.
-
- Args:
- stream: Stream name
- group: Consumer group name
- start_id: Start reading from ('$' = new only, '0' = all)
-
- Returns:
- True if created or already exists
- """
- try:
- if self.use_redis and self.redis and self._streams_available:
- try:
- await self.redis.xgroup_create(stream, group, start_id, mkstream=True)
- logger.info(f"Created consumer group: {group} on {stream}")
- return True
- except Exception as e:
- if "BUSYGROUP" in str(e):
- # Group already exists - this is fine
- return True
- raise
- return False
- except Exception as e:
- logger.error(f"Stream create group failed: {stream}/{group}", error=str(e))
- return False
-
- async def stream_read_group(
- self, group: str, consumer: str, streams: Dict[str, str], count: int = 1, block: Optional[int] = None
- ) -> Optional[List[Any]]:
- """Read from streams using consumer group.
-
- Args:
- group: Consumer group name
- consumer: Consumer name (unique per worker)
- streams: Dict of stream_name -> last_id (use '>' for new pending messages)
- count: Maximum messages to read
- block: Milliseconds to block
-
- Returns:
- List of messages or None
- """
- try:
- if self.use_redis and self.redis and self._streams_available:
- result = await self.redis.xreadgroup(group, consumer, streams, count=count, block=block)
- return result
- return None
- except Exception as e:
- error_str = str(e).lower()
- # Timeout errors are expected during blocking reads - log at debug level
- if "timeout" in error_str or "timed out" in error_str:
- logger.debug(f"Stream read group timeout: {group}/{consumer}", error=str(e))
- else:
- logger.error(f"Stream read group failed: {group}/{consumer}", error=str(e))
- return None
-
- async def stream_ack(self, stream: str, group: str, *msg_ids: str) -> int:
- """Acknowledge messages in consumer group.
-
- Args:
- stream: Stream name
- group: Consumer group name
- msg_ids: Message IDs to acknowledge
-
- Returns:
- Number of messages acknowledged
- """
- try:
- if self.use_redis and self.redis:
- count = await self.redis.xack(stream, group, *msg_ids)
- return count
- return 0
- except Exception as e:
- logger.error(f"Stream ack failed: {stream}/{group}", error=str(e))
- return 0
-
- async def stream_delete(self, stream: str, *msg_ids: str) -> int:
- """Delete messages from stream.
-
- Args:
- stream: Stream name
- msg_ids: Message IDs to delete
-
- Returns:
- Number of messages deleted
- """
- try:
- if self.use_redis and self.redis:
- count = await self.redis.xdel(stream, *msg_ids)
- return count
- return 0
- except Exception as e:
- logger.error(f"Stream delete failed: {stream}", error=str(e))
- return 0
+ # Consumer-group methods (stream_create_group / stream_read_group /
+ # stream_ack / stream_delete) and the public is_streams_available()
+ # were retired in Wave 15.3 with the event_waiter Redis branch.
+ # stream_add/stream_read stay for ExecutionCache.add_event/get_events;
+ # the _streams_available flag stays because stream_add guards on it.
def is_redis_available(self) -> bool:
"""Check if Redis is available and connected."""
return self.use_redis and self.redis is not None
-
- def is_streams_available(self) -> bool:
- """Check if Redis Streams are available (for trigger nodes).
-
- Returns True only if Redis is connected AND supports Streams commands.
- This is checked once during startup to avoid runtime failures.
- """
- return self.use_redis and self.redis is not None and self._streams_available
diff --git a/server/main.py b/server/main.py
index bdc4158c..b4cc51b7 100644
--- a/server/main.py
+++ b/server/main.py
@@ -176,7 +176,7 @@ async def lifespan(app: FastAPI):
# Initialize event waiter with cache service for Redis Streams support
from services import event_waiter
- event_waiter.set_cache_service(container.cache())
+ event_waiter.capture_main_loop()
# Initialize execution engine recovery sweeper
from services.execution import (
diff --git a/server/services/event_waiter.py b/server/services/event_waiter.py
index ba4018aa..931050d2 100644
--- a/server/services/event_waiter.py
+++ b/server/services/event_waiter.py
@@ -1,64 +1,43 @@
"""Event Waiter Service - Generic event waiting for trigger nodes.
-Supports any trigger type (WhatsApp, Email, Webhook, MQTT, etc.)
-Uses Redis Streams when available for persistence, falls back to asyncio.Future.
-
-Architecture:
-- Redis mode: Events stored in Redis Streams, waiters poll streams with blocking XREAD
-- Memory mode: Events dispatched to in-memory asyncio.Future waiters
+Supports any trigger type (WhatsApp, Email, Webhook, MQTT, etc.).
+Events are dispatched to in-memory asyncio.Future waiters. This backs
+the canvas-Run path (``TriggerNode.execute()``); deployed triggers use
+the Temporal-durable canary path (``services/events/dispatch.py``).
+The Redis-Streams branch that previously offered cross-restart waiter
+persistence was retired in Wave 15.3 — Temporal owns durability now.
"""
import asyncio
-import json
import uuid
import time
from dataclasses import dataclass, field
-from typing import Dict, Any, Optional, Callable, List, TYPE_CHECKING
+from typing import Dict, Any, Optional, Callable, List
from core.logging import get_logger
-if TYPE_CHECKING:
- from core.cache import CacheService
-
logger = get_logger(__name__)
# =============================================================================
-# CACHE SERVICE REFERENCE
+# MAIN LOOP REFERENCE (thread-safe dispatch)
# =============================================================================
-_cache_service: Optional["CacheService"] = None
_main_loop: Optional[asyncio.AbstractEventLoop] = None
-def set_cache_service(cache: "CacheService") -> None:
- """Set the cache service for Redis Streams support.
+def capture_main_loop() -> None:
+ """Capture the running event loop for thread-safe dispatch.
- Called during application startup from main.py.
+ Called during application startup from main.py. ``dispatch`` uses
+ the stored loop when invoked from a non-async thread context.
"""
- global _cache_service, _main_loop
- _cache_service = cache
- # Store reference to the main event loop for thread-safe dispatch
+ global _main_loop
try:
_main_loop = asyncio.get_running_loop()
except RuntimeError:
_main_loop = None
- mode = "Redis Streams" if cache and cache.is_redis_available() else "asyncio.Future"
- logger.info(f"[EventWaiter] Initialized with {mode} backend")
-
-
-def get_cache_service() -> Optional["CacheService"]:
- """Get the cache service if available."""
- return _cache_service
-
-
-def is_redis_mode() -> bool:
- """Check if Redis Streams mode is active.
-
- Returns True only if Redis is connected AND supports Streams commands.
- This prevents runtime failures when Redis doesn't support XREADGROUP/XADD.
- """
- return _cache_service is not None and _cache_service.is_streams_available()
+ logger.info("[EventWaiter] Initialized with asyncio.Future backend")
# =============================================================================
@@ -401,22 +380,9 @@ class Waiter:
created_at: float = field(default_factory=time.time)
-# Module-level waiter storage (used in both modes for tracking)
+# Module-level waiter storage
_waiters: Dict[str, Waiter] = {}
-# Redis stream names
-EVENTS_STREAM_PREFIX = "events:"
-WAITERS_KEY_PREFIX = "waiters:"
-# NOTE: Each waiter uses its own consumer group to ensure ALL waiters receive ALL messages.
-# Redis consumer groups deliver each message to only ONE consumer in the group.
-# For trigger nodes, we want broadcast semantics where every waiter evaluates every event.
-CONSUMER_GROUP_PREFIX = "waiter_group_" # Each waiter gets: waiter_group_{waiter_id}
-
-
-def _get_stream_name(event_type: str) -> str:
- """Get Redis stream name for event type."""
- return f"{EVENTS_STREAM_PREFIX}{event_type}"
-
# =============================================================================
# WAITER REGISTRATION
@@ -447,41 +413,14 @@ async def register(node_type: str, node_id: str, params: Dict) -> Waiter:
filter_fn=build_filter(node_type, params),
)
- if is_redis_mode():
- # Redis mode: store waiter metadata in Redis
- cache = get_cache_service()
- waiter_key = f"{WAITERS_KEY_PREFIX}{waiter.id}"
-
- # Each waiter gets its own consumer group for broadcast semantics
- # This ensures ALL waiters receive ALL messages (not load-balanced)
- consumer_group = f"{CONSUMER_GROUP_PREFIX}{waiter.id}"
-
- waiter_data = {
- "id": waiter.id,
- "node_id": node_id,
- "node_type": node_type,
- "event_type": config.event_type,
- "params": json.dumps(params),
- "created_at": waiter.created_at,
- "consumer_group": consumer_group, # Store for cleanup
- }
- await cache.set(waiter_key, waiter_data, ttl=86400) # 24 hour TTL
-
- # Create unique consumer group for this waiter
- # start_id='$' means only new messages from this point forward
- stream_name = _get_stream_name(config.event_type)
- await cache.stream_create_group(stream_name, consumer_group, start_id="$")
-
- logger.debug(f"[EventWaiter] Registered {node_type} waiter {waiter.id} (Redis)")
- else:
- # Memory mode: create asyncio.Future
- try:
- loop = asyncio.get_running_loop()
- waiter.future = loop.create_future()
- except RuntimeError:
- waiter.future = asyncio.get_event_loop().create_future()
+ # Create asyncio.Future the dispatcher resolves on a matching event
+ try:
+ loop = asyncio.get_running_loop()
+ waiter.future = loop.create_future()
+ except RuntimeError:
+ waiter.future = asyncio.get_event_loop().create_future()
- logger.debug(f"[EventWaiter] Registered {node_type} waiter {waiter.id}")
+ logger.debug(f"[EventWaiter] Registered {node_type} waiter {waiter.id}")
_waiters[waiter.id] = waiter
return waiter
@@ -501,16 +440,8 @@ async def wait_for_event(waiter: Waiter, timeout: Optional[float] = None) -> Dic
asyncio.CancelledError: If waiter was cancelled
asyncio.TimeoutError: If timeout exceeded
"""
- if is_redis_mode():
- return await _wait_redis(waiter, timeout)
- else:
- return await _wait_memory(waiter, timeout)
-
-
-async def _wait_memory(waiter: Waiter, timeout: Optional[float]) -> Dict:
- """Wait using asyncio.Future (memory mode)."""
if waiter.future is None:
- raise RuntimeError("Waiter has no Future (memory mode not initialized)")
+ raise RuntimeError("Waiter has no Future (not registered?)")
try:
if timeout:
@@ -522,85 +453,10 @@ async def _wait_memory(waiter: Waiter, timeout: Optional[float]) -> Dict:
raise
-async def _wait_redis(waiter: Waiter, timeout: Optional[float]) -> Dict:
- """Wait using Redis Streams polling.
-
- Polls the event stream with blocking XREAD, checking each message against the filter.
- Each waiter has its own consumer group for broadcast semantics.
- """
- cache = get_cache_service()
- stream_name = _get_stream_name(waiter.event_type)
-
- # Use waiter-specific consumer group for broadcast (all waiters see all messages)
- consumer_group = f"{CONSUMER_GROUP_PREFIX}{waiter.id}"
- consumer_name = f"consumer_{waiter.id}"
-
- # Start reading from now (new messages only)
- block_ms = 5000 # 5 second blocks to allow cancellation checks
-
- start_time = time.time()
-
- while not waiter.cancelled:
- # Check timeout
- if timeout and (time.time() - start_time) > timeout:
- raise asyncio.TimeoutError(f"Waiter {waiter.id} timed out after {timeout}s")
-
- # Read from stream with blocking using waiter's own consumer group
- try:
- result = await cache.stream_read_group(
- consumer_group, # Each waiter has its own group
- consumer_name,
- {stream_name: ">"}, # '>' = new messages for this consumer
- count=10,
- block=block_ms,
- )
-
- if not result:
- # No messages, continue polling
- continue
-
- # Process messages
- for stream_data in result:
- stream, messages = stream_data
- for msg_id, fields in messages:
- # Deserialize event data
- event_data = {}
- for k, v in fields.items():
- try:
- event_data[k] = json.loads(v)
- except (json.JSONDecodeError, TypeError):
- event_data[k] = v
-
- # Check filter
- if waiter.filter_fn(event_data):
- # Match found - acknowledge and return
- await cache.stream_ack(stream_name, consumer_group, msg_id)
- _cleanup_waiter(waiter.id)
- logger.info(f"[EventWaiter] Waiter {waiter.id} matched event {msg_id}")
- return event_data
- else:
- # No match - acknowledge but continue waiting
- await cache.stream_ack(stream_name, consumer_group, msg_id)
-
- except asyncio.CancelledError:
- _cleanup_waiter(waiter.id)
- raise
-
- # Waiter was cancelled via cancel() flag
- _cleanup_waiter(waiter.id)
- raise asyncio.CancelledError(f"Waiter {waiter.id} cancelled")
-
-
def _cleanup_waiter(waiter_id: str) -> None:
"""Remove waiter from storage."""
_waiters.pop(waiter_id, None)
- # Also remove from Redis if in Redis mode
- if is_redis_mode():
- cache = get_cache_service()
- waiter_key = f"{WAITERS_KEY_PREFIX}{waiter_id}"
- asyncio.create_task(cache.delete(waiter_key))
-
# =============================================================================
# EVENT DISPATCH
@@ -614,9 +470,9 @@ def _unpack_event(
"""Normalise either ``(WorkflowEvent,)`` or ``(event_type, data)`` to
the underlying ``(event_type, data)`` pair the dispatcher uses.
- Wave 11.I, milestone Q: ``dispatch`` and ``dispatch_async`` accept a
- ``WorkflowEvent`` directly so the ``WorkflowEvent(**event)`` rewrap
- in ``events/triggers.py`` becomes a no-op. The legacy
+ Wave 11.I, milestone Q: ``dispatch`` accepts a ``WorkflowEvent``
+ directly so the ``WorkflowEvent(**event)`` rewrap in
+ ``events/triggers.py`` becomes a no-op. The legacy
``(event_type, data)`` shape stays supported via
:meth:`WorkflowEvent.from_legacy` upstream of the dispatcher (the
public API just forwards either form).
@@ -632,44 +488,17 @@ def _unpack_event(
raise TypeError(f"dispatch expects a WorkflowEvent or (event_type: str, data: Dict); " f"got {type(event).__name__}")
-async def dispatch_async(
- event: "Any",
- data: Optional[Dict] = None,
-) -> int:
- """Dispatch event asynchronously (for Redis mode).
-
- Args:
- event: Either a :class:`WorkflowEvent` (preferred, Wave 11.I) or
- an event-type string. The legacy ``(event_type, data)`` form
- stays supported.
- data: Event payload (when ``event`` is a string).
-
- Returns:
- 1 if event was added to stream, 0 otherwise
- """
- event_type, payload = _unpack_event(event, data)
- logger.debug(f"[EventWaiter] dispatch_async: event_type='{event_type}'")
-
- if is_redis_mode():
- cache = get_cache_service()
- stream_name = _get_stream_name(event_type)
- msg_id = await cache.stream_add(stream_name, payload)
- if msg_id:
- logger.debug(f"[EventWaiter] Added event to stream {stream_name}: {msg_id}")
- return 1
- return 0
- else:
- # Fall back to sync dispatch for memory mode
- return dispatch(event_type, payload)
-
-
def dispatch(
event: "Any",
data: Optional[Dict] = None,
) -> int:
- """Dispatch event to matching waiters (synchronous, memory mode).
+ """Dispatch event to matching waiters.
- Thread-safe: Can be called from APScheduler threads or async context.
+ Thread-safe for resolution purposes: the asyncio.Future writes
+ happen on whichever thread calls this, which is safe because every
+ production caller runs on the main event loop. ``_main_loop``
+ (captured at startup) remains available for future thread-context
+ callers via ``asyncio.run_coroutine_threadsafe``.
Args:
event: Either a :class:`WorkflowEvent` (preferred, Wave 11.I) or
@@ -681,22 +510,6 @@ def dispatch(
Number of waiters resolved
"""
event_type, data = _unpack_event(event, data)
- if is_redis_mode():
- # In Redis mode, use async dispatch
- # Handle both async context and thread context (e.g., APScheduler callbacks)
- try:
- # Try to get the current running loop
- asyncio.get_running_loop()
- # We're in an async context - schedule task normally
- asyncio.create_task(dispatch_async(event_type, data))
- except RuntimeError:
- # No running loop - we're in a thread (e.g., APScheduler callback)
- # Use the stored main loop with thread-safe dispatch
- if _main_loop is not None and _main_loop.is_running():
- asyncio.run_coroutine_threadsafe(dispatch_async(event_type, data), _main_loop)
- else:
- logger.warning(f"[EventWaiter] No event loop available for dispatch of {event_type}")
- return 0 # Actual resolution happens in _wait_redis
resolved = 0
to_remove = []
@@ -744,12 +557,6 @@ def cancel(waiter_id: str) -> bool:
if w.future and not w.future.done():
w.future.cancel()
- # Also remove from Redis if in Redis mode
- if is_redis_mode():
- cache = get_cache_service()
- waiter_key = f"{WAITERS_KEY_PREFIX}{waiter_id}"
- asyncio.create_task(cache.delete(waiter_key))
-
logger.debug(f"[EventWaiter] Cancelled waiter {waiter_id}")
return True
@@ -780,7 +587,7 @@ def get_active_waiters() -> List[Dict[str, Any]]:
"done": w.future.done() if w.future else False,
"cancelled": w.cancelled,
"age_seconds": time.time() - w.created_at,
- "mode": "redis" if is_redis_mode() else "memory",
+ "mode": "memory",
}
for w in _waiters.values()
]
@@ -794,15 +601,9 @@ def clear_all() -> int:
if w.future and not w.future.done():
w.future.cancel()
_waiters.clear()
-
- # Clear Redis waiter keys if in Redis mode
- if is_redis_mode():
- cache = get_cache_service()
- asyncio.create_task(cache.clear_pattern(f"{WAITERS_KEY_PREFIX}*"))
-
return count
def get_backend_mode() -> str:
"""Get current backend mode for debugging."""
- return "redis" if is_redis_mode() else "memory"
+ return "memory"
diff --git a/server/services/status_broadcaster.py b/server/services/status_broadcaster.py
index 8a50dc06..7446ab5e 100644
--- a/server/services/status_broadcaster.py
+++ b/server/services/status_broadcaster.py
@@ -1066,20 +1066,19 @@ class StatusBroadcaster:
async def send_custom_event(self, event_type: str, data: Any):
"""Send a custom event to all connected clients AND dispatch to event waiters.
- Uses dispatch_async() directly since we're in an async context.
- The sync dispatch() is for thread contexts like APScheduler callbacks.
- See DESIGN.md section "Cross-Thread Event Dispatch" for pattern details.
+ ``event_waiter.dispatch`` resolves in-memory asyncio.Future
+ waiters synchronously (the Redis-Streams async path was retired
+ in Wave 15.3).
"""
# Broadcast to all WebSocket clients
await self.broadcast({"type": event_type, "data": data})
# Dispatch to event waiters (for trigger nodes)
- # Use dispatch_async directly - we're in async context
try:
from services import event_waiter
event_data = data if isinstance(data, dict) else {"data": data}
- resolved_count = await event_waiter.dispatch_async(event_type, event_data)
+ resolved_count = event_waiter.dispatch(event_type, event_data)
if resolved_count > 0:
logger.info(f"[StatusBroadcaster] Event {event_type} resolved {resolved_count} waiters")
except Exception as e:
diff --git a/server/tests/test_status_broadcasts.py b/server/tests/test_status_broadcasts.py
index e53f1bdf..1d839859 100644
--- a/server/tests/test_status_broadcasts.py
+++ b/server/tests/test_status_broadcasts.py
@@ -189,10 +189,12 @@ class TestCredentialBroadcastUsesWorkflowEvent:
class TestEventWaiterDispatchAcceptsEnvelope:
- """Wave 11.I, milestone Q. ``dispatch`` and ``dispatch_async``
- accept either a ``WorkflowEvent`` or a ``(str, dict)`` pair via
- ``_unpack_event`` -- the (str, dict) shape stays supported via
+ """Wave 11.I, milestone Q. ``dispatch`` accepts either a
+ ``WorkflowEvent`` or a ``(str, dict)`` pair via ``_unpack_event``
+ -- the (str, dict) shape stays supported via
``WorkflowEvent.from_legacy`` upstream of the dispatcher.
+ (``dispatch_async`` was the Redis-Streams sibling; retired in
+ Wave 15.3 along with the whole Redis branch.)
Locks the contract so future refactors don't drop the envelope
path silently.
@@ -215,9 +217,14 @@ class TestEventWaiterDispatchAcceptsEnvelope:
"dispatch() must route through _unpack_event() so a " "WorkflowEvent argument is normalised before the dispatch loop."
)
- def test_dispatch_async_calls_unpack_event(self, event_waiter_module):
- src = inspect.getsource(event_waiter_module.dispatch_async)
- assert "_unpack_event" in src, "dispatch_async() must route through _unpack_event() for the " "same reason as dispatch()."
+ def test_dispatch_async_retired(self, event_waiter_module):
+ """Wave 15.3: the Redis-Streams dispatch path is gone; a
+ reappearing ``dispatch_async`` means someone resurrected it."""
+ assert not hasattr(event_waiter_module, "dispatch_async"), (
+ "event_waiter.dispatch_async was retired in Wave 15.3 "
+ "(Redis-Streams branch). Memory-mode dispatch() is the only "
+ "path; Temporal owns durable event delivery."
+ )
def test_unpack_event_handles_workflow_event(self, event_waiter_module):
"""Functional check: a WorkflowEvent input round-trips to