1 files changed, 134 insertions, 0 deletions
diff --git a/src/network.rs b/src/network.rs
new file mode 100644
index 0000000..7df4a0b
--- /dev/null
+++ b/src/network.rs
@@ -0,0 +1,134 @@
+//! Create and manage user-defined networks that containers can be attached to.
+//!
+//! API Reference: <https://docs.docker.com/engine/api/v1.41/#tag/Network>
+
+use hyper::Body;
+
+use crate::{
+    builder::{ContainerConnectionOptions, NetworkCreateOptions, NetworkListOptions},
+    errors::Result,
+    rep::{NetworkCreateInfo, NetworkDetails as NetworkInfo},
+    Docker,
+};
+
+/// Interface for docker network
+pub struct Networks<'docker> {
+    docker: &'docker Docker,
+}
+
+impl<'docker> Networks<'docker> {
+    /// Exports an interface for interacting with docker Networks
+    pub fn new(docker: &'docker Docker) -> Self {
+        Networks { docker }
+    }
+
+    /// List the docker networks on the current docker host
+    pub async fn list(
+        &self,
+        opts: &NetworkListOptions,
+    ) -> Result<Vec<NetworkInfo>> {
+        let mut path = vec!["/networks".to_owned()];
+        if let Some(query) = opts.serialize() {
+            path.push(query);
+        }
+        self.docker.get_json(&path.join("?")).await
+    }
+
+    /// Returns a reference to a set of operations available to a specific network instance
+    pub fn get<S>(
+        &self,
+        id: S,
+    ) -> Network<'docker>
+    where
+        S: Into<String>,
+    {
+        Network::new(self.docker, id)
+    }
+
+    /// Create a new Network instance
+    pub async fn create(
+        &self,
+        opts: &NetworkCreateOptions,
+    ) -> Result<NetworkCreateInfo> {
+        let body: Body = opts.serialize()?.into();
+        let path = vec!["/networks/create".to_owned()];
+
+        self.docker
+            .post_json(&path.join("?"), Some((body, mime::APPLICATION_JSON)))
+            .await
+    }
+}
+
+/// Interface for accessing and manipulating a docker network
+pub struct Network<'docker> {
+    docker: &'docker Docker,
+    id: String,
+}
+
+impl<'docker> Network<'docker> {
+    /// Exports an interface exposing operations against a network instance
+    pub fn new<S>(
+        docker: &'docker Docker,
+        id: S,
+    ) -> Self
+    where
+        S: Into<String>,
+    {
+        Network {
+            docker,
+            id: id.into(),
+        }
+    }
+
+    /// a getter for the Network id
+    pub fn id(&self) -> &str {
+        &self.id
+    }
+
+    /// Inspects the current docker network instance's details
+    pub async fn inspect(&self) -> Result<NetworkInfo> {
+        self.docker
+            .get_json(&format!("/networks/{}", self.id)[..])
+            .await
+    }
+
+    /// Delete the network instance
+    pub async fn delete(&self) -> Result<()> {
+        self.docker
+            .delete(&format!("/networks/{}", self.id)[..])
+            .await?;
+        Ok(())
+    }
+
+    /// Connect container to network
+    pub async fn connect(
+        &self,
+        opts: &ContainerConnectionOptions,
+    ) -> Result<()> {
+        self.do_connection("connect", opts).await
+    }
+
+    /// Disconnect container to network
+    pub async fn disconnect(
+        &self,
+        opts: &ContainerConnectionOptions,
+    ) -> Result<()> {
+        self.do_connection("disconnect", opts).await
+    }
+
+    async fn do_connection(
+        &self,
+        segment: &str,
+        opts: &ContainerConnectionOptions,
+    ) -> Result<()> {
+        let body: Body = opts.serialize()?.into();
+
+        self.docker
+            .post(
+                &format!("/networks/{}/{}", self.id, segment)[..],
+                Some((body, mime::APPLICATION_JSON)),
+            )
+            .await?;
+        Ok(())
+    }
+}