use std::{
fmt,
future::Future,
sync::Arc,
time::{Duration, Instant as WallClockInstant},
};
use runlimit_core::{
AdmissionObservation, BatchDecision, Check, CleanupObservation, Decision, FixedWindowPolicy,
Limiter, Observation, Observer, observe_safely, validate_batch,
};
use sqlx::{
PgPool, Postgres,
migrate::{MigrateError, Migrator},
pool::PoolConnection,
};
use tokio::time::Instant;
#[derive(Debug)]
pub(crate) enum ConnectionOutcome<T> {
Reusable(T),
MustClose(T),
}
impl<T> ConnectionOutcome<T> {
fn map<U>(self, map: impl FnOnce(T) -> U) -> ConnectionOutcome<U> {
match self {
Self::Reusable(value) => ConnectionOutcome::Reusable(map(value)),
Self::MustClose(value) => ConnectionOutcome::MustClose(map(value)),
}
}
}
mod admission;
mod config;
mod errors;
mod maintenance;
mod protocol;
pub use config::{PostgresConfig, PostgresConfigError};
pub use errors::{CheckError, MaintenanceError};
pub use protocol::{CAPACITY_SHARD_COUNT, HARD_MAX_ROWS_PER_SHARD};
use admission::{
BatchSqlInput, acquire_check_connection, run_check_transaction, single_decision_from_batch,
};
use errors::check_error_consumption;
use maintenance::{acquire_maintenance_connection, run_cleanup_transaction};
#[cfg(test)]
use admission::{
PendingAllowance, PendingBatchDenial, PendingDenial, PendingQuotaDenial, database_integer,
finish_denied_transaction,
};
#[cfg(test)]
use protocol::{
BATCH_PREFLIGHT_SQL, BATCH_UPSERT_SQL, CLEANUP_SQL, advisory_lock_id, capacity_shard,
};
#[cfg(test)]
use runlimit_core::BatchError;
#[cfg(test)]
use sqlx::postgres::types::PgInterval;
pub const CREATE_RUNLIMIT_FIXED_WINDOWS_SQL: &str =
include_str!("../migrations/20260723000000_create_runlimit_fixed_windows.sql");
pub const SET_RUNLIMIT_FIXED_WINDOWS_FILLFACTOR_SQL: &str =
include_str!("../migrations/20260725000000_set_runlimit_fixed_windows_fillfactor.sql");
pub const BOUND_RUNLIMIT_FIXED_WINDOW_CARDINALITY_SQL: &str =
include_str!("../migrations/20260726000000_bound_runlimit_fixed_window_cardinality.sql");
pub static MIGRATOR: Migrator = sqlx::migrate!("./migrations");
#[derive(Clone)]
pub struct PostgresLimiter {
pool: PgPool,
config: PostgresConfig,
observer: Option<Arc<dyn Observer>>,
}
impl fmt::Debug for PostgresLimiter {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("PostgresLimiter")
.field("pool", &self.pool)
.field("config", &self.config)
.field("has_observer", &self.observer.is_some())
.finish_non_exhaustive()
}
}
impl PostgresLimiter {
pub const fn new(pool: PgPool) -> Self {
Self {
pool,
config: PostgresConfig::new(),
observer: None,
}
}
pub const fn with_config(pool: PgPool, config: PostgresConfig) -> Self {
Self {
pool,
config,
observer: None,
}
}
#[must_use]
pub fn with_observer(mut self, observer: Arc<dyn Observer>) -> Self {
self.observer = Some(observer);
self
}
pub const fn pool(&self) -> &PgPool {
&self.pool
}
pub const fn config(&self) -> PostgresConfig {
self.config
}
pub async fn migrate(&self) -> Result<(), MigrateError> {
let connection = self.pool.acquire().await?;
let mut guarded_connection = ConnectionCancellationGuard::new(connection);
let mut migrator = sqlx::migrate!("./migrations");
migrator.set_ignore_missing(true);
let result = migrator
.run_direct(&mut **guarded_connection.connection())
.await;
if result.is_ok() {
guarded_connection.reuse();
}
result
}
pub async fn check(&self, check: &Check<'_>) -> Result<Decision, CheckError> {
let started = WallClockInstant::now();
let result = self
.check_all_unobserved(std::slice::from_ref(check))
.await
.and_then(single_decision_from_batch);
self.observe_single_admission(check, &result, started.elapsed());
result
}
pub async fn check_all(&self, checks: &[Check<'_>]) -> Result<BatchDecision, CheckError> {
let started = WallClockInstant::now();
let result = self.check_all_unobserved(checks).await;
self.observe_batch_admission(checks, &result, started.elapsed());
result
}
async fn check_all_unobserved(
&self,
checks: &[Check<'_>],
) -> Result<BatchDecision, CheckError> {
validate_batch(checks, self.config.max_batch_size())?;
if checks.is_empty() {
return Ok(BatchDecision::allowed(Vec::new()));
}
let input = BatchSqlInput::from_checks(checks);
let connection =
acquire_check_connection(&self.pool, self.config.pool_acquire_timeout()).await?;
let deadline = Instant::now() + self.config.operation_timeout();
let mut guarded_connection = ConnectionCancellationGuard::new(connection);
let outcome = run_check_transaction(
guarded_connection.connection(),
&input,
checks,
self.config.maximum_rows_per_shard(),
deadline,
)
.await;
guarded_connection.finish(outcome)
}
pub async fn cleanup_expired(&self, maximum_rows: u32) -> Result<u64, MaintenanceError> {
let started = WallClockInstant::now();
let result = self.cleanup_expired_unobserved(maximum_rows).await;
self.observe_cleanup(maximum_rows, &result, started.elapsed());
result
}
async fn cleanup_expired_unobserved(&self, maximum_rows: u32) -> Result<u64, MaintenanceError> {
if maximum_rows == 0 {
return Ok(0);
}
let connection =
acquire_maintenance_connection(&self.pool, self.config.pool_acquire_timeout()).await?;
let deadline = Instant::now() + self.config.operation_timeout();
let mut guarded_connection = ConnectionCancellationGuard::new(connection);
let outcome =
run_cleanup_transaction(guarded_connection.connection(), maximum_rows, deadline).await;
guarded_connection.finish(outcome)
}
fn observe_single_admission(
&self,
check: &Check<'_>,
result: &Result<Decision, CheckError>,
elapsed: Duration,
) {
match result {
Ok(decision) => self
.observe_admission(|| AdmissionObservation::from_check(check, decision, elapsed)),
Err(error) => self.observe_admission(|| {
AdmissionObservation::failed_check(check, check_error_consumption(error), elapsed)
}),
}
}
fn observe_batch_admission(
&self,
checks: &[Check<'_>],
result: &Result<BatchDecision, CheckError>,
elapsed: Duration,
) {
match result {
Ok(decision) => self
.observe_admission(|| AdmissionObservation::from_batch(checks, decision, elapsed)),
Err(error) => {
self.observe_admission(|| {
if let [check] = checks {
AdmissionObservation::failed_batch_for_check(
check,
check_error_consumption(error),
elapsed,
)
} else {
AdmissionObservation::failed_batch(
checks.len(),
check_error_consumption(error),
elapsed,
)
}
});
}
}
}
fn observe_admission<'a>(&self, build_observation: impl FnOnce() -> AdmissionObservation<'a>) {
let Some(observer) = &self.observer else {
return;
};
let admission = build_observation();
observe_safely(observer.as_ref(), &Observation::Admission(admission));
}
fn observe_cleanup(
&self,
requested: u32,
result: &Result<u64, MaintenanceError>,
elapsed: Duration,
) {
let Some(observer) = &self.observer else {
return;
};
let requested = usize::try_from(requested).unwrap_or(usize::MAX);
let observation = match result {
Ok(removed) => CleanupObservation::confirmed(requested, *removed, elapsed),
Err(error) if error.may_have_removed_rows() => {
CleanupObservation::outcome_unknown(requested, elapsed)
}
Err(_) => CleanupObservation::definitely_no_effect(requested, elapsed),
};
observe_safely(observer.as_ref(), &Observation::Cleanup(observation));
}
}
impl Limiter for PostgresLimiter {
type Policy = FixedWindowPolicy;
type Error = CheckError;
fn check(
&self,
check: &Check<'_>,
) -> impl Future<Output = Result<Decision, Self::Error>> + Send {
PostgresLimiter::check(self, check)
}
fn check_all(
&self,
checks: &[Check<'_>],
) -> impl Future<Output = Result<BatchDecision, Self::Error>> + Send {
PostgresLimiter::check_all(self, checks)
}
}
struct ConnectionCancellationGuard {
connection: PoolConnection<Postgres>,
armed: bool,
}
impl ConnectionCancellationGuard {
const fn new(connection: PoolConnection<Postgres>) -> Self {
Self {
connection,
armed: true,
}
}
const fn connection(&mut self) -> &mut PoolConnection<Postgres> {
&mut self.connection
}
const fn reuse(&mut self) {
self.armed = false;
}
fn finish<T, E>(mut self, outcome: ConnectionOutcome<Result<T, E>>) -> Result<T, E> {
match outcome {
ConnectionOutcome::Reusable(result) => {
self.reuse();
result
}
ConnectionOutcome::MustClose(result) => result,
}
}
}
impl Drop for ConnectionCancellationGuard {
fn drop(&mut self) {
if self.armed {
self.connection.close_on_drop();
}
}
}
#[cfg(test)]
mod tests {
use std::{
sync::{Arc, Mutex},
time::Duration,
};
use super::*;
use runlimit_core::{
AdmissionOperation, AdmissionOutcome, ConsumptionStatus, FixedWindowPolicy, MAX_LIMIT,
MAX_WINDOW, MAX_WINDOW_MILLIS, PolicyId, QuotaDenial, ScopeId, SubjectKey,
};
fn policy(id: &str, scope: &str) -> FixedWindowPolicy {
FixedWindowPolicy::new(
PolicyId::new(id).expect("valid policy identifier"),
ScopeId::new(scope).expect("valid scope identifier"),
10,
Duration::from_secs(60),
)
.expect("valid policy")
}
fn key(byte: u8) -> SubjectKey {
SubjectKey::from_digest([byte; 32])
}
#[derive(Default)]
struct RecordingObserver {
events: Mutex<Vec<(AdmissionOperation, AdmissionOutcome, ConsumptionStatus)>>,
cleanups: Mutex<Vec<(usize, Option<u64>, ConsumptionStatus)>>,
}
impl Observer for RecordingObserver {
fn observe(&self, observation: &Observation<'_>) {
match observation {
Observation::Admission(admission) => self.events.lock().unwrap().push((
admission.operation(),
admission.outcome(),
admission.consumption(),
)),
Observation::Cleanup(cleanup) => self.cleanups.lock().unwrap().push((
cleanup.requested(),
cleanup.removed(),
cleanup.consumption(),
)),
_ => {}
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct RecordedAdmissionMetadata {
operation: AdmissionOperation,
batch_size: usize,
has_policy_id: bool,
has_scope_id: bool,
has_policy_fingerprint: bool,
consumption: ConsumptionStatus,
}
#[derive(Default)]
struct AdmissionMetadataObserver {
admissions: Mutex<Vec<RecordedAdmissionMetadata>>,
}
impl Observer for AdmissionMetadataObserver {
fn observe(&self, observation: &Observation<'_>) {
let Observation::Admission(admission) = observation else {
return;
};
self.admissions
.lock()
.unwrap()
.push(RecordedAdmissionMetadata {
operation: admission.operation(),
batch_size: admission.batch_size(),
has_policy_id: admission.policy_id().is_some(),
has_scope_id: admission.scope_id().is_some(),
has_policy_fingerprint: admission.policy_fingerprint().is_some(),
consumption: admission.consumption(),
});
}
}
struct PanickingObserver;
impl Observer for PanickingObserver {
fn observe(&self, _: &Observation<'_>) {
panic!("injected observer panic");
}
}
#[test]
fn portable_core_boundaries_fit_database_values_exactly() {
let policy = FixedWindowPolicy::new(
PolicyId::new("portable.maximum").unwrap(),
ScopeId::new("subject").unwrap(),
MAX_LIMIT,
MAX_WINDOW,
)
.unwrap();
let check = Check::with_cost(&policy, key(1), MAX_LIMIT).unwrap();
assert_eq!(database_integer(policy.limit()), i64::MAX);
assert_eq!(database_integer(check.cost()), i64::MAX);
let interval = PgInterval::try_from(policy.window()).unwrap();
assert_eq!(interval.months, 0);
assert_eq!(interval.days, 0);
assert_eq!(
interval.microseconds,
i64::try_from(MAX_WINDOW_MILLIS * 1_000).unwrap()
);
}
#[test]
fn row_lock_permutation_orders_complete_counter_keys() {
let alpha_client = policy("alpha", "client");
let alpha_identity = policy("alpha", "identity");
let beta_client = policy("beta", "client");
let checks = [
Check::new(&beta_client, key(0)),
Check::new(&alpha_identity, key(0)),
Check::new(&alpha_client, key(1)),
Check::new(&alpha_client, key(0)),
];
let input = BatchSqlInput::from_checks(&checks);
let locked_keys = input
.lock_input_positions
.iter()
.map(|position| checks[usize::try_from(*position - 1).unwrap()].counter_key())
.collect::<Vec<_>>();
assert!(locked_keys.windows(2).all(|pair| pair[0] < pair[1]));
}
#[test]
fn advisory_lock_protocol_has_a_golden_vector() {
let policy = policy("login", "client");
let check = Check::new(&policy, key(7));
assert_eq!(
advisory_lock_id(check.counter_key()),
4_549_358_434_381_602_087
);
}
#[test]
fn capacity_shard_protocol_has_a_golden_vector() {
let policy = policy("login", "client");
let check = Check::new(&policy, key(7));
assert_eq!(capacity_shard(check.counter_key()), 141);
}
#[tokio::test]
async fn observer_reports_connection_free_operations_and_isolates_panics() {
let pool = sqlx::postgres::PgPoolOptions::new()
.connect_lazy("postgresql://runlimit:runlimit@127.0.0.1:1/runlimit")
.expect("syntactically valid database URL");
let observer = Arc::new(RecordingObserver::default());
let limiter = PostgresLimiter::new(pool.clone()).with_observer(observer.clone());
assert_eq!(
limiter.check_all(&[]).await.unwrap(),
BatchDecision::allowed(Vec::new())
);
assert_eq!(limiter.cleanup_expired(0).await.unwrap(), 0);
assert_eq!(
observer.events.lock().unwrap().as_slice(),
[(
AdmissionOperation::Batch,
AdmissionOutcome::Allowed,
ConsumptionStatus::NotConsumed,
)]
);
assert_eq!(
observer.cleanups.lock().unwrap().as_slice(),
[(0, Some(0), ConsumptionStatus::Consumed)]
);
let panicking = PostgresLimiter::new(pool).with_observer(Arc::new(PanickingObserver));
assert_eq!(
panicking.check_all(&[]).await.unwrap(),
BatchDecision::allowed(Vec::new())
);
assert_eq!(panicking.cleanup_expired(0).await.unwrap(), 0);
}
#[tokio::test]
async fn failed_postgres_batches_preserve_one_item_policy_metadata() {
let pool = sqlx::postgres::PgPoolOptions::new()
.connect_lazy("postgresql://runlimit:runlimit@127.0.0.1:1/runlimit")
.expect("syntactically valid database URL");
let observer = Arc::new(AdmissionMetadataObserver::default());
let limiter = PostgresLimiter::new(pool).with_observer(observer.clone());
let first_policy = policy("observed.failure.first", "client");
let second_policy = policy("observed.failure.second", "client");
let first = Check::new(&first_policy, key(1));
let second = Check::new(&second_policy, key(2));
let elapsed = Duration::from_millis(5);
limiter.observe_single_admission(&first, &Err(CheckError::CommitTimedOut), elapsed);
limiter.observe_batch_admission(&[first], &Err(CheckError::CommitTimedOut), elapsed);
limiter.observe_batch_admission(
&[first, second],
&Err(CheckError::CommitTimedOut),
elapsed,
);
assert_eq!(
observer.admissions.lock().unwrap().as_slice(),
[
RecordedAdmissionMetadata {
operation: AdmissionOperation::Check,
batch_size: 1,
has_policy_id: true,
has_scope_id: true,
has_policy_fingerprint: true,
consumption: ConsumptionStatus::PossiblyConsumed,
},
RecordedAdmissionMetadata {
operation: AdmissionOperation::Batch,
batch_size: 1,
has_policy_id: true,
has_scope_id: true,
has_policy_fingerprint: true,
consumption: ConsumptionStatus::PossiblyConsumed,
},
RecordedAdmissionMetadata {
operation: AdmissionOperation::Batch,
batch_size: 2,
has_policy_id: false,
has_scope_id: false,
has_policy_fingerprint: false,
consumption: ConsumptionStatus::PossiblyConsumed,
},
]
);
}
#[tokio::test]
async fn cleanup_observations_map_every_backend_effect_class() {
let pool = sqlx::postgres::PgPoolOptions::new()
.connect_lazy("postgresql://runlimit:runlimit@127.0.0.1:1/runlimit")
.expect("syntactically valid database URL");
let observer = Arc::new(RecordingObserver::default());
let limiter = PostgresLimiter::new(pool).with_observer(observer.clone());
let elapsed = Duration::from_millis(5);
limiter.observe_cleanup(7, &Ok(3), elapsed);
limiter.observe_cleanup(
7,
&Err(MaintenanceError::Database(sqlx::Error::RowNotFound)),
elapsed,
);
limiter.observe_cleanup(
7,
&Err(MaintenanceError::TimedOutBeforeCommit {
operation: "testing",
}),
elapsed,
);
limiter.observe_cleanup(
7,
&Err(MaintenanceError::CommitOutcomeUnknown(
sqlx::Error::RowNotFound,
)),
elapsed,
);
limiter.observe_cleanup(7, &Err(MaintenanceError::CommitTimedOut), elapsed);
assert_eq!(
observer.cleanups.lock().unwrap().as_slice(),
[
(7, Some(3), ConsumptionStatus::Consumed),
(7, Some(0), ConsumptionStatus::NotConsumed),
(7, Some(0), ConsumptionStatus::NotConsumed),
(7, None, ConsumptionStatus::PossiblyConsumed),
(7, None, ConsumptionStatus::PossiblyConsumed),
]
);
}
#[test]
fn response_metadata_subtracts_only_authoritative_elapsed_time() {
let allowed = PendingAllowance {
limit: 10,
remaining: 4,
reset_from_sample: Duration::from_millis(250),
}
.finish(Duration::from_millis(80));
let denied = PendingDenial::Quota(PendingQuotaDenial {
limit: 10,
retry_from_sample: Duration::from_millis(150),
})
.finish(Duration::from_millis(80));
assert_eq!(
allowed.replenishes_after(),
Some(Duration::from_millis(170))
);
assert_eq!(denied.retry_after(), Some(Duration::from_millis(70)));
assert_eq!(denied.retry_after_seconds(), Some(1));
}
#[tokio::test]
async fn denied_decision_survives_rollback_failure_and_discards_connection() {
let outcome = finish_denied_transaction(
Instant::now() + Duration::from_secs(1),
PendingBatchDenial::Enforced {
index: 2,
denial: PendingDenial::Quota(PendingQuotaDenial {
limit: 10,
retry_from_sample: Duration::from_millis(150),
}),
},
Duration::from_millis(20),
std::future::ready(Err(sqlx::Error::Protocol(
"injected rollback failure".to_owned(),
))),
)
.await;
let ConnectionOutcome::MustClose(decision) = outcome else {
panic!("rollback failure must close the connection")
};
assert_eq!(decision.denied_index(), Some(2));
assert_eq!(
decision.quota_denial(),
Some(QuotaDenial::try_new(10, Duration::from_millis(130)).unwrap())
);
}
#[tokio::test]
async fn denied_decision_survives_rollback_deadline_and_discards_connection() {
let outcome = finish_denied_transaction(
Instant::now(),
PendingBatchDenial::Enforced {
index: 0,
denial: PendingDenial::Quota(PendingQuotaDenial {
limit: 1,
retry_from_sample: Duration::from_millis(50),
}),
},
Duration::ZERO,
std::future::pending(),
)
.await;
let ConnectionOutcome::MustClose(decision) = outcome else {
panic!("rollback deadline must close the connection")
};
assert_eq!(decision.denied_index(), Some(0));
assert_eq!(decision.quota_denial().map(QuotaDenial::capacity), Some(1));
}
#[tokio::test]
async fn shadow_quota_denial_is_reported_after_rollback() {
let outcome = finish_denied_transaction(
Instant::now() + Duration::from_secs(1),
PendingBatchDenial::Shadow {
index: 0,
denial: PendingQuotaDenial {
limit: 1,
retry_from_sample: Duration::from_secs(1),
},
},
Duration::ZERO,
std::future::ready(Ok(())),
)
.await;
let ConnectionOutcome::Reusable(decision) = outcome else {
panic!("successful rollback must reuse the connection")
};
assert!(decision.is_shadow_denied());
assert_eq!(decision.denied_index(), Some(0));
assert_eq!(decision.quota_denial().map(QuotaDenial::capacity), Some(1));
}
#[test]
fn configuration_bounds_batches_and_deadlines() {
let defaults = PostgresConfig::new();
assert_eq!(defaults.maximum_rows_per_shard(), 4_096);
assert_eq!(defaults.max_batch_size(), 32);
assert_eq!(defaults.pool_acquire_timeout(), Duration::from_secs(3));
assert_eq!(defaults.operation_timeout(), Duration::from_secs(3));
assert_eq!(
defaults.with_maximum_rows_per_shard(0),
Err(PostgresConfigError::ZeroMaximumRowsPerShard)
);
assert_eq!(
defaults.with_maximum_rows_per_shard(HARD_MAX_ROWS_PER_SHARD + 1),
Err(PostgresConfigError::MaximumRowsPerShardTooLarge {
actual: HARD_MAX_ROWS_PER_SHARD + 1,
maximum: HARD_MAX_ROWS_PER_SHARD,
})
);
assert_eq!(
defaults.with_max_batch_size(0),
Err(PostgresConfigError::ZeroBatchSize)
);
assert_eq!(
defaults.with_pool_acquire_timeout(Duration::ZERO),
Err(PostgresConfigError::ZeroPoolAcquireTimeout)
);
assert_eq!(
defaults.with_pool_acquire_timeout(Duration::from_secs(61)),
Err(PostgresConfigError::PoolAcquireTimeoutTooLong {
actual: Duration::from_secs(61),
maximum: Duration::from_secs(60),
})
);
assert_eq!(
defaults.with_operation_timeout(Duration::ZERO),
Err(PostgresConfigError::ZeroOperationTimeout)
);
assert_eq!(
defaults.with_operation_timeout(Duration::from_secs(61)),
Err(PostgresConfigError::OperationTimeoutTooLong {
actual: Duration::from_secs(61),
maximum: Duration::from_secs(60),
})
);
}
#[tokio::test]
async fn duplicate_storage_keys_fail_before_connecting() {
let alpha = policy("alpha", "client");
let beta = policy("beta", "client");
let checks = [
Check::new(&beta, key(7)),
Check::new(&beta, key(7)),
Check::new(&alpha, key(8)),
Check::new(&alpha, key(8)),
];
let pool = sqlx::postgres::PgPoolOptions::new()
.connect_lazy("postgresql://runlimit:runlimit@127.0.0.1:1/runlimit")
.expect("syntactically valid database URL");
let limiter = PostgresLimiter::new(pool);
let error = limiter
.check_all(&checks)
.await
.expect_err("duplicate keys must be rejected");
assert!(matches!(
error,
CheckError::InvalidBatch(BatchError::DuplicateKey {
first_index: 0,
duplicate_index: 1,
})
));
}
#[tokio::test]
async fn oversized_batch_fails_before_connecting() {
let first_policy = policy("login", "client");
let second_policy = policy("signup", "client");
let checks = [
Check::new(&first_policy, key(1)),
Check::new(&second_policy, key(2)),
];
let pool = sqlx::postgres::PgPoolOptions::new()
.connect_lazy("postgresql://runlimit:runlimit@127.0.0.1:1/runlimit")
.expect("syntactically valid database URL");
let config = PostgresConfig::new()
.with_max_batch_size(1)
.expect("one is a valid batch limit");
let limiter = PostgresLimiter::with_config(pool, config);
let error = limiter
.check_all(&checks)
.await
.expect_err("oversized batch must be rejected");
assert!(matches!(
error,
CheckError::InvalidBatch(BatchError::BatchTooLarge {
actual: 2,
maximum: 1,
})
));
}
#[test]
fn error_reports_consumption_uncertainty() {
let definite = CheckError::DefinitelyNotConsumed(sqlx::Error::RowNotFound);
let unknown = CheckError::CommitOutcomeUnknown(sqlx::Error::RowNotFound);
let rolled_back_invariant = CheckError::ResponseInvariant;
let committed_invariant = CheckError::CommittedResponseInvariant;
let cleanup_definite = MaintenanceError::Database(sqlx::Error::RowNotFound);
let cleanup_unknown = MaintenanceError::CommitOutcomeUnknown(sqlx::Error::RowNotFound);
assert!(!definite.may_have_consumed_quota());
assert!(unknown.may_have_consumed_quota());
assert!(CheckError::CommitTimedOut.may_have_consumed_quota());
assert!(!rolled_back_invariant.may_have_consumed_quota());
assert!(committed_invariant.may_have_consumed_quota());
assert_eq!(
check_error_consumption(&definite),
ConsumptionStatus::NotConsumed
);
assert_eq!(
check_error_consumption(&unknown),
ConsumptionStatus::PossiblyConsumed
);
assert_eq!(
check_error_consumption(&CheckError::CommitTimedOut),
ConsumptionStatus::PossiblyConsumed
);
assert_eq!(
check_error_consumption(&rolled_back_invariant),
ConsumptionStatus::NotConsumed
);
assert_eq!(
check_error_consumption(&committed_invariant),
ConsumptionStatus::Consumed
);
assert!(!cleanup_definite.may_have_removed_rows());
assert!(cleanup_unknown.may_have_removed_rows());
assert!(MaintenanceError::CommitTimedOut.may_have_removed_rows());
}
#[test]
fn malformed_single_responses_preserve_consumption_status() {
let denial = QuotaDenial::try_new(1, Duration::from_secs(1)).unwrap();
let committed = single_decision_from_batch(BatchDecision::allowed(Vec::new()))
.expect_err("malformed allowed response follows a confirmed commit");
let rolled_back = single_decision_from_batch(BatchDecision::denied(1, denial))
.expect_err("malformed denied response follows a rollback");
assert!(matches!(committed, CheckError::CommittedResponseInvariant));
assert!(committed.may_have_consumed_quota());
assert!(matches!(rolled_back, CheckError::ResponseInvariant));
assert!(!rolled_back.may_have_consumed_quota());
}
#[test]
fn cleanup_query_is_bounded_and_nonblocking() {
assert_eq!(
CLEANUP_SQL.matches("pg_catalog.clock_timestamp()").count(),
1
);
assert!(CLEANUP_SQL.contains("AS MATERIALIZED"));
assert!(CLEANUP_SQL.contains("SELECT sampled_at\n FROM authoritative_time"));
assert!(!CLEANUP_SQL.contains("window_expires_at <= pg_catalog.clock_timestamp()"));
assert!(CLEANUP_SQL.contains("LIMIT $1"));
assert!(CLEANUP_SQL.contains("FOR UPDATE SKIP LOCKED"));
assert!(CLEANUP_SQL.contains("ORDER BY capacity.capacity_shard"));
assert!(CLEANUP_SQL.contains("FOR UPDATE OF capacity"));
}
#[test]
fn every_production_clock_call_is_catalog_qualified() {
for (name, sql) in [
("batch preflight", BATCH_PREFLIGHT_SQL),
("batch upsert", BATCH_UPSERT_SQL),
("cleanup", CLEANUP_SQL),
] {
let without_qualified_calls = sql.replace("pg_catalog.clock_timestamp()", "");
assert!(
!without_qualified_calls.contains("clock_timestamp()"),
"{name} contains a search_path-resolved clock_timestamp() call"
);
}
}
}