runlikers 0.1.2

Reverse-engineer docker run command line arguments based on running containers
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

use crate::Inspector;
use serde_json::Value;

impl Inspector {
    pub fn parse_network(&self, options: &mut Vec<String>) {
        if let Some(n) = self.get_container_fact("HostConfig.NetworkMode") {
            if n != "default" && !n.is_empty() {
                options.push(format!("--network={}", n));
            }
        }
    }

    pub fn parse_privileged(&self, options: &mut Vec<String>) {
        if let Some(p) = self.get_container_fact("HostConfig.Privileged") {
            if p == "true" {
                options.push("--privileged".to_string());
            }
        }
    }

    pub fn parse_pid(&self, options: &mut Vec<String>) {
        if let Some(pid) = self.get_container_fact("HostConfig.PidMode") {
            if !pid.is_empty() && pid != "default" {
                options.push(format!("--pid {}", self.quote(&pid)));
            }
        }
    }

    pub fn parse_ipc(&self, options: &mut Vec<String>) {
        if let Some(v) = self.get_container_fact("HostConfig.IpcMode") {
            if !v.is_empty() && v != "default" {
                options.push(format!("--ipc={}", v));
            }
        }
    }

    pub fn parse_uts(&self, options: &mut Vec<String>) {
        if let Some(v) = self.get_container_fact("HostConfig.UTSMode") {
            if !v.is_empty() && v != "default" {
                options.push(format!("--uts={}", v));
            }
        }
    }

    pub fn parse_userns(&self, options: &mut Vec<String>) {
        if let Some(v) = self.get_container_fact("HostConfig.UsernsMode") {
            if !v.is_empty() {
                options.push(format!("--userns={}", v));
            }
        }
    }

    pub fn parse_dns(&mut self, options: &mut Vec<String>) {
        self.multi_option(options, "HostConfig.Dns", "dns");
    }

    pub fn parse_dns_option(&mut self, options: &mut Vec<String>) {
        self.multi_option(options, "HostConfig.DnsOptions", "dns-option");
    }

    pub fn parse_dns_search(&mut self, options: &mut Vec<String>) {
        self.multi_option(options, "HostConfig.DnsSearch", "dns-search");
    }

    pub fn parse_extra_hosts(&self, options: &mut Vec<String>) {
        for host in &self.get_container_fact_list("HostConfig.ExtraHosts") {
            if let Value::String(s) = host {
                options.push(format!("--add-host {}", self.quote(s)));
            }
        }
    }

    pub fn parse_network_alias(&self, options: &mut Vec<String>) {
        for network in self
            .get_container_fact_map("NetworkSettings.Networks")
            .values()
        {
            if let Some(Value::Array(aliases)) = network.get("Aliases") {
                for alias in aliases {
                    if let Value::String(s) = alias {
                        options.push(format!("--network-alias {}", s));
                    }
                }
                break;
            }
        }
    }

    pub fn parse_link_local_ip(&self, options: &mut Vec<String>) {
        for network in self
            .get_container_fact_map("NetworkSettings.Networks")
            .values()
        {
            if let Some(Value::Array(ips)) = network.get("LinkLocalIPs") {
                for ip in ips {
                    if let Value::String(s) = ip {
                        options.push(format!("--link-local-ip {}", s));
                    }
                }
                break;
            }
        }
    }
}