moleculer-rs

Inspired and compatible with Moleculer JS

You can currently do all the basics of emit, broadcast and call.

However it only works with the NATS transporter and JSON serializer/deserializer.

Getting Started

Available on crates: crates.io/moleculer

Documentation available at: docs.rs/moleculer

toml moleculer = "0.3.3"

Simple example showing how to receive an event, and responding to a request, for more check the examples folder

```rust use std::error::Error; use moleculer::{ config::{ConfigBuilder, Transporter}, service::{Context, Event, EventBuilder, Service}, ServiceBroker, }; use serde::Deserialize;

[tokio::main]

async fn main() -> eyre::Result<()> { envlogger::init(); coloreyre::install()?;

// build config
let config = ConfigBuilder::default().transporter("nats://localhost:4222")
.build();

// create the first event
let print_hi = EventBuilder::new("printHi").add_callback(print_hi).build();

// create the second event
let print_name = EventBuilder::new("printName")
    .add_callback(print_name)
    .build();

// create math action
let math_action = ActionBuilder::new("mathAdd").add_callback(math_add).build();

// create a service with events and actions
let greeter_service = Service::new("rustGreeter")
    .add_event(print_hi)
    .add_event(print_name)
    .add_action(math_action);

// create service broker with service
let service_broker = ServiceBroker::new(config).add_service(greeter_service);

// start the service broker
service_broker.start().await;

Ok(())

}

// callback for first event, will be called whenever "printHi" event is received fn printhi(ctx: Context) -> Result<(), Box> { println!("Hello from Rust"); Ok(()) }

// callback for second event, will be called whenever "printName" event is received fn printname(ctx: Context) -> Result<(), Box> { let msg: PrintNameMessage = serdejson::from_value(ctx.params)?;

println!("Hello to: {} from Rust", msg.name);

Ok(())

}

// callback for math action fn mathadd(ctx: Context) -> Result<(), Box> { // get message decode using serde let msg: ActionMessage = serdejson::from_value(ctx.params.clone())?; let answer = msg.a + msg.b;

// serialize reply using serde and send reply
let _ = ctx.reply(answer.into());

Ok(())

}

[derive(Deserialize)]

struct PrintNameMessage { name: String, }

[derive(Deserialize)]

struct ActionMessage { a: i32, b: i32, } ```

Current Status

Usable but missing some options

What it does

• Is discoverable by other moleculer clients
• Only NATS transporter
• Only JSON serialization/deserialization
• Can emit and broadcast events
• Can call to send request and wait for response (#20)
• Can respond to events from other molecular clients using callbacks (see: simple event example)
• Can create actions, and respond to requests (#19)

What its missing:

• Tests #17
• Better error handling on actions #24
• Support for different serializer/deserializer #23
• Support for Bulkhead, CircuitBreaker and RetryPolicy
• Support for tracing
• Support for different transporters other than NATS
• Support for different loggers