passivized_docker_engine_client 0.0.9

Docker Engine Client - manage and run containers, images, and volumes.
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

use std::collections::HashMap;

use serde::Serialize;

use crate::model::NetworkIpam;

/// See https://docs.docker.com/engine/api/v1.41/#tag/Network/operation/NetworkCreate
#[derive(Clone, Debug, Serialize)]
pub struct CreateNetworkRequest {

    #[serde(rename = "Name")]
    name: String,

    #[serde(rename = "CheckDuplicate")]
    check_duplicate: bool,

    #[serde(rename = "Driver")]
    driver: Option<String>,

    #[serde(rename = "Internal")]
    internal: Option<bool>,

    #[serde(rename = "Attachable")]
    attachable: Option<bool>,

    #[serde(rename = "Ingress")]
    ingress: Option<bool>,

    #[serde(rename = "IPAM")]
    ipam: NetworkIpam,

    #[serde(rename = "EnableIPv6")]
    enable_ipv6: Option<bool>,

    #[serde(rename = "Options")]
    options: HashMap<String, String>,

    #[serde(rename = "Labels")]
    labels: HashMap<String, String>
}

impl CreateNetworkRequest {

    pub fn name<V: Into<String>>(mut self, v: V) -> Self {
        self.name = v.into();
        self
    }

    pub fn check_duplicate(mut self, v: bool) -> Self {
        self.check_duplicate = v;
        self
    }

    pub fn driver<V: Into<String>>(mut self, v: V) -> Self {
        self.driver = Some(v.into());
        self
    }

    pub fn internal(mut self, v: bool) -> Self {
        self.internal = Some(v);
        self
    }

    pub fn attachable(mut self, v: bool) -> Self {
        self.attachable = Some(v);
        self
    }

    pub fn ingress(mut self, v: bool) -> Self {
        self.ingress = Some(v);
        self
    }

    pub fn ipam(mut self, v: NetworkIpam) -> Self {
        self.ipam = v;
        self
    }

    pub fn enable_ipv6(mut self, v: bool) -> Self {
        self.enable_ipv6 = Some(v);
        self
    }

    /// Add an option. Can be called multiple times.
    pub fn option<K, V>(mut self, k: K, v: V) -> Self
        where
            K: Into<String>,
            V: Into<String>
    {
        self.options.insert(k.into(), v.into());
        self
    }

    /// Add a label. Can be called multiple times.
    pub fn label<K, V>(mut self, k: K, v: V) -> Self
        where
            K: Into<String>,
            V: Into<String>
    {
        self.labels.insert(k.into(), v.into());
        self
    }
}

impl Default for CreateNetworkRequest {
    fn default() -> Self {
        Self {
            name: Default::default(),
            // The official documentation doesn't specify what the default is. True seems like a reasonable choice,
            // so we explicitly set the check to True.
            check_duplicate: true,
            driver: Default::default(),
            internal: Default::default(),
            attachable: Default::default(),
            ingress: Default::default(),
            ipam: Default::default(),
            enable_ipv6: Default::default(),
            options: Default::default(),
            labels: Default::default()
        }
    }
}