Struct EventQueueManager 

pub struct EventQueueManager { /* private fields */ }

Manages event queues for active tasks.

Each task can have at most one active writer. Multiple readers can subscribe to the same writer concurrently (fan-out), enabling SubscribeToTask to work even when another SSE stream is active.

Implementations

impl EventQueueManager

pub fn new() -> EventQueueManager

Creates a new, empty event queue manager with default capacity.

Examples

use a2a_protocol_server::EventQueueManager;

let manager = EventQueueManager::new();

pub fn with_capacity(capacity: usize) -> EventQueueManager

Creates a new event queue manager with the specified channel capacity.

pub const fn with_write_timeout(self, timeout: Duration) -> EventQueueManager

Sets the write timeout for event queue sends.

Retained for API compatibility. Broadcast-based queues do not block on writes, so this value is not actively used for backpressure.

pub const fn with_max_event_size( self, max_event_size: usize, ) -> EventQueueManager

Creates a new event queue manager with the specified maximum event size.

Events exceeding this size (in serialized bytes) will be rejected with an error to prevent OOM conditions.

pub fn with_metrics(self, metrics: Arc<dyn Metrics>) -> EventQueueManager

Sets the metrics hook for reporting queue depth changes.

pub const fn with_max_concurrent_queues(self, max: usize) -> EventQueueManager

Sets the maximum number of concurrent event queues.

When the limit is reached, new queue creation will return an error reader (None) to signal capacity exhaustion.

pub async fn get_or_create( &self, task_id: &TaskId, ) -> (Arc<InMemoryQueueWriter>, Option<InMemoryQueueReader>)

Returns the writer for the given task, creating a new queue if none exists.

If a queue already exists, the returned reader is None (callers should use subscribe() to get additional readers for existing queues). If a new queue is created, both the writer and the first reader are returned.

If max_concurrent_queues is set and the limit is reached, returns the writer with None reader (same as existing queue case).

pub async fn get_or_create_with_persistence( &self, task_id: &TaskId, ) -> (Arc<InMemoryQueueWriter>, Option<InMemoryQueueReader>, Option<Receiver<Result<StreamResponse, A2aError>>>)

Like get_or_create, but also creates a dedicated persistence channel for the background event processor.

Returns (writer, Option<sse_reader>, Option<persistence_rx>). The persistence receiver is only returned when a new queue is created (not for existing queues). The persistence channel is independent of the broadcast channel and is not affected by slow SSE consumers.

pub async fn subscribe(&self, task_id: &TaskId) -> Option<InMemoryQueueReader>

Creates a new reader for an existing task’s event queue.

Returns None if no queue exists for the given task. The returned reader will receive all future events written to the queue.

This enables SubscribeToTask (resubscribe) to work even when another SSE stream is already consuming events from the same queue.

pub async fn destroy(&self, task_id: &TaskId)

Removes and drops the event queue for the given task.

pub async fn active_count(&self) -> usize

Returns the number of active event queues.

pub async fn destroy_all(&self)

Removes all event queues, causing all readers to see EOF.

Trait Implementations

impl Clone for EventQueueManager

fn clone(&self) -> EventQueueManager

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EventQueueManager

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for EventQueueManager

fn default() -> EventQueueManager

Returns the “default value” for a type.