use parking_lot::RwLock;
use std::sync::Arc;
use tracing::error;
use super::{
PollCompleted, PollFailure, PollSkippedPaused, PollStarted, TaskExecutionCompleted,
TaskExecutionFailure, TaskExecutionStarted, TaskRunnerEventsListener, TaskUpdateCompleted,
TaskUpdateFailure, ThreadUncaughtException, WorkflowStartFailure, WorkflowStarted,
};
pub struct EventDispatcher {
listeners: Arc<RwLock<Vec<Arc<dyn TaskRunnerEventsListener>>>>,
}
impl Default for EventDispatcher {
fn default() -> Self {
Self::new()
}
}
impl Clone for EventDispatcher {
fn clone(&self) -> Self {
Self {
listeners: Arc::clone(&self.listeners),
}
}
}
impl EventDispatcher {
#[must_use]
pub fn new() -> Self {
Self {
listeners: Arc::new(RwLock::new(Vec::new())),
}
}
pub fn register(&self, listener: Arc<dyn TaskRunnerEventsListener>) {
self.listeners.write().push(listener);
}
pub fn clear(&self) {
self.listeners.write().clear();
}
#[must_use]
pub fn listener_count(&self) -> usize {
self.listeners.read().len()
}
#[inline]
fn get_listeners(&self) -> Vec<Arc<dyn TaskRunnerEventsListener>> {
self.listeners.read().clone()
}
pub fn publish_poll_started(&self, event: &PollStarted) {
let listeners = self.get_listeners();
for listener in listeners {
if let Err(e) = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
listener.on_poll_started(event);
})) {
error!("Listener panicked on poll_started: {:?}", e);
}
}
}
pub fn publish_poll_completed(&self, event: &PollCompleted) {
let listeners = self.get_listeners();
for listener in listeners {
if let Err(e) = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
listener.on_poll_completed(event);
})) {
error!("Listener panicked on poll_completed: {:?}", e);
}
}
}
pub fn publish_poll_failure(&self, event: &PollFailure) {
let listeners = self.get_listeners();
for listener in listeners {
if let Err(e) = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
listener.on_poll_failure(event);
})) {
error!("Listener panicked on poll_failure: {:?}", e);
}
}
}
pub fn publish_poll_skipped_paused(&self, event: &PollSkippedPaused) {
let listeners = self.get_listeners();
for listener in listeners {
if let Err(e) = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
listener.on_poll_skipped_paused(event);
})) {
error!("Listener panicked on poll_skipped_paused: {:?}", e);
}
}
}
pub fn publish_task_execution_started(&self, event: &TaskExecutionStarted) {
let listeners = self.get_listeners();
for listener in listeners {
if let Err(e) = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
listener.on_task_execution_started(event);
})) {
error!("Listener panicked on task_execution_started: {:?}", e);
}
}
}
pub fn publish_task_execution_completed(&self, event: &TaskExecutionCompleted) {
let listeners = self.get_listeners();
for listener in listeners {
if let Err(e) = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
listener.on_task_execution_completed(event);
})) {
error!("Listener panicked on task_execution_completed: {:?}", e);
}
}
}
pub fn publish_task_execution_failure(&self, event: &TaskExecutionFailure) {
let listeners = self.get_listeners();
for listener in listeners {
if let Err(e) = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
listener.on_task_execution_failure(event);
})) {
error!("Listener panicked on task_execution_failure: {:?}", e);
}
}
}
pub fn publish_task_update_completed(&self, event: &TaskUpdateCompleted) {
let listeners = self.get_listeners();
for listener in listeners {
if let Err(e) = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
listener.on_task_update_completed(event);
})) {
error!("Listener panicked on task_update_completed: {:?}", e);
}
}
}
pub fn publish_task_update_failure(&self, event: &TaskUpdateFailure) {
let listeners = self.get_listeners();
for listener in listeners {
if let Err(e) = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
listener.on_task_update_failure(event);
})) {
error!("Listener panicked on task_update_failure: {:?}", e);
}
}
}
pub fn publish_thread_uncaught_exception(&self, event: &ThreadUncaughtException) {
let listeners = self.get_listeners();
for listener in listeners {
if let Err(e) = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
listener.on_thread_uncaught_exception(event);
})) {
error!("Listener panicked on thread_uncaught_exception: {:?}", e);
}
}
}
pub fn publish_workflow_started(&self, event: &WorkflowStarted) {
let listeners = self.get_listeners();
for listener in listeners {
if let Err(e) = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
listener.on_workflow_started(event);
})) {
error!("Listener panicked on workflow_started: {:?}", e);
}
}
}
pub fn publish_workflow_start_failure(&self, event: &WorkflowStartFailure) {
let listeners = self.get_listeners();
for listener in listeners {
if let Err(e) = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
listener.on_workflow_start_failure(event);
})) {
error!("Listener panicked on workflow_start_failure: {:?}", e);
}
}
}
}
pub type SyncEventDispatcher = EventDispatcher;
#[cfg(test)]
mod tests {
use super::*;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::time::Duration;
struct CountingListener {
count: AtomicUsize,
}
impl CountingListener {
fn new() -> Self {
Self {
count: AtomicUsize::new(0),
}
}
fn count(&self) -> usize {
self.count.load(Ordering::SeqCst)
}
}
impl TaskRunnerEventsListener for CountingListener {
fn on_poll_started(&self, _event: &PollStarted) {
self.count.fetch_add(1, Ordering::SeqCst);
}
fn on_task_execution_completed(&self, _event: &TaskExecutionCompleted) {
self.count.fetch_add(1, Ordering::SeqCst);
}
}
#[test]
fn test_dispatcher_registration() {
let dispatcher = EventDispatcher::new();
let listener = Arc::new(CountingListener::new());
assert_eq!(dispatcher.listener_count(), 0);
dispatcher.register(listener);
assert_eq!(dispatcher.listener_count(), 1);
dispatcher.clear();
assert_eq!(dispatcher.listener_count(), 0);
}
#[test]
fn test_event_publishing() {
let dispatcher = EventDispatcher::new();
let listener = Arc::new(CountingListener::new());
dispatcher.register(Arc::clone(&listener) as Arc<dyn TaskRunnerEventsListener>);
let event = PollStarted::new("test_task", "worker-1", 10);
dispatcher.publish_poll_started(&event);
assert_eq!(listener.count(), 1);
let event = TaskExecutionCompleted::new(
"test_task",
"task-1",
"wf-1",
"worker-1",
Duration::from_millis(100),
None,
);
dispatcher.publish_task_execution_completed(&event);
assert_eq!(listener.count(), 2);
}
#[test]
fn test_multiple_listeners() {
let dispatcher = EventDispatcher::new();
let listener1 = Arc::new(CountingListener::new());
let listener2 = Arc::new(CountingListener::new());
dispatcher.register(Arc::clone(&listener1) as Arc<dyn TaskRunnerEventsListener>);
dispatcher.register(Arc::clone(&listener2) as Arc<dyn TaskRunnerEventsListener>);
let event = PollStarted::new("test_task", "worker-1", 10);
dispatcher.publish_poll_started(&event);
assert_eq!(listener1.count(), 1);
assert_eq!(listener2.count(), 1);
}
}