vmm: config: Port memory option parsing to OptionParser

This simplifies the parsing of the option by using OptionParser along
with its automatic conversion behaviour.

Signed-off-by: Rob Bradford <robert.bradford@intel.com>

vmm/src/config.rs

@@ -29,10 +29,6 @@ pub const DEFAULT_QUEUE_SIZE_VUBLK: u16 = 128;
 pub enum Error {
     /// Max is less than boot
     ParseCpusMaxLowerThanBoot,
-    /// Failed parsing memory hotplug_method parameter.
-    ParseMemoryHotplugMethodParam(ParseHotplugMethodError),
-    /// Failed parsing memory file parameter.
-    ParseMemoryFileParam,
     /// Failed parsing kernel parameters.
     ParseKernelParams,
     /// Failed parsing kernel command line parameters.
@@ -109,6 +105,8 @@ pub enum Error {
     ParseOnOff,
     /// Error parsing CPU options
     ParseCpus(OptionParserError),
+    /// Error parsing memory options
+    ParseMemory(OptionParserError),
 }
 pub type Result<T> = result::Result<T, Error>;
 
@@ -395,55 +393,41 @@ pub struct MemoryConfig {
 
 impl MemoryConfig {
     pub fn parse(memory: &str) -> Result<Self> {
-        // Split the parameters based on the comma delimiter
+        let mut parser = OptionParser::new();
-        let params_list: Vec<&str> = memory.split(',').collect();
+        parser
+            .add("size")
+            .add("file")
+            .add("mergeable")
+            .add("hotplug_method")
+            .add("hotplug_size");
+        parser.parse(memory).map_err(Error::ParseMemory)?;
 
-        let mut size_str: &str = "512M";
+        let size = parser
-        let mut file_str: &str = "";
+            .convert::<ByteSized>("size")
-        let mut mergeable_str: &str = "";
+            .map_err(Error::ParseMemory)?
-        let mut backed = false;
+            .unwrap_or(ByteSized(DEFAULT_MEMORY_MB << 20))
-        let mut hotplug_method_str: &str = "acpi";
+            .0;
-        let mut hotplug_str: &str = "";
+        let file = parser.get("file").map(PathBuf::from);
-
+        let mergeable = parser
-        for param in params_list.iter() {
+            .convert::<Toggle>("mergeable")
-            if param.starts_with("size=") {
+            .map_err(Error::ParseMemory)?
-                size_str = &param[5..];
+            .unwrap_or(Toggle(false))
-            } else if param.starts_with("file=") {
+            .0;
-                backed = true;
+        let hotplug_method = parser
-                file_str = &param[5..];
+            .convert("hotplug_method")
-            } else if param.starts_with("mergeable=") {
+            .map_err(Error::ParseMemory)?
-                mergeable_str = &param[10..];
+            .unwrap_or_default();
-            } else if param.starts_with("hotplug_method=") {
+        let hotplug_size = parser
-                hotplug_method_str = &param[15..];
+            .convert::<ByteSized>("hotplug_size")
-            } else if param.starts_with("hotplug_size=") {
+            .map_err(Error::ParseMemory)?
-                hotplug_str = &param[13..]
+            .map(|v| v.0);
-            }
-        }
-
-        let file = if backed {
-            if file_str.is_empty() {
-                return Err(Error::ParseMemoryFileParam);
-            }
-
-            Some(PathBuf::from(file_str))
-        } else {
-            None
-        };
-
-        let hotplug_method = hotplug_method_str[..]
-            .parse()
-            .map_err(Error::ParseMemoryHotplugMethodParam)?;
 
         Ok(MemoryConfig {
-            size: parse_size(size_str)?,
+            size,
             file,
-            mergeable: parse_on_off(mergeable_str)?,
+            mergeable,
             hotplug_method,
-            hotplug_size: if hotplug_str == "" {
+            hotplug_size,
-                None
-            } else {
-                Some(parse_size(hotplug_str)?)
-            },
         })
     }
 }