juiz_core 0.0.9

Core library for JUIZ application. This package is not required if you want to build juiz functional module.
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

use juiz_sdk::{anyhow::Context, process_identifier::ProcessIdentifier};
use std::sync::{Arc, Mutex};

use crate::{
    ecs::{
        execution_context_function::ExecutionContextFunction,
        execution_context_holder_factory::ExecutionContextHolderFactory, ExecutionContextFactory,
    },
    plugin::{concat_dirname, plugin_name_to_file_name, RustPlugin},
    prelude::*,
};

pub(super) fn setup_execution_context_factories(
    system: &System,
    manifest: &Value,
) -> JuizResult<()> {
    log::trace!("system_builder::setup_execution_context_factories() called");
    for (name, value) in get_hashmap(manifest)?.iter() {
        log::debug!("ExecutionContextFactory (name={name:}, value='{value:}') Loading...");
        let working_dir = None;
        let plugin_filename = concat_dirname(value, plugin_name_to_file_name(name), working_dir)?;

        log::debug!(" - filename: {plugin_filename:?}");
        let cpf;
        unsafe {
            type ECFactorySymbolType<'a> = libloading::Symbol<
                'a,
                unsafe extern "Rust" fn() -> JuizResult<Arc<Mutex<dyn ExecutionContextFactory>>>,
            >;
            let plugin: RustPlugin = RustPlugin::load(plugin_filename)?;
            {
                let symbol =
                    plugin.load_symbol::<ECFactorySymbolType>(b"execution_context_factory")?;
                cpf = (symbol)().with_context(|| {
                    format!("calling symbol 'execution_context_factory'. arg is {manifest:}")
                })?;
                let _ccpf = juiz_lock(&cpf)?;
            }
            system
                .core_broker()
                .lock_mut()?
                .worker_mut()
                .store_mut()
                .ecs
                .register_factory(ExecutionContextHolderFactory::new(Some(plugin), cpf)?)?;
        }
        log::info!("ExecutionContextFactory (name={name:}) Loaded");
    }
    Ok(())
}

pub(super) fn setup_main_loop_ec_factory(system: &mut System) -> JuizResult<()> {
    log::trace!("【呼出】setup_main_loop_ec()");
    let ecf = crate::ecs::main_loop_ec::execution_context_factory()?;
    system
        .core_broker()
        .lock_mut()?
        .worker_mut()
        .store_mut()
        .ecs
        .register_factory(ExecutionContextHolderFactory::new(None, ecf)?)?;
    Ok(())
}

pub(super) fn setup_ecs(system: &mut System, manifest: &Value) -> JuizResult<()> {
    log::trace!("system_builder::setup_ecs({manifest}) called");
    for p in get_array(manifest)?.iter() {
        let name = obj_get_str(p, "name")?;
        let type_name = obj_get_str(p, "type_name")?;
        log::debug!("ExecutionContext ({:}:{:}) Creating...", name, type_name);
        let ec = system
            .core_broker()
            .lock_mut()?
            .worker_mut()
            .create_ec_ref(p.clone())?;
        log::info!("ExecutionContext ({:}:{:}) Created", name, type_name);
        juiz_lock(&ec)?.on_load(system);
        match obj_get(p, "bind") {
            Err(_) => {}
            Ok(binds_obj) => {
                log::trace!("start bind setup for {binds_obj}");
                for b in get_array(binds_obj)?.iter() {
                    setup_ec_bind(system, Arc::clone(&ec), b)?;
                }
            }
        };
        // match obj_get(p, "auto_start") {
        //     Err(_) => {},
        //     Ok(auto_start_obj) => {
        //         log::trace!("start ec setup for {auto_start_obj}");
        //         match auto_start_obj.as_bool() {
        //             Some(flag) => {
        //                 if flag {
        //                     juiz_lock(&ec)?.start()?;
        //                 }
        //             }
        //             None => {},
        //         }
        //     }
        // };
    }
    Ok(())
}

pub(super) fn cleanup_ecs(system: &System) -> JuizResult<()> {
    log::trace!("system_builder::cleanup_ecs() called");
    system.core_broker().lock_mut()?.worker_mut().cleanup_ecs()
}

fn setup_ec_bind(
    system: &System,
    ec: Arc<Mutex<dyn ExecutionContextFunction>>,
    bind_info: &Value,
) -> JuizResult<()> {
    let ec_id = juiz_lock(&ec)?.identifier().clone();
    log::trace!("system_builder::setup_ec_bind(ec={:}) called", ec_id);
    let target_process = system
        .core_broker()
        .lock_mut()?
        .worker_mut()
        .any_process_from_identifier(&ProcessIdentifier::from_value(bind_info)?, false)?;
    let proc_id = target_process.identifier().clone();
    log::trace!("EC({:}) -> Process({:})", ec_id, proc_id);
    let ret = juiz_lock(&ec)?.bind(target_process);
    log::info!("EC({:}) -> Process({:}) Bound", ec_id, proc_id);
    ret
}