Appliance

Overview

Appliance is a lightweight Rust framework for building highly customizable asynchronous components adapted for message-based intercommunications. This project is an attempt to make actix-like approach more flexible by exempting a user from using predefined execution runtimes. With the library you can design any composition logic for async agents avoiding data races and unnecessary locks.

Features

• Explicit control over agent lifecycle (no global runtime).
• Equipping agents with customized async executors.
• Minimal overhead when calling handlers (no traits used).

Installation

The recommended way to use this library is to add it as a dependency in your Cargo.toml file:

[dependencies] appliance = "0.1.5"

A quick ping-pong example

```rust use appliance::Appliance; use std::{ sync::{Arc, Weak}, thread, time::Duration, };

enum PingMessage { RegisterPong(Weak>), Send(i16), }

[derive(Default)]

struct PingState { pong: Weak>, }

fn pinghandler(state: &mut PingState, message: PingMessage) { match message { PingMessage::RegisterPong(pong) => state.pong = pong, PingMessage::Send(c) => { if let Some(pong) = &state.pong.upgrade() { println!("ping received {}", c); let _ = pong.send(PongMessage::Send(c + 1)); thread::sleep(Duration::fromsecs(1)); } } } }

enum PongMessage { RegisterPing(Weak>), Send(i16), }

[derive(Default)]

struct PongState { ping: Weak>, }

fn ponghandler(state: &mut PongState, message: PongMessage) { match message { PongMessage::RegisterPing(ping) => state.ping = ping, PongMessage::Send(c) => { if let Some(ping) = &state.ping.upgrade() { println!("pong received {}", c); let _ = ping.send(PingMessage::Send(c + 1)); thread::sleep(Duration::fromsecs(1)); } } } }

fn main() { let executor = &appliance::DEFAULTEXECUTOR; // Create ping appliance. let pingstate: PingState = Default::default(); let ping = Arc::new(Appliance::newunbounded(executor, pingstate, pinghandler)); // Create pong appliance. let pongstate: PongState = Default::default(); let pong = Arc::new(Appliance::newunbounded(executor, pongstate, ponghandler)); // Cross-register appliances. let _ = ping.send(PingMessage::RegisterPong(Arc::downgrade(&pong))); let _ = pong.send(PongMessage::RegisterPing(Arc::downgrade(&ping))); // Ignite ping-pong. let _ = ping.send(PingMessage::Send(0)); thread::sleep(Duration::fromsecs(5)); } ```