From 17400339fcac2cb2bb14d83f9b16044d2403ca4c Mon Sep 17 00:00:00 2001
From: Noor <noormohammedb@protonmail.com>
Date: Thu, 30 Jan 2025 20:25:46 +0530
Subject: [PATCH] container creation from brain and send response

---
 Cargo.lock  |  2 +-
 src/data.rs |  6 +----
 src/main.rs | 68 ++++++++++++++++++++++++++++++++++++++++++++++-------
 3 files changed, 62 insertions(+), 14 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c14e3ed..9c59d46 100644
--- a/Cargo.lock
+++ b/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",
diff --git a/src/data.rs b/src/data.rs
index ecfcf51..112753a 100644
--- a/src/data.rs
+++ b/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}");
diff --git a/src/main.rs b/src/main.rs
index 723d164..cc2e231 100644
--- a/src/main.rs
+++ b/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>,
-    sender: Sender<DaemonMessage>,
-    config: Config,
-    // res: state::Resources,
+    pub receiver: Receiver<BrainMessage>,
+    pub sender: Sender<DaemonMessage>,
+    pub config: Config,
+    pub data: DaemonState,
 }
 
 impl ContainerHandler {
@@ -43,6 +48,7 @@ impl ContainerHandler {
             receiver,
             sender,
             config: Config::default(),
+            data: DaemonState::default(),
         }
     }
 
@@ -72,12 +78,58 @@ 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: new_container_req.uuid,
-                ..Default::default()
+                uuid: container_uuid,
+                status: "Success".to_string(),
+                error: "".to_string(),
+                ip_address: "".to_string(),
+                mapped_ports,
             })),
         };