use std::time::Duration;
use sqlx::PgPool;
use crate::{Config, Error, Position};
#[derive(Debug, Clone, PartialEq)]
pub struct Trim {
pub every: Duration,
pub max_age: Duration,
pub keep_per_channel: i64,
}
impl Default for Trim {
fn default() -> Self {
Trim {
every: Duration::from_secs(60),
max_age: Duration::from_secs(7 * 24 * 3600),
keep_per_channel: 1000,
}
}
}
pub(crate) async fn trim_on(
pool: &PgPool,
schema: &str,
grace: Duration,
max_age: Duration,
keep_per_channel: i64,
wait: bool,
) -> Result<Option<u64>, Error> {
let mut tx = pool.begin().await?;
let key = format!("pg-bus trim:{schema}");
if wait {
sqlx::query("SELECT pg_advisory_xact_lock(hashtext($1))")
.bind(&key)
.execute(&mut *tx)
.await?;
} else {
let locked: bool = sqlx::query_scalar("SELECT pg_try_advisory_xact_lock(hashtext($1))")
.bind(&key)
.fetch_one(&mut *tx)
.await?;
if !locked {
return Ok(None);
}
}
let (count, xid, id): (i64, Option<String>, Option<i64>) = sqlx::query_as(&format!(
"WITH RECURSIVE channels(channel) AS ( \
(SELECT channel FROM {schema}.messages ORDER BY channel LIMIT 1) \
UNION ALL \
SELECT (SELECT m.channel FROM {schema}.messages m \
WHERE m.channel > c.channel ORDER BY m.channel LIMIT 1) \
FROM channels c WHERE c.channel IS NOT NULL), \
cutoffs AS ( \
SELECT c.channel, cut.xid, cut.id FROM channels c, \
LATERAL (SELECT m.xid, m.id FROM {schema}.messages m WHERE m.channel = c.channel \
ORDER BY m.xid DESC, m.id DESC OFFSET $2 LIMIT 1) cut \
WHERE c.channel IS NOT NULL), \
doomed AS ( \
SELECT m.id FROM {schema}.messages m JOIN cutoffs k ON m.channel = k.channel \
WHERE (m.xid, m.id) <= (k.xid, k.id) \
UNION \
SELECT m.id FROM {schema}.messages m \
WHERE m.created_at < now() - make_interval(secs => $1)), \
deleted AS ( \
DELETE FROM {schema}.messages m USING doomed d \
WHERE m.id = d.id AND m.xid < pg_snapshot_xmin(pg_current_snapshot()) \
AND m.created_at < now() - make_interval(secs => $3) \
RETURNING m.xid, m.id) \
SELECT (SELECT count(*) FROM deleted), \
(SELECT deleted.xid::text FROM deleted \
ORDER BY deleted.xid DESC, deleted.id DESC LIMIT 1), \
(SELECT deleted.id FROM deleted \
ORDER BY deleted.xid DESC, deleted.id DESC LIMIT 1)"
))
.bind(max_age.as_secs_f64())
.bind(keep_per_channel.max(0))
.bind(grace.as_secs_f64())
.fetch_one(&mut *tx)
.await?;
if let (Some(xid), Some(id)) = (xid, id) {
let xid: u64 = xid.parse().map_err(|_| Error::InvalidPosition(xid))?;
let p = Position { xid, id };
sqlx::query(&format!(
"UPDATE {schema}.state SET trimmed_xid = $1::text::xid8, trimmed_id = $2 \
WHERE ($1::text::xid8, $2) > (trimmed_xid, trimmed_id)"
))
.bind(p.xid.to_string())
.bind(p.id)
.execute(&mut *tx)
.await?;
}
tx.commit().await?;
Ok(Some(count as u64))
}
pub(crate) async fn run(pool: PgPool, config: Config) {
let Some(policy) = config.trim.clone() else {
return;
};
loop {
tokio::time::sleep(policy.every).await;
let trimmed = trim_on(
&pool,
&config.schema,
config.trim_grace,
policy.max_age,
policy.keep_per_channel,
false,
)
.await;
if let Err(e) = trimmed {
tracing::warn!("pg-bus: trim failed: {e}");
}
}
}