api_server: add get for machine-config

Signed-off-by: Andreea Florescu <fandree@amazon.com>

Author: andreeaflorescu

api_server/src/http_service.rs

@@ -200,7 +200,13 @@ fn parse_request<'a>(
             _ => Err(Error::InvalidPathMethod(path, method)),
         },
         "machine-config" => match v[1..].len() {
-            0 if is_get => Ok(ParsedRequest::Dummy),
+            0 if is_get =>
+                // Create an empty MachineConfiguration which is used for sending the body
+                Ok(MachineConfiguration {
+                    vcpu_count: None,
+                    mem_size_mib: None,
+                }.into_parsed_request(Method::Get)
+                    .map_err(|s| Error::Generic(StatusCode::BadRequest, s))?),
 
             0 if is_put => Ok(serde_json::from_slice::<MachineConfiguration>(body)
                 .map_err(Error::SerdeJson)?

api_server/src/request/sync/machine_configuration.rs

@@ -48,12 +48,40 @@ impl GenerateResponse for PutMachineConfigurationOutcome {
     }
 }
 
+impl GenerateResponse for MachineConfiguration {
+    fn generate_response(&self) -> Response {
+        let vcpu_count = match self.vcpu_count {
+            Some(v) => v.to_string(),
+            None => String::from("Uninitialized"),
+        };
+        let mem_size = match self.mem_size_mib {
+            Some(v) => v.to_string(),
+            None => String::from("Uninitialized"),
+        };
+
+        json_response(
+            StatusCode::Ok,
+            format!(
+                "{{ \"vcpu_count\": {:?}, \"mem_size_mib\": {:?} }}",
+                vcpu_count, mem_size
+            ),
+        )
+    }
+}
+
 impl IntoParsedRequest for MachineConfiguration {
-    fn into_parsed_request(self, _method: Method) -> result::Result<ParsedRequest, String> {
+    fn into_parsed_request(self, method: Method) -> result::Result<ParsedRequest, String> {
         let (sender, receiver) = oneshot::channel();
-        Ok(ParsedRequest::Sync(
-            SyncRequest::PutMachineConfiguration(self, sender),
-            receiver,
-        ))
+        match method {
+            Method::Get => Ok(ParsedRequest::Sync(
+                SyncRequest::GetMachineConfiguration(sender),
+                receiver,
+            )),
+            Method::Put => Ok(ParsedRequest::Sync(
+                SyncRequest::PutMachineConfiguration(self, sender),
+                receiver,
+            )),
+            _ => Ok(ParsedRequest::Dummy),
+        }
     }
 }

api_server/src/request/sync/mod.rs

@@ -53,6 +53,7 @@ pub enum DeviceState {
 // This enum contains messages for the VMM which represent sync requests. They each contain various
 // bits of information (ids, paths, etc.), together with an OutcomeSender, which is always present.
 pub enum SyncRequest {
+    GetMachineConfiguration(SyncOutcomeSender),
     PutBootSource(BootSourceBody, SyncOutcomeSender),
     PutDrive(DriveDescription, SyncOutcomeSender),
     PutMachineConfiguration(MachineConfiguration, SyncOutcomeSender),

data_model/src/vm/machine_config.rs

@@ -1,4 +1,4 @@
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct MachineConfiguration {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub vcpu_count: Option<u8>,

vmm/src/lib.rs

@@ -900,6 +900,12 @@ impl Vmm {
             }
             ApiRequest::Sync(req) => {
                 match req {
+                    SyncRequest::GetMachineConfiguration(sender) => {
+                        sender
+                            .send(Box::new(self.vm_config.clone()))
+                            .map_err(|_| ())
+                            .expect("one-shot channel closed");
+                    }
                     SyncRequest::PutDrive(drive_description, sender) => {
                         match self.put_block_device(BlockDeviceConfig::from(drive_description)) {
                             Ok(_) =>