Struct EventBus 

pub struct EventBus { /* private fields */ }

Event bus for publishing and subscribing to node events

The EventBus is the central coordination point for the event system. It allows components to publish events and provides two mechanisms for subscribing to events:

1. Callback-based: Register an EventSubscriber to receive events via callbacks
2. Channel-based: Get a broadcast::Receiver<NodeEvent> for async event processing

Thread Safety

The EventBus is designed to be thread-safe, with all mutable state protected by appropriate synchronization primitives. It can be safely shared across threads using Arc<EventBus>.

Example Usage

use std::sync::Arc;
use tap_node::event::{EventBus, NodeEvent};

async fn example() {
    // Create a new event bus
    let event_bus = Arc::new(EventBus::new());

    // Subscribe to events using a channel
    let mut receiver = event_bus.subscribe_channel();

    // Publish an event using public methods
    let did = "did:example:123".to_string();
    event_bus.publish_agent_registered(did).await;

    // Process events from the channel
    tokio::spawn(async move {
        while let Ok(event) = receiver.recv().await {
            println!("Received event: {:?}", event);
        }
    });
}

Implementations

impl EventBus

pub fn new() -> Self

Create a new event bus

pub async fn subscribe(&self, subscriber: Arc<dyn EventSubscriber>)

Subscribe to node events

pub fn subscribe_channel(&self) -> Receiver<NodeEvent>

Get a receiver for node events

pub async fn unsubscribe(&self, subscriber: &Arc<dyn EventSubscriber>)

Remove a subscriber from the event bus

pub async fn publish_message_received(&self, message: PlainMessage)

Publish a message received event

pub async fn publish_message_sent( &self, message: PlainMessage, from: String, to: String, )

Publish a message sent event

pub async fn publish_agent_registered(&self, did: String)

Publish an agent registered event

pub async fn publish_agent_unregistered(&self, did: String)

Publish an agent unregistered event

pub async fn publish_agent_message(&self, did: String, message: Vec<u8>)

Publish an agent message event

pub async fn publish_did_resolved(&self, did: String, success: bool)

Publish a DID resolved event

pub async fn publish_message_rejected( &self, message_id: String, reason: String, from: String, to: String, )

Publish a message rejected event

pub async fn publish_message_accepted( &self, message_id: String, message_type: String, from: String, to: String, )

Publish a message accepted event

pub async fn publish_reply_received( &self, original_message_id: String, reply_message: PlainMessage, original_message: PlainMessage, )

Publish a reply received event

pub async fn publish_transaction_state_changed( &self, transaction_id: String, old_state: String, new_state: String, agent_did: Option<String>, )

Publish a transaction state changed event

pub async fn publish_decision_required( &self, transaction_id: String, transaction_state: String, decision: Value, pending_agents: Vec<String>, )

Publish a decision required event

pub async fn publish_event(&self, event: NodeEvent)

Publish an event to all subscribers

Trait Implementations

impl Clone for EventBus

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for EventBus

fn default() -> Self

Returns the “default value” for a type.