From 83d7def2900b5ff2fa736b5b84074f53a57a2e35 Mon Sep 17 00:00:00 2001
From: Marc Schreiber <schrieveslaach@online.de>
Date: Sat, 22 Dec 2018 11:33:51 +0100
Subject: Fix serialization of network commands and add
 ContainerConnectionOptionsBuilder (#133)

---
 src/builder.rs | 82 ++++++++++++++++++++++++++++------------------------------
 1 file changed, 40 insertions(+), 42 deletions(-)

(limited to 'src/builder.rs')

diff --git a/src/builder.rs b/src/builder.rs
index fbebeb7..bee4c6e 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -1130,9 +1130,7 @@ impl NetworkListOptions {
 /// Interface for creating new docker network
 #[derive(Serialize)]
 pub struct NetworkCreateOptions {
-    pub name: Option<String>,
-    params: HashMap<&'static str, String>,
-    params_hash: HashMap<String, Vec<HashMap<String, String>>>,
+    params: HashMap<&'static str, Value>,
 }
 
 impl NetworkCreateOptions {
@@ -1141,16 +1139,9 @@ impl NetworkCreateOptions {
         NetworkCreateOptionsBuilder::new(name)
     }
 
-    fn to_json(&self) -> Value {
-        let mut body = serde_json::Map::new();
-        self.parse_from(&self.params, &mut body);
-        self.parse_from(&self.params_hash, &mut body);
-        Value::Object(body)
-    }
-
     /// serialize options as a string. returns None if no options are defined
     pub fn serialize(&self) -> Result<String> {
-        serde_json::to_string(&self.to_json()).map_err(Error::from)
+        serde_json::to_string(&self.params).map_err(Error::from)
     }
 
     pub fn parse_from<'a, K, V>(
@@ -1173,21 +1164,15 @@ impl NetworkCreateOptions {
 
 #[derive(Default)]
 pub struct NetworkCreateOptionsBuilder {
-    name: Option<String>,
-    params: HashMap<&'static str, String>,
-    params_hash: HashMap<String, Vec<HashMap<String, String>>>,
+    params: HashMap<&'static str, Value>,
 }
 
 impl NetworkCreateOptionsBuilder {
     pub(crate) fn new(name: &str) -> Self {
         let mut params = HashMap::new();
-        let params_hash = HashMap::new();
-
-        params.insert("Name", name.to_owned());
+        params.insert("Name", json!(name));
         NetworkCreateOptionsBuilder {
-            name: None,
-            params,
-            params_hash,
+            params
         }
     }
 
@@ -1196,29 +1181,22 @@ impl NetworkCreateOptionsBuilder {
         name: &str,
     ) -> &mut Self {
         if !name.is_empty() {
-            self.params.insert("Driver", name.to_owned());
+            self.params.insert("Driver", json!(name));
         }
         self
     }
 
     pub fn label(
         &mut self,
-        labels: Vec<HashMap<String, String>>,
+        labels: HashMap<String, String>,
     ) -> &mut Self {
-        for l in labels {
-            self.params_hash
-                .entry("Labels".to_string())
-                .or_insert_with(Vec::new)
-                .push(l)
-        }
+        self.params.insert("Labels", json!(labels));
         self
     }
 
     pub fn build(&self) -> NetworkCreateOptions {
         NetworkCreateOptions {
-            name: self.name.clone(),
             params: self.params.clone(),
-            params_hash: self.params_hash.clone(),
         }
     }
 }
@@ -1226,14 +1204,13 @@ impl NetworkCreateOptionsBuilder {
 /// Interface for connect container to network
 #[derive(Serialize)]
 pub struct ContainerConnectionOptions {
-    pub container: Option<String>,
-    params: HashMap<&'static str, String>,
+    params: HashMap<&'static str, Value>,
 }
 
 impl ContainerConnectionOptions {
     /// serialize options as a string. returns None if no options are defined
     pub fn serialize(&self) -> Result<String> {
-        serde_json::to_string(self).map_err(Error::from)
+        serde_json::to_string(&self.params).map_err(Error::from)
     }
 
     pub fn parse_from<'a, K, V>(
@@ -1253,19 +1230,40 @@ impl ContainerConnectionOptions {
         }
     }
 
-    pub fn new(container_id: &str) -> ContainerConnectionOptions {
+    /// return a new instance of a builder for options
+    pub fn builder(container_id: &str) -> ContainerConnectionOptionsBuilder {
+        ContainerConnectionOptionsBuilder::new(container_id)
+    }
+}
+
+#[derive(Default)]
+pub struct ContainerConnectionOptionsBuilder {
+    params: HashMap<&'static str, Value>,
+}
+
+impl ContainerConnectionOptionsBuilder {
+    pub(crate) fn new(container_id: &str) -> Self {
         let mut params = HashMap::new();
-        params.insert("Container", container_id.to_owned());
-        ContainerConnectionOptions {
-            container: None,
-            params: params.clone(),
-        }
+        params.insert("Container", json!(container_id));
+        ContainerConnectionOptionsBuilder { params }
+    }
+
+    pub fn aliases(
+        &mut self,
+        aliases: Vec<&str>,
+    ) -> &mut Self {
+        self.params
+            .insert("EndpointConfig", json!({"Aliases": json!(aliases)}));
+        self
+    }
+
+    pub fn force(&mut self) -> &mut Self {
+        self.params.insert("Force", json!(true));
+        self
     }
 
-    pub fn force(&mut self) -> ContainerConnectionOptions {
-        self.params.insert("Force", "true".to_owned());
+    pub fn build(&self) -> ContainerConnectionOptions {
         ContainerConnectionOptions {
-            container: None,
             params: self.params.clone(),
         }
     }
-- 
cgit v1.2.3