vmm & api_server refactoring

The api_server now depends on the vmm and imports all
the necessary structures from it. The structures are defined
in the vmm_config crate.

Redefined the one shot channels by which the vmm and the API
communicate so that on each channel we put bits of information
that are in a vmm specific language.

As much as possible, renamed the structures in the VMM so they
do not have words related to the API in them.

Refactored the error handling. We now have 2 types of errors:
* errors associated with the VMM public interface (VmmActionError).
  Each of the sub-categories of this error kind corresponds to an
  action from the public interface as defined in the enum
  VmmAction.
* errors associated with the internal state of the VMM or its
  components. These errors cannot be directly triggered by the user.

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

Author: andreeaflorescu

api_server/Cargo.toml

@@ -20,3 +20,4 @@ jailer = { path = "../jailer" }
 logger = { path = "../logger" }
 net_util = { path = "../net_util" }
 sys_util = { path = "../sys_util" }
+vmm = { path = "../vmm" }

api_server/src/http_service.rs

@@ -11,16 +11,17 @@ use hyper::{self, Chunk, Headers, Method, StatusCode};
 use serde_json;
 
 use data_model::mmds::Mmds;
-use data_model::vm::{BlockDeviceConfig, MachineConfiguration};
+use data_model::vm::{BlockDeviceConfig, VmConfig};
 use logger::{Metric, METRICS};
 use request::actions::ActionBody;
-use request::boot_source::BootSourceConfig;
 use request::drive::PatchDrivePayload;
-use request::instance_info::InstanceInfo;
-use request::logger::APILoggerDescription;
-use request::net::NetworkInterfaceBody;
-use request::{IntoParsedRequest, ParsedRequest, VmmAction};
+use request::{GenerateHyperResponse, IntoParsedRequest, ParsedRequest};
 use sys_util::EventFd;
+use vmm::vmm_config::boot_source::BootSourceConfig;
+use vmm::vmm_config::instance_info::InstanceInfo;
+use vmm::vmm_config::logger::LoggerConfig;
+use vmm::vmm_config::net::NetworkInterfaceBody;
+use vmm::VmmAction;
 
 fn build_response_base<B: Into<hyper::Body>>(
     status: StatusCode,
@@ -256,7 +257,7 @@ fn parse_logger_req<'a>(
 
         0 if method == Method::Put => {
             METRICS.put_api_requests.logger_count.inc();
-            Ok(serde_json::from_slice::<APILoggerDescription>(body)
+            Ok(serde_json::from_slice::<LoggerConfig>(body)
                 .map_err(|e| {
                     METRICS.put_api_requests.logger_fails.inc();
                     Error::SerdeJson(e)
@@ -280,7 +281,7 @@ fn parse_machine_config_req<'a>(
     match path_tokens[1..].len() {
         0 if method == Method::Get => {
             METRICS.get_api_requests.machine_cfg_count.inc();
-            let empty_machine_config = MachineConfiguration {
+            let empty_machine_config = VmConfig {
                 vcpu_count: None,
                 mem_size_mib: None,
                 ht_enabled: None,
@@ -296,7 +297,7 @@ fn parse_machine_config_req<'a>(
 
         0 if method == Method::Put => {
             METRICS.put_api_requests.machine_cfg_count.inc();
-            Ok(serde_json::from_slice::<MachineConfiguration>(body)
+            Ok(serde_json::from_slice::<VmConfig>(body)
                 .map_err(|e| {
                     METRICS.put_api_requests.machine_cfg_fails.inc();
                     Error::SerdeJson(e)
@@ -580,12 +581,13 @@ mod tests {
     use serde_json::{Map, Value};
     use std::path::PathBuf;
 
-    use data_model::vm::{CpuFeaturesTemplate, DeviceState};
+    use data_model::vm::CpuFeaturesTemplate;
     use futures::sync::oneshot;
     use hyper::header::{ContentType, Headers};
     use hyper::Body;
     use net_util::MacAddr;
-    use request::VmmAction;
+    use vmm::vmm_config::DeviceState;
+    use vmm::VmmAction;
 
     fn body_to_string(body: hyper::Body) -> String {
         let ret = body
@@ -1006,7 +1008,7 @@ mod tests {
 
         // PUT
         let logger_body =
-            serde_json::from_slice::<APILoggerDescription>(&body).expect("deserialization failed");
+            serde_json::from_slice::<LoggerConfig>(&body).expect("deserialization failed");
         match parse_logger_req(&path_tokens, &path, Method::Put, &body) {
             Ok(pr) => {
                 let (sender, receiver) = oneshot::channel();
@@ -1056,18 +1058,20 @@ mod tests {
         );
 
         // PUT
-        let mcb = MachineConfiguration {
+        let vm_config = VmConfig {
             vcpu_count: Some(42),
             mem_size_mib: Some(1025),
             ht_enabled: Some(true),
             cpu_template: Some(CpuFeaturesTemplate::T2),
         };
 
-        match mcb.into_parsed_request(None, Method::Put) {
-            Ok(pr) => match parse_machine_config_req(&path_tokens, &path, Method::Put, &body) {
-                Ok(pr_mcb) => assert!(pr.eq(&pr_mcb)),
-                _ => assert!(false),
-            },
+        match vm_config.into_parsed_request(None, Method::Put) {
+            Ok(parsed_req) => {
+                match parse_machine_config_req(&path_tokens, &path, Method::Put, &body) {
+                    Ok(other_parsed_req) => assert!(parsed_req.eq(&other_parsed_req)),
+                    _ => assert!(false),
+                }
+            }
             _ => assert!(false),
         }
 

api_server/src/lib.rs

@@ -11,6 +11,7 @@ extern crate tokio_uds;
 extern crate data_model;
 extern crate fc_util;
 extern crate jailer;
+extern crate vmm;
 #[macro_use]
 extern crate logger;
 extern crate net_util;
@@ -34,9 +35,9 @@ use tokio_uds::UnixListener;
 use data_model::mmds::Mmds;
 use http_service::ApiServerHttpService;
 use logger::{Metric, METRICS};
-use request::instance_info::InstanceInfo;
-use request::VmmAction;
 use sys_util::EventFd;
+use vmm::vmm_config::instance_info::InstanceInfo;
+use vmm::VmmAction;
 
 #[derive(Debug)]
 pub enum Error {

api_server/src/request/actions.rs

@@ -6,7 +6,8 @@ use futures::sync::oneshot;
 use hyper::Method;
 use serde_json::Value;
 
-use request::{IntoParsedRequest, ParsedRequest, VmmAction};
+use request::{IntoParsedRequest, ParsedRequest};
+use vmm::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
@@ -22,23 +23,13 @@ pub enum DeviceType {
     Drive,
 }
 
-// Represents the associated json block from the sync request body.
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
-#[serde(deny_unknown_fields)]
-pub struct InstanceDeviceDetachAction {
-    pub device_type: DeviceType,
-    pub device_resource_id: String,
-    pub force: bool,
-}
-
 // The model of the json body from a sync request. We use Serde to transform each associated
 // json body into this.
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct ActionBody {
     pub action_type: ActionType,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub instance_device_detach_action: Option<InstanceDeviceDetachAction>,
     pub payload: Option<Value>,
 }
 
@@ -107,36 +98,31 @@ mod tests {
         // Test InstanceStart.
         let action_body = ActionBody {
             action_type: ActionType::InstanceStart,
-            instance_device_detach_action: None,
             payload: None,
         };
         assert!(validate_payload(&action_body).is_ok());
         // Error case: InstanceStart with payload.
         let action_body = ActionBody {
             action_type: ActionType::InstanceStart,
-            instance_device_detach_action: None,
             payload: Some(Value::String("dummy-payload".to_string())),
         };
         assert!(validate_payload(&action_body).is_err());
 
         // Test BlockDeviceRescan
         let action_body = ActionBody {
             action_type: ActionType::BlockDeviceRescan,
-            instance_device_detach_action: None,
             payload: Some(Value::String(String::from("dummy_id"))),
         };
         assert!(validate_payload(&action_body).is_ok());
         // Error case: no payload.
         let action_body = ActionBody {
             action_type: ActionType::BlockDeviceRescan,
-            instance_device_detach_action: None,
             payload: None,
         };
         assert!(validate_payload(&action_body).is_err());
         // Error case: payload is not String.
         let action_body = ActionBody {
             action_type: ActionType::BlockDeviceRescan,
-            instance_device_detach_action: None,
             payload: Some(Value::Bool(false)),
         };
         assert!(validate_payload(&action_body).is_err());
@@ -167,13 +153,10 @@ mod tests {
         }
 
         {
-            let json = "{
-                \"action_type\": \"InstanceStart\",
-                \"instance_device_detach_action\": {\
-                    \"device_type\": \"Drive\",
-                    \"device_resource_id\": \"dummy\",
-                    \"force\": true}
-              }";
+            let json = r#"{
+                "action_type": "InstanceStart"
+            }"#;
+
             let (sender, receiver) = oneshot::channel();
             let req: ParsedRequest = ParsedRequest::Sync(VmmAction::StartMicroVm(sender), receiver);
             let result: Result<ActionBody, serde_json::Error> = serde_json::from_str(json);

api_server/src/request/boot_source.rs

@@ -1,48 +1,11 @@
 use std::result;
 
 use futures::sync::oneshot;
-use hyper::{Method, Response, StatusCode};
+use hyper::Method;
 
-use http_service::{json_fault_message, json_response};
-use request::{GenerateResponse, IntoParsedRequest, ParsedRequest, VmmAction};
-
-#[derive(Debug, Deserialize, PartialEq, Serialize)]
-#[serde(deny_unknown_fields)]
-pub struct BootSourceConfig {
-    pub kernel_image_path: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub boot_args: Option<String>,
-}
-
-#[derive(Debug)]
-pub enum BootSourceConfigError {
-    InvalidKernelPath,
-    InvalidKernelCommandLine,
-    UpdateNotAllowedPostBoot,
-}
-
-impl GenerateResponse for BootSourceConfigError {
-    fn generate_response(&self) -> Response {
-        use self::BootSourceConfigError::*;
-        match *self {
-            InvalidKernelPath => json_response(
-                StatusCode::BadRequest,
-                json_fault_message(
-                    "The kernel file cannot \
-                     be opened due to invalid kernel path or invalid permissions.",
-                ),
-            ),
-            InvalidKernelCommandLine => json_response(
-                StatusCode::BadRequest,
-                json_fault_message("The kernel command line is invalid!"),
-            ),
-            UpdateNotAllowedPostBoot => json_response(
-                StatusCode::BadRequest,
-                json_fault_message("The update operation is not allowed after boot."),
-            ),
-        }
-    }
-}
+use request::{IntoParsedRequest, ParsedRequest};
+use vmm::vmm_config::boot_source::BootSourceConfig;
+use vmm::VmmAction;
 
 impl IntoParsedRequest for BootSourceConfig {
     fn into_parsed_request(
@@ -62,22 +25,6 @@ impl IntoParsedRequest for BootSourceConfig {
 mod tests {
     use super::*;
 
-    #[test]
-    fn test_generate_response_put_boot_source_config_error() {
-        assert_eq!(
-            BootSourceConfigError::InvalidKernelPath
-                .generate_response()
-                .status(),
-            StatusCode::BadRequest
-        );
-        assert_eq!(
-            BootSourceConfigError::InvalidKernelCommandLine
-                .generate_response()
-                .status(),
-            StatusCode::BadRequest
-        );
-    }
-
     #[test]
     fn test_into_parsed_request() {
         let body = BootSourceConfig {