api & vmm refactoring

We are trying to reverse the dependency between the API and the
VMM. The API should depend on the VMM and the VMM should not have
structures/functions that suggest that there is an interaction
with an HTTP/or any other kind of API.

As part of this effort:
* renamed the SyncRequest to VmmAction as this enum will be later
  moved to the vmm crate
* renamed the variants from VmmAction enum so we don't have them
  tied to an API.
* renamed the function run_api_cmd to run_vmm_action.
* renamed SyncOutcomeSender to OutcomeSender as all out requests
  are sync. Same for SyncOutcomeReceiver.

Signed-off-by: Andreea Florescu <[email protected]>

Author: andreeaflorescu

api_server/src/http_service.rs

@@ -19,7 +19,7 @@ use request::drive::PatchDrivePayload;
 use request::instance_info::InstanceInfo;
 use request::logger::APILoggerDescription;
 use request::net::NetworkInterfaceBody;
-use request::{IntoParsedRequest, ParsedRequest, SyncRequest};
+use request::{IntoParsedRequest, ParsedRequest, VmmAction};
 use sys_util::EventFd;
 
 fn build_response_base<B: Into<hyper::Body>>(
@@ -399,8 +399,8 @@ fn parse_request<'a>(method: Method, path: &'a str, body: &Chunk) -> Result<'a,
 // A helper function which is always used when a message is placed into the communication channel
 // with the VMM (so we don't forget to write to the EventFd).
 fn send_to_vmm(
-    req: SyncRequest,
-    sender: &mpsc::Sender<Box<SyncRequest>>,
+    req: VmmAction,
+    sender: &mpsc::Sender<Box<VmmAction>>,
     send_event: &EventFd,
 ) -> result::Result<(), ()> {
     sender.send(Box::new(req)).map_err(|_| ())?;
@@ -417,7 +417,7 @@ pub struct ApiServerHttpService {
     // This allows sending messages to the VMM thread. It makes sense to use a Rc for the sender
     // (instead of cloning) because everything happens on a single thread, so there's no risk of
     // having races (if that was even a problem to begin with).
-    api_request_sender: Rc<mpsc::Sender<Box<SyncRequest>>>,
+    api_request_sender: Rc<mpsc::Sender<Box<VmmAction>>>,
     // We write to this EventFd to let the VMM know about new messages.
     vmm_send_event: Rc<EventFd>,
 }
@@ -426,7 +426,7 @@ impl ApiServerHttpService {
     pub fn new(
         mmds_info: Arc<Mutex<Mmds>>,
         vmm_shared_info: Arc<RwLock<InstanceInfo>>,
-        api_request_sender: Rc<mpsc::Sender<Box<SyncRequest>>>,
+        api_request_sender: Rc<mpsc::Sender<Box<VmmAction>>>,
         vmm_send_event: Rc<EventFd>,
     ) -> Self {
         ApiServerHttpService {
@@ -583,7 +583,7 @@ mod tests {
     use hyper::header::{ContentType, Headers};
     use hyper::Body;
     use net_util::MacAddr;
-    use request::SyncRequest;
+    use request::VmmAction;
 
     fn body_to_string(body: hyper::Body) -> String {
         let ret = body
@@ -724,7 +724,7 @@ mod tests {
             Ok(pr) => {
                 let (sender, receiver) = oneshot::channel();
                 assert!(pr.eq(&ParsedRequest::Sync(
-                    SyncRequest::StartInstance(sender),
+                    VmmAction::StartMicroVm(sender),
                     receiver
                 )));
             }
@@ -743,7 +743,7 @@ mod tests {
             Ok(pr) => {
                 let (sender, receiver) = oneshot::channel();
                 assert!(pr.eq(&ParsedRequest::Sync(
-                    SyncRequest::RescanBlockDevice("dummy_id".to_string(), sender),
+                    VmmAction::RescanBlockDevice("dummy_id".to_string(), sender),
                     receiver
                 )));
             }
@@ -807,7 +807,7 @@ mod tests {
                     Ok(pr) => {
                         let (sender, receiver) = oneshot::channel();
                         assert!(pr.eq(&ParsedRequest::Sync(
-                            SyncRequest::PutBootSource(boot_source_body, sender),
+                            VmmAction::ConfigureBootSource(boot_source_body, sender),
                             receiver,
                         )));
                     }
@@ -1011,7 +1011,7 @@ mod tests {
             Ok(pr) => {
                 let (sender, receiver) = oneshot::channel();
                 assert!(pr.eq(&ParsedRequest::Sync(
-                    SyncRequest::PutLogger(logger_body, sender),
+                    VmmAction::ConfigureLogger(logger_body, sender),
                     receiver,
                 )));
             }

api_server/src/lib.rs

@@ -35,7 +35,7 @@ use data_model::mmds::Mmds;
 use http_service::ApiServerHttpService;
 use logger::{Metric, METRICS};
 use request::instance_info::InstanceInfo;
-use request::SyncRequest;
+use request::VmmAction;
 use sys_util::EventFd;
 
 #[derive(Debug)]
@@ -52,15 +52,15 @@ pub struct ApiServer {
     // VMM instance info directly accessible from the API thread.
     vmm_shared_info: Arc<RwLock<InstanceInfo>>,
     // Sender which allows passing messages to the VMM.
-    api_request_sender: Rc<mpsc::Sender<Box<SyncRequest>>>,
+    api_request_sender: Rc<mpsc::Sender<Box<VmmAction>>>,
     efd: Rc<EventFd>,
 }
 
 impl ApiServer {
     pub fn new(
         mmds_info: Arc<Mutex<Mmds>>,
         vmm_shared_info: Arc<RwLock<InstanceInfo>>,
-        api_request_sender: mpsc::Sender<Box<SyncRequest>>,
+        api_request_sender: mpsc::Sender<Box<VmmAction>>,
     ) -> Result<Self> {
         Ok(ApiServer {
             mmds_info,

api_server/src/request/actions.rs

@@ -6,7 +6,7 @@ use futures::sync::oneshot;
 use hyper::Method;
 use serde_json::Value;
 
-use request::{IntoParsedRequest, ParsedRequest, SyncRequest};
+use request::{IntoParsedRequest, ParsedRequest, VmmAction};
 
 // The names of the members from this enum must precisely correspond (as a string) to the possible
 // values of "action_type" from the json request body. This is useful to get a strongly typed
@@ -78,14 +78,14 @@ impl IntoParsedRequest for ActionBody {
                 let block_device_id = self.payload.unwrap().as_str().unwrap().to_string();
                 let (sync_sender, sync_receiver) = oneshot::channel();
                 Ok(ParsedRequest::Sync(
-                    SyncRequest::RescanBlockDevice(block_device_id, sync_sender),
+                    VmmAction::RescanBlockDevice(block_device_id, sync_sender),
                     sync_receiver,
                 ))
             }
             ActionType::InstanceStart => {
                 let (sync_sender, sync_receiver) = oneshot::channel();
                 Ok(ParsedRequest::Sync(
-                    SyncRequest::StartInstance(sync_sender),
+                    VmmAction::StartMicroVm(sync_sender),
                     sync_receiver,
                 ))
             }
@@ -147,7 +147,7 @@ mod tests {
               }"#;
             let (sender, receiver) = oneshot::channel();
             let req = ParsedRequest::Sync(
-                SyncRequest::RescanBlockDevice("dummy_id".to_string(), sender),
+                VmmAction::RescanBlockDevice("dummy_id".to_string(), sender),
                 receiver,
             );
 
@@ -171,8 +171,7 @@ mod tests {
                     \"force\": true}
               }";
             let (sender, receiver) = oneshot::channel();
-            let req: ParsedRequest =
-                ParsedRequest::Sync(SyncRequest::StartInstance(sender), receiver);
+            let req: ParsedRequest = ParsedRequest::Sync(VmmAction::StartMicroVm(sender), receiver);
             let result: Result<ActionBody, serde_json::Error> = serde_json::from_str(json);
             assert!(result.is_ok());
             assert!(

api_server/src/request/boot_source.rs

@@ -4,7 +4,7 @@ use futures::sync::oneshot;
 use hyper::{Response, StatusCode};
 
 use http_service::{json_fault_message, json_response};
-use request::{GenerateResponse, ParsedRequest, SyncRequest};
+use request::{GenerateResponse, ParsedRequest, VmmAction};
 
 #[derive(Debug, Deserialize, PartialEq, Serialize)]
 pub enum BootSourceType {
@@ -69,7 +69,7 @@ impl BootSourceBody {
     pub fn into_parsed_request(self) -> result::Result<ParsedRequest, String> {
         let (sender, receiver) = oneshot::channel();
         Ok(ParsedRequest::Sync(
-            SyncRequest::PutBootSource(self, sender),
+            VmmAction::ConfigureBootSource(self, sender),
             receiver,
         ))
     }
@@ -115,7 +115,7 @@ mod tests {
         };
         let (sender, receiver) = oneshot::channel();
         assert!(body.into_parsed_request().eq(&Ok(ParsedRequest::Sync(
-            SyncRequest::PutBootSource(same_body, sender),
+            VmmAction::ConfigureBootSource(same_body, sender),
             receiver
         ))))
     }

api_server/src/request/drive.rs

@@ -6,7 +6,7 @@ use serde_json::{Map, Value};
 
 use data_model::vm::{BlockDeviceConfig, DriveError};
 
-use super::{GenerateResponse, SyncRequest};
+use super::{GenerateResponse, VmmAction};
 use http_service::{json_fault_message, json_response};
 use request::{IntoParsedRequest, ParsedRequest};
 
@@ -82,7 +82,7 @@ impl IntoParsedRequest for PatchDrivePayload {
 
                 let (sender, receiver) = oneshot::channel();
                 Ok(ParsedRequest::Sync(
-                    SyncRequest::PatchDrive(drive_id, path_on_host, sender),
+                    VmmAction::UpdateDrivePath(drive_id, path_on_host, sender),
                     receiver,
                 ))
             }
@@ -96,7 +96,7 @@ impl IntoParsedRequest for BlockDeviceConfig {
         let (sender, receiver) = oneshot::channel();
         match method {
             Method::Put => Ok(ParsedRequest::Sync(
-                SyncRequest::PutDrive(self, sender),
+                VmmAction::InsertBlockDevice(self, sender),
                 receiver,
             )),
             _ => Ok(ParsedRequest::Dummy),
@@ -232,7 +232,7 @@ mod tests {
             pdp.clone()
                 .into_parsed_request(Method::Patch)
                 .eq(&Ok(ParsedRequest::Sync(
-                    SyncRequest::PatchDrive("foo".to_string(), "dummy".to_string(), sender),
+                    VmmAction::UpdateDrivePath("foo".to_string(), "dummy".to_string(), sender),
                     receiver
                 )))
         );
@@ -317,7 +317,7 @@ mod tests {
                 .clone()
                 .into_parsed_request(Method::Put)
                 .eq(&Ok(ParsedRequest::Sync(
-                    SyncRequest::PutDrive(desc, sender),
+                    VmmAction::InsertBlockDevice(desc, sender),
                     receiver
                 )))
         );

api_server/src/request/logger.rs

@@ -4,7 +4,7 @@ use futures::sync::oneshot;
 use hyper::{Response, StatusCode};
 
 use http_service::{json_fault_message, json_response};
-use request::{GenerateResponse, ParsedRequest, SyncRequest};
+use request::{GenerateResponse, ParsedRequest, VmmAction};
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub enum APILoggerLevel {
@@ -48,7 +48,7 @@ impl APILoggerDescription {
     pub fn into_parsed_request(self) -> result::Result<ParsedRequest, String> {
         let (sender, receiver) = oneshot::channel();
         Ok(ParsedRequest::Sync(
-            SyncRequest::PutLogger(self, sender),
+            VmmAction::ConfigureLogger(self, sender),
             receiver,
         ))
     }
@@ -93,7 +93,7 @@ mod tests {
                 .clone()
                 .into_parsed_request()
                 .eq(&Ok(ParsedRequest::Sync(
-                    SyncRequest::PutLogger(desc, sender),
+                    VmmAction::ConfigureLogger(desc, sender),
                     receiver
                 )))
         );

api_server/src/request/machine_configuration.rs

@@ -5,7 +5,7 @@ use hyper::{Method, Response, StatusCode};
 
 use data_model::vm::MachineConfiguration;
 use http_service::{json_fault_message, json_response};
-use request::{GenerateResponse, IntoParsedRequest, ParsedRequest, SyncRequest};
+use request::{GenerateResponse, IntoParsedRequest, ParsedRequest, VmmAction};
 
 #[derive(Debug, PartialEq)]
 pub enum PutMachineConfigurationError {
@@ -62,7 +62,7 @@ impl IntoParsedRequest for MachineConfiguration {
         let (sender, receiver) = oneshot::channel();
         match method {
             Method::Get => Ok(ParsedRequest::Sync(
-                SyncRequest::GetMachineConfiguration(sender),
+                VmmAction::GetMachineConfiguration(sender),
                 receiver,
             )),
             Method::Put => {
@@ -74,7 +74,7 @@ impl IntoParsedRequest for MachineConfiguration {
                     return Err(String::from("Empty request."));
                 }
                 Ok(ParsedRequest::Sync(
-                    SyncRequest::PutMachineConfiguration(self, sender),
+                    VmmAction::SetVmConfiguration(self, sender),
                     receiver,
                 ))
             }
@@ -123,7 +123,7 @@ mod tests {
             body.clone()
                 .into_parsed_request(Method::Put)
                 .eq(&Ok(ParsedRequest::Sync(
-                    SyncRequest::PutMachineConfiguration(body, sender),
+                    VmmAction::SetVmConfiguration(body, sender),
                     receiver
                 )))
         );

api_server/src/request/mod.rs

@@ -20,16 +20,16 @@ use self::boot_source::BootSourceBody;
 use self::logger::APILoggerDescription;
 use self::net::NetworkInterfaceBody;
 
-pub type SyncOutcomeSender = oneshot::Sender<Box<GenerateResponse + Send>>;
-pub type SyncOutcomeReceiver = oneshot::Receiver<Box<GenerateResponse + Send>>;
+pub type OutcomeSender = oneshot::Sender<Box<GenerateResponse + Send>>;
+pub type OutcomeReceiver = oneshot::Receiver<Box<GenerateResponse + Send>>;
 
 pub enum ParsedRequest {
     Dummy,
     GetInstanceInfo,
     GetMMDS,
     PatchMMDS(Value),
     PutMMDS(Value),
-    Sync(SyncRequest, SyncOutcomeReceiver),
+    Sync(VmmAction, OutcomeReceiver),
 }
 
 pub trait IntoParsedRequest {
@@ -67,21 +67,21 @@ impl GenerateResponse for () {
 
 // 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),
-    PatchDrive(String, String, SyncOutcomeSender), // drive_id, path_on_host, channel
-    PutBootSource(BootSourceBody, SyncOutcomeSender),
-    PutDrive(BlockDeviceConfig, SyncOutcomeSender),
-    PutLogger(APILoggerDescription, SyncOutcomeSender),
-    PutMachineConfiguration(MachineConfiguration, SyncOutcomeSender),
-    PutNetworkInterface(NetworkInterfaceBody, SyncOutcomeSender),
-    RescanBlockDevice(String, SyncOutcomeSender),
-    StartInstance(SyncOutcomeSender),
+pub enum VmmAction {
+    ConfigureBootSource(BootSourceBody, OutcomeSender),
+    ConfigureLogger(APILoggerDescription, OutcomeSender),
+    GetMachineConfiguration(OutcomeSender),
+    InsertBlockDevice(BlockDeviceConfig, OutcomeSender),
+    InsertNetworkDevice(NetworkInterfaceBody, OutcomeSender),
+    RescanBlockDevice(String, OutcomeSender),
+    StartMicroVm(OutcomeSender),
+    SetVmConfiguration(MachineConfiguration, OutcomeSender),
+    UpdateDrivePath(String, String, OutcomeSender), // drive_id, path_on_host, channel
 }
 
-impl fmt::Debug for SyncRequest {
+impl fmt::Debug for VmmAction {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "SyncRequest")
+        write!(f, "VmmActions")
     }
 }
 
@@ -196,38 +196,38 @@ mod tests {
 
     // Implementation for the "==" operator.
     // Can't derive PartialEq directly because the sender members can't be compared.
-    impl PartialEq for SyncRequest {
-        fn eq(&self, other: &SyncRequest) -> bool {
+    impl PartialEq for VmmAction {
+        fn eq(&self, other: &VmmAction) -> bool {
             match (self, other) {
                 (
-                    &SyncRequest::PatchDrive(ref drive_id, ref path_on_host, _),
-                    &SyncRequest::PatchDrive(ref other_drive_id, ref other_path_on_host, _),
+                    &VmmAction::UpdateDrivePath(ref drive_id, ref path_on_host, _),
+                    &VmmAction::UpdateDrivePath(ref other_drive_id, ref other_path_on_host, _),
                 ) => drive_id == other_drive_id && path_on_host == other_path_on_host,
                 (
-                    &SyncRequest::PutBootSource(ref bsb, _),
-                    &SyncRequest::PutBootSource(ref other_bsb, _),
+                    &VmmAction::ConfigureBootSource(ref bsb, _),
+                    &VmmAction::ConfigureBootSource(ref other_bsb, _),
                 ) => bsb == other_bsb,
                 (
-                    &SyncRequest::PutDrive(ref ddesc, _),
-                    &SyncRequest::PutDrive(ref other_ddesc, _),
+                    &VmmAction::InsertBlockDevice(ref ddesc, _),
+                    &VmmAction::InsertBlockDevice(ref other_ddesc, _),
                 ) => ddesc == other_ddesc,
                 (
-                    &SyncRequest::PutLogger(ref logdesc, _),
-                    &SyncRequest::PutLogger(ref other_logdesc, _),
+                    &VmmAction::ConfigureLogger(ref logdesc, _),
+                    &VmmAction::ConfigureLogger(ref other_logdesc, _),
                 ) => logdesc == other_logdesc,
                 (
-                    &SyncRequest::PutMachineConfiguration(ref mcb, _),
-                    &SyncRequest::PutMachineConfiguration(ref other_mcb, _),
+                    &VmmAction::SetVmConfiguration(ref mcb, _),
+                    &VmmAction::SetVmConfiguration(ref other_mcb, _),
                 ) => mcb == other_mcb,
                 (
-                    &SyncRequest::PutNetworkInterface(ref netif, _),
-                    &SyncRequest::PutNetworkInterface(ref other_netif, _),
+                    &VmmAction::InsertNetworkDevice(ref netif, _),
+                    &VmmAction::InsertNetworkDevice(ref other_netif, _),
                 ) => netif == other_netif,
                 (
-                    &SyncRequest::RescanBlockDevice(ref req, _),
-                    &SyncRequest::RescanBlockDevice(ref other_req, _),
+                    &VmmAction::RescanBlockDevice(ref req, _),
+                    &VmmAction::RescanBlockDevice(ref other_req, _),
                 ) => req == other_req,
-                (&SyncRequest::StartInstance(_), &SyncRequest::StartInstance(_)) => true,
+                (&VmmAction::StartMicroVm(_), &VmmAction::StartMicroVm(_)) => true,
                 _ => false,
             }
         }