kael 0.2.0

GPU-accelerated native UI framework for Rust — build desktop apps with Metal, DirectX, and Vulkan rendering
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use std::{
    sync::{Arc, Mutex},
    time::{Duration, Instant},
};

use kael::{ExecutionModel, ExtensionHostRuntime, PluginManifestBuilder, SupervisorEvent};

fn extension_child_path() -> &'static str {
    env!("CARGO_BIN_EXE_kael-extension-child")
}

#[test]
fn external_process_extension_activates_and_deactivates() {
    let tmp = std::env::temp_dir().join(format!(
        "kael-extension-process-test-{}",
        std::process::id()
    ));
    let _ = std::fs::remove_dir_all(&tmp);
    std::fs::create_dir_all(&tmp).unwrap();

    let manifest = PluginManifestBuilder::new(
        "com.kael.integration.extension",
        "Integration Extension",
        "1.0.0",
        "1.0.0",
        extension_child_path(),
        ExecutionModel::ExternalProcess,
    )
    .build()
    .unwrap();

    let mut runtime = ExtensionHostRuntime::new(tmp.join("extensions"), "test-app");
    runtime.load(manifest).unwrap();
    runtime
        .activate("com.kael.integration.extension")
        .expect("extension activates through real child process");

    assert!(
        runtime
            .get("com.kael.integration.extension")
            .unwrap()
            .is_active
    );
    assert_eq!(runtime.active().len(), 1);

    runtime
        .deactivate("com.kael.integration.extension")
        .expect("extension deactivates cleanly");
    assert!(
        !runtime
            .get("com.kael.integration.extension")
            .unwrap()
            .is_active
    );

    let _ = std::fs::remove_dir_all(&tmp);
}

#[test]
fn external_process_extension_handles_commands_and_contributions() {
    let tmp = std::env::temp_dir().join(format!("kael-extension-rpc-test-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&tmp);
    std::fs::create_dir_all(&tmp).unwrap();

    let manifest = PluginManifestBuilder::new(
        "com.kael.integration.rpc",
        "Integration RPC Extension",
        "1.0.0",
        "1.0.0",
        extension_child_path(),
        ExecutionModel::ExternalProcess,
    )
    .build()
    .unwrap();

    let mut runtime = ExtensionHostRuntime::new(tmp.join("extensions"), "test-app-rpc");
    runtime.load(manifest).unwrap();
    runtime.activate("com.kael.integration.rpc").unwrap();

    runtime
        .send_command("com.kael.integration.rpc", "integration.echo", None)
        .expect("extension command returns ack");

    let contributions = runtime
        .request_contributions("com.kael.integration.rpc")
        .expect("extension returns contributions over RPC");
    assert_eq!(contributions.commands.len(), 1);
    assert_eq!(contributions.commands[0].id, "integration.echo");

    runtime.deactivate("com.kael.integration.rpc").unwrap();
    let _ = std::fs::remove_dir_all(&tmp);
}

#[test]
fn external_process_extension_crash_is_reported() {
    let tmp =
        std::env::temp_dir().join(format!("kael-extension-crash-test-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&tmp);
    std::fs::create_dir_all(&tmp).unwrap();

    let events = Arc::new(Mutex::new(Vec::new()));
    let mut runtime = ExtensionHostRuntime::new(tmp.join("extensions"), "test-app-crash");
    runtime.supervisor_mut().on_event({
        let events = Arc::clone(&events);
        move |event| events.lock().unwrap().push(event)
    });

    let manifest = PluginManifestBuilder::new(
        "com.kael.integration.crash",
        "Integration Crash Extension",
        "1.0.0",
        "1.0.0",
        extension_child_path(),
        ExecutionModel::ExternalProcess,
    )
    .build()
    .unwrap();

    runtime.load(manifest).unwrap();
    runtime.activate("com.kael.integration.crash").unwrap();
    let process_id = runtime
        .get("com.kael.integration.crash")
        .and_then(|info| info.process_id)
        .expect("extension has process id");

    let result = runtime.send_command("com.kael.integration.crash", "integration.crash", None);
    assert!(result.is_err(), "crashing command should break RPC");

    let deadline = Instant::now() + Duration::from_secs(5);
    loop {
        if events
            .lock()
            .unwrap()
            .iter()
            .any(|event| matches!(event, SupervisorEvent::Exited { id, .. } if *id == process_id))
        {
            break;
        }

        assert!(
            Instant::now() < deadline,
            "extension exit event was not observed"
        );
        std::thread::sleep(Duration::from_millis(50));
    }

    let _ = std::fs::remove_dir_all(&tmp);
}