use std::sync::Mutex;
use super::state::SessionState;
use super::{PendingCommandGuard, SendUserTurnOptions, Session, SessionOpening};
use crate::client::{FacadeResult, lock};
use crate::errors::{MuseError, ProtocolError};
use crate::msp::{LastTurn, TurnStartResult};
use crate::turn::Turn;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PendingTurn {
pub(super) session_id: String,
pub(super) command_id: String,
pub(super) options: SendUserTurnOptions,
pub(super) turn_id: Option<String>,
}
impl PendingTurn {
pub fn session_id(&self) -> &str {
&self.session_id
}
pub fn command_id(&self) -> &str {
&self.command_id
}
pub fn options(&self) -> &SendUserTurnOptions {
&self.options
}
pub fn turn_id(&self) -> Option<&str> {
self.turn_id.as_deref()
}
}
#[allow(clippy::large_enum_variant)]
#[non_exhaustive]
pub enum Reconnected {
Live(Turn),
Ended {
ack: TurnStartResult,
last_turn: LastTurn,
},
}
pub struct ReconnectResolution {
pub command_id: String,
pub result: Result<Reconnected, MuseError>,
}
impl Session {
pub fn pending(&self) -> Vec<PendingTurn> {
lock(&self.inner.state).pending_turns(&self.inner.session_id)
}
pub async fn resolve_reconnect(
&self,
carried: Vec<PendingTurn>,
) -> FacadeResult<Vec<ReconnectResolution>> {
self.inner.ensure_available()?;
if let Some(foreign) = carried
.iter()
.find(|entry| entry.session_id != self.inner.session_id)
{
return Err(ProtocolError::new(
format!(
"pending turn {} belongs to session {}, not {}",
foreign.command_id, foreign.session_id, self.inner.session_id
),
None,
)
.into());
}
let _release = ReleaseSettledAliasHold(&self.inner.state);
let last_turn = match &self.inner.opening {
SessionOpening::Resume(result) => result.last_turn.clone(),
SessionOpening::Start(_) => None,
};
let mut guards: Vec<PendingCommandGuard> = carried
.iter()
.map(|entry| {
PendingCommandGuard::begin(
&self.inner,
entry.command_id.clone(),
entry.options.clone(),
)
})
.collect();
let mut resolutions = Vec::with_capacity(carried.len());
for (entry, guard) in carried.into_iter().zip(guards.iter_mut()) {
let answer = self
.inner
.submit_turn(&entry.command_id, entry.options, guard)
.await;
let result = answer.map(|ack| match &last_turn {
Some(last_turn) if last_turn.turn_id == ack.turn_id => {
lock(&self.inner.state).forget_submission(&entry.command_id);
Reconnected::Ended {
ack,
last_turn: last_turn.clone(),
}
}
_ => Reconnected::Live(self.inner.follow_submitted_turn(
&entry.command_id,
&ack,
None,
)),
});
resolutions.push(ReconnectResolution {
command_id: entry.command_id,
result,
});
}
drop(guards);
Ok(resolutions)
}
}
struct ReleaseSettledAliasHold<'a>(&'a Mutex<SessionState>);
impl Drop for ReleaseSettledAliasHold<'_> {
fn drop(&mut self) {
lock(self.0).release_settled_alias_hold();
}
}