data_model: added module for saving vmm state

This module should contain in the future all the structures
that need to be shared between the API server and
VMM. For now only contains the vm configuration.

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

Author: andreeaflorescu

api_server/Cargo.toml

@@ -13,6 +13,7 @@ tokio-core = "=0.1.12"
 tokio-uds = "=0.1.7"
 tokio-io = "=0.1.5"
 
+data_model = { path = "../data_model" }
 fc_util = { path = "../fc_util" }
 net_util = { path = "../net_util" }
 sys_util = { path = "../sys_util" }

api_server/src/http_service.rs

@@ -12,6 +12,7 @@ use hyper::{self, Chunk, Headers, Method, StatusCode};
 use serde_json;
 use tokio_core::reactor::Handle;
 
+use data_model::vm::MachineConfiguration;
 use request::{self, ApiRequest, AsyncOutcome, AsyncRequestBody, IntoParsedRequest, ParsedRequest};
 use request::instance_info::InstanceInfo;
 use super::{ActionMap, ActionMapValue};
@@ -184,9 +185,7 @@ fn parse_machine_config_req<'a>(
     match path_tokens[1..].len() {
         0 if method == Method::Get => Ok(ParsedRequest::Dummy),
 
-        0 if method == Method::Put => Ok(serde_json::from_slice::<
-            request::MachineConfigurationBody,
-        >(body)
+        0 if method == Method::Put => Ok(serde_json::from_slice::<MachineConfiguration>(body)
             .map_err(Error::SerdeJson)?
             .into_parsed_request(method)
             .map_err(|s| Error::Generic(StatusCode::BadRequest, s))?),
@@ -500,8 +499,8 @@ mod tests {
     use net_util::MacAddr;
     use fc_util::LriHashMap;
     use request::async::AsyncRequest;
-    use request::sync::{DeviceState, DriveDescription, DrivePermissions, MachineConfigurationBody,
-                        NetworkInterfaceBody, SyncRequest, VsockJsonBody};
+    use request::sync::{DeviceState, DriveDescription, DrivePermissions, NetworkInterfaceBody,
+                        SyncRequest, VsockJsonBody};
 
     fn body_to_string(body: hyper::Body) -> String {
         let ret = body.fold(Vec::new(), |mut acc, chunk| {
@@ -876,7 +875,7 @@ mod tests {
         );
 
         // PUT
-        let mcb = MachineConfigurationBody {
+        let mcb = MachineConfiguration {
             vcpu_count: Some(42),
             mem_size_mib: Some(1025),
         };

api_server/src/lib.rs

@@ -7,6 +7,7 @@ extern crate serde_json;
 extern crate tokio_core;
 extern crate tokio_uds;
 
+extern crate data_model;
 extern crate fc_util;
 extern crate net_util;
 extern crate sys_util;

api_server/src/request/mod.rs

@@ -6,9 +6,8 @@ use std::result;
 use hyper::Method;
 pub use self::async::{AsyncOutcome, AsyncOutcomeReceiver, AsyncOutcomeSender, AsyncRequest,
                       AsyncRequestBody};
-pub use self::sync::{BootSourceBody, DriveDescription, MachineConfigurationBody,
-                     NetworkInterfaceBody, SyncOutcomeReceiver, SyncOutcomeSender, SyncRequest,
-                     VsockJsonBody};
+pub use self::sync::{BootSourceBody, DriveDescription, NetworkInterfaceBody, SyncOutcomeReceiver,
+                     SyncOutcomeSender, SyncRequest, VsockJsonBody};
 
 pub mod instance_info;
 

api_server/src/request/sync/machine_configuration.rs

@@ -3,18 +3,11 @@ use std::result;
 use futures::sync::oneshot;
 use hyper::{Method, Response, StatusCode};
 
+use data_model::vm::MachineConfiguration;
 use http_service::{empty_response, json_fault_message, json_response};
 use request::{IntoParsedRequest, ParsedRequest, SyncRequest};
 use request::sync::GenerateResponse;
 
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
-pub struct MachineConfigurationBody {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub vcpu_count: Option<u8>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub mem_size_mib: Option<usize>,
-}
-
 #[derive(Debug)]
 pub enum PutMachineConfigurationError {
     InvalidVcpuCount,
@@ -55,7 +48,7 @@ impl GenerateResponse for PutMachineConfigurationOutcome {
     }
 }
 
-impl IntoParsedRequest for MachineConfigurationBody {
+impl IntoParsedRequest for MachineConfiguration {
     fn into_parsed_request(self, _method: Method) -> result::Result<ParsedRequest, String> {
         let (sender, receiver) = oneshot::channel();
         Ok(ParsedRequest::Sync(
@@ -109,7 +102,7 @@ mod tests {
 
     #[test]
     fn test_into_parsed_request() {
-        let body = MachineConfigurationBody {
+        let body = MachineConfiguration {
             vcpu_count: Some(8),
             mem_size_mib: Some(1024),
         };

api_server/src/request/sync/mod.rs

@@ -4,6 +4,7 @@ use std::result;
 use futures::sync::oneshot;
 use hyper::{self, StatusCode};
 
+use data_model::vm::MachineConfiguration;
 use http_service::{empty_response, json_fault_message, json_response};
 use net_util::TapError;
 
@@ -15,7 +16,6 @@ mod vsock;
 
 pub use self::drive::{DriveDescription, DriveError, DrivePermissions, PutDriveOutcome};
 pub use self::boot_source::{BootSourceBody, BootSourceType, LocalImage};
-pub use self::machine_configuration::MachineConfigurationBody;
 pub use self::net::NetworkInterfaceBody;
 pub use self::vsock::VsockJsonBody;
 
@@ -55,7 +55,7 @@ pub enum DeviceState {
 pub enum SyncRequest {
     PutBootSource(BootSourceBody, SyncOutcomeSender),
     PutDrive(DriveDescription, SyncOutcomeSender),
-    PutMachineConfiguration(MachineConfigurationBody, SyncOutcomeSender),
+    PutMachineConfiguration(MachineConfiguration, SyncOutcomeSender),
     PutNetworkInterface(NetworkInterfaceBody, SyncOutcomeSender),
     PutVsock(VsockJsonBody, SyncOutcomeSender),
 }

data_model/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "data_model"
+version = "0.1.0"
+authors = ["Amazon firecracker team <firecracker-devel@amazon.com>"]
+
+[dependencies]
+serde = "=1.0.27"
+serde_derive = "=1.0.27"

data_model/src/lib.rs

@@ -0,0 +1,5 @@
+extern crate serde;
+#[macro_use]
+extern crate serde_derive;
+
+pub mod vm;

data_model/src/vm/machine_config.rs

@@ -0,0 +1,16 @@
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+pub struct MachineConfiguration {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub vcpu_count: Option<u8>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mem_size_mib: Option<usize>,
+}
+
+impl Default for MachineConfiguration {
+    fn default() -> Self {
+        MachineConfiguration {
+            vcpu_count: Some(1),
+            mem_size_mib: Some(128),
+        }
+    }
+}

data_model/src/vm/mod.rs

@@ -0,0 +1,3 @@
+pub mod machine_config;
+
+pub use vm::machine_config::MachineConfiguration;