start using actix for interface

src/deploy/container.rs

@@ -0,0 +1,87 @@
+use bollard::container::{StartContainerOptions, CreateContainerOptions, Config, NetworkingConfig};
+use bollard::models::{EndpointSettings, EndpointIpamConfig};
+use bollard::errors::Error;
+use std::collections::hash_map::HashMap;
+
+pub struct Container {
+    name: String,
+    start: bool,
+    ip: String,
+    net: String,
+    id: Option<String>,
+}
+
+impl Container {
+    pub async fn new(docker: bollard::Docker,
+                name: String,
+                ip: String,
+                net: String) -> Result<Container, Error> {
+
+        let mut container = Container {
+            name: name,
+            ip: ip,
+            net: net,
+            start: false,
+            id: None,
+        };
+
+        match container.create(docker).await {
+            Ok(c) => {
+                container.start=true;
+                container.id = Some(c);
+                Ok(container)
+            }
+            Err(e) => Err(e),
+        }
+    }
+
+    async fn create(&self, docker: bollard::Docker) -> Result<String, Error>{
+        let create = docker.create_container(Some(
+                                        create_options(self.name.clone())),
+                                        create_config(self.ip.clone(), self.net.clone()))
+                                        .await?;
+        docker.start_container(&self.name, None::<StartContainerOptions<String>>).await?;
+        return Ok(create.id);
+    }
+
+    pub fn get_id(&self) -> String {
+        match &self.id {
+            Some(id) => id.clone(),
+            None => String::from(""),
+        }
+    }
+}
+fn create_config(ip: String, net: String) -> Config<String> {
+    let endpoint = EndpointSettings {
+        ipam_config: Some(EndpointIpamConfig{
+                ipv4_address: Some(ip),
+                ..Default::default()
+            }),
+        ..Default::default()
+    };
+    let mut hash = HashMap::new();
+    hash.insert(net, endpoint);
+    let net = NetworkingConfig {
+        endpoints_config: hash
+    };
+    let env = vec!["EULA=TRUE".to_string()];
+    Config {
+        image: Some("itzg/minecraft-server:latest".to_string()),
+        env: Some(env),
+        networking_config: Some(net),
+        ..Default::default()
+    }
+}
+
+fn create_options(name: String) -> CreateContainerOptions<String> {
+    CreateContainerOptions{
+        name: name,
+        platform: None,
+    }
+}
+
+async fn create(docker: bollard::Docker, name: String, ip: String, net: String) -> Result<String, Error>{
+    let create = docker.create_container(Some(create_options(name.clone())), create_config(ip, net)).await?;
+    docker.start_container(&name, None::<StartContainerOptions<String>>).await?;
+    return Ok(create.id);
+}