organix 0.1.3

Building organic application in rust, leveraging tokio and defining inter communication layer mechanism
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

use std::{collections::HashMap, future::Future};
use tokio::runtime::Handle;

pub struct Runtimes {
    watchdog: Runtime,
    shared: Runtime,
    individuals: HashMap<&'static str, Runtime>,
}

#[derive(Debug)]
pub struct RuntimeConfig {
    pub thread_name: &'static str,
    pub io_driver: bool,
    pub time_driver: bool,
    pub core_threads: Option<usize>,
    pub max_threads: Option<usize>,
    pub thread_stack_size: Option<usize>,
}

pub struct Runtime {
    rt: tokio::runtime::Runtime,
    config: RuntimeConfig,
}

impl Runtimes {
    pub fn new() -> std::io::Result<Self> {
        let watchdog = Runtime::build(RuntimeConfig::watchdog())?;
        let shared = Runtime::build(RuntimeConfig::shared())?;

        Ok(Self {
            watchdog,
            shared,
            individuals: HashMap::new(),
        })
    }

    pub fn watchdog(&self) -> &Runtime {
        &self.watchdog
    }

    pub fn watchdog_mut(&mut self) -> &mut Runtime {
        &mut self.watchdog
    }

    pub fn shared(&self) -> &Runtime {
        &self.shared
    }

    pub fn shared_mut(&mut self) -> &mut Runtime {
        &mut self.shared
    }

    pub fn add(&mut self, rt: Runtime) {
        self.individuals.insert(rt.config.thread_name, rt);
    }

    pub fn individual(&self, k: &'static str) -> Option<&Runtime> {
        self.individuals.get(k)
    }

    pub fn individual_mut(&mut self, k: &'static str) -> Option<&mut Runtime> {
        self.individuals.get_mut(k)
    }
}

impl Runtime {
    pub fn build(config: RuntimeConfig) -> std::io::Result<Self> {
        let mut builder = tokio::runtime::Builder::new();

        builder.thread_name(config.thread_name);

        if config.io_driver {
            builder.enable_io();
        }

        if config.time_driver {
            builder.enable_time();
        }

        if let Some(core_threads) = config.core_threads {
            builder.core_threads(core_threads);
        }

        if let Some(max_threads) = config.max_threads {
            builder.max_threads(max_threads);
        }

        if let Some(thread_stack_size) = config.thread_stack_size {
            builder.thread_stack_size(thread_stack_size);
        }

        builder
            .threaded_scheduler()
            .build()
            .map(|rt| Self { rt, config })
    }

    pub fn handle(&self) -> &Handle {
        self.rt.handle()
    }

    pub fn block_on<F: Future>(&mut self, future: F) -> F::Output {
        self.rt.block_on(future)
    }

    pub fn config(&self) -> &RuntimeConfig {
        &self.config
    }
}

impl RuntimeConfig {
    pub fn new(thread_name: &'static str) -> Self {
        Self {
            thread_name,
            io_driver: false,
            time_driver: false,
            core_threads: None,
            max_threads: None,
            thread_stack_size: None,
        }
    }

    fn watchdog() -> Self {
        Self {
            thread_name: "watchdog",
            io_driver: false,
            time_driver: true,
            core_threads: None,
            max_threads: None,
            thread_stack_size: None,
        }
    }

    fn shared() -> Self {
        Self {
            thread_name: "shared",
            io_driver: true,
            time_driver: true,
            core_threads: None,
            max_threads: None,
            thread_stack_size: None,
        }
    }
}