use crate::multiplex::MultiplexedConnKey;
use crate::reliable_conn::{ReliableOrderedStreamToTarget, ReliableOrderedStreamToTargetExt};
use crate::sync::subscription::Subscribable;
use crate::sync::subscription::SubscriptionBiStream;
use crate::sync::RelativeNodeType;
use citadel_io::tokio::sync::{Mutex, MutexGuard};
use futures::Future;
use serde::{Deserialize, Serialize};
use std::pin::Pin;
use std::task::{Context, Poll};
pub struct NetSelectOk<'a, R> {
future: Pin<Box<dyn Future<Output = Result<NetSelectOkResult<R>, anyhow::Error>> + Send + 'a>>,
}
impl<'a, R: Send + 'a> NetSelectOk<'a, R> {
pub fn new<
S: Subscribable<ID = K, UnderlyingConn = Conn>,
K: MultiplexedConnKey + 'a,
Conn: ReliableOrderedStreamToTarget + 'static,
F: Future<Output = Result<R, anyhow::Error>> + Send + 'a,
>(
conn: &'a S,
local_node_type: RelativeNodeType,
future: F,
) -> Self {
Self {
future: Box::pin(resolve(conn, local_node_type, future)),
}
}
}
impl<R> Future for NetSelectOk<'_, R> {
type Output = Result<NetSelectOkResult<R>, anyhow::Error>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
self.future.as_mut().poll(cx)
}
}
#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
enum State {
Pending,
ObtainedValidResult,
ResolvedLocalWon,
ResolvedAdjacentWins,
ResolvedBothFail,
NonPreferredFinished,
Error,
Pinging(Option<bool>),
}
impl State {
fn implies_remote_success(&self) -> bool {
matches!(self, Self::ObtainedValidResult | Self::Pinging(Some(true)))
}
fn implies_remote_failure(&self) -> bool {
matches!(self, Self::Error | Self::Pinging(Some(false)))
}
}
#[derive(Debug)]
pub struct NetSelectOkResult<R> {
pub result: Option<R>,
pub other_side_succeeded: bool,
}
impl<R> NetSelectOkResult<R> {
pub fn global_failure(&self) -> bool {
self.result.is_none() && !self.other_side_succeeded
}
}
#[allow(clippy::if_same_then_else)]
async fn resolve<
S: Subscribable<ID = K, UnderlyingConn = Conn>,
K: MultiplexedConnKey,
Conn: ReliableOrderedStreamToTarget + 'static,
F,
R,
>(
conn: &S,
local_node_type: RelativeNodeType,
future: F,
) -> Result<NetSelectOkResult<R>, anyhow::Error>
where
F: Future<Output = Result<R, anyhow::Error>>,
{
let conn = &(conn.initiate_subscription().await?);
log::trace!(target: "citadel", "NET_SELECT_OK started conv={:?} for {:?}", conn.id(), local_node_type);
let (stopper_tx, stopper_rx) = citadel_io::tokio::sync::oneshot::channel::<()>();
struct LocalState<R> {
local_state: State,
ret_value: Option<Result<R, anyhow::Error>>,
}
let local_state = LocalState {
local_state: State::Pending,
ret_value: None,
};
let local_state_ref = &Mutex::new(local_state);
let has_preference = local_node_type == RelativeNodeType::Initiator;
let evaluator = async move {
let _stopper_tx = stopper_tx;
async fn return_sequence<Conn: ReliableOrderedStreamToTarget, R>(
conn: &Conn,
new_state: State,
mut state: MutexGuard<'_, LocalState<R>>,
adjacent_success: bool,
) -> Result<(Option<Result<R, anyhow::Error>>, bool), anyhow::Error> {
state.local_state = new_state.clone();
conn.send_serialized(new_state.clone()).await?;
Ok((state.ret_value.take(), adjacent_success))
}
loop {
log::trace!(target: "citadel", "{local_node_type:?} awaiting ...");
let received_remote_state = conn.recv_serialized::<State>().await?;
log::trace!(target: "citadel", "{:?} RECV'd {:?}", local_node_type, &received_remote_state);
let mut lock = local_state_ref.lock().await;
let local_state_info = lock.ret_value.as_ref().map(|r| r.is_ok());
let adjacent_success = received_remote_state.implies_remote_success();
log::trace!(target: "citadel", "[conv={:?} Node {:?} recv {:?} || Local state: {:?}", conn.id(), local_node_type, received_remote_state, lock.local_state);
if has_preference {
match lock.local_state {
State::ObtainedValidResult => {
return return_sequence(conn, State::ResolvedLocalWon, lock, false).await;
}
State::Error => {
if received_remote_state.implies_remote_success() {
return return_sequence(
conn,
State::ResolvedAdjacentWins,
lock,
adjacent_success,
)
.await;
} else {
if received_remote_state.implies_remote_failure() {
return return_sequence(conn, State::ResolvedBothFail, lock, false)
.await;
} else {
conn.send_serialized(State::Pinging(local_state_info))
.await?;
}
}
}
_ => {
if received_remote_state.implies_remote_success() {
return return_sequence(
conn,
State::ResolvedAdjacentWins,
lock,
adjacent_success,
)
.await;
} else {
if received_remote_state.implies_remote_failure() {
conn.send_serialized(State::Pinging(local_state_info))
.await?;
} else {
conn.send_serialized(State::Pinging(local_state_info))
.await?;
}
}
}
}
} else {
match received_remote_state {
State::ResolvedAdjacentWins => {
lock.local_state = State::ResolvedLocalWon;
return Ok((lock.ret_value.take(), false));
}
State::ResolvedLocalWon => {
lock.local_state = State::ResolvedAdjacentWins;
return Ok((None, true));
}
State::ResolvedBothFail => {
std::mem::drop(lock);
return Ok((None, false));
}
_ => {
conn.send_serialized(State::Pinging(local_state_info))
.await?;
}
}
}
}
};
let completer = async move {
let res = future.await;
let mut local_state = local_state_ref.lock().await;
let state = res
.as_ref()
.map(|_| State::ObtainedValidResult)
.unwrap_or(State::Error);
local_state.local_state = state.clone();
local_state.ret_value = Some(res);
conn.send_serialized(state).await?;
std::mem::drop(local_state);
stopper_rx.await?;
Err(anyhow::Error::msg("Stopped before the resolver"))
};
citadel_io::tokio::select! {
res0 = evaluator => {
log::trace!(target: "citadel", "[conv={:?}] NET_SELECT_OK Ending for {:?}", conn.id(), local_node_type);
let (ret, remote_success) = res0?;
let local_state = local_state_ref.lock().await;
Ok(wrap_return(ret, local_state.local_state == State::ResolvedLocalWon, remote_success))
},
res1 = completer => res1
}
}
fn wrap_return<R>(
result: Option<Result<R, anyhow::Error>>,
did_win: bool,
other_side_succeeded: bool,
) -> NetSelectOkResult<R> {
NetSelectOkResult {
result: if did_win {
result.and_then(|r| r.ok())
} else {
None
},
other_side_succeeded,
}
}
#[cfg(test)]
mod tests {
use crate::sync::network_application::NetworkApplication;
use crate::sync::test_utils::create_streams;
use citadel_io::tokio;
use std::fmt::Debug;
use std::future::Future;
use std::time::Duration;
#[tokio::test]
async fn racer() {
citadel_logging::setup_log();
let (server_stream, client_stream) = create_streams().await;
const COUNT: i32 = 100;
for idx in 0..COUNT {
log::trace!(target: "citadel", "[Meta] ERR:ERR ({idx}/{COUNT})");
inner(
server_stream.clone(),
client_stream.clone(),
dummy_function_err(),
dummy_function_err(),
)
.await;
}
for idx in 0..COUNT {
log::trace!(target: "citadel", "[Meta] OK:OK ({idx}/{COUNT})");
inner(
server_stream.clone(),
client_stream.clone(),
dummy_function(),
dummy_function(),
)
.await;
}
for idx in 0..COUNT {
log::trace!(target: "citadel", "[Meta] ERR:OK ({idx}/{COUNT})");
inner(
server_stream.clone(),
client_stream.clone(),
dummy_function_err(),
dummy_function(),
)
.await;
}
for idx in 0..COUNT {
log::trace!(target: "citadel", "[Meta] OK:ERR ({idx}/{COUNT})");
inner(
server_stream.clone(),
client_stream.clone(),
dummy_function(),
dummy_function_err(),
)
.await;
}
}
async fn inner<
R: Send + Debug + 'static,
F: Future<Output = Result<R, anyhow::Error>> + Send + 'static,
Y: Future<Output = Result<R, anyhow::Error>> + Send + 'static,
>(
conn0: NetworkApplication,
conn1: NetworkApplication,
fx_1: F,
fx_2: Y,
) {
let server = async move {
let res = conn0.net_select_ok(fx_1).await.unwrap();
log::trace!(target: "citadel", "Server res: {res:?}");
res
};
let client = async move {
let res = conn1.net_select_ok(fx_2).await.unwrap();
log::trace!(target: "citadel", "Client res: {res:?}");
res
};
let server = citadel_io::tokio::spawn(server);
let client = citadel_io::tokio::spawn(client);
let (res0, res1) = citadel_io::tokio::join!(server, client);
let (res0, res1) = (res0.unwrap(), res1.unwrap());
if res0.result.is_some() {
assert!(!res0.other_side_succeeded);
assert!(res1.result.is_none());
assert!(res1.other_side_succeeded);
}
if res1.result.is_some() {
assert!(!res1.other_side_succeeded);
assert!(res0.result.is_none());
assert!(res0.other_side_succeeded);
}
if res0.result.is_none() && res1.result.is_none() {
assert!(!res0.other_side_succeeded);
assert!(!res1.other_side_succeeded);
assert!(res0.global_failure());
assert!(res1.global_failure());
}
log::trace!(target: "citadel", "DONE executing")
}
async fn dummy_function() -> Result<(), anyhow::Error> {
citadel_io::time::sleep(Duration::from_millis(50)).await;
Ok(())
}
async fn dummy_function_err() -> Result<(), anyhow::Error> {
Err(anyhow::Error::msg("Error!!"))
}
}