api_server: add get for machine-config

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

Author: andreeaflorescu

api_server/src/http_service.rs

@@ -183,7 +183,15 @@ fn parse_machine_config_req<'a>(
     body: &Chunk,
 ) -> Result<'a, ParsedRequest> {
     match path_tokens[1..].len() {
-        0 if method == Method::Get => Ok(ParsedRequest::Dummy),
+        0 if method == Method::Get => {
+            let empty_machine_config = MachineConfiguration {
+                vcpu_count: None,
+                mem_size_mib: None,
+            };
+            Ok(empty_machine_config
+                .into_parsed_request(method)
+                .map_err(|s| Error::Generic(StatusCode::BadRequest, s))?)
+        }
 
         0 if method == Method::Put => Ok(serde_json::from_slice::<MachineConfiguration>(body)
             .map_err(Error::SerdeJson)?
@@ -860,10 +868,7 @@ mod tests {
         let body: Chunk = Chunk::from(json);
 
         // GET
-        match parse_machine_config_req(&path_tokens, &path, Method::Get, &body) {
-            Ok(pr_dummy) => assert!(pr_dummy.eq(&ParsedRequest::Dummy)),
-            _ => assert!(false),
-        }
+        assert!(parse_machine_config_req(&path_tokens, &path, Method::Get, &body).is_ok());
 
         assert!(
             parse_machine_config_req(

api_server/src/request/sync/machine_configuration.rs

@@ -48,13 +48,41 @@ 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),
+        }
     }
 }
 
@@ -115,5 +143,20 @@ mod tests {
                     receiver
                 )))
         );
+        let uninitialized = MachineConfiguration {
+            vcpu_count: None,
+            mem_size_mib: None,
+        };
+        assert!(
+            uninitialized
+                .clone()
+                .into_parsed_request(Method::Get)
+                .is_ok()
+        );
+        assert!(
+            uninitialized
+                .into_parsed_request(Method::Patch)
+                .eq(&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),

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(_) =>