fix some database managements

src/controller/mod.rs

@@ -1,27 +1,82 @@
 use bollard::Docker;
 use crate::deploy;
+use crate::conf::storage::MemStorage;
+use crate::conf::Instance;
+use std::sync::Mutex;
 
 pub struct Controller {
     driver: Docker,
     network: String,
+    storage: Mutex<MemStorage>,
+    started: bool,
 }
 
 impl Controller {
     pub async fn new(driver: Docker, network: String, range: String) -> Result<Self, bollard::errors::Error>{
         deploy::network::Network::new(driver.clone(), network.clone(), range).await?;
-        Ok(Controller {
+        let cont = Self {
             driver: driver,
             network: network,
-        })
+            storage: Mutex::new(MemStorage::new().unwrap()),
+            started: false,
+        };
+        Ok(cont)
     }
 
-    pub async fn create_container(&self, domain: String, ip: String) -> String {
-        match deploy::container::Container::new(self.driver.clone(),
-                                                domain,
-                                                ip,
-                                                self.network.clone()).await {
-            Ok(c) => c.get_id(),
-            Err(e) => "error creating container".to_string(),
+    pub async fn create_container(&self, domain: String, ip: String, image: String) -> String {
+        match self.load_container(domain.clone(),ip.clone(),image.clone()).await {
+            Ok(c) => {
+                let ret = c.get_id();
+                self.storage.lock().unwrap().new_instance(c).unwrap();
+                ret
+            },
+            Err(_e) => "error creating container".to_string(),
         }
     }
+
+    pub async fn start_container_from_instance(&self, instance: Instance) {
+        let image = match self.storage.lock().unwrap().id_to_image(instance.image.clone()) {
+            Ok(i) => i,
+            Err(_e) => return, //meter logs aquí
+        };
+        match self.load_container(
+                        instance.domain.clone(),
+                        instance.ip.clone(),
+                        image).await {
+            Ok(c) => {
+                self.storage.lock().unwrap().loaded_instance(instance, c);
+            },
+            Err(_e) => (),
+        }
+    }
+
+    async fn load_container(&self, domain: String,
+                                ip: String,
+                                image: String) -> Result<deploy::container::Container,
+                                                        bollard::errors::Error>
+    {
+        deploy::container::Container::new(self.driver.clone(),
+                                            domain.clone(),
+                                            ip.clone(),
+                                            image.clone(),
+                                            self.network.clone()).await
+    }
+
+    pub async fn is_started(&self) -> bool {
+        self.started
+    }
+
+    pub async fn load_all_instances(&self) -> bool {
+        let data = match self.storage.lock().unwrap().get_instances_db() {
+            Ok(d) => d,
+            Err(_e) => return false,
+        };
+        println!("instances {}", data.len());
+        for instance in data {
+            self.start_container_from_instance(instance).await;
+        }
+        return true;
+    }
+
+    //pub async fn stop_container(&self, )
 }