my-ecs 0.1.2

An Entity Component System (ECS) library
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

#[cfg(not(target_arch = "wasm32"))]
fn main() {
    non_web::good_example();
    non_web::bad_example();
}

#[cfg(target_arch = "wasm32")]
fn main() {}

#[cfg(not(target_arch = "wasm32"))]
mod non_web {
    use futures::{channel::oneshot, select, FutureExt};
    use my_ecs::prelude::*;
    use std::{
        thread,
        time::{Duration, Instant},
    };

    pub(super) fn good_example() {
        // Creates instance with two groups.
        let mut ecs = Ecs::create(WorkerPool::with_len(2), [1, 1]);

        let (exit_tx, exit_rx) = oneshot::channel();

        // Runs as follows.
        // - Async io tasks in group 0.
        // - Compute tasks in group 1.

        ecs.add_once_systems((
            move |rr: ResRead<Post>| rr.send_future(async_io_server(exit_rx)),
            move |rr: ResRead<Post>| rr.send_future(async_io_client(exit_tx)),
        ))
        .add_system(
            SystemDesc::new()
                .with_group_index(1)
                .with_once(|rr: ResRead<Post>| {
                    rr.send_future(async_compute());
                    rr.send_future(async_compute());
                }),
        )
        .unwrap();

        print!("[GOOD example] ");
        ecs.run(|_| {});
    }

    pub(super) fn bad_example() {
        // Creates instance.
        let mut ecs = Ecs::create(WorkerPool::with_len(2), [2]);

        let (exit_tx, exit_rx) = oneshot::channel();

        // Runs as follows.
        // - Async io tasks in group 0.
        // - Compute tasks in group 0.

        ecs.add_once_systems((
            move |rr: ResRead<Post>| rr.send_future(async_io_server(exit_rx)),
            |rr: ResRead<Post>| {
                rr.send_future(async_compute());
                rr.send_future(async_compute());
            },
            move |rr: ResRead<Post>| {
                rr.send_future(async_io_client(exit_tx));
            },
        ))
        .unwrap();

        print!("[BAD example] ");
        ecs.run(|_| {});
    }

    // Function that needs to respond quickly.
    async fn async_io_server(exit_rx: oneshot::Receiver<()>) -> DynResult<()> {
        let mut server = tide::new();
        server.at("/health").get(|_| async { Ok("ok") });

        select! {
            _ = server.listen("127.0.0.1:48080").fuse() => {},
            _ = exit_rx.fuse() => {},
        };
        Ok(())
    }

    // Function that hopes quick response.
    async fn async_io_client(exit_tx: oneshot::Sender<()>) -> DynResult<()> {
        let start = Instant::now();

        let body = surf::get("http://127.0.0.1:48080/health")
            .await?
            .body_string()
            .await?;
        assert_eq!(&body, "ok");

        let elapsed = start.elapsed();
        println!("GET /health : Took {elapsed:?}");

        drop(exit_tx);
        Ok(())
    }

    // Function that takes a little bit long.
    async fn async_compute() -> DynResult<()> {
        thread::sleep(Duration::from_secs(1));
        Ok(())
    }
}