Crate bromine

source ·
Expand description

This project provides an ipc server and client implementation using messagepack. All calls are asynchronous and event based. Client Example:

use bromine::prelude::*;
use tokio::net::TcpListener;

/// Callback ping function
async fn handle_ping(ctx: &Context, event: Event) -> IPCResult<Response> {
    println!("Received ping event.");
    ctx.emit("pong", ()).await?;

    Ok(Response::empty())
}

pub struct MyNamespace;

impl MyNamespace {
    async fn ping(_ctx: &Context, _event: Event) -> IPCResult<Response> {
        println!("My namespace received a ping");
        Ok(Response::empty())
    }
}

impl NamespaceProvider for MyNamespace {
    fn name() -> &'static str {"my_namespace"}

    fn register(handler: &mut EventHandler) {
        events!(handler,
            "ping" => Self::ping,
            "ping2" => Self::ping
        );
    }
}

#[tokio::main]
async fn main() {
    // create the client
    use std::net::ToSocketAddrs;
let ctx = IPCBuilder::<TcpListener>::new()
        .address("127.0.0.1:2020".to_socket_addrs().unwrap().next().unwrap())
        // register callback
        .on("ping", callback!(handle_ping))
        .namespace("mainspace-client")
        // register callback inline
        .on("something", callback!(ctx, event, async move {
            println!("I think the server did something");
            ctx.emit_to("mainspace-server", "ok", ()).await?;
            Ok(Response::empty())
        }))
        .build()
        .add_namespace(namespace!(MyNamespace))
        .build_client().await.unwrap();

    // emit an initial event
    let response = ctx.emit("ping", ()).await_reply().await.unwrap();
    assert_eq!(response.name(), "pong");
}

Server Example:

use std::net::ToSocketAddrs;
use trait_bound_typemap::{TypeMapKey, TypeMap};
use bromine::IPCBuilder;
use bromine::prelude::*;
use tokio::net::TcpListener;

struct MyKey;

impl TypeMapKey for MyKey {
    type Value = u32;
}

// create the server
IPCBuilder::<TcpListener>::new()
    .address("127.0.0.1:2020".to_socket_addrs().unwrap().next().unwrap())
    // register callback
    .on("ping", callback!(ctx, event, async move {
        println!("Received ping event.");
        ctx.emit("pong", ()).await?;
        Ok(Response::empty())
    }))
    .namespace("mainspace-server")
    .on("do-something", callback!(ctx, event, async move {
        println!("Doing something");
        {
            // access data
            let mut data = ctx.data.write().await;
            let mut my_key = data.get_mut::<MyKey>().unwrap();
            *my_key += 1;
        }
        ctx.emit_to("mainspace-client", "something", ()).await?;
        Ok(Response::empty())
    }))
    .build()
    // store additional data
    .insert::<MyKey>(3)
    .build_server().await.unwrap();

Re-exports§

Modules§

Macros§

Structs§