container-rs 0.1.3

simple container cli and lib!
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use std::collections::HashSet;
use std::fs;
use std::io::{Read};
use std::thread;
use std::time;
use nix::unistd;

use futures::stream::TryStreamExt;
use ipnetwork::IpNetwork;
use rtnetlink::new_connection;
use anyhow::Context;

#[derive(Clone, Debug)]
pub struct Network {
    name: String,
    pid: i32,
    ip_address0: IpNetwork,
    ip_address1: IpNetwork,
}

impl Network {
    pub fn new(name: String, ip_address0: String, ip_address1: String, pid: i32) -> Network {
        Network {
            name,
            pid,
            ip_address0: ip_address0.parse::<IpNetwork>().unwrap(),
            ip_address1: ip_address1.parse::<IpNetwork>().unwrap()
        }
    }
    pub fn start(&self) -> Result<(), anyhow::Error>{
        loop {
            let x = Network::find_child(self.pid).with_context(||"Error to find child process!")?;
            if x > 0 {
                break;
            }
            thread::sleep(time::Duration::new(0, 0));
        }

        tokio::runtime::Builder::new_multi_thread()
            .enable_io()
            .build()
            .unwrap()
            .block_on(self.v_eth()).with_context(||"Error to setup namespace veth!")?;
        Ok(())
    }
    async fn v_eth(&self) -> Result<(), anyhow::Error> {
        let (connection, handle, _) = new_connection().unwrap();
        tokio::spawn(connection);
        handle
            .link()
            .add()
            .veth(format!("{}_eth0", self.name), format!("{}_eth1", self.name))
            .execute()
            .await?;
        let eth0 = handle
            .link()
            .get()
            .set_name_filter(format!("{}_eth0", self.name))
            .execute()
            .try_next()
            .await
            .unwrap()
            .unwrap();
        handle.address()
            .add(eth0.header.index, self.ip_address0.ip(), self.ip_address0.prefix())
            .execute().await?;
        handle.link().set(eth0.header.index).up().execute().await?;
        let eth1 = handle
            .link()
            .get()
            .set_name_filter(format!("{}_eth1", self.name))
            .execute()
            .try_next()
            .await
            .unwrap()
            .unwrap();
        handle.link().set(eth1.header.index)
            .setns_by_pid(self.pid as u32)
            .execute().await?;
        Ok(())
    }
    pub fn enable_network(&self) -> Result<(), anyhow::Error>{
        tokio::runtime::Builder::new_multi_thread()
            .enable_io()
            .build()
            .unwrap()
            .block_on(self.ns_ip()).with_context(||"Error to setup namespace veth!")?;
        Ok(())
    }
    async fn ns_ip(&self)-> Result<(), anyhow::Error>{
        let (connection, handle, _) = new_connection().unwrap();
        tokio::spawn(connection);
        let eth1 = handle
            .link()
            .get()
            .set_name_filter(format!("{}_eth1", self.name))
            .execute()
            .try_next()
            .await
            .unwrap()
            .unwrap();
        handle.address()
            .add(eth1.header.index, self.ip_address1.ip(), self.ip_address1.prefix())
            .execute().await?;
        handle.link().set(eth1.header.index).up().execute().await?;
        Ok(())
    }
    fn find_child(ppid: i32) -> Result<i32, anyhow::Error> {
        let mut pid = fs::read_dir("/proc")
            .unwrap()
            .filter(|p| {
                match p
                    .as_ref()
                    .unwrap()
                    .file_name()
                    .to_str()
                    .unwrap()
                    .parse::<u64>() {
                        Ok(_) => true,
                        Err(_) => false
                }
            }
            )
            .map(|pid| {
                let mut data = Vec::new();
                let ppid_1 = match fs::File::open( pid.as_ref().unwrap().path().join("stat"))
                {
                    Ok(mut f) => {
                        match f.read_to_end(&mut data) {
                            Ok(_) => {
                                String::from_utf8(data)
                                    .unwrap()
                                    .as_str()
                                    .split(" ")
                                    .map(|x| x.parse::<i32>().unwrap_or(0)).collect::<Vec<i32>>()[3]
                            }
                            Err(_) => {
                                0
                            }
                        }
                    }
                    Err(_) => {
                        0
                    }
                };
                if ppid_1 == ppid {
                    pid.as_ref().unwrap().file_name().to_str().unwrap().parse::<i32>().unwrap()
                } else {
                    0
                }
            }).collect::<HashSet<i32>>();
        pid.remove(&0i32);
        pid.remove(&unistd::getpid().as_raw());
        match pid.is_empty() {
            true => { Ok(0) }
            false => {
                Ok(pid.iter().collect::<Vec<&i32>>()[0].clone())
            }
        }
    }
}