use std::collections::VecDeque;
use std::sync::Arc;
use tokio::sync::broadcast;
use tokio::sync::broadcast::error::RecvError;
use crate::stats::Counters;
use crate::{Bus, Error, Filter, Message, Position};
const BATCH: i64 = 500;
#[derive(Debug, Clone, PartialEq)]
pub enum Item {
Message(Message),
Gap,
}
pub struct Subscription {
bus: Bus,
filter: Filter,
position: Position,
feed: broadcast::Receiver<Arc<Message>>,
queue: VecDeque<Message>,
catching_up: bool,
gap_checked: bool,
}
impl Subscription {
pub(crate) fn new(bus: Bus, from: Position, filter: Filter) -> Subscription {
let feed = bus.feed();
Subscription {
bus,
filter,
position: from,
feed,
queue: VecDeque::new(),
catching_up: true,
gap_checked: false,
}
}
pub fn position(&self) -> Position {
self.position
}
pub async fn next(&mut self) -> Result<Item, Error> {
if !self.gap_checked {
let in_memory = self
.bus
.recent_after(self.position, &self.filter, 0)
.is_some();
let trimmed = !in_memory && self.bus.trimmed_after(self.position).await?;
self.gap_checked = true;
if trimmed {
return Ok(Item::Gap);
}
}
loop {
if let Some(message) = self.queue.pop_front() {
if message.position <= self.position {
debug_assert!(
false,
"pg-bus: {} delivered after {} ({})",
message.position, self.position, message.channel
);
Counters::add(&self.bus.counters().out_of_order, 1);
tracing::error!(
"pg-bus: skipped {} after {}: out of order",
message.position,
self.position
);
continue;
}
self.position = message.position;
return Ok(Item::Message(message));
}
if self.catching_up {
let batch = match self
.bus
.recent_after(self.position, &self.filter, BATCH as usize)
{
Some(batch) => {
Counters::add(&self.bus.counters().catch_ups_from_memory, 1);
batch
}
None => {
let batch = self.bus.backlog(self.position, &self.filter, BATCH).await?;
Counters::add(&self.bus.counters().catch_ups_from_database, 1);
tracing::debug!(
"pg-bus: caught up {} message(s) from the backlog table after {}",
batch.len(),
self.position
);
batch
}
};
if (batch.len() as i64) < BATCH {
self.catching_up = false;
}
self.queue.extend(batch);
continue;
}
match self.feed.recv().await {
Ok(message) => {
if message.position <= self.position {
continue;
}
if self.filter.matches(&message) {
self.queue.push_back((*message).clone());
} else {
self.position = message.position;
}
}
Err(RecvError::Lagged(n)) => {
Counters::add(&self.bus.counters().lagged, 1);
tracing::debug!("pg-bus: subscriber fell {n} message(s) behind the feed");
self.catching_up = true;
}
Err(RecvError::Closed) => return Err(Error::Closed),
}
}
}
}