use std::future::Future;
use std::marker::PhantomData;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::{Arc, Mutex, PoisonError};
use tokio::sync::OwnedMutexGuard;
use super::tx::TxStatus;
use super::{transaction_pool, write_transaction, ExecError, PoolTx};
use crate::sql::{Pool, PoolId};
type Callback = Box<dyn FnOnce() + Send>;
struct Slot {
state: Arc<tokio::sync::Mutex<TxState>>,
cancelled: AtomicUsize,
cancelled_point: Mutex<Option<(usize, usize)>>,
guards: AtomicUsize,
claims: AtomicUsize,
fatal: Arc<AtomicBool>,
tx_key: usize,
}
struct Claim<'a>(&'a Slot);
impl<'a> Claim<'a> {
fn new(slot: &'a Slot) -> Self {
slot.claims.fetch_add(1, Ordering::SeqCst);
Self(slot)
}
}
impl Drop for Claim<'_> {
fn drop(&mut self) {
self.0.claims.fetch_sub(1, Ordering::SeqCst);
}
}
struct TxState {
tx: Option<PoolTx<'static>>,
depth: usize,
poisoned: bool,
ended: bool,
retry_points: usize,
points: Vec<(usize, usize)>,
}
impl TxState {
fn tx(&mut self) -> &mut PoolTx<'static> {
self.tx.as_mut().expect("atomic transaction is open")
}
async fn savepoint(&mut self, verb: &str, depth: usize) -> Result<(), ExecError> {
self.named_savepoint(verb, &format!("rustango_sp_{depth}"))
.await
}
async fn named_savepoint(&mut self, verb: &str, name: &str) -> Result<(), ExecError> {
let tx = self.tx();
let name = tx.dialect().quote_ident(name);
let r = tx.execute_unprepared(&format!("{verb} {name}")).await;
if r.is_err() {
self.poisoned = true;
}
Ok(r?)
}
async fn rollback_to(&mut self, depth: usize) -> Result<(), ExecError> {
self.savepoint("ROLLBACK TO SAVEPOINT", depth).await?;
self.savepoint("RELEASE SAVEPOINT", depth).await?;
self.left(depth);
Ok(())
}
fn left(&mut self, depth: usize) {
self.depth = depth - 1;
self.points.retain(|&(_, d)| d < depth);
}
fn point_gone(&mut self, n: usize) {
self.points.retain(|&(m, _)| m < n);
}
fn unguarded(&self) -> bool {
self.depth == 0 && self.points.is_empty()
}
async fn check_open(&mut self, slot: &Slot) -> Result<(), ExecError> {
let status = self.tx().status().await;
if status == TxStatus::Open {
return Ok(());
}
self.poisoned = true;
if status == TxStatus::Ended && !slot.fatal.load(Ordering::SeqCst) {
self.ended = true;
return Err(ExecError::AtomicEndedEarly);
}
Err(ExecError::AtomicAborted)
}
async fn settle(&mut self, slot: &Slot) -> Result<(), ExecError> {
if self.ended {
return Err(ExecError::AtomicEndedEarly);
}
if self.poisoned || slot.fatal.load(Ordering::SeqCst) {
return Err(ExecError::AtomicAborted);
}
let d = slot.cancelled.swap(0, Ordering::SeqCst);
if d != 0 && d <= self.depth {
self.rollback_to(d).await?;
}
let point = {
let mut cp = slot
.cancelled_point
.lock()
.unwrap_or_else(PoisonError::into_inner);
match *cp {
Some((_, depth)) if depth > self.depth => {
*cp = None;
None
}
Some((_, depth)) if depth == self.depth => cp.take(),
_ => None,
}
};
if let Some((n, _)) = point {
let name = retry_point_name(n);
self.named_savepoint("ROLLBACK TO SAVEPOINT", &name).await?;
self.named_savepoint("RELEASE SAVEPOINT", &name).await?;
self.point_gone(n);
}
Ok(())
}
}
async fn in_background<T: Send + 'static>(
fut: impl Future<Output = Result<T, ExecError>> + Send + 'static,
) -> Result<T, ExecError> {
match tokio::spawn(fut).await {
Ok(r) => r,
Err(e) if e.is_panic() => std::panic::resume_unwind(e.into_panic()),
Err(_) => Err(ExecError::AtomicAborted),
}
}
async fn acquire(slot: &Arc<Slot>) -> Result<OwnedMutexGuard<TxState>, ExecError> {
let busy =
|s: &Slot| s.guards.load(Ordering::SeqCst) > 0 || s.claims.load(Ordering::SeqCst) > 0;
let guard = loop {
match Arc::clone(&slot.state).try_lock_owned() {
Ok(g) => break g,
Err(_) if busy(slot) => return Err(ExecError::NestedAtomic),
Err(_) => tokio::time::sleep(std::time::Duration::from_millis(1)).await,
}
};
if !guard.poisoned
&& !slot.fatal.load(Ordering::SeqCst)
&& slot.cancelled.load(Ordering::SeqCst) == 0
&& slot
.cancelled_point
.lock()
.unwrap_or_else(PoisonError::into_inner)
.is_none()
{
return Ok(guard);
}
let _claim = Claim::new(slot);
let task_slot = Arc::clone(slot);
in_background(async move {
let mut g = guard;
g.settle(&task_slot).await?;
Ok(g)
})
.await
}
pub(crate) struct Gate(Option<Arc<Slot>>);
impl Gate {
pub(crate) const OPEN: Self = Self(None);
}
pub(crate) fn gate(tx: &PoolTx<'_>) -> Result<Gate, ExecError> {
let key = std::ptr::from_ref::<PoolTx<'_>>(tx) as usize;
let slot = std::iter::successors(current(), |b| b.enclosing.clone())
.map(|b| Arc::clone(&b.slot))
.find(|s| s.tx_key == key);
if slot
.as_ref()
.is_some_and(|s| s.fatal.load(Ordering::SeqCst))
{
return Err(ExecError::AtomicAborted);
}
Ok(Gate(slot))
}
impl Gate {
pub(crate) fn check<T>(&self, r: Result<T, ExecError>) -> Result<T, ExecError> {
if let (Some(slot), Err(ExecError::Driver(e))) = (&self.0, &r) {
if ends_transaction(e) {
slot.fatal.store(true, Ordering::SeqCst);
}
}
r
}
}
#[allow(unused_variables)]
fn is_lock_wait_timeout<T>(r: &Result<T, ExecError>) -> bool {
#[cfg(feature = "mysql")]
if let Err(ExecError::Driver(sqlx::Error::Database(db))) = r {
return db
.try_downcast_ref::<sqlx::mysql::MySqlDatabaseError>()
.is_some_and(|m| m.number() == 1205);
}
false
}
fn ends_transaction(e: &sqlx::Error) -> bool {
match e {
sqlx::Error::Io(_) | sqlx::Error::PoolClosed | sqlx::Error::WorkerCrashed => true,
#[allow(unused_variables)]
sqlx::Error::Database(db) => {
#[cfg(feature = "mysql")]
if db
.try_downcast_ref::<sqlx::mysql::MySqlDatabaseError>()
.is_some_and(|m| matches!(m.number(), 1213 | 1205))
{
return true;
}
#[cfg(feature = "postgres")]
if db
.try_downcast_ref::<sqlx::postgres::PgDatabaseError>()
.is_some_and(|p| {
use sqlx::postgres::PgSeverity;
matches!(p.severity(), PgSeverity::Fatal | PgSeverity::Panic)
})
{
return true;
}
false
}
_ => false,
}
}
struct Block {
pool: PoolId,
slot: Arc<Slot>,
depth: usize,
enclosing: Option<Arc<Block>>,
callbacks: Mutex<Vec<Callback>>,
committed: AtomicBool,
}
impl Block {
fn take_callbacks(&self) -> Vec<Callback> {
std::mem::take(
&mut self
.callbacks
.lock()
.unwrap_or_else(PoisonError::into_inner),
)
}
}
tokio::task_local! {
static BLOCK: Option<Arc<Block>>;
}
fn current() -> Option<Arc<Block>> {
BLOCK.try_with(Clone::clone).ok().flatten()
}
#[cfg(any(feature = "cache", feature = "tenancy"))]
pub(crate) async fn detached<F: Future>(fut: F) -> F::Output {
BLOCK.scope(None, fut).await
}
pub struct AtomicTx {
block: Arc<Block>,
}
impl AtomicTx {
pub async fn lock(&self) -> Result<TxGuard<'_>, ExecError> {
let slot = &self.block.slot;
let guard = acquire(slot).await?;
if guard.depth != self.block.depth {
return Err(ExecError::NestedAtomic);
}
slot.guards.fetch_add(1, Ordering::SeqCst);
Ok(TxGuard {
guard,
slot: Arc::clone(slot),
_handle: PhantomData,
})
}
}
pub struct TxGuard<'a> {
guard: OwnedMutexGuard<TxState>,
slot: Arc<Slot>,
_handle: PhantomData<&'a AtomicTx>,
}
impl Drop for TxGuard<'_> {
fn drop(&mut self) {
self.slot.guards.fetch_sub(1, Ordering::SeqCst);
}
}
impl std::ops::Deref for TxGuard<'_> {
type Target = PoolTx<'static>;
fn deref(&self) -> &PoolTx<'static> {
self.guard.tx.as_ref().expect("atomic transaction is open")
}
}
impl std::ops::DerefMut for TxGuard<'_> {
fn deref_mut(&mut self) -> &mut PoolTx<'static> {
self.guard.tx()
}
}
#[derive(Default)]
struct Opening {
opened: AtomicBool,
abandoned: AtomicBool,
}
struct OpenSavepoint {
slot: Arc<Slot>,
depth: usize,
opening: Arc<Opening>,
ending: bool,
}
fn mark_cancelled(slot: &Slot, depth: usize) {
let _ = slot
.cancelled
.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |c| {
Some(if c == 0 { depth } else { c.min(depth) })
});
}
impl Drop for OpenSavepoint {
fn drop(&mut self) {
if !self.ending {
self.opening.abandoned.store(true, Ordering::SeqCst);
if self.opening.opened.load(Ordering::SeqCst) {
mark_cancelled(&self.slot, self.depth);
}
}
}
}
fn block_on(pool: &Pool) -> Option<Arc<Block>> {
let id = PoolId::of(pool);
std::iter::successors(current(), |b| b.enclosing.clone()).find(|b| b.pool.same(&id))
}
pub(crate) fn in_block(pool: &Pool) -> bool {
block_on(pool).is_some()
}
#[derive(Clone, Copy, PartialEq, Eq)]
pub(crate) enum Stmt {
Plain,
Write,
}
pub(crate) struct Joined {
guard: OwnedMutexGuard<TxState>,
slot: Arc<Slot>,
phase: Phase,
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum Phase {
Done,
Opening(usize),
Open(usize),
Releasing(usize),
}
pub(crate) async fn join(pool: &Pool, stmt: Stmt) -> Option<Result<Joined, ExecError>> {
let block = block_on(pool)?;
Some(Joined::open(&block, stmt).await)
}
impl Joined {
async fn open(block: &Block, stmt: Stmt) -> Result<Self, ExecError> {
let slot = Arc::clone(&block.slot);
if slot.fatal.load(Ordering::SeqCst) {
return Err(ExecError::AtomicAborted);
}
let guard = acquire(&slot).await?;
if guard.depth != block.depth {
return Err(ExecError::NestedAtomic);
}
slot.guards.fetch_add(1, Ordering::SeqCst);
let mut j = Self {
guard,
slot,
phase: Phase::Done,
};
if stmt == Stmt::Write {
let depth = block.depth + 1;
j.phase = Phase::Opening(depth);
j.guard.savepoint("SAVEPOINT", depth).await?;
j.guard.depth = depth;
j.phase = Phase::Open(depth);
}
Ok(j)
}
pub(crate) async fn finish<T>(mut self, r: Result<T, ExecError>) -> Result<T, ExecError> {
let r = Gate(Some(Arc::clone(&self.slot))).check(r);
if is_lock_wait_timeout(&r) && self.guard.tx().status().await == TxStatus::Open {
self.slot.fatal.store(false, Ordering::SeqCst);
}
if let Err(ExecError::Driver(sqlx::Error::Database(_))) = &r {
if self.guard.unguarded()
&& self
.guard
.tx
.as_ref()
.is_some_and(|t| t.dialect().name() == "postgres")
{
self.slot.fatal.store(true, Ordering::SeqCst);
}
}
let v = r?;
self.release().await?;
Ok(v)
}
pub(crate) async fn release(mut self) -> Result<(), ExecError> {
let Phase::Open(depth) = self.phase else {
return Ok(());
};
self.phase = Phase::Releasing(depth);
self.guard.savepoint("RELEASE SAVEPOINT", depth).await?;
self.guard.left(depth);
self.phase = Phase::Done;
Ok(())
}
}
impl Drop for Joined {
fn drop(&mut self) {
match self.phase {
Phase::Open(depth) => mark_cancelled(&self.slot, depth),
Phase::Releasing(depth) => self.guard.left(depth),
Phase::Done | Phase::Opening(_) => {}
}
self.slot.guards.fetch_sub(1, Ordering::SeqCst);
}
}
impl std::ops::Deref for Joined {
type Target = PoolTx<'static>;
fn deref(&self) -> &PoolTx<'static> {
self.guard.tx.as_ref().expect("atomic transaction is open")
}
}
impl std::ops::DerefMut for Joined {
fn deref_mut(&mut self) -> &mut PoolTx<'static> {
self.guard.tx()
}
}
pub(crate) fn refuse_in_block(
pool: &Pool,
op: &'static str,
reason: &'static str,
) -> Result<(), ExecError> {
if in_block(pool) {
return Err(ExecError::InAtomic { op, reason });
}
Ok(())
}
pub(crate) async fn retry_point(pool: &Pool) -> Result<Option<RetryPoint>, ExecError> {
match block_on(pool) {
Some(block) => RetryPoint::open(&block).await,
None => Ok(None),
}
}
pub(crate) async fn caught<T>(
pool: &Pool,
step: impl Future<Output = Result<T, ExecError>>,
) -> Result<T, ExecError> {
let Some(point) = retry_point(pool).await? else {
return step.await;
};
let r = step.await;
let ended = point.end(r.is_ok()).await;
r.and_then(|v| ended.map(|()| v))
}
fn retry_point_name(n: usize) -> String {
format!("rustango_rp_{n}")
}
pub(crate) struct RetryPoint {
slot: Arc<Slot>,
depth: usize,
n: usize,
done: bool,
}
impl RetryPoint {
async fn open(block: &Block) -> Result<Option<Self>, ExecError> {
let slot = Arc::clone(&block.slot);
let mut guard = match acquire(&slot).await {
Ok(g) => g,
Err(ExecError::NestedAtomic) => return Ok(None),
Err(e) => return Err(e),
};
if guard.depth != block.depth {
return Ok(None);
}
guard.retry_points += 1;
let n = guard.retry_points;
let claim = Claim::new(&slot);
let depth = block.depth;
let opened = in_background(async move {
let mut g = guard;
g.named_savepoint("SAVEPOINT", &retry_point_name(n)).await?;
g.points.push((n, depth));
Ok(())
})
.await;
drop(claim);
opened?;
Ok(Some(Self {
slot,
depth: block.depth,
n,
done: false,
}))
}
pub(crate) async fn end(mut self, keep: bool) -> Result<(), ExecError> {
let guard = match acquire(&self.slot).await {
Ok(g) => g,
Err(ExecError::NestedAtomic) => {
self.done = keep;
return Ok(());
}
Err(e) => return Err(e),
};
if guard.depth != self.depth {
self.done = keep;
return Ok(());
}
let (n, name) = (self.n, retry_point_name(self.n));
self.done = true;
let _claim = Claim::new(&self.slot);
in_background(async move {
let mut g = guard;
if !keep {
g.named_savepoint("ROLLBACK TO SAVEPOINT", &name).await?;
}
g.named_savepoint("RELEASE SAVEPOINT", &name).await?;
g.point_gone(n);
Ok(())
})
.await
}
}
impl Drop for RetryPoint {
fn drop(&mut self) {
if self.done {
return;
}
let mut cp = self
.slot
.cancelled_point
.lock()
.unwrap_or_else(PoisonError::into_inner);
if cp.is_none_or(|(n, _)| self.n < n) {
*cp = Some((self.n, self.depth));
}
}
}
#[cfg(feature = "jobs")]
pub(crate) fn in_any_block() -> bool {
current().is_some_and(|b| !b.committed.load(Ordering::SeqCst))
}
pub async fn atomic<F, T>(pool: &Pool, f: F) -> Result<T, ExecError>
where
F: for<'tx> FnOnce(
&'tx AtomicTx,
) -> std::pin::Pin<
Box<dyn std::future::Future<Output = Result<T, ExecError>> + Send + 'tx>,
>,
{
atomic_with(pool, AtomicOptions::new(), f).await
}
pub async fn atomic_with<F, T>(pool: &Pool, opts: AtomicOptions, f: F) -> Result<T, ExecError>
where
F: for<'tx> FnOnce(
&'tx AtomicTx,
) -> std::pin::Pin<
Box<dyn std::future::Future<Output = Result<T, ExecError>> + Send + 'tx>,
>,
{
run(pool, End::Commit, opts, f).await
}
#[must_use]
pub fn in_atomic(pool: &Pool) -> bool {
in_block(pool)
}
#[derive(Debug, Clone)]
#[must_use]
pub struct AtomicOptions {
isolation: Option<Isolation>,
settings: Vec<TxSetting>,
begin: Begin,
}
impl Default for AtomicOptions {
fn default() -> Self {
Self {
isolation: None,
settings: Vec::new(),
begin: Begin::Immediate,
}
}
}
impl AtomicOptions {
pub fn new() -> Self {
Self::default()
}
pub fn isolation(mut self, level: Isolation) -> Self {
self.isolation = Some(level);
self
}
pub fn setting(mut self, setting: TxSetting) -> Self {
self.settings.push(setting);
self
}
fn changes_the_begin(&self) -> bool {
self.isolation.is_some() || !self.settings.is_empty()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum Isolation {
ReadCommitted,
RepeatableRead,
Serializable,
}
impl Isolation {
#[cfg(any(feature = "postgres", feature = "mysql"))]
fn sql(self) -> &'static str {
match self {
Self::ReadCommitted => "READ COMMITTED",
Self::RepeatableRead => "REPEATABLE READ",
Self::Serializable => "SERIALIZABLE",
}
}
}
#[derive(Debug, Clone)]
pub struct TxSetting {
name: String,
value: String,
}
impl TxSetting {
pub fn new(name: &str, value: impl Into<String>) -> Result<Self, ExecError> {
let plain = name.contains('.') && name.split('.').all(crate::core::is_plain_identifier);
if !plain {
return Err(ExecError::InvalidTxSetting {
name: name.to_owned(),
});
}
Ok(Self {
name: name.to_owned(),
value: value.into(),
})
}
}
#[deprecated(
since = "0.67.0",
note = "use `atomic`: it begins SQLite blocks with `BEGIN IMMEDIATE` now; removed in 0.68.0"
)]
pub async fn atomic_immediate<F, T>(pool: &Pool, f: F) -> Result<T, ExecError>
where
F: for<'tx> FnOnce(
&'tx AtomicTx,
) -> std::pin::Pin<
Box<dyn std::future::Future<Output = Result<T, ExecError>> + Send + 'tx>,
>,
{
atomic_with(pool, AtomicOptions::new(), f).await
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Begin {
Deferred,
Immediate,
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum End {
Commit,
Rollback,
}
pub(crate) async fn rolled_back<F, T>(pool: &Pool, f: F) -> Result<T, ExecError>
where
F: for<'tx> FnOnce(
&'tx AtomicTx,
) -> std::pin::Pin<
Box<dyn std::future::Future<Output = Result<T, ExecError>> + Send + 'tx>,
>,
{
let opts = AtomicOptions {
begin: Begin::Deferred,
..AtomicOptions::new()
};
run(pool, End::Rollback, opts, f).await
}
async fn run<F, T>(pool: &Pool, end: End, opts: AtomicOptions, f: F) -> Result<T, ExecError>
where
F: for<'tx> FnOnce(
&'tx AtomicTx,
) -> std::pin::Pin<
Box<dyn std::future::Future<Output = Result<T, ExecError>> + Send + 'tx>,
>,
{
let id = PoolId::of(pool);
let enclosing = current();
let same_pool = std::iter::successors(enclosing.clone(), |b| b.enclosing.clone())
.find(|b| b.pool.same(&id));
match same_pool {
Some(_) if opts.changes_the_begin() => Err(ExecError::InAtomic {
op: "an isolation level or setting",
reason: "it applies only when the outermost block begins",
}),
Some(parent) => nested(parent, enclosing, end, f).await,
None => outermost(pool, id, enclosing, end, &opts, f).await,
}
}
async fn begin_block(
pool: &Pool,
opts: &AtomicOptions,
top: bool,
) -> Result<PoolTx<'static>, ExecError> {
if !opts.settings.is_empty() && pool.dialect().name() != "postgres" {
return Err(ExecError::Sql(
crate::sql::SqlError::OperatorNotSupportedInDialect {
op: "set_config",
dialect: pool.dialect().name(),
},
));
}
let mut tx = match (pool, opts.isolation) {
#[cfg(feature = "postgres")]
(Pool::Postgres(pg), Some(level)) => PoolTx::new(
super::TxConn::Postgres(
pg.begin_with(format!("BEGIN ISOLATION LEVEL {}", level.sql()))
.await?,
),
PoolId::of(pool),
),
#[cfg(feature = "mysql")]
(Pool::Mysql(my), Some(level)) => PoolTx::new(
super::TxConn::Mysql(
my.begin_with(format!(
"SET TRANSACTION ISOLATION LEVEL {}; START TRANSACTION",
level.sql()
))
.await?,
),
PoolId::of(pool),
),
_ if opts.begin == Begin::Immediate && top => write_transaction(pool).await?,
_ => transaction_pool(pool).await?,
};
for s in &opts.settings {
let d = tx.dialect();
let sql = format!(
"SELECT set_config({}, {}, true)",
d.placeholder(1),
d.placeholder(2)
);
let binds = vec![s.name.clone().into(), s.value.clone().into()];
super::raw_execute_tx(&mut tx, &sql, binds).await?;
}
Ok(tx)
}
async fn outermost<F, T>(
pool: &Pool,
id: PoolId,
enclosing: Option<Arc<Block>>,
end: End,
opts: &AtomicOptions,
f: F,
) -> Result<T, ExecError>
where
F: for<'tx> FnOnce(
&'tx AtomicTx,
) -> std::pin::Pin<
Box<dyn std::future::Future<Output = Result<T, ExecError>> + Send + 'tx>,
>,
{
let fatal = Arc::new(AtomicBool::new(false));
let mut tx = begin_block(pool, opts, enclosing.is_none()).await?;
let hook = Arc::clone(&fatal);
tx.on_sqlite_rollback(move || hook.store(true, Ordering::SeqCst))
.await?;
let state = Arc::new(tokio::sync::Mutex::new(TxState {
tx: Some(tx),
depth: 0,
poisoned: false,
ended: false,
retry_points: 0,
points: Vec::new(),
}));
let tx_key = state
.try_lock()
.ok()
.and_then(|g| g.tx.as_ref().map(|t| std::ptr::from_ref(t) as usize))
.unwrap_or(0);
let slot = Arc::new(Slot {
state,
cancelled: AtomicUsize::new(0),
cancelled_point: Mutex::new(None),
guards: AtomicUsize::new(0),
claims: AtomicUsize::new(0),
fatal,
tx_key,
});
let block = Arc::new(Block {
pool: id,
slot: Arc::clone(&slot),
depth: 0,
enclosing,
callbacks: Mutex::new(Vec::new()),
committed: AtomicBool::new(false),
});
let handle = AtomicTx {
block: Arc::clone(&block),
};
let res = BLOCK
.scope(Some(Arc::clone(&block)), async { f(&handle).await })
.await;
let mut st = slot.state.lock().await;
let settled = match st.settle(&slot).await {
Ok(()) if st.depth != 0 => Err(ExecError::AtomicAborted),
Ok(()) if res.is_ok() && end == End::Commit => st.check_open(&slot).await,
other => other,
};
let mut tx = st.tx.take().expect("atomic transaction is open");
drop(st);
tx.clear_sqlite_rollback().await;
match res.and_then(|v| settled.map(|()| v)) {
Ok(v) if end == End::Rollback => {
tx.rollback().await?;
Ok(v)
}
Ok(v) => {
tx.commit().await?;
block.committed.store(true, Ordering::SeqCst);
let callbacks = block.take_callbacks();
BLOCK.sync_scope(Some(block), || {
for cb in callbacks {
let run = std::panic::catch_unwind(std::panic::AssertUnwindSafe(cb));
if let Err(panic) = run {
tracing::error!(
target: "rustango::error",
panic = crate::panic_guard::panic_message(&*panic),
"on_commit callback panicked"
);
}
}
});
Ok(v)
}
Err(e) => {
let _ = tx.rollback().await;
Err(e)
}
}
}
async fn nested<F, T>(
parent: Arc<Block>,
enclosing: Option<Arc<Block>>,
end: End,
f: F,
) -> Result<T, ExecError>
where
F: for<'tx> FnOnce(
&'tx AtomicTx,
) -> std::pin::Pin<
Box<dyn std::future::Future<Output = Result<T, ExecError>> + Send + 'tx>,
>,
{
let slot = Arc::clone(&parent.slot);
let guard = acquire(&slot).await?;
let parent_depth = parent.depth;
let depth = parent_depth + 1;
let opening = Arc::new(Opening::default());
let mut open = OpenSavepoint {
slot: Arc::clone(&slot),
depth,
opening: Arc::clone(&opening),
ending: false,
};
let (task_slot, task_opening) = (Arc::clone(&slot), Arc::clone(&opening));
let claim = Claim::new(&slot);
let opened = in_background(async move {
let mut g = guard;
if g.depth != parent_depth {
return Err(ExecError::NestedAtomic);
}
g.savepoint("SAVEPOINT", depth).await?;
g.depth = depth;
task_opening.opened.store(true, Ordering::SeqCst);
if task_opening.abandoned.load(Ordering::SeqCst) {
mark_cancelled(&task_slot, depth);
}
Ok(())
})
.await;
drop(claim);
if let Err(e) = opened {
open.ending = true;
return Err(e);
}
let block = Arc::new(Block {
pool: parent.pool.clone(),
slot: Arc::clone(&slot),
depth,
enclosing,
callbacks: Mutex::new(Vec::new()),
committed: AtomicBool::new(false),
});
let handle = AtomicTx {
block: Arc::clone(&block),
};
let res = BLOCK
.scope(Some(Arc::clone(&block)), async { f(&handle).await })
.await;
let guard = match acquire(&slot).await {
Ok(g) => g,
Err(e) => return Err(res.err().unwrap_or(e)),
};
open.ending = true;
let release = res.is_ok() && end == End::Commit;
let claim = Claim::new(&slot);
let ended = in_background(async move {
let mut g = guard;
if g.depth != depth {
g.poisoned = true;
return Err(ExecError::AtomicAborted);
}
if release {
g.savepoint("RELEASE SAVEPOINT", depth).await?;
g.left(depth);
let callbacks = block.take_callbacks();
parent
.callbacks
.lock()
.unwrap_or_else(PoisonError::into_inner)
.extend(callbacks);
Ok(())
} else {
g.rollback_to(depth).await
}
})
.await;
drop(claim);
let v = res?;
ended?;
Ok(v)
}
#[macro_export]
macro_rules! atomic {
($pool:expr, |$tx:ident| $body:block) => {
async {
let __rustango_atomic_pool = ::core::clone::Clone::clone($pool);
$crate::sql::atomic(&__rustango_atomic_pool, |$tx| {
::std::boxed::Box::pin(async move { $body })
})
.await
}
};
}
pub fn on_commit<F>(f: F)
where
F: FnOnce() + Send + 'static,
{
let block = current().unwrap_or_else(|| {
panic!(
"rustango::sql::on_commit called outside an `atomic` block — \
the callback would never fire. Wrap the caller in \
`atomic(&pool, |tx| async move {{ ... on_commit(...) ... }})`."
);
});
if block.committed.load(Ordering::SeqCst) {
f();
} else {
block
.callbacks
.lock()
.unwrap_or_else(PoisonError::into_inner)
.push(Box::new(f));
}
}
#[must_use]
pub fn on_commit_pending() -> usize {
std::iter::successors(current(), |b| b.enclosing.clone())
.map(|b| {
b.callbacks
.lock()
.unwrap_or_else(PoisonError::into_inner)
.len()
})
.sum()
}