use std::collections::HashMap;
use std::sync::{
Arc, Mutex,
atomic::{AtomicBool, Ordering},
};
use std::time::Duration;
use async_trait::async_trait;
use disruptor::{BusySpin, Polling, Producer, SingleConsumerBarrier, build_multi_producer};
use tokio::sync::oneshot;
use tracing::Instrument;
use crate::broker::{Broker, ErasedHandler, SubscriptionId};
use crate::error::EventError;
use crate::event::cloud::CloudEvent;
use crate::event::scope::EventScope;
type InProcessHandlers =
Arc<std::sync::RwLock<HashMap<String, Vec<(SubscriptionId, ErasedHandler)>>>>;
pub struct InProcessBroker {
producer: Mutex<disruptor::MultiProducer<CloudEvent, SingleConsumerBarrier>>,
handlers: InProcessHandlers,
pending_requests: Arc<Mutex<HashMap<String, oneshot::Sender<CloudEvent>>>>,
shutdown: Arc<AtomicBool>,
thread_handle: Mutex<Option<std::thread::JoinHandle<()>>>,
}
impl InProcessBroker {
pub fn new(capacity: usize, runtime: tokio::runtime::Handle) -> Self {
assert!(
capacity.is_power_of_two(),
"capacity must be a power of two, got {capacity}"
);
let handlers: InProcessHandlers = Arc::new(std::sync::RwLock::new(HashMap::new()));
let pending_requests: Arc<Mutex<HashMap<String, oneshot::Sender<CloudEvent>>>> =
Arc::new(Mutex::new(HashMap::new()));
let shutdown = Arc::new(AtomicBool::new(false));
let h = Arc::clone(&handlers);
let pr = Arc::clone(&pending_requests);
let s = Arc::clone(&shutdown);
let factory = || CloudEvent {
id: String::new(),
source: String::new(),
specversion: "1.0".into(),
r#type: String::new(),
data: serde_json::Value::Null,
datacontenttype: None,
dataschema: None,
subject: None,
time: chrono::Utc::now(),
scope: EventScope::Process,
extensions: HashMap::new(),
span: None,
};
let (mut poller, builder) =
build_multi_producer(capacity, factory, BusySpin).new_event_poller();
let producer = builder.build();
let thread_handle = std::thread::spawn(move || {
loop {
if s.load(Ordering::Relaxed) {
break;
}
match poller.poll() {
Ok(mut events) => {
for event in &mut events {
let event_type = &event.r#type;
if event_type.starts_with("_reply.")
&& let Some(corr) = event
.extensions
.get("correlationid")
.and_then(|v: &serde_json::Value| v.as_str())
&& let Some(sender) = pr.lock().unwrap().remove(corr)
{
let _ = sender.send(event.clone());
continue;
}
let handlers_map = h.read().unwrap();
if let Some(handler_list) = handlers_map.get(event_type) {
let evt = event.clone();
let to_dispatch: Vec<(ErasedHandler, CloudEvent)> = handler_list
.iter()
.map(|(_id, h): &(SubscriptionId, ErasedHandler)| {
(h.clone(), evt.clone())
})
.collect();
drop(handlers_map);
for (h, evt) in to_dispatch {
let span = evt.span.clone().unwrap_or_else(tracing::Span::none);
runtime.spawn(
async move {
if let Err(e) = h(evt).await {
tracing::error!(
error = %e,
"InProcessBroker handler error"
);
}
}
.instrument(span),
);
}
}
}
}
Err(Polling::NoEvents) => {
std::thread::sleep(Duration::from_micros(100));
}
Err(Polling::Shutdown) => break,
}
}
tracing::debug!("InProcessBroker poller thread stopped");
});
Self {
producer: Mutex::new(producer),
handlers,
pending_requests,
shutdown,
thread_handle: Mutex::new(Some(thread_handle)),
}
}
}
#[async_trait]
impl Broker for InProcessBroker {
async fn publish(&self, event: CloudEvent) -> Result<(), EventError> {
self.producer.lock().unwrap().publish(|slot| *slot = event);
Ok(())
}
async fn subscribe(
&self,
event_type: &str,
handler: ErasedHandler,
) -> Result<SubscriptionId, EventError> {
let id = SubscriptionId::new();
self.handlers
.write()
.unwrap()
.entry(event_type.to_string())
.or_default()
.push((id, handler));
Ok(id)
}
async fn unsubscribe(&self, id: SubscriptionId) -> Result<(), EventError> {
let mut handlers = self.handlers.write().unwrap();
for list in handlers.values_mut() {
list.retain(|(sid, _)| *sid != id);
}
Ok(())
}
async fn call(&self, event: CloudEvent, timeout: Duration) -> Result<CloudEvent, EventError> {
let correlation_id = uuid::Uuid::new_v4().to_string();
let reply_channel = format!("_reply.{correlation_id}");
let (tx, rx) = oneshot::channel();
self.pending_requests
.lock()
.unwrap()
.insert(correlation_id.clone(), tx);
let mut event = event;
event.scope = EventScope::Process;
event.extensions.insert(
"correlationid".into(),
serde_json::Value::String(correlation_id.clone()),
);
event
.extensions
.insert("reply_to".into(), serde_json::Value::String(reply_channel));
self.producer.lock().unwrap().publish(|slot| *slot = event);
match tokio::time::timeout(timeout, rx).await {
Ok(Ok(event)) => Ok(event),
Ok(Err(_)) => {
self.pending_requests
.lock()
.unwrap()
.remove(&correlation_id);
Err(EventError::Publish("response channel closed".into()))
}
Err(_) => {
self.pending_requests
.lock()
.unwrap()
.remove(&correlation_id);
Err(EventError::Timeout("call timed out".into()))
}
}
}
async fn shutdown(&self) -> Result<(), EventError> {
self.shutdown.store(true, Ordering::Relaxed);
if let Some(handle) = self.thread_handle.lock().unwrap().take() {
handle
.join()
.map_err(|_| EventError::Shutdown("failed to join poller thread".into()))?;
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
fn runtime() -> tokio::runtime::Handle {
tokio::runtime::Handle::current()
}
fn make_test_event(event_type: &str) -> CloudEvent {
CloudEvent {
id: uuid::Uuid::new_v4().to_string(),
source: "/test".into(),
specversion: "1.0".into(),
r#type: event_type.into(),
data: serde_json::json!({"msg": "hello"}),
datacontenttype: Some("application/json".into()),
dataschema: None,
subject: None,
time: chrono::Utc::now(),
scope: EventScope::Process,
extensions: HashMap::new(),
span: None,
}
}
#[tokio::test]
async fn publish_and_receive() {
let broker = InProcessBroker::new(256, runtime());
let counter = Arc::new(AtomicUsize::new(0));
let c = Arc::clone(&counter);
let handler: ErasedHandler = Arc::new(move |_event: CloudEvent| {
let c = Arc::clone(&c);
Box::pin(async move {
c.fetch_add(1, AtomicOrdering::SeqCst);
Ok(())
})
});
broker.subscribe("test.event", handler).await.unwrap();
broker.publish(make_test_event("test.event")).await.unwrap();
tokio::time::sleep(Duration::from_millis(50)).await;
assert_eq!(counter.load(AtomicOrdering::SeqCst), 1);
}
#[tokio::test]
async fn unsubscribe_stops_delivery() {
let broker = InProcessBroker::new(256, runtime());
let counter = Arc::new(AtomicUsize::new(0));
let c = Arc::clone(&counter);
let handler: ErasedHandler = Arc::new(move |_event: CloudEvent| {
let c = Arc::clone(&c);
Box::pin(async move {
c.fetch_add(1, AtomicOrdering::SeqCst);
Ok(())
})
});
let id = broker.subscribe("test.event", handler).await.unwrap();
broker.unsubscribe(id).await.unwrap();
broker.publish(make_test_event("test.event")).await.unwrap();
tokio::time::sleep(Duration::from_millis(50)).await;
assert_eq!(counter.load(AtomicOrdering::SeqCst), 0);
}
#[tokio::test]
async fn multiple_handlers_same_event() {
let broker = InProcessBroker::new(256, runtime());
let counter = Arc::new(AtomicUsize::new(0));
for _ in 0..3 {
let c = Arc::clone(&counter);
let handler: ErasedHandler = Arc::new(move |_event: CloudEvent| {
let c = Arc::clone(&c);
Box::pin(async move {
c.fetch_add(1, AtomicOrdering::SeqCst);
Ok(())
})
});
broker.subscribe("test.multi", handler).await.unwrap();
}
broker.publish(make_test_event("test.multi")).await.unwrap();
tokio::time::sleep(Duration::from_millis(50)).await;
assert_eq!(counter.load(AtomicOrdering::SeqCst), 3);
}
#[tokio::test]
async fn rpc_call_and_response() {
let broker = Arc::new(InProcessBroker::new(256, runtime()));
let broker2 = Arc::clone(&broker);
let handler: ErasedHandler = Arc::new(move |event: CloudEvent| {
let broker = Arc::clone(&broker2);
Box::pin(async move {
let reply_to = event
.extensions
.get("reply_to")
.and_then(|v: &serde_json::Value| v.as_str())
.map(String::from);
let correlation_id = event
.extensions
.get("correlationid")
.and_then(|v: &serde_json::Value| v.as_str())
.map(String::from);
let mut response = event.clone();
response.data = serde_json::json!({"doubled": 84});
if let (Some(reply_to), Some(corr)) = (reply_to, correlation_id) {
response.r#type = reply_to;
response
.extensions
.insert("correlationid".into(), serde_json::Value::String(corr));
}
broker.publish(response).await
})
});
broker.subscribe("com.test.cmd", handler).await.unwrap();
let request = make_test_event("com.test.cmd");
let response = broker.call(request, Duration::from_secs(5)).await.unwrap();
assert_eq!(response.data, serde_json::json!({"doubled": 84}));
}
}