Struct NotificationService 

pub struct NotificationService {
    db: Arc<dyn NotificationWriter>,
    redis_client: Option<Client>,
    redis_conn: Arc<Mutex<Option<ConnectionManager>>>,
    redis_last_failure_ms: Arc<AtomicU64>,
    publish_tx: Sender<PublishJob>,
}

Fields

db: Arc<dyn NotificationWriter>

redis_client: Option<Client>

Lazily-established Redis connection. None when the service was constructed without a Redis client – cache ops become no-ops.

redis_conn: Arc<Mutex<Option<ConnectionManager>>>

redis_last_failure_ms: Arc<AtomicU64>

ms timestamp of the last Redis connect failure; 0 means “no recent failure, try again”. Atomic so every path can read without taking the Mutex.

publish_tx: Sender<PublishJob>

Implementations

impl NotificationService

pub fn new( db: Arc<dyn NotificationWriter>, redis_client: Option<Client>, shutdown_rx: Receiver<()>, ) -> Arc<Self>

fn in_redis_backoff(&self) -> bool

Are we inside the “recently failed” backoff window?

fn mark_redis_failure(&self)

fn clear_redis_failure(&self)

async fn conn(&self) -> Option<ConnectionManager>

async fn set_has_unread(&self, wallet_lower: &str)

async fn clear_has_unread(&self, wallet_lower: &str)

async fn reconcile_has_unread_after_clear(&self, wallet_lower: &str)

After a mark-read batch clears the Redis bit, a concurrent publish may have landed between our pg count_unread and our Redis DEL. Re-check pg; if pg now has unread, re-SET so we don’t leave the bell stuck at cleared while rows are actually unread.

pub fn enqueue_publish( &self, wallet: &str, notification_type: &str, payload_msgpack: Vec<u8>, ) -> Result<(), ()>

Fire-and-forget publish: enqueue onto the bounded channel. Returns Err only if the channel is full (drainer can’t keep up). The caller is expected to warn + drop rather than block the trading event pipeline.

pub async fn publish( &self, wallet: &str, notification_type: &str, payload_msgpack: Vec<u8>, ) -> Result<NotificationRecord>

Synchronous publish – insert a notification and update the Redis bit. Prefer [enqueue_publish] on the fill hot path; this method is mainly for tests and paths where the caller genuinely wants to wait on the insert.

pub async fn list( &self, wallet: &str, before_id: Option<i64>, limit: Option<i64>, ) -> Result<Vec<NotificationRecord>>

pub async fn count_unread(&self, wallet: &str) -> Result<i64>

pub async fn mark_read(&self, wallet: &str, ids: &[i64]) -> Result<usize>

pub async fn mark_all_read(&self, wallet: &str) -> Result<usize>