feat: implement VM pause and resume

firepilot/src/executor.rs

@@ -26,6 +26,7 @@
 use tracing::{debug, error, info, instrument, trace};
 
 use crate::machine::FirepilotError;
+use firepilot_models::models::vm::Vm;
 use firepilot_models::models::{BootSource, Drive, NetworkInterface};
 
 /// Interface to determine how to execute commands on the socket and where to do it
@@ -35,7 +36,7 @@
     /// Execute a command onto the binary behind the executor
     ///
     /// It is only used to spawn the executor process, not to send commands to it
     fn spawn_binary_child(&self, args: &Vec<String>) -> Result<Child, ExecuteError>;
 }
 
 #[derive(thiserror::Error, Debug)]
@@ -103,7 +104,7 @@
 
 impl Executor {
     /// Create a new Executor with no implementation, and with id "default"
     pub fn new() -> Executor {
         Executor {
             firecracker: None,
             socket_process: None,
@@ -134,7 +135,7 @@
     /// Return the configured executor, or panic if none is configured
     fn executor(&self) -> &dyn Execute {
         match &self.firecracker {
             Some(firecracker) => return firecracker,
             None => panic!("No executor found"),
         }
     }
@@ -158,11 +159,16 @@
     }
 
     #[instrument(skip_all, fields(id = %self.id))]
-    async fn send_request(&self, url: hyper::Uri, body: String) -> Result<(), ExecuteError> {
+    async fn send_request(
+        &self,
+        url: hyper::Uri,
+        method: Method,
+        body: String,
+    ) -> Result<(), ExecuteError> {
         debug!("Send request to socket: {}", url);
         trace!("Sent body to socket [{}]: {}", url, body);
         let request = Request::builder()
-            .method(Method::PUT)
+            .method(method)
             .uri(url.clone())
             .header("Content-Type", "application/json")
             .header("Accept", "application/json")
@@ -204,7 +210,18 @@
         let json = serde_json::to_string(&action).map_err(ExecuteError::Serialize)?;
 
         let url: hyper::Uri = Uri::new(self.chroot().join("firecracker.socket"), "/actions").into();
-        self.send_request(url, json).await?;
+        self.send_request(url, Method::PUT, json).await?;
+        Ok(())
+    }
+
+    /// Sets the microVM the to the specified state
+    #[instrument(skip_all, fields(id = %self.id))]
+    pub async fn set_vm_state(&self, state: Vm) -> Result<(), ExecuteError> {
+        debug!("Change VM state: {:#?}", state);
+        let json = serde_json::to_string(&state).map_err(ExecuteError::Serialize)?;
+
+        let url: hyper::Uri = Uri::new(self.chroot().join("firecracker.socket"), "/vm").into();
+        self.send_request(url, Method::PATCH, json).await?;
         Ok(())
     }
 
@@ -261,7 +278,7 @@
 
         let url: hyper::Uri =
             Uri::new(self.chroot().join("firecracker.socket"), "/boot-source").into();
-        self.send_request(url, json).await?;
+        self.send_request(url, Method::PUT, json).await?;
         Ok(())
     }
 
@@ -276,7 +293,7 @@
 
             let path = format!("/drives/{}", drive.drive_id);
             let url: hyper::Uri = Uri::new(self.chroot().join("firecracker.socket"), &path).into();
-            self.send_request(url, json).await?;
+            self.send_request(url, Method::PUT, json).await?;
         }
         Ok(())
     }
@@ -296,7 +313,7 @@
 
             let path = format!("/network-interfaces/{}", network_interface.iface_id);
             let url: hyper::Uri = Uri::new(self.chroot().join("firecracker.socket"), &path).into();
-            self.send_request(url, json).await?;
+            self.send_request(url, Method::PUT, json).await?;
         }
         Ok(())
     }

firepilot/src/machine.rs

@@ -35,6 +35,8 @@ use crate::{
     executor::{Action, Executor},
 };
 
+use firepilot_models::models::vm::{State, Vm};
+
 #[derive(Debug)]
 pub enum FirepilotError {
     /// Mostly problems related to directories error or unavailable files
@@ -151,4 +153,16 @@ impl Machine {
         self.executor.send_action(Action::SendCtrlAltDel).await?;
         Ok(())
     }
+
+    /// Pause a running VM
+    pub async fn pause(&self) -> Result<(), FirepilotError> {
+        self.executor.set_vm_state(Vm::new(State::Paused)).await?;
+        Ok(())
+    }
+
+    /// Resume a paused VM
+    pub async fn resume(&self) -> Result<(), FirepilotError> {
+        self.executor.set_vm_state(Vm::new(State::Resumed)).await?;
+        Ok(())
+    }
 }