Struct Channel 

pub struct Channel { /* private fields */ }

Just a export struct for the event::Emitter

Implementations

impl Channel

pub fn new(rt: &Arc<Runtime>) -> Self

pub fn channel(rt: &Arc<Runtime>, options: &ChannelOptions) -> Self

create a emit channel to receive message if the message is not received by client, the engine will re-send at the next time interval

pub fn on_message( self: &Arc<Self>, f: impl Fn(&Event<Message>) + Send + Sync + 'static, )

Receive act message

Example

use acts::{Engine, Act, Workflow, Vars, Message};

#[tokio::main]
async fn main() {
    let engine = Engine::new().start();
    let workflow = Workflow::new().with_id("m1").with_step(|step| {
            step.with_id("step1").with_act(Act::irq(|act| act.with_key("act1")))
    });

    engine.channel().on_message(move |e| {
        if e.is_irq() {
            println!("act message: state={} inputs={:?} outputs={:?}", e.state, e.inputs, e.outputs);
        }
    });
    let exec = engine.executor();
    exec.model().deploy(&workflow).expect("fail to deploy workflow");
    let mut vars = Vars::new();
    vars.insert("pid".into(), "w1".into());
    exec.proc().start(
       &workflow.id,
       &vars,
   );
}

pub fn on_start( self: &Arc<Self>, f: impl Fn(&Event<Message>) + Send + Sync + 'static, )

pub fn on_complete( self: &Arc<Self>, f: impl Fn(&Event<Message>) + Send + Sync + 'static, )

pub fn on_error( self: &Arc<Self>, f: impl Fn(&Event<Message>) + Send + Sync + 'static, )

pub fn close(&self)