Crate ioevent 

IOEVENT

A lightweight Rust crate for building event-driven applications on top of Tokio’s async I/O streams with low overhead. Facilitates decoupled architectures, suitable for inter-process communication or modular designs.

Features

• Event-driven Architecture: Transforms async I/O operations into unified event streams
• Tokio Integration: Built upon and integrates seamlessly with Tokio’s async runtime
• Extensibility: Supports custom event types and dynamic handler registration
• Bi-directional Communication: Enables event emission and response handling through Procedure Calls

Quick Examples

See full working examples in the examples directory.

Define Events

#[derive(Deserialize, Serialize, Debug, Event)]
pub struct Ping {
    pub timestamp: i64,
}

// Custom event tag
#[derive(Deserialize, Serialize, Debug, Event)]
#[event(tag = "com::demo::my::Event")]
pub struct CustomEvent(pub String, pub i64);

Create Subscribers

#[subscriber]
async fn handle_ping(state: State<AppState>, event: Ping) -> Result {
    state.wright.emit(&Pong { timestamp: event.timestamp })?;
    Ok(())
}

static SUBSCRIBERS: &[Subscriber<AppState>] = &[create_subscriber!(handle_ping)];

Build and Run

// Build the event bus
let subscribers = Subscribers::init(SUBSCRIBERS);
let mut builder = BusBuilder::new(subscribers);
builder.add_pair(IoPair::stdio());
let (bus, effect_wright) = builder.build();

// Run the bus
let state = State::new(AppState {}, effect_wright);
bus.run(state, &|error| { eprintln!("{:?}", error); }).await;

Procedure Call (RPC)

See the complete RPC example in examples/rpc.

Define Procedures

// Custom the path
#[derive(Deserialize, Serialize, Debug, ProcedureCall)]
#[procedure(path = "com::demo::my::CallPrint")]
pub struct CallPrint(pub String);
impl ProcedureCallRequest for CallPrint {
    type RESPONSE = CallPrintResponse;
}

#[derive(Deserialize, Serialize, Debug, ProcedureCall)]
pub struct CallPrintResponse(pub u64);
impl ProcedureCallResponse for CallPrintResponse {}

Handle Procedures

#[procedure]
async fn print_handler(request: CallPrint) -> Result {
    println!("Message: {}", request.0);
    Ok(CallPrintResponse(42))
}

Make Calls

let response = state.call(&CallPrint("Hello".to_string())).await?;
//  ^ CallPrintResponse

License

This project is licensed under the Unlicense - see the LICENSE file for details.

Re-exports

pub use prelude::*;

Modules

bus

Event bus module for managing event communication between different parts of the system.

error

Error handling module for the I/O event system.

event

Core event handling module for the I/O event system.

future

Future types module for the I/O event system.

prelude

rpc

state

State module for managing application state and event shooters.

util

Utility module providing helper types and macros for the I/O event system.

Macros

create_subscriber

A macro for creating a subscriber for a given event type.