acts 0.19.0

a fast, lightweight, extensiable workflow engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use crate::{ActPlugin, ActRunAs, Engine};
use std::sync::{Arc, Mutex};

use serial_test::serial;
#[serial]
#[tokio::test(flavor = "multi_thread")]
async fn plugin_common_register() {
    let test_plugin = TestPlugin::new();
    Engine::new().add_plugin(&test_plugin).start().unwrap();
    assert!(*test_plugin.is_init.lock().unwrap());
}

#[serial]
#[tokio::test(flavor = "multi_thread")]
async fn plugin_package_register() {
    let test_plugin = TestPackagePlugin;
    let engine = Engine::new().add_plugin(&test_plugin).start().unwrap();
    let pack1 = engine.executor().pack().get("test_package").unwrap();
    assert_eq!(pack1.run_as, ActRunAs::Irq);

    let pack2 = engine.executor().pack().get("test_package2").unwrap();
    assert_eq!(pack2.run_as, ActRunAs::Msg);
}

#[derive(Debug, Clone)]
struct TestPlugin {
    is_init: Arc<Mutex<bool>>,
}

impl TestPlugin {
    fn new() -> Self {
        Self {
            is_init: Arc::new(Mutex::new(false)),
        }
    }
}

#[async_trait::async_trait]
impl ActPlugin for TestPlugin {
    fn on_init(&self, engine: &Engine) -> crate::Result<()> {
        println!("TestPlugin");
        *self.is_init.lock().unwrap() = true;

        // engine.register_module("name", module);
        let emitter = engine.channel();
        emitter.on_start(|_w| {});
        emitter.on_complete(|_w| {});

        emitter.on_message(|_msg| {});

        Ok(())
    }
}

#[derive(Debug, Clone)]
struct TestPackagePlugin;

#[async_trait::async_trait]
impl ActPlugin for TestPackagePlugin {
    fn on_init(&self, engine: &Engine) -> crate::Result<()> {
        println!("TestPackagePlugin");

        engine.extender().register_package(&crate::ActPackageMeta {
            id: "test_package",
            name: "test_package",
            desc: "test package description",
            icon: "test_package_icon",
            doc: "test package doc",
            version: "0.1.0",
            schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "v1": { "type": "number" }
                }
            }),
            options: Some(serde_json::json!({
                "v1": {
                    "ui:widget": "text",
                }
            })),
            run_as: crate::ActRunAs::Irq,
            resources: vec![],
            catalog: crate::ActPackageCatalog::App,
        })?;

        engine.extender().register_package(&crate::ActPackageMeta {
            id: "test_package2",
            name: "test_package2",
            desc: "test package description",
            icon: "test_package_icon",
            doc: "test package doc",
            version: "0.1.0",
            schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "v1": { "type": "number" }
                }
            }),
            options: Some(serde_json::json!({
                "v1": {
                    "ui:widget": "text",
                }
            })),
            run_as: crate::ActRunAs::Msg,
            resources: vec![],
            catalog: crate::ActPackageCatalog::App,
        })?;
        Ok(())
    }
}