container creation from brain and send response

Cargo.lock

@@ -318,7 +318,7 @@ dependencies = [
 [[package]]
 name = "detee-shared"
 version = "0.1.0"
-source = "git+ssh://git@gitea.detee.cloud/noormohammedb/detee-shared#a2899ba5a25794aec60a093695675ff24f967484"
+source = "git+ssh://git@gitea.detee.cloud/noormohammedb/detee-shared#6e1b1853838905c44d535d984d1221dd5d0dc2bc"
 dependencies = [
  "base64",
  "prost",

src/data.rs

@@ -22,15 +22,11 @@ pub struct Container {
 }
 
 impl DaemonState {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
     pub async fn create_new_container(
         &mut self,
         req_data: ContainerConfig,
         unarchive_dir: String,
-    ) -> Result<Vec<(u16, u16)>, Box<dyn std::error::Error>> {
+    ) -> Result<Vec<(u16, u16)>> {
         let publishing_ports = req_data.resource.clone().unwrap().port;
         let uuid = req_data.uuid;
         let container_name = format!("dtpm-{uuid}");

src/main.rs

@@ -12,12 +12,16 @@ use detee_shared::pb::daemon::BrainMessage;
 use detee_shared::pb::daemon::DaemonMessage;
 use detee_shared::pb::daemon::NewContainerRes;
 use detee_shared::pb::shared::ContainerContracts;
-use detee_shared::types::shared::Container;
+
+use detee_shared::pb::shared::MappedPort;
+use detee_shared::types::shared::Container as ContainerConfig;
 
 use tokio::sync::mpsc::Receiver;
 use tokio::sync::mpsc::Sender;
 use tokio::time::sleep;
+use utils::handle_package;
 
+#[derive(Debug)]
 pub struct Config {
     pub brain_url: String,
 }
@@ -30,11 +34,12 @@ impl Default for Config {
     }
 }
 
+#[derive(Debug)]
 pub struct ContainerHandler {
-    receiver: Receiver<BrainMessage>,
+    pub receiver: Receiver<BrainMessage>,
-    sender: Sender<DaemonMessage>,
+    pub sender: Sender<DaemonMessage>,
-    config: Config,
+    pub config: Config,
-    // res: state::Resources,
+    pub data: DaemonState,
 }
 
 impl ContainerHandler {
@@ -43,6 +48,7 @@ impl ContainerHandler {
             receiver,
             sender,
             config: Config::default(),
+            data: DaemonState::default(),
         }
     }
 
@@ -72,15 +78,61 @@ impl ContainerHandler {
         }
     }
 
-    async fn handle_new_container_req(&mut self, new_container_req: Container) {
+    async fn handle_new_container_req(&mut self, new_container_req: ContainerConfig) {
         dbg!(&new_container_req);
+
+        let container_uuid = new_container_req.uuid.clone();
+
+        let unarchive_dir = match handle_package(new_container_req.package_url.clone()).await {
+            Ok(unarchive_dir) => unarchive_dir,
+            Err(e) => {
                 let res = DaemonMessage {
                     msg: Some(daemon_message::Msg::NewContainerResp(NewContainerRes {
                         uuid: new_container_req.uuid,
+                        status: "failed".to_string(),
+                        error: e.to_string(),
                         ..Default::default()
                     })),
                 };
 
+                println!("sending response {:?}", res);
+                let _ = self.sender.send(res).await;
+                return;
+            }
+        };
+
+        let mapped_ports = match self
+            .data
+            .create_new_container(new_container_req, unarchive_dir)
+            .await
+        {
+            Ok(mapped_ports) => mapped_ports.into_iter().map(MappedPort::from).collect(),
+            Err(e) => {
+                let res = DaemonMessage {
+                    msg: Some(daemon_message::Msg::NewContainerResp(NewContainerRes {
+                        uuid: container_uuid,
+                        status: "failed".to_string(),
+                        error: e.to_string(),
+                        ..Default::default()
+                    })),
+                };
+
+                println!("sending response {:?}", res);
+                let _ = self.sender.send(res).await;
+                return;
+            }
+        };
+
+        let res = DaemonMessage {
+            msg: Some(daemon_message::Msg::NewContainerResp(NewContainerRes {
+                uuid: container_uuid,
+                status: "Success".to_string(),
+                error: "".to_string(),
+                ip_address: "".to_string(),
+                mapped_ports,
+            })),
+        };
+
         println!("sending response {:?}", res);
         let _ = self.sender.send(res).await;
     }