use crate::bus::{operation, reply_names};
use crate::channels::{BRIDGED_CHANNELS, TRACE_FIELD};
use crate::errors::{BusRequestError, BusRequestErrorCode, TransportError, TransportErrorCode};
use crate::event_bus::EventBus;
use crate::locked;
use crate::transport::{
BoxFuture, ConnectionState, Envelope, Events, Failures, Frame, FrameHub, FrameRefusal, Frames,
PendingReply, ReplyRouter, ResourceHold, STREAM_BACKLOG, Transport,
};
use crate::types::ResourceId;
use serde_json::{Map, Value};
use std::collections::{HashMap, VecDeque};
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use std::time::Duration;
use tokio::sync::{broadcast, watch};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FaultAction {
Deliver,
DropReply,
Delay(Duration),
DuplicateReply,
RejectEmit,
}
#[derive(Debug, Clone, PartialEq)]
pub struct RequestLogEntry {
pub channel: String,
pub action: FaultAction,
pub correlation_id: Option<String>,
pub retry_key: String,
pub payload: Map<String, Value>,
}
pub fn retry_key_of(channel: &str, payload: &Map<String, Value>) -> String {
let mut fields: Vec<(&String, &Value)> = payload
.iter()
.filter(|(key, _)| key.as_str() != TRACE_FIELD && key.as_str() != "_userId")
.collect();
fields.sort_by(|a, b| a.0.cmp(b.0));
let fields: Vec<Value> = fields
.into_iter()
.map(|(key, value)| Value::Array(vec![Value::String(key.clone()), value.clone()]))
.collect();
format!("{channel} {}", Value::Array(fields))
}
pub type MakeResponse =
dyn Fn(&str, &Map<String, Value>) -> Result<Option<Value>, String> + Send + Sync;
pub type Refuse = dyn Fn(&str, &Map<String, Value>) -> Option<Value> + Send + Sync;
struct Inner {
schedule: Vec<FaultAction>,
make_response: Box<MakeResponse>,
refuse: Mutex<Option<Box<Refuse>>>,
replies: Mutex<HashMap<String, VecDeque<Option<Value>>>>,
log: Mutex<Vec<RequestLogEntry>>,
emitted: Mutex<Vec<Frame>>,
held: Mutex<HashMap<ResourceId, usize>>,
requests: AtomicUsize,
hub: FrameHub,
router: Arc<ReplyRouter>,
state: watch::Sender<ConnectionState>,
failures: Mutex<Option<broadcast::Sender<TransportError>>>,
bridges: Mutex<Vec<Arc<EventBus>>>,
closed: AtomicBool,
unnamed: Mutex<Vec<String>>,
}
impl Inner {
fn deliver(&self, carried: Result<Frame, FrameRefusal>) {
if self.closed.load(Ordering::SeqCst) {
return;
}
self.router.route(carried.as_ref());
let channel = match &carried {
Ok(frame) => &frame.channel,
Err(refusal) => &refusal.channel,
};
if BRIDGED_CHANNELS.contains(&channel.as_str()) {
for bus in locked(&self.bridges).iter() {
match &carried {
Ok(frame) => {
bus.emit(
&frame.channel,
frame.payload.clone(),
Envelope {
correlation_id: frame.correlation_id.clone(),
scope: None,
},
);
}
Err(refusal) => {
bus.emit_refusal(FrameRefusal {
scope: None,
..refusal.clone()
});
}
}
}
}
self.hub.deliver(carried);
}
}
#[derive(Clone)]
pub struct FaultyTransport {
inner: Arc<Inner>,
}
impl FaultyTransport {
pub fn new(schedule: Vec<FaultAction>) -> FaultyTransport {
FaultyTransport::answering(schedule, |operation, _| {
Err(format!(
"No response scripted for bus operation \"{operation}\". Script one with queue_reply(\"{operation}\", ...) or build the transport with FaultyTransport::answering."
))
})
}
pub fn answering(
schedule: Vec<FaultAction>,
make_response: impl Fn(&str, &Map<String, Value>) -> Result<Option<Value>, String>
+ Send
+ Sync
+ 'static,
) -> FaultyTransport {
FaultyTransport {
inner: Arc::new(Inner {
schedule,
make_response: Box::new(make_response),
refuse: Mutex::new(None),
replies: Mutex::new(HashMap::new()),
log: Mutex::new(Vec::new()),
emitted: Mutex::new(Vec::new()),
held: Mutex::new(HashMap::new()),
requests: AtomicUsize::new(0),
hub: FrameHub::new(),
router: ReplyRouter::new(),
state: watch::channel(ConnectionState::Open).0,
failures: Mutex::new(Some(broadcast::channel(STREAM_BACKLOG).0)),
bridges: Mutex::new(Vec::new()),
closed: AtomicBool::new(false),
unnamed: Mutex::new(Vec::new()),
}),
}
}
pub fn queue_reply(&self, operation: &str, responses: impl IntoIterator<Item = Option<Value>>) {
locked(&self.inner.replies)
.entry(operation.to_owned())
.or_default()
.extend(responses);
}
pub fn refuse_when(
&self,
refuse: impl Fn(&str, &Map<String, Value>) -> Option<Value> + Send + Sync + 'static,
) {
*locked(&self.inner.refuse) = Some(Box::new(refuse));
}
pub fn fail(&self, error: TransportError) {
if let Some(failures) = locked(&self.inner.failures).as_ref() {
let _ = failures.send(error);
}
}
pub fn request_log(&self) -> Vec<RequestLogEntry> {
locked(&self.inner.log).clone()
}
pub fn emitted(&self) -> Vec<Frame> {
locked(&self.inner.emitted).clone()
}
pub fn holds(&self, resource_id: &ResourceId) -> usize {
locked(&self.inner.held)
.get(resource_id)
.copied()
.unwrap_or(0)
}
pub fn scopes(&self) -> Vec<ResourceId> {
let mut scopes: Vec<ResourceId> = locked(&self.inner.held).keys().cloned().collect();
scopes.sort();
scopes
}
pub fn pending_replies(&self) -> Vec<String> {
self.inner.router.awaited()
}
pub fn set_state(&self, state: ConnectionState) {
if !self.inner.closed.load(Ordering::SeqCst) {
self.inner.state.send_replace(state);
}
}
pub fn deliver(&self, frame: Frame) {
self.inner.deliver(Ok(frame));
}
pub fn deliver_refusal(&self, refusal: FrameRefusal) {
self.inner.deliver(Err(refusal));
}
pub fn unname(&self, channel: &str) {
locked(&self.inner.unnamed).push(channel.to_owned());
}
}
impl Transport for FaultyTransport {
fn base_url(&self) -> &str {
"faulty://simulator"
}
fn emit<'a>(
&'a self,
channel: &'a str,
payload: Map<String, Value>,
envelope: Envelope,
) -> BoxFuture<'a, Result<Option<u64>, TransportError>> {
Box::pin(async move {
let inner = &self.inner;
if inner.closed.load(Ordering::SeqCst) {
return Ok(None);
}
let request = Frame {
channel: channel.to_owned(),
payload: payload.clone(),
correlation_id: envelope.correlation_id.clone(),
scope: envelope.scope.clone(),
trace: None,
};
locked(&inner.emitted).push(request.clone());
let Some(op) = operation(channel) else {
inner.deliver(Ok(request));
return Ok(Some(1));
};
let action = if inner.schedule.is_empty() {
FaultAction::Deliver
} else {
inner.schedule[inner.requests.load(Ordering::SeqCst) % inner.schedule.len()]
};
inner.requests.fetch_add(1, Ordering::SeqCst);
locked(&inner.log).push(RequestLogEntry {
channel: channel.to_owned(),
action,
correlation_id: envelope.correlation_id.clone(),
retry_key: retry_key_of(channel, &payload),
payload: payload.clone(),
});
if action == FaultAction::RejectEmit {
return Err(TransportError::without_response(
format!("FaultyTransport: emit rejected by schedule on {channel}"),
TransportErrorCode::Error,
));
}
let refused = locked(&inner.refuse)
.as_ref()
.and_then(|refuse| refuse(channel, &payload));
let (reply_channel, reply_payload) = match refused {
Some(Value::Object(failure)) => (op.failure, failure),
Some(other) => {
return Err(TransportError::without_response(
format!("FaultyTransport: a failure is a JSON object, not {other}"),
TransportErrorCode::Error,
));
}
None => {
let queued = locked(&inner.replies)
.get_mut(channel)
.and_then(VecDeque::pop_front);
let response = match queued {
Some(response) => response,
None => (inner.make_response)(channel, &payload).map_err(|refusal| {
TransportError::without_response(refusal, TransportErrorCode::Error)
})?,
};
let mut reply_payload = Map::new();
for named in reply_names(channel) {
let stated = payload.get(*named).ok_or_else(|| {
TransportError::without_response(
format!(
"FaultyTransport: the reply to {channel} names \"{named}\", which this request does not state"
),
TransportErrorCode::Error,
)
})?;
reply_payload.insert((*named).to_owned(), stated.clone());
}
if let Some(response) = response {
reply_payload.insert("response".to_owned(), response);
}
(op.result, reply_payload)
}
};
inner.deliver(Ok(request));
let reply = Frame {
channel: reply_channel.to_owned(),
payload: reply_payload,
correlation_id: envelope.correlation_id,
scope: None,
trace: None,
};
let (copies, after) = match action {
FaultAction::Deliver => (1, Duration::ZERO),
FaultAction::DuplicateReply => (2, Duration::ZERO),
FaultAction::Delay(after) => (1, after),
FaultAction::DropReply | FaultAction::RejectEmit => (0, Duration::ZERO),
};
if copies > 0 {
let inner = self.inner.clone();
tokio::spawn(async move {
if !after.is_zero() {
tokio::time::sleep(after).await;
}
for _ in 0..copies {
inner.deliver(Ok(reply.clone()));
}
});
}
Ok(Some(1))
})
}
fn frames(&self, channel: &str) -> Result<Frames, BusRequestError> {
if !self.is_subscribed(channel) {
return Err(BusRequestError::new(
BusRequestErrorCode::Unsubscribed,
format!("FaultyTransport: the stream does not name {channel}"),
));
}
Ok(self.inner.hub.frames(channel))
}
fn is_subscribed(&self, channel: &str) -> bool {
!locked(&self.inner.unnamed)
.iter()
.any(|unnamed| unnamed == channel)
}
fn subscribe_to_resource(&self, resource_id: &ResourceId) -> ResourceHold {
*locked(&self.inner.held)
.entry(resource_id.clone())
.or_insert(0) += 1;
let inner = self.inner.clone();
let resource_id = resource_id.clone();
ResourceHold::new(move || {
let mut held = locked(&inner.held);
if let Some(holds) = held.get_mut(&resource_id) {
*holds -= 1;
if *holds == 0 {
held.remove(&resource_id);
}
}
})
}
fn state(&self) -> watch::Receiver<ConnectionState> {
self.inner.state.subscribe()
}
fn failures(&self) -> Failures {
match locked(&self.inner.failures).as_ref() {
Some(failures) => Events::new(failures.subscribe()),
None => Events::new(broadcast::channel(1).1),
}
}
fn track_reply(&self, correlation_id: &str, reply_channels: &[&str]) -> PendingReply {
self.inner.router.track(correlation_id, reply_channels)
}
fn bridge_into(&self, bus: Arc<EventBus>) {
locked(&self.inner.bridges).push(bus);
}
fn close(&self) -> BoxFuture<'_, ()> {
Box::pin(async move {
if self.inner.closed.swap(true, Ordering::SeqCst) {
return;
}
self.inner.state.send_replace(ConnectionState::Closed);
self.inner.hub.close();
self.inner.router.close();
*locked(&self.inner.failures) = None;
})
}
}