juiz_core 0.0.4

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

mod setup_plugins;
mod setup_objects;
mod cleanup_objects;
mod containers;
mod processes;
mod brokers;
mod ecs;
mod components;
mod connections;
mod subsystems;
mod topics;

mod http_broker;
mod ipc_broker;
mod local_broker;

use crate::prelude::*;
pub(crate) use setup_plugins::setup_plugins;
pub(crate) use setup_objects::setup_objects;
pub(crate) use cleanup_objects::cleanup_objects;
use uuid::Uuid;

use crate::brokers::{broker_proxy::TopicBrokerProxy, SystemBrokerProxy};

use super::system::System;


pub(crate) fn setup_topic_synchronization(system: &mut System) -> JuizResult<()> {
    log::trace!("setup_topic_synchronization() called");
    let mut should_request_subscribe_topic_names : Vec<String> = Vec::new();
    let mut should_request_publish_topic_names : Vec<String> = Vec::new();
    system.core_broker().lock_mut().and_then(|mut cb| {
        let system_uuid = Uuid::parse_str(cb.system_uuid()?.as_str().unwrap())?;
        for (topic_name, topic) in cb.worker_mut().store_mut().topics.iter() {
            if topic.num_local_publishers().unwrap() > 0 {
                should_request_subscribe_topic_names.push(topic_name.to_owned());

            }
            if topic.num_local_subscribers().unwrap() > 0 {
                should_request_publish_topic_names.push(topic_name.to_owned());

            }
        }
        for topic_name in should_request_subscribe_topic_names.iter() {
            let _result = cb.topic_request_subscribe(topic_name, Some(system_uuid))?;
        }
        for topic_name in should_request_publish_topic_names.iter() {
            let _result = cb.topic_request_publish(topic_name, Some(system_uuid))?;
        }

        log::trace!("setup_topic_synchronization() exit");
        Ok(())
    })
}

pub(crate) use processes::register_process_factory;
pub(crate) use containers::{register_container_factory, register_container_process_factory};
pub(crate) use components::register_component;


pub(crate) fn setup_ec_activation(system: &mut System) -> JuizResult<()> {
    let ec_ids = system.core_broker().lock()?.ec_list(false)?.as_array().unwrap().iter().map(|v|{v.as_str().unwrap().to_owned()}).collect::<Vec<String>>();
    for ec_id in ec_ids.iter() {
        let ec = system.core_broker().lock()?.worker().ec_from_id(&ec_id)?;
        let prof = juiz_lock(&ec)?.profile_full()?;
        let auto_start = match obj_get_bool(&prof, "auto_start") {
            Ok(v) => v,
            Err(_) => false
        };
        if auto_start {
            juiz_lock(&ec)?.start()?;
        }
    }
    Ok(())
}