Implemented stop / state

Signed-off-by: Lukas Frank <lukas.frank@sap.com>

Author: lukasfrank

src/daemon.rs

@@ -349,7 +349,8 @@ impl FeosGrpc for FeOSAPI {
         let id = Uuid::parse_str(&request.get_ref().uuid)
             .map_err(|_| Status::invalid_argument("Failed to parse UUID"))?;
 
-        self.vmm.shutdown_vm(id).map_err(handle_error)?;
+        // TODO differentiate between kill and shutdown
+        self.vmm.kill_vm(id).map_err(handle_error)?;
 
         Ok(Response::new(feos_grpc::ShutdownVmResponse {}))
     }

src/isolated_container/mod.rs

@@ -1,5 +1,5 @@
 use crate::container::container_service::container_service_client::ContainerServiceClient;
-use crate::container::container_service::{CreateContainerRequest, RunContainerRequest};
+use crate::container::container_service::{CreateContainerRequest, RunContainerRequest, StateContainerRequest};
 use crate::daemon::FeOSAPI;
 use crate::feos_grpc::Empty;
 use crate::ringbuffer::RingBuffer;
@@ -88,7 +88,7 @@ fn handle_error(e: vm::Error) -> tonic::Status {
     }
 }
 
-async fn retry_get_channel(path: String) -> Result<Channel, Error> {
+async fn get_channel(path: String) -> Result<Channel, Error> {
     async fn get_channel(path: String) -> Result<Channel, Error> {
         let channel = Endpoint::try_from("http://[::]:50051")
             .map_err(|e| Error::Failed)?
@@ -192,7 +192,7 @@ impl IsolatedContainerService for IsolatedContainerAPI {
             .expect("failed to start network");
 
         let path = format!("vsock{}.sock", network::Manager::device_name(&id));
-        let channel = retry_get_channel(path).await.expect("abc");
+        let channel = get_channel(path).await.expect("abc");
 
         let mut client = ContainerServiceClient::new(channel);
         let request = tonic::Request::new(CreateContainerRequest {
@@ -236,7 +236,7 @@ impl IsolatedContainerService for IsolatedContainerAPI {
         };
 
         let path = format!("vsock{}.sock", network::Manager::device_name(&vm_id));
-        let channel = retry_get_channel(path).await.expect("abc");
+        let channel = get_channel(path).await.expect("abc");
 
         let mut client = ContainerServiceClient::new(channel);
         let request = tonic::Request::new(RunContainerRequest {
@@ -255,7 +255,20 @@ impl IsolatedContainerService for IsolatedContainerAPI {
     ) -> Result<Response<isolated_container_service::StopContainerResponse>, Status> {
         info!("Got stop_container request");
 
+
         let container_id: String = request.get_ref().uuid.clone();
+        let container_id = Uuid::parse_str(&container_id)
+            .map_err(|_| Status::invalid_argument("failed to parse uuid"))?;
+
+        self.network
+            .stop_dhcp(container_id)
+            .await
+            .expect("failed to start network");
+
+        self.vmm.kill_vm(container_id).map_err(handle_error)?;
+
+        let mut vm_to_container = self.vm_to_container.lock().unwrap();
+        vm_to_container.remove(&container_id);
 
         Ok(Response::new(
             isolated_container_service::StopContainerResponse {},
@@ -270,10 +283,34 @@ impl IsolatedContainerService for IsolatedContainerAPI {
 
         let container_id: String = request.get_ref().uuid.clone();
 
+        let vm_id: String = request.get_ref().uuid.clone();
+        let vm_id = Uuid::parse_str(&vm_id)
+            .map_err(|_| Status::invalid_argument("failed to parse uuid"))?;
+
+        let container_id = {
+            let vm_to_container = self
+                .vm_to_container
+                .lock()
+                .map_err(|_| Status::internal("Failed to lock mutex"))?;
+            *vm_to_container
+                .get(&vm_id)
+                .ok_or_else(|| Status::not_found(format!("VM with ID '{}' not found", vm_id)))?
+        };
+
+        let path = format!("vsock{}.sock", network::Manager::device_name(&vm_id));
+        let channel = get_channel(path).await.expect("abc");
+
+        let mut client = ContainerServiceClient::new(channel);
+        let request = tonic::Request::new( StateContainerRequest {
+            uuid: container_id.to_string(),
+        });
+        let response = client.state_container(request).await?;
+
+
         Ok(Response::new(
             isolated_container_service::StateContainerResponse {
-                state: "".to_string(),
-                pid: None,
+                state:  response.get_ref().state.to_string(),
+                pid: response.get_ref().pid,
             },
         ))
     }

src/network/mod.rs

@@ -79,6 +79,15 @@ impl Manager {
         Ok(())
     }
 
+    pub async fn stop_dhcp(&self, id: Uuid) -> Result<(), Error> {
+        let mut instances = self.instances.lock().unwrap();
+        if let Some(handle) = instances.remove(&id)  {
+            handle.radv_handle.abort();
+            handle.dhcpv6_handle.abort();
+        }
+
+        Ok(())
+    }
     pub async fn start_dhcp(&self, id: Uuid) -> Result<(), Error> {
         self.exists(id)?;
 

src/vm/mod.rs

@@ -376,7 +376,7 @@ impl Manager {
         Ok(String::new())
     }
 
-    pub fn shutdown_vm(&self, id: Uuid) -> Result<String, Error> {
+    pub fn kill_vm(&self, id: Uuid) -> Result<String, Error> {
         let mut vms = self.vms.lock().unwrap();
         let vm_info = match vms.get_mut(&id) {
             Some(info) => info,
@@ -396,17 +396,20 @@ impl Manager {
             info!("shutdown vm: id {}, response: {}", id, x);
         }
 
-        if let Err(e) = vm_info.child.kill() {
-            error!("Failed to kill child process for VM {}: {}", id, e);
-        } else {
-            info!("Sent kill signal to VM {}", id);
-        }
 
-        match vm_info.child.wait() {
-            Ok(status) => info!("VM {} exited with status {}", id, status),
-            Err(e) => error!("Failed to wait for VM {}: {}", id, e),
+        let response = api_client::simple_api_full_command_and_response(
+            &mut socket,
+            "PUT",
+            "vmm.shutdown",
+            None,
+        )
+            .map_err(Error::CHApiFailure)?;
+
+        if let Some(x) = &response {
+            info!("shutdown vmm: id {}, response: {}", id, x);
         }
 
+
         vms.remove(&id);
 
         Ok(String::new())