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

use std::io::prelude::*;
use std::{
    cell::RefCell,
    io::BufReader,
    sync::{Arc, Mutex},
    time::Duration,
};

use crate::prelude::*;
use interprocess::local_socket::{prelude::*, GenericFilePath, Stream};

use crate::brokers::messenger_broker_proxy_factory::create_messenger_broker_proxy_factory;

//use super::ipc_broker::ProxySideSenderReceiverPair;

use crate::brokers::{
    BrokerProxyFactory, MessengerBrokerProxyCore, MessengerBrokerProxyCoreFactory,
};

// pub type IPCBrokerProxy = MessengerBrokerProxy;

#[allow(unused)]
pub struct IPCBrokerProxyCore {
    name: String,
    buf_reader: RefCell<BufReader<Stream>>,
    buf_size: usize,
    //sender_receiver: Arc<Mutex<ProxySideSenderReceiverPair>>,
}

impl IPCBrokerProxyCore {
    //pub fn new(name: &str, buf_reader: BufReader<Stream>, buf_size: usize) -> IPCBrokerProxyCore {
    //    IPCBrokerProxyCore{name: name.to_owned(), buf_reader: RefCell::new(buf_reader), buf_size}
    // }
}

pub struct IPCBrokerProxyCoreFactory {
    //sender_receiver: Arc<Mutex<ProxySideSenderReceiverPair>>,
}

impl IPCBrokerProxyCoreFactory {
    pub fn new() -> JuizResult<Box<dyn MessengerBrokerProxyCoreFactory>> {
        Ok(Box::new(IPCBrokerProxyCoreFactory {}))
    }
}

impl MessengerBrokerProxyCoreFactory for IPCBrokerProxyCoreFactory {
    fn create_core(&self, object_name: &str) -> JuizResult<Box<dyn MessengerBrokerProxyCore>> {
        /* let name = if GenericNamespaced::is_supported() {
            object_name.to_ns_name::<GenericNamespaced>()?
        } else {
            object_name.to_fs_name::<GenericFilePath>()?
        }; */
        let name = format!("/tmp/{:}", object_name).to_fs_name::<GenericFilePath>()?;
        let buf_size: usize = 4096;
        let conn = Stream::connect(name)?;
        Ok(Box::new(IPCBrokerProxyCore {
            name: object_name.to_owned(),
            buf_reader: RefCell::new(BufReader::new(conn)),
            buf_size,
        }))
    }
}

impl MessengerBrokerProxyCore for IPCBrokerProxyCore {
    fn send_and_receive(&self, value: CapsuleMap, _timeout: Duration) -> JuizResult<CapsulePtr> {
        log::trace!("IPCBrokerProxyCore::send_and_receive(value={value:?}) called");
        let mut buffer = String::with_capacity(self.buf_size);
        let v: Value = value.into();
        let strv = v.to_string() + "\n";
        log::trace!(" - payload = {strv:}");
        self.buf_reader
            .borrow_mut()
            .get_mut()
            .write_all(strv.as_bytes())?;

        self.buf_reader.borrow_mut().read_line(&mut buffer)?;
        Ok(juiz_sdk::serde_json::from_str::<Value>(buffer.as_str())?.into())
        //Ok(Value::from(buffer).try_into()?)
    }

    fn send_and_receive_output(
        &self,
        _v: CapsuleMap,
        _timeout: Duration,
    ) -> JuizResult<CapsulePtr> {
        todo!("Outputクラスをどう扱うか。")
    }
}

pub fn create_ipc_broker_proxy_factory() -> JuizResult<Arc<Mutex<dyn BrokerProxyFactory>>> {
    log::trace!("create_ipc_broker_factory called");
    create_messenger_broker_proxy_factory(
        "IPCBrokerProxyFactory",
        "ipc",
        IPCBrokerProxyCoreFactory::new()?,
    )
}