Struct QueueManager 

pub struct QueueManager {
    pub channel: Arc<Channel>,
    pub backend: Option<Arc<dyn MqBackend>>,
    pub compensator: Option<Arc<dyn Compensator>>,
    pub blob_storage: Option<Arc<dyn BlobStorage>>,
    pub batch_concurrency: usize,
    pub compression_threshold: usize,
    pub nack_policy: NackPolicy,
    pub log_topic: String,
}

Fields

channel: Arc<Channel>

backend: Option<Arc<dyn MqBackend>>

compensator: Option<Arc<dyn Compensator>>

blob_storage: Option<Arc<dyn BlobStorage>>

batch_concurrency: usize

compression_threshold: usize

nack_policy: NackPolicy

log_topic: String

Implementations

impl QueueManager

pub fn new(backend: Option<Arc<dyn MqBackend>>, capacity: usize) -> Self

pub fn from_config(cfg: &Config) -> Arc<Self>

pub fn from_config_with_log_topic( cfg: &Config, log_topic: Option<&str>, ) -> Arc<Self>

pub fn with_backend(&mut self, backend: Arc<dyn MqBackend>)

pub fn with_compensator(&mut self, compensator: Arc<dyn Compensator>)

pub fn with_blob_storage(&mut self, storage: Arc<dyn BlobStorage>)

pub fn with_concurrency(&mut self, concurrency: usize)

pub fn with_compression_threshold(&mut self, threshold: usize)

pub fn with_log_topic(&mut self, topic: impl Into<String>)

pub fn subscribe(&self)

pub fn get_task_push_channel(&self) -> Sender<QueuedItem<TaskEvent>>

pub fn get_task_pop_channel( &self, ) -> Arc<Mutex<Receiver<QueuedItem<TaskEvent>>>>

pub fn get_request_pop_channel( &self, ) -> Arc<Mutex<Receiver<QueuedItem<Request>>>>

pub fn get_request_push_channel(&self) -> Sender<QueuedItem<Request>>

pub fn get_response_push_channel(&self) -> Sender<QueuedItem<Response>>

pub fn try_send_local_response( &self, item: QueuedItem<Response>, ) -> Result<(), TrySendError<QueuedItem<Response>>>

Attempts to send directly to local consumers (bypassing the MQ backend). Optimization: if local consumers exist and the channel is not full, send directly to avoid serialization and network overhead.

pub fn get_response_pop_channel( &self, ) -> Arc<Mutex<Receiver<QueuedItem<Response>>>>

pub fn get_parser_task_pop_channel( &self, ) -> Arc<Mutex<Receiver<QueuedItem<TaskParserEvent>>>>

pub fn get_parser_task_push_channel( &self, ) -> Sender<QueuedItem<TaskParserEvent>>

pub fn get_error_pop_channel( &self, ) -> Arc<Mutex<Receiver<QueuedItem<TaskErrorEvent>>>>

pub fn get_error_push_channel(&self) -> Sender<QueuedItem<TaskErrorEvent>>

pub fn get_log_push_channel(&self) -> Sender<QueuedItem<LogModel>>

pub async fn local_pending_count(&self) -> usize

Local pending message count across processor queues

pub async fn local_pending_breakdown( &self, ) -> (usize, usize, usize, usize, usize, usize)

pub async fn clean_storage(&self) -> Result<()>

pub async fn send_to_dlq<T>( &self, topic: &str, item: &T, reason: &str, ) -> Result<()>

where T: Serialize + Identifiable + Send + Sync,

Send a message to the Dead Letter Queue (DLQ) manually.

This is useful when the application logic decides a message cannot be processed even if the message delivery itself was successful (e.g., max logic retries exceeded).

pub async fn read_dlq( &self, topic: &str, count: usize, ) -> Result<Vec<(String, Vec<u8>, String, String)>>