evx 0.1.0

A type-safe event bus for domain events, CQRS, Redis Pub/Sub, and durable work queues
Documentation
//! In-process transport backed by a disruptor ring buffer.

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;

/// Handler map for in-process broker.
type InProcessHandlers =
    Arc<std::sync::RwLock<HashMap<String, Vec<(SubscriptionId, ErasedHandler)>>>>;

/// An in-process broker backed by a disruptor ring buffer.
///
/// Producers synchronously publish into the ring buffer. A dedicated polling
/// thread consumes envelopes and spawns asynchronous handlers on the supplied
/// Tokio runtime. Request-response calls use correlation IDs and one-shot
/// channels over the same ring buffer.
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 {
    /// Creates a broker with a power-of-two ring-buffer capacity.
    ///
    /// Async handlers are spawned on `runtime`; construction panics if
    /// `capacity` is not a power of two.
    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);

        // Factory: create default CloudEvent slots in the ring buffer
        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;

                            // Check for RPC response (_reply.*)
                            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;
                            }

                            // Regular event dispatch
                            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();

        // Store pending request
        self.pending_requests
            .lock()
            .unwrap()
            .insert(correlation_id.clone(), tx);

        // Set correlation metadata
        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));

        // Publish to ring buffer
        self.producer.lock().unwrap().publish(|slot| *slot = event);

        // Wait for response
        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}));
    }
}