use super::{key::TransactionRole, TransactionState};
use crate::platform::sync::Mutex;
use crate::prelude::*;
#[derive(Default)]
pub(crate) struct InviteUsage {
client_pending: bool,
server_pending: bool,
server_waiting_ack: usize,
}
enum Phase {
ClientPending,
ServerPending,
ServerWaitingAck,
}
pub(crate) struct InviteReservation {
usage: Arc<Mutex<InviteUsage>>,
phase: Option<Phase>,
}
impl InviteReservation {
pub(crate) fn acquire(
usage: &Arc<Mutex<InviteUsage>>,
role: TransactionRole,
) -> core::result::Result<Self, TransactionRole> {
let mut state = usage.lock();
if state.client_pending {
return Err(TransactionRole::Client);
}
if state.server_pending
|| (role == TransactionRole::Client && state.server_waiting_ack != 0)
{
return Err(TransactionRole::Server);
}
let phase = match role {
TransactionRole::Client => {
state.client_pending = true;
Phase::ClientPending
}
TransactionRole::Server => {
state.server_pending = true;
Phase::ServerPending
}
};
Ok(Self {
usage: usage.clone(),
phase: Some(phase),
})
}
pub(crate) fn transition(&mut self, state: &TransactionState) {
match (&self.phase, state) {
(
Some(Phase::ClientPending),
TransactionState::Completed | TransactionState::Accepted,
)
| (_, TransactionState::Confirmed | TransactionState::Terminated) => self.release(),
(
Some(Phase::ServerPending),
TransactionState::Completed | TransactionState::Accepted,
) => {
let mut usage = self.usage.lock();
usage.server_pending = false;
usage.server_waiting_ack += 1;
self.phase = Some(Phase::ServerWaitingAck);
}
_ => (),
}
}
fn release(&mut self) {
if let Some(phase) = self.phase.take() {
let mut usage = self.usage.lock();
match phase {
Phase::ClientPending => usage.client_pending = false,
Phase::ServerPending => usage.server_pending = false,
Phase::ServerWaitingAck => usage.server_waiting_ack -= 1,
}
}
}
}
impl Drop for InviteReservation {
fn drop(&mut self) {
self.release();
}
}