...

Author: mzhang28

Cargo.lock

@@ -12,7 +12,6 @@ base64 = "0.9"
 bcrypt = "0.2"
 cache = { path = "components/cache" }
 diesel = { version = "1.3", features = ["mysql"] }
-embed = { git = "https://github.com/iptq/embed" }
 env_logger = "0.5"
 failure = "0.1.1"
 idna = "0.1"

Cargo.toml

@@ -5,12 +5,9 @@ use std::path::PathBuf;
 use toml;
 
 use errors::{CustomError, DirError};
+use util::read_file;
 use Error;
 
-lazy_static! {
-    static ref REQUIRED_FIELDS: [&'static str; 3] = ["title", "description_file", "grader_file"];
-}
-
 #[derive(Debug, StructOpt)]
 pub enum ChalCommand {
     /// Import challenges from a directory into the database
@@ -46,6 +43,20 @@ impl ChalImportCommand {
             };
             let path = entry.path();
 
+            match path
+                .file_name()
+                .and_then(|ostr| ostr.to_str())
+                .and_then(|name| {
+                    if name.starts_with(".") {
+                        None
+                    } else {
+                        Some(())
+                    }
+                }) {
+                Some(_) => (),
+                None => continue,
+            }
+
             // find problem.toml
             let problem_toml_path = path.join("problem.toml");
             if !problem_toml_path.exists() {
@@ -57,21 +68,7 @@ impl ChalImportCommand {
             }
 
             // read the problem file
-            let problem_contents = match {
-                let mut file = match File::open(&problem_toml_path) {
-                    Ok(file) => file,
-                    Err(err) => {
-                        return Err(CustomError::new(format!("Error accessing file: {}", err)).into())
-                    }
-                };
-                let mut contents = String::new();
-                match file.read_to_string(&mut contents) {
-                    Ok(_) => Ok::<_, Error>(contents),
-                    Err(err) => {
-                        Err(CustomError::new(format!("Error reading file: {}", err)).into())
-                    }
-                }
-            } {
+            let problem_contents = match read_file(&problem_toml_path) {
                 Ok(problem) => problem,
                 Err(err) => {
                     failed.push((Some(path), err));
@@ -102,31 +99,77 @@ impl ChalImportCommand {
             };
 
             // check for the existence of required fields
-            let mut flag = false;
-            for field in REQUIRED_FIELDS.iter() {
-                if !problem_toml.contains_key(field.to_owned()) {
+            let title = match problem_toml.get("title") {
+                Some(toml::Value::String(title)) => title,
+                _ => {
                     failed.push((
                         Some(path),
-                        CustomError::new(format!(
-                            "problem.toml is missing required key '{}'",
-                            field
-                        )).into(),
+                        CustomError::new("String key 'title' not found.").into(),
                     ));
-                    flag = true;
-                    break;
+                    continue;
                 }
-            }
-            if flag {
-                continue;
-            }
+            };
+            let description = match (
+                problem_toml.get("description"),
+                problem_toml.get("description_file"),
+            ) {
+                (Some(_), Some(_)) => {
+                    failed.push((
+                        Some(path),
+                        CustomError::new("Cannot use both 'description' and 'description_file'.")
+                            .into(),
+                    ));
+                    continue;
+                }
+                (Some(toml::Value::String(description)), None) => description.clone(),
+                (None, Some(toml::Value::String(description_file))) => {
+                    match read_file(&description_file) {
+                        Ok(description) => description,
+                        Err(err) => {
+                            failed.push((Some(path), err.into()));
+                            continue;
+                        }
+                    }
+                }
+                _ => {
+                    failed.push((
+                        Some(path),
+                        CustomError::new("Neither 'description' nor 'description_file' found.")
+                            .into(),
+                    ));
+                    continue;
+                }
+            };
+            let grader = match problem_toml.get("grader") {
+                Some(toml::Value::String(grader_path)) => {
+                    let path = PathBuf::from(&grader_path);
+                    if !path.exists() {
+                        failed.push((
+                            Some(path),
+                            CustomError::new("Grader file not found.").into(),
+                        ));
+                        continue;
+                    }
+                    path
+                }
+                _ => {
+                    failed.push((
+                        Some(path),
+                        CustomError::new("String key 'grader' not found.").into(),
+                    ));
+                    continue;
+                }
+            };
         }
 
         if failed.len() > 0 {
             error!("Failed to load directories:");
             for (path, err) in failed {
-                error!(" - {:?}: {}", path, err);
+                error!(" - {:?}: {:?}", path, err);
             }
+            return Err(CustomError::new("Failed to import some challenges.").into());
         }
+        info!("Successfully imported all challenges.");
         Ok(())
     }
 }

src/cli/chal.rs

@@ -9,14 +9,22 @@ use serde_json;
 #[fail(display = "Error traversing the directory")]
 pub struct DirError(#[cause] pub io::Error);
 
+#[derive(Debug, Fail)]
+#[fail(display = "Error accessing the file")]
+pub struct FileOpenError(#[cause] pub io::Error);
+
+#[derive(Debug, Fail)]
+#[fail(display = "Error reading the file")]
+pub struct FileReadError(#[cause] pub io::Error);
+
 #[derive(Debug)]
 pub struct CustomError(String);
 
 macro_rules! error_derive_from {
     ([$($error:path[$v:expr] => $into:ident,)*]) => {
         #[derive(Debug, Fail)]
         pub enum Error {
-            #[fail(display = "")]
+            #[fail(display = "{}", _0)]
             Custom(#[cause] CustomError),
             $(
                 #[fail(display = $v)]
@@ -37,7 +45,9 @@ macro_rules! error_derive_from {
 error_derive_from!([
     rocket::error::LaunchError["Error launching Rocket application"] => RocketLaunch,
     serde_json::Error["Error during the serialization of JSON"] => JSONSerialization,
-    DirError["Error traversing the directory"] => Dir,
+    DirError[""] => Dir,
+    FileOpenError[""] => FileOpen,
+    FileReadError[""] => FileRead,
 ]);
 
 impl CustomError {

src/errors.rs

@@ -15,8 +15,6 @@ extern crate r2d2_diesel;
 extern crate base64;
 extern crate bcrypt;
 extern crate cache;
-#[macro_use]
-extern crate embed;
 extern crate env_logger;
 #[macro_use]
 extern crate failure;
@@ -47,6 +45,7 @@ mod errors;
 pub mod models;
 mod schema;
 mod tasks;
+mod util;
 pub mod web;
 
 pub use challenge::Challenge;

src/lib.rs

@@ -0,0 +1,19 @@
+use std::fs::File;
+use std::io::Read;
+use std::path::Path;
+
+use errors::{FileOpenError, FileReadError};
+use Error;
+
+pub fn read_file(path: impl AsRef<Path>) -> Result<String, Error> {
+    let mut file = match File::open(path.as_ref()) {
+        Ok(file) => file,
+        Err(err) => return Err(FileOpenError(err).into()),
+    };
+    let mut contents = String::new();
+
+    match file.read_to_string(&mut contents) {
+        Ok(_) => Ok(contents),
+        Err(err) => Err(FileReadError(err).into()),
+    }
+}