bitcoin-ipc 0.1.16-alpha.0

tools for handling inter-process communication
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

crate::ix!();

use crate::protocol::Protocol;

//-------------------------------------------[.cpp/bitcoin/src/ipc/interfaces.cpp]

pub struct Ipc {
    exe_name:      *const u8,
    process_argv0: *const u8,
    init:          Rc<RefCell<dyn Init>>,
    protocol:      Box<dyn Protocol>,
    process:       Box<dyn ProcessInterface>,
}

impl IpcInterface for Ipc { }

impl SpawnProcess for Ipc { 

    fn spawn_process(&mut self, new_exe_name: *const u8) -> Box<dyn Init> {
        
        todo!();
        /*
            int pid;
            int fd = m_process->spawn(new_exe_name, m_process_argv0, pid);
            LogPrint(::BCLog::IPC, "Process %s pid %i launched\n", new_exe_name, pid);
            auto init = m_protocol->connect(fd, m_exe_name);
            Ipc::addCleanup(*init, [this, new_exe_name, pid] {
                int status = m_process->waitSpawned(pid);
                LogPrint(::BCLog::IPC, "Process %s pid %i exited with status %i\n", new_exe_name, pid, status);
            });
            return init;
        */
    }
}

impl StartSpawnedProcess for Ipc { 

    fn start_spawned_process(&mut self, 
        argc:        i32,
        argv:        &[*mut u8],
        exit_status: &mut i32) -> bool {
        
        todo!();
        /*
            exit_status = EXIT_FAILURE;
            int32_t fd = -1;
            if (!m_process->checkSpawned(argc, argv, fd)) {
                return false;
            }
            m_protocol->serve(fd, m_exe_name, m_init);
            exit_status = EXIT_SUCCESS;
            return true;
        */
    }
}

impl AddCleanup for Ipc { 

    fn add_cleanup(&mut self, 
        ty:      TypeIndex,
        iface:   *mut c_void,
        cleanup: fn() -> ())  {
        
        todo!();
        /*
            m_protocol->addCleanup(type, iface, std::move(cleanup));
        */
    }
}

impl Context for Ipc { 

    fn context(&mut self) -> Rc<RefCell<IpcContext>> {
        
        todo!();
        /*
            return m_protocol->context();
        */
    }
}

impl Ipc {
    
    pub fn new(
        exe_name:      *const u8,
        process_argv0: *const u8,
        init:          Rc<RefCell<dyn Init>>) -> Self {
    
        todo!();
        /*
           : m_exe_name(exe_name), m_process_argv0(process_argv0), m_init(init),
           m_protocol(ipc::capnp::MakeCapnpProtocol()), m_process(ipc::MakeProcess())
           */
    }
}

/**
  | Return implementation of Ipc interface.
  |
  */
pub fn make_ipc(
        exe_name:      *const u8,
        process_argv0: *const u8,
        init:          Rc<RefCell<dyn Init>>) -> Box<Ipc> {
    
    todo!();
        /*
            return std::make_unique<ipc::Ipc>(exe_name, process_argv0, init);
        */
}