use crate::Instant;
use crate::{Error, ErrorKind, Result, wire::BsonWriter};
use bson::{
Document, Timestamp,
raw::{RawDocument, RawDocumentBuf},
};
use std::time::Duration;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TransactionState {
None,
Starting,
InProgress,
Committed,
Aborted,
}
#[derive(Debug)]
pub struct Session {
pub id: [u8; 16],
pub txn_number: i64,
pub state: TransactionState,
pub dirty: bool,
pub operation_time: Option<Timestamp>,
pub cluster_time: Option<RawDocumentBuf>,
pub recovery_token: Option<RawDocumentBuf>,
pub transaction_write_concern: Option<RawDocumentBuf>,
pub transaction_read_concern: Option<RawDocumentBuf>,
pub max_commit_time_ms: Option<i64>,
has_operations: bool,
pub pinned_server: Option<String>,
}
impl Session {
pub fn new(id: [u8; 16]) -> Self {
Self {
id,
txn_number: 0,
state: TransactionState::None,
dirty: false,
operation_time: None,
cluster_time: None,
recovery_token: None,
transaction_write_concern: None,
transaction_read_concern: None,
max_commit_time_ms: None,
has_operations: false,
pinned_server: None,
}
}
pub fn start_transaction(&mut self) -> Result<()> {
if matches!(
self.state,
TransactionState::Starting | TransactionState::InProgress
) {
return Err(Error::new(
ErrorKind::InvalidArgument,
"Transaction already in progress",
));
}
self.txn_number = self
.txn_number
.checked_add(1)
.ok_or_else(|| Error::protocol("Transaction number exhausted"))?;
self.state = TransactionState::Starting;
self.recovery_token = None;
self.has_operations = false;
self.pinned_server = None;
Ok(())
}
pub fn next_retryable_write(&mut self) -> Result<()> {
if matches!(
self.state,
TransactionState::Starting | TransactionState::InProgress
) {
return Err(Error::new(
ErrorKind::InvalidArgument,
"Retryable write is inside a transaction",
));
}
self.txn_number = self
.txn_number
.checked_add(1)
.ok_or_else(|| Error::protocol("Transaction number exhausted"))?;
Ok(())
}
pub fn decorate(&mut self, w: &mut BsonWriter, retryable_write: bool) -> Result<()> {
if matches!(
self.state,
TransactionState::Committed | TransactionState::Aborted
) {
self.state = TransactionState::None;
self.recovery_token = None;
self.pinned_server = None;
}
if let Some(t) = &self.cluster_time {
w.document("$clusterTime", t)?;
}
let l = w.start_document("lsid", false)?;
w.binary("id", 4, &self.id)?;
w.end_document(l)?;
if retryable_write
|| matches!(
self.state,
TransactionState::Starting | TransactionState::InProgress
)
{
w.int64("txnNumber", self.txn_number)?;
}
if matches!(
self.state,
TransactionState::Starting | TransactionState::InProgress
) {
w.boolean("autocommit", false)?;
if self.state == TransactionState::Starting {
w.boolean("startTransaction", true)?;
if let Some(c) = &self.transaction_read_concern {
w.document("readConcern", c)?;
}
self.has_operations = true;
self.state = TransactionState::InProgress;
}
}
Ok(())
}
pub fn commit(&mut self, w: &mut BsonWriter, retry: bool) -> Result<bool> {
if self.state == TransactionState::Starting
|| (self.state == TransactionState::Committed && !self.has_operations)
{
self.state = TransactionState::Committed;
return Ok(false);
}
if !matches!(
self.state,
TransactionState::InProgress | TransactionState::Committed
) {
return Err(Error::new(
ErrorKind::InvalidArgument,
if self.state == TransactionState::Aborted {
"Cannot call commitTransaction after calling abortTransaction"
} else {
"No transaction started"
},
));
}
self.end_command(
w,
"commitTransaction",
retry || self.state == TransactionState::Committed,
)?;
self.state = TransactionState::Committed;
Ok(true)
}
pub fn abort(&mut self, w: &mut BsonWriter) -> Result<bool> {
if self.state == TransactionState::Starting {
self.state = TransactionState::Aborted;
return Ok(false);
}
if self.state != TransactionState::InProgress {
return Err(Error::new(
ErrorKind::InvalidArgument,
match self.state {
TransactionState::Committed => {
"Cannot call abortTransaction after calling commitTransaction"
}
TransactionState::Aborted => "Cannot call abortTransaction twice",
_ => "No transaction started",
},
));
}
self.end_command(w, "abortTransaction", false)?;
self.state = TransactionState::Aborted;
Ok(true)
}
fn end_command(&self, w: &mut BsonWriter, name: &str, majority: bool) -> Result<()> {
w.clear();
w.int32(name, 1)?;
let l = w.start_document("lsid", false)?;
w.binary("id", 4, &self.id)?;
w.end_document(l)?;
w.int64("txnNumber", self.txn_number)?;
w.boolean("autocommit", false)?;
if majority {
let c = w.start_document("writeConcern", false)?;
if let Some(wc) = &self.transaction_write_concern {
w.append_fields(wc, &["w"])?;
}
w.string("w", "majority")?;
if self
.transaction_write_concern
.as_ref()
.is_none_or(|wc| wc.get("wtimeout").ok().flatten().is_none())
{
w.int32("wtimeout", 10000)?;
}
w.end_document(c)?;
} else if let Some(wc) = &self.transaction_write_concern {
w.document("writeConcern", wc)?;
}
if let Some(token) = &self.recovery_token {
w.document("recoveryToken", token)?;
}
if let Some(t) = &self.cluster_time {
w.document("$clusterTime", t)?;
}
if name == "commitTransaction"
&& let Some(ms) = self.max_commit_time_ms
{
w.int64("maxTimeMS", ms)?;
}
w.string("$db", "admin")?;
w.finish()?;
Ok(())
}
pub fn observe(&mut self, reply: &Document) {
if matches!(
self.state,
TransactionState::Starting | TransactionState::InProgress | TransactionState::Committed
) && let Ok(token) = reply.get_document("recoveryToken")
{
self.recovery_token = RawDocumentBuf::try_from(token).ok();
}
if let Ok(t) = reply.get_timestamp("operationTime") {
self.operation_time = Some(self.operation_time.map_or(t, |old| old.max(t)));
}
if let Ok(c) = reply.get_document("$clusterTime")
&& let Ok(t) = c.get_timestamp("clusterTime")
&& self
.cluster_time
.as_ref()
.and_then(|d| d.get_timestamp("clusterTime").ok())
.is_none_or(|old| t > old)
{
self.cluster_time = RawDocumentBuf::try_from(c).ok();
}
}
pub fn decorate_causal_read(&mut self, w: &mut BsonWriter, level: Option<&str>) -> Result<()> {
if matches!(
self.state,
TransactionState::Starting | TransactionState::InProgress
) {
return Err(Error::new(
ErrorKind::InvalidArgument,
"Use transaction readConcern for transaction operations",
));
}
self.decorate(w, false)?;
if level.is_some() || self.operation_time.is_some() {
let c = w.start_document("readConcern", false)?;
if let Some(level) = level {
w.string("level", level)?;
}
if let Some(t) = self.operation_time {
w.timestamp("afterClusterTime", t)?;
}
w.end_document(c)?;
}
Ok(())
}
pub fn observe_recovery_token(&mut self, reply: &RawDocument) -> Result<()> {
if let Some(t) = reply
.get("recoveryToken")
.ok()
.flatten()
.and_then(|v| v.as_document())
{
self.recovery_token = Some(
RawDocumentBuf::from_bytes(t.as_bytes().to_vec())
.map_err(|_| Error::protocol("Invalid recovery token"))?,
);
}
Ok(())
}
pub fn pin(&mut self, address: &str) -> Result<()> {
if self.pinned_server.as_ref().is_some_and(|a| a != address) {
return Err(Error::protocol("Transaction is pinned to another mongos"));
}
if self.pinned_server.is_none() {
self.pinned_server = Some(address.into());
}
Ok(())
}
pub fn unpin_on_error(&mut self, error: &Error) {
if error.has_label("TransientTransactionError")
|| error.has_label("UnknownTransactionCommitResult")
{
self.pinned_server = None;
}
}
pub fn retry_abort(&self, w: &mut BsonWriter) -> Result<()> {
if self.state != TransactionState::Aborted {
return Err(Error::protocol("No abort attempt to retry"));
}
self.end_command(w, "abortTransaction", false)
}
pub fn retry_commit(error: &Error) -> bool {
matches!(error.kind, ErrorKind::Network | ErrorKind::Timeout)
|| error.has_label("RetryableWriteError")
}
}
#[derive(Default, Debug)]
pub struct ChangeStream {
pub resume_token: Option<Document>,
pub start_after: bool,
pub received_document: bool,
pub operation_time: Option<Timestamp>,
pub resumed: bool,
}
impl ChangeStream {
pub fn observe_document(&mut self, event: &RawDocument) -> Result<()> {
let id = event.get_document("_id").map_err(|_| {
Error::protocol("Cannot provide resume functionality when the resume token is missing")
})?;
self.resume_token = Some(
id.try_into()
.map_err(|_| Error::protocol("Invalid resume token"))?,
);
self.received_document = true;
self.resumed = false;
Ok(())
}
pub fn finish_batch(&mut self, token: Option<&RawDocument>) -> Result<()> {
self.resumed = false;
if let Some(t) = token {
self.resume_token = Some(
t.try_into()
.map_err(|_| Error::protocol("Invalid post batch resume token"))?,
);
}
Ok(())
}
pub fn stage(&self) -> Document {
let mut options = Document::new();
if let Some(t) = &self.resume_token {
options.insert(
if self.start_after && !self.received_document {
"startAfter"
} else {
"resumeAfter"
},
t.clone(),
);
} else if let Some(t) = self.operation_time {
options.insert("startAtOperationTime", t);
}
bson::doc! {"$changeStream":options}
}
pub fn should_resume(&mut self, error: &Error, wire_version: i32) -> bool {
if self.resumed {
return false;
}
let allowed = matches!(error.kind, ErrorKind::Network | ErrorKind::Timeout)
|| if wire_version >= 9 {
error.has_label("ResumableChangeStreamError")
} else {
error.code.is_some_and(|c| {
matches!(
c,
6 | 7
| 43
| 63
| 89
| 91
| 150
| 189
| 234
| 262
| 9001
| 10107
| 11600
| 11602
| 13388
| 13435
| 13436
)
})
};
if allowed {
self.resumed = true;
}
allowed
}
}
#[derive(Default)]
pub struct SessionPool {
idle: Vec<(Session, Instant)>,
timeout: Duration,
}
impl SessionPool {
pub fn new(logical_timeout: Duration) -> Self {
Self {
idle: Vec::with_capacity(16),
timeout: logical_timeout.saturating_sub(Duration::from_secs(60)),
}
}
pub fn checkout(&mut self, now: Instant) -> Option<Session> {
self.handle_timeout(now);
self.idle.pop().map(|(s, _)| s)
}
pub fn checkin(&mut self, mut session: Session, now: Instant) -> bool {
if session.dirty
|| matches!(
session.state,
TransactionState::Starting | TransactionState::InProgress
)
|| self.timeout.is_zero()
{
return false;
}
session.state = TransactionState::None;
session.operation_time = None;
session.cluster_time = None;
session.recovery_token = None;
session.pinned_server = None;
session.has_operations = false;
session.transaction_read_concern = None;
session.transaction_write_concern = None;
session.max_commit_time_ms = None;
self.idle.push((session, now));
true
}
pub fn next_timeout(&self) -> Option<Instant> {
self.idle
.iter()
.filter_map(|(_, at)| at.checked_add(self.timeout))
.min()
}
pub fn handle_timeout(&mut self, now: Instant) {
self.idle
.retain(|(_, at)| now.saturating_duration_since(*at) < self.timeout);
}
pub fn len(&self) -> usize {
self.idle.len()
}
pub fn is_empty(&self) -> bool {
self.idle.is_empty()
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum EndKind {
Commit,
Abort,
}
#[derive(Debug)]
pub enum EndAction {
Retry,
Complete,
Failed(Error),
}
pub struct TransactionEnd {
pub kind: EndKind,
retried: bool,
}
impl TransactionEnd {
pub fn new(kind: EndKind) -> Self {
Self {
kind,
retried: false,
}
}
pub fn failed(
&mut self,
session: &mut Session,
mut error: Error,
wire_version: i32,
writer: &mut BsonWriter,
) -> Result<EndAction> {
let retry = crate::retry::Retry {
kind: crate::retry::RetryKind::Write,
enabled: true,
attempts: u8::from(self.retried),
in_transaction: false,
wire_version,
sessions_supported: true,
standalone: false,
acknowledged: true,
}
.allowed(&error);
if retry {
self.retried = true;
session.pinned_server = None;
match self.kind {
EndKind::Commit => {
session.commit(writer, true)?;
}
EndKind::Abort => session.retry_abort(writer)?,
}
return Ok(EndAction::Retry);
}
if self.kind == EndKind::Abort {
session.pinned_server = None;
return Ok(EndAction::Complete);
}
let concern = error
.response
.as_ref()
.is_some_and(|r| r.contains_key("writeConcernError"))
&& !matches!(error.code, Some(79 | 100));
if (matches!(
error.kind,
ErrorKind::Network
| ErrorKind::Timeout
| ErrorKind::PoolCleared
| ErrorKind::ServerSelectionTimeout
) || error.has_label("RetryableWriteError")
|| error.code == Some(50)
|| concern)
&& !error.has_label("UnknownTransactionCommitResult")
{
error.labels.push("UnknownTransactionCommitResult".into());
}
session.unpin_on_error(&error);
Ok(EndAction::Failed(error))
}
}